Add support for attention (emphasis, strong)

17 files changed, 660 insertions, 253 deletions

diff --git a/readme.md b/readme.md
index 103b201..d31a4c7 100644
--- a/readme.md
+++ b/readme.md
@@ -59,7 +59,7 @@ cargo doc --document-private-items
 
 ### Constructs
 
-- [ ] (5) attention (emphasis, strong)
+- [x] attention (emphasis, strong)
 - [x] autolink
 - [x] blank line
 - [ ] (5) block quote
@@ -97,8 +97,8 @@ cargo doc --document-private-items
   - [x] html (flow)
   - [x] paragraph
   - [x] thematic break
-- [ ] (8) text
-  - [ ] attention (emphasis, strong) (text)
+- [x] text
+  - [x] attention (emphasis, strong) (text)
   - [x] autolink
   - [x] character escape
   - [x] character reference
@@ -117,6 +117,7 @@ cargo doc --document-private-items
 
 #### Docs
 
+- [ ] (1) Document attention
 - [ ] (1) Go through all bnf
 - [ ] (1) Go through all docs
 - [ ] (1) Add overview docs on how everything works
@@ -127,9 +128,7 @@ cargo doc --document-private-items
 
 #### Parse
 
-- [ ] (5) attention\
-       test (`character_reference`, `hard_break_escape`, `hard_break_trailing`,
-      `heading_atx`, `heading_setext`, `html_flow`, `thematic_break`)\
+- [ ] (2) attention/label interplay
 - [ ] (8) block quote\
        test (`code_fenced`, `definition`, `code_indented`, `heading_atx`, `heading_setext`,
       `html_flow`, `misc_default_line_ending`, `thematic_break`)
@@ -150,6 +149,8 @@ cargo doc --document-private-items
 
 #### Misc
 
+- [ ] (3) Unicode punctuation
+- [ ] (1) use `char::REPLACEMENT_CHARACTER`?
 - [ ] (3) Check subtokenizer unraveling is ok
 - [ ] (3) Remove splicing and cloning in subtokenizer
 - [ ] (3) Pass more references around
@@ -271,3 +272,4 @@ important.
 - [x] (8) Make paragraphs fast by merging them at the end, not checking whether
       things interrupt them each line
 - [x] (3) Add support for interrupting (or not)
+- [x] (5) attention
diff --git a/src/compiler.rs b/src/compiler.rs
index 1f16648..061d3e3 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -421,6 +421,7 @@ pub fn compile(events: &[Event], codes: &[Code], options: &Options) -> String {
     enter_map.insert(TokenType::CodeIndented, on_enter_code_indented);
     enter_map.insert(TokenType::CodeFenced, on_enter_code_fenced);
     enter_map.insert(TokenType::CodeText, on_enter_code_text);
+    enter_map.insert(TokenType::Emphasis, on_enter_emphasis);
     enter_map.insert(TokenType::HtmlFlow, on_enter_html_flow);
     enter_map.insert(TokenType::HtmlText, on_enter_html_text);
     enter_map.insert(TokenType::Image, on_enter_image);
@@ -431,6 +432,7 @@ pub fn compile(events: &[Event], codes: &[Code], options: &Options) -> String {
         on_enter_resource_destination_string,
     );
     enter_map.insert(TokenType::Paragraph, on_enter_paragraph);
+    enter_map.insert(TokenType::Strong, on_enter_strong);
     enter_map.insert(TokenType::Definition, on_enter_definition);
     enter_map.insert(
         TokenType::DefinitionDestinationString,
@@ -441,6 +443,7 @@ pub fn compile(events: &[Event], codes: &[Code], options: &Options) -> String {
     enter_map.insert(TokenType::DefinitionTitleString, on_enter_buffer);
 
     let mut exit_map: Map = HashMap::new();
+    exit_map.insert(TokenType::Emphasis, on_exit_emphasis);
     exit_map.insert(TokenType::Label, on_exit_label);
     exit_map.insert(TokenType::LabelText, on_exit_label_text);
     exit_map.insert(TokenType::ReferenceString, on_exit_reference_string);
@@ -452,6 +455,7 @@ pub fn compile(events: &[Event], codes: &[Code], options: &Options) -> String {
         TokenType::ResourceTitleString,
         on_exit_resource_title_string,
     );
+    exit_map.insert(TokenType::Strong, on_exit_strong);
     exit_map.insert(TokenType::Image, on_exit_media);
     exit_map.insert(TokenType::Link, on_exit_media);
     exit_map.insert(TokenType::CodeTextData, on_exit_data);
@@ -644,6 +648,11 @@ fn on_enter_definition_destination_string(context: &mut CompileContext) {
     context.ignore_encode = true;
 }
 
+/// Handle [`Enter`][EventType::Enter]:[`Emphasis`][TokenType::Emphasis].
+fn on_enter_emphasis(context: &mut CompileContext) {
+    context.tag("<em>".to_string());
+}
+
 /// Handle [`Enter`][EventType::Enter]:[`HtmlFlow`][TokenType::HtmlFlow].
 fn on_enter_html_flow(context: &mut CompileContext) {
     context.line_ending_if_needed();
@@ -704,6 +713,11 @@ fn on_enter_resource_destination_string(context: &mut CompileContext) {
     context.ignore_encode = true;
 }
 
+/// Handle [`Enter`][EventType::Enter]:[`Strong`][TokenType::Strong].
+fn on_enter_strong(context: &mut CompileContext) {
+    context.tag("<strong>".to_string());
+}
+
 /// Handle [`Exit`][EventType::Exit]:[`AutolinkEmail`][TokenType::AutolinkEmail].
 fn on_exit_autolink_email(context: &mut CompileContext) {
     let slice = serialize(
@@ -933,6 +947,11 @@ fn on_exit_definition_title_string(context: &mut CompileContext) {
     definition.title = Some(buf);
 }
 
+/// Handle [`Exit`][EventType::Exit]:[`Strong`][TokenType::Emphasis].
+fn on_exit_emphasis(context: &mut CompileContext) {
+    context.tag("</em>".to_string());
+}
+
 /// Handle [`Exit`][EventType::Exit]:[`HeadingAtx`][TokenType::HeadingAtx].
 fn on_exit_heading_atx(context: &mut CompileContext) {
     let rank = context
@@ -1132,6 +1151,11 @@ fn on_exit_resource_title_string(context: &mut CompileContext) {
     media.title = Some(buf);
 }
 
+/// Handle [`Exit`][EventType::Exit]:[`Strong`][TokenType::Strong].
+fn on_exit_strong(context: &mut CompileContext) {
+    context.tag("</strong>".to_string());
+}
+
 /// Handle [`Exit`][EventType::Exit]:[`ThematicBreak`][TokenType::ThematicBreak].
 fn on_exit_thematic_break(context: &mut CompileContext) {
     context.tag("<hr />".to_string());
diff --git a/src/construct/attention.rs b/src/construct/attention.rs
new file mode 100644
index 0000000..f022e6e
--- /dev/null
+++ b/src/construct/attention.rs
@@ -0,0 +1,401 @@
+//! To do.
+
+use crate::tokenizer::{Code, Event, EventType, Point, State, StateFnResult, TokenType, Tokenizer};
+use crate::util::edit_map::EditMap;
+
+/// To do
+#[derive(Debug, PartialEq)]
+enum GroupKind {
+    Whitespace,
+    Punctuation,
+    Other,
+}
+
+/// To do
+#[derive(Debug, PartialEq)]
+enum MarkerKind {
+    Asterisk,
+    Underscore,
+}
+
+impl MarkerKind {
+    fn from_char(char: char) -> MarkerKind {
+        match char {
+            '*' => MarkerKind::Asterisk,
+            '_' => MarkerKind::Underscore,
+            _ => unreachable!("invalid char"),
+        }
+    }
+    fn from_code(code: Code) -> MarkerKind {
+        match code {
+            Code::Char(char) => MarkerKind::from_char(char),
+            _ => unreachable!("invalid code"),
+        }
+    }
+}
+
+/// To do
+#[derive(Debug)]
+struct Run {
+    marker: MarkerKind,
+    event_index: usize,
+    start_point: Point,
+    start_index: usize,
+    end_point: Point,
+    end_index: usize,
+    size: usize,
+    open: bool,
+    close: bool,
+}
+
+/// Before a paragraph.
+///
+/// ```markdown
+/// |qwe
+/// ```
+pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
+    match code {
+        Code::Char(char) if char == '*' || char == '_' => {
+            tokenizer.enter(TokenType::AttentionSequence);
+            inside(tokenizer, code, char)
+        }
+        _ => (State::Nok, None),
+    }
+}
+
+/// In a paragraph.
+///
+/// ```markdown
+/// al|pha
+/// ```
+fn inside(tokenizer: &mut Tokenizer, code: Code, marker: char) -> StateFnResult {
+    match code {
+        Code::Char(char) if char == marker => {
+            tokenizer.consume(code);
+            (State::Fn(Box::new(move |t, c| inside(t, c, marker))), None)
+        }
+        _ => {
+            tokenizer.exit(TokenType::AttentionSequence);
+            tokenizer.register_resolver("attention".to_string(), Box::new(resolve));
+            (State::Ok, Some(vec![code]))
+        }
+    }
+}
+
+/// To do.
+#[allow(clippy::too_many_lines)]
+pub fn resolve(tokenizer: &mut Tokenizer) -> Vec<Event> {
+    let mut index = 0;
+    println!("before: {:?}", tokenizer.events.len());
+    while index < tokenizer.events.len() {
+        let event = &tokenizer.events[index];
+        println!(
+            "ev: {:?} {:?} {:?} {:?} {:?} {:?}",
+            index,
+            event.event_type,
+            event.token_type,
+            event.content_type,
+            event.previous,
+            event.next
+        );
+        index += 1;
+    }
+
+    let codes = &tokenizer.parse_state.codes;
+    let mut edit_map = EditMap::new();
+    let mut start = 0;
+    let mut runs: Vec<Run> = vec![];
+
+    // Find runs of sequences and information about them.
+    while start < tokenizer.events.len() {
+        let enter = &tokenizer.events[start];
+
+        if enter.event_type == EventType::Enter && enter.token_type == TokenType::AttentionSequence
+        {
+            let end = start + 1;
+            let exit = &tokenizer.events[end];
+            let marker = MarkerKind::from_code(codes[enter.index]);
+            let before = classify_character(if enter.index > 0 {
+                codes[enter.index - 1]
+            } else {
+                Code::None
+            });
+            let after = classify_character(if exit.index < codes.len() {
+                codes[exit.index]
+            } else {
+                Code::None
+            });
+            let open = after == GroupKind::Other
+                || (after == GroupKind::Punctuation && before != GroupKind::Other);
+            // To do: GFM strikethrough?
+            // || attentionMarkers.includes(code)
+            let close = before == GroupKind::Other
+                || (before == GroupKind::Punctuation && after != GroupKind::Other);
+            // To do: GFM strikethrough?
+            // || attentionMarkers.includes(previous)
+
+            runs.push(Run {
+                event_index: start,
+                start_point: enter.point.clone(),
+                start_index: enter.index,
+                end_point: exit.point.clone(),
+                end_index: exit.index,
+                size: exit.index - enter.index,
+                open: if marker == MarkerKind::Asterisk {
+                    open
+                } else {
+                    open && (before != GroupKind::Other || !close)
+                },
+                close: if marker == MarkerKind::Asterisk {
+                    close
+                } else {
+                    close && (after != GroupKind::Other || !open)
+                },
+                marker,
+            });
+
+            start += 1;
+        }
+
+        start += 1;
+    }
+
+    // Walk through runs and match them.
+    let mut close = 0;
+
+    while close < runs.len() {
+        let run_close = &runs[close];
+
+        // Find a run that can close.
+        if run_close.close {
+            let mut open = close;
+
+            // Now walk back to find an opener.
+            while open > 0 {
+                open -= 1;
+
+                let run_open = &runs[open];
+
+                // Find a token that can open the closer.
+                if run_open.open && run_close.marker == run_open.marker {
+                    // If the opening can close or the closing can open,
+                    // and the close size *is not* a multiple of three,
+                    // but the sum of the opening and closing size *is*
+                    // multiple of three, then **don’t** match.
+                    if (run_open.close || run_close.open)
+                        && run_close.size % 3 != 0
+                        && (run_open.size + run_close.size) % 3 == 0
+                    {
+                        continue;
+                    }
+
+                    // Number of markers to use from the sequence.
+                    let take = if run_open.size > 1 && run_close.size > 1 {
+                        2
+                    } else {
+                        1
+                    };
+
+                    let run_close = &mut runs[close];
+                    let close_event_index = run_close.event_index;
+                    let seq_close_enter = (run_close.start_point.clone(), run_close.start_index);
+                    run_close.size -= take;
+                    run_close.start_point.column += take;
+                    run_close.start_point.offset += take;
+                    let seq_close_exit = (run_close.start_point.clone(), run_close.start_index);
+
+                    // Remove closing run if fully used.
+                    if run_close.size == 0 {
+                        runs.remove(close);
+                        edit_map.add(close_event_index, 2, vec![]);
+                    }
+
+                    let run_open = &mut runs[open];
+                    let open_event_index = run_open.event_index;
+                    let seq_open_exit = (run_open.end_point.clone(), run_open.end_index);
+                    run_open.size -= take;
+                    run_open.end_point.column -= take;
+                    run_open.end_point.offset -= take;
+                    let seq_open_enter = (run_open.end_point.clone(), run_open.end_index);
+
+                    // Remove opening run if fully used.
+                    if run_open.size == 0 {
+                        runs.remove(open);
+                        edit_map.add(open_event_index, 2, vec![]);
+                    }
+
+                    // Opening.
+                    edit_map.add(
+                        open_event_index,
+                        0,
+                        vec![
+                            Event {
+                                event_type: EventType::Enter,
+                                token_type: if take == 1 {
+                                    TokenType::Emphasis
+                                } else {
+                                    TokenType::Strong
+                                },
+                                point: seq_open_enter.0.clone(),
+                                index: seq_open_enter.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                            Event {
+                                event_type: EventType::Enter,
+                                token_type: if take == 1 {
+                                    TokenType::EmphasisSequence
+                                } else {
+                                    TokenType::StrongSequence
+                                },
+                                point: seq_open_enter.0.clone(),
+                                index: seq_open_enter.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                            Event {
+                                event_type: EventType::Exit,
+                                token_type: if take == 1 {
+                                    TokenType::EmphasisSequence
+                                } else {
+                                    TokenType::StrongSequence
+                                },
+                                point: seq_open_exit.0.clone(),
+                                index: seq_open_exit.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                            Event {
+                                event_type: EventType::Enter,
+                                token_type: if take == 1 {
+                                    TokenType::EmphasisText
+                                } else {
+                                    TokenType::StrongText
+                                },
+                                point: seq_open_exit.0.clone(),
+                                index: seq_open_exit.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                        ],
+                    );
+                    // Closing.
+                    edit_map.add(
+                        close_event_index,
+                        0,
+                        vec![
+                            Event {
+                                event_type: EventType::Exit,
+                                token_type: if take == 1 {
+                                    TokenType::EmphasisText
+                                } else {
+                                    TokenType::StrongText
+                                },
+                                point: seq_close_enter.0.clone(),
+                                index: seq_close_enter.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                            Event {
+                                event_type: EventType::Enter,
+                                token_type: if take == 1 {
+                                    TokenType::EmphasisSequence
+                                } else {
+                                    TokenType::StrongSequence
+                                },
+                                point: seq_close_enter.0.clone(),
+                                index: seq_close_enter.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                            Event {
+                                event_type: EventType::Exit,
+                                token_type: if take == 1 {
+                                    TokenType::EmphasisSequence
+                                } else {
+                                    TokenType::StrongSequence
+                                },
+                                point: seq_close_exit.0.clone(),
+                                index: seq_close_exit.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                            Event {
+                                event_type: EventType::Exit,
+                                token_type: if take == 1 {
+                                    TokenType::Emphasis
+                                } else {
+                                    TokenType::Strong
+                                },
+                                point: seq_close_exit.0.clone(),
+                                index: seq_close_exit.1,
+                                previous: None,
+                                next: None,
+                                content_type: None,
+                            },
+                        ],
+                    );
+
+                    break;
+                }
+            }
+        }
+
+        close += 1;
+    }
+
+    // Mark remaining sequences as data.
+    let mut index = 0;
+    while index < runs.len() {
+        let run = &runs[index];
+        // To do: resize!
+        tokenizer.events[run.event_index].token_type = TokenType::Data;
+        tokenizer.events[run.event_index + 1].token_type = TokenType::Data;
+
+        index += 1;
+    }
+
+    let events = edit_map.consume(&mut tokenizer.events);
+    let mut index = 0;
+    println!("after: {:?}", events.len());
+    while index < events.len() {
+        let event = &events[index];
+        println!(
+            "ev: {:?} {:?} {:?} {:?} {:?} {:?}",
+            index,
+            event.event_type,
+            event.token_type,
+            event.content_type,
+            event.previous,
+            event.next
+        );
+        index += 1;
+    }
+
+    events
+}
+
+fn classify_character(code: Code) -> GroupKind {
+    match code {
+        // Markdown whitespace.
+        Code::None
+        | Code::CarriageReturnLineFeed
+        | Code::VirtualSpace
+        | Code::Char('\t' | '\r' | '\n' | ' ') => GroupKind::Whitespace,
+        // Unicode whitespace.
+        Code::Char(char) if char.is_whitespace() => GroupKind::Whitespace,
+        // Unicode punctuation.
+        // To do: `is_punctuation` is not in rust? Why not?
+        // Perhaps we need to generate stuff just like:
+        // <https://github.com/micromark/micromark/blob/main/packages/micromark-util-character/dev/lib/unicode-punctuation-regex.js>.
+        Code::Char(char) if char.is_ascii_punctuation() => GroupKind::Punctuation,
+        Code::Char(_) => GroupKind::Other,
+    }
+}
diff --git a/src/construct/mod.rs b/src/construct/mod.rs
index 9e3dfb0..66b2a3c 100644
--- a/src/construct/mod.rs
+++ b/src/construct/mod.rs
@@ -14,7 +14,7 @@
 //!
 //! The following constructs are found in markdown:
 //!
-//! *   attention (strong, emphasis)
+//! *   [attention (strong, emphasis)][attention]
 //! *   [autolink][]
 //! *   [blank line][blank_line]
 //! *   block quote
@@ -61,6 +61,7 @@
 //! example `ascii_punctuation` refers to
 //! [`char::is_ascii_punctuation`][char::is_ascii_punctuation].
 
+pub mod attention;
 pub mod autolink;
 pub mod blank_line;
 pub mod character_escape;
diff --git a/src/construct/partial_label.rs b/src/construct/partial_label.rs
index e505997..32182d6 100644
--- a/src/construct/partial_label.rs
+++ b/src/construct/partial_label.rs
@@ -41,7 +41,7 @@
 //! > ([label start (image)][label_start_image] or
 //! > [label start (link)][label_start_link]) and a closing
 //! > ([label end][label_end]), so as to allow further phrasing such as
-//! > [code (text)][code_text] or attention.
+//! > [code (text)][code_text] or [attention][].
 //!
 //! ## References
 //!
@@ -49,6 +49,7 @@
 //!
 //! [definition]: crate::construct::definition
 //! [string]: crate::content::string
+//! [attention]: crate::construct::attention
 //! [character_escape]: crate::construct::character_escape
 //! [character_reference]: crate::construct::character_reference
 //! [label_start_image]: crate::construct::label_start_image
@@ -56,8 +57,6 @@
 //! [label_end]: crate::construct::label_end
 //! [code_text]: crate::construct::code_text
 //! [link_reference_size_max]: crate::constant::LINK_REFERENCE_SIZE_MAX
-//!
-//! <!-- To do: link attention. -->
 
 use super::partial_space_or_tab::{space_or_tab_eol_with_options, EolOptions};
 use crate::constant::LINK_REFERENCE_SIZE_MAX;
diff --git a/src/content/text.rs b/src/content/text.rs
index c3f4e1b..ecb6ae1 100644
--- a/src/content/text.rs
+++ b/src/content/text.rs
@@ -1,12 +1,13 @@
 //! The text content type.
 //!
-//! **Text** contains phrasing content such as attention (emphasis, strong),
-//! media (links, images), and actual text.
+//! **Text** contains phrasing content such as
+//! [attention][crate::construct::attention] (emphasis, strong),
+//! [code (text)][crate::construct::code_text], and actual text.
 //!
 //! The constructs found in text are:
 //!
+//! *   [Attention][crate::construct::attention]
 //! *   [Autolink][crate::construct::autolink]
-//! *   Attention
 //! *   [HTML (text)][crate::construct::html_text]
 //! *   [Hard break (escape)][crate::construct::hard_break_escape]
 //! *   [Hard break (trailing)][crate::construct::hard_break_trailing]
@@ -18,9 +19,9 @@
 //! *   [Character reference][crate::construct::character_reference]
 
 use crate::construct::{
-    autolink::start as autolink, character_escape::start as character_escape,
-    character_reference::start as character_reference, code_text::start as code_text,
-    hard_break_escape::start as hard_break_escape,
+    attention::start as attention, autolink::start as autolink,
+    character_escape::start as character_escape, character_reference::start as character_reference,
+    code_text::start as code_text, hard_break_escape::start as hard_break_escape,
     hard_break_trailing::start as hard_break_trailing, html_text::start as html_text,
     label_end::start as label_end, label_start_image::start as label_start_image,
     label_start_link::start as label_start_link, partial_data::start as data,
@@ -28,16 +29,18 @@ use crate::construct::{
 };
 use crate::tokenizer::{Code, State, StateFnResult, Tokenizer};
 
-const MARKERS: [Code; 10] = [
+const MARKERS: [Code; 12] = [
     Code::VirtualSpace, // `whitespace`
     Code::Char('\t'),   // `whitespace`
     Code::Char(' '),    // `hard_break_trailing`, `whitespace`
     Code::Char('!'),    // `label_start_image`
     Code::Char('&'),    // `character_reference`
+    Code::Char('*'),    // `attention`
     Code::Char('<'),    // `autolink`, `html_text`
     Code::Char('['),    // `label_start_link`
     Code::Char('\\'),   // `character_escape`, `hard_break_escape`
     Code::Char(']'),    // `label_end`
+    Code::Char('_'),    // `attention`
     Code::Char('`'),    // `code_text`
 ];
 
@@ -55,6 +58,7 @@ pub fn start(tokenizer: &mut Tokenizer, code: Code) -> StateFnResult {
         Code::None => (State::Ok, None),
         _ => tokenizer.attempt_n(
             vec![
+                Box::new(attention),
                 Box::new(autolink),
                 Box::new(character_escape),
                 Box::new(character_reference),
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
index b70e706..282c99f 100644
--- a/src/tokenizer.rs
+++ b/src/tokenizer.rs
@@ -1593,6 +1593,15 @@ pub enum TokenType {
     ///     ^ ^ ^
     /// ```
     ThematicBreakSequence,
+    Strong,
+    StrongSequence,
+    StrongText,
+    Emphasis,
+    EmphasisSequence,
+    EmphasisText,
+    // To do: this is removed.
+    // Should it reuse something e.g., emphasis? Data?
+    AttentionSequence,
 }
 
 /// Embedded content type.
diff --git a/tests/character_reference.rs b/tests/character_reference.rs
index c87657e..dec1d0c 100644
--- a/tests/character_reference.rs
+++ b/tests/character_reference.rs
@@ -85,12 +85,11 @@ fn character_reference() {
         "should not support character references in indented code"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("&#42;foo&#42;\n*foo*"),
-    //     "<p>*foo*\n<em>foo</em></p>",
-    //     "should not support character references as construct markers (1)"
-    // );
+    assert_eq!(
+        micromark("&#42;foo&#42;\n*foo*"),
+        "<p>*foo*\n<em>foo</em></p>",
+        "should not support character references as construct markers (1)"
+    );
 
     // To do: list.
     // assert_eq!(
diff --git a/tests/hard_break_escape.rs b/tests/hard_break_escape.rs
index 740e706..a486ade 100644
--- a/tests/hard_break_escape.rs
+++ b/tests/hard_break_escape.rs
@@ -15,12 +15,11 @@ fn hard_break_escape() {
         "should support leading spaces after an escape hard break"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*foo\\\nbar*"),
-    //     "<p><em>foo<br />\nbar</em></p>",
-    //     "should support escape hard breaks in emphasis"
-    // );
+    assert_eq!(
+        micromark("*foo\\\nbar*"),
+        "<p><em>foo<br />\nbar</em></p>",
+        "should support escape hard breaks in emphasis"
+    );
 
     assert_eq!(
         micromark("``code\\\ntext``"),
diff --git a/tests/hard_break_trailing.rs b/tests/hard_break_trailing.rs
index 2a4b534..d67ad37 100644
--- a/tests/hard_break_trailing.rs
+++ b/tests/hard_break_trailing.rs
@@ -21,19 +21,17 @@ fn hard_break_trailing() {
         "should support leading spaces after a trailing hard break"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*foo  \nbar*"),
-    //     "<p><em>foo<br />\nbar</em></p>",
-    //     "should support trailing hard breaks in emphasis"
-    // );
+    assert_eq!(
+        micromark("*foo  \nbar*"),
+        "<p><em>foo<br />\nbar</em></p>",
+        "should support trailing hard breaks in emphasis"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*foo\\\nbar*"),
-    //     "<p><em>foo<br />\nbar</em></p>",
-    //     "should support escape hard breaks in emphasis"
-    // );
+    assert_eq!(
+        micromark("*foo\\\nbar*"),
+        "<p><em>foo<br />\nbar</em></p>",
+        "should support escape hard breaks in emphasis"
+    );
 
     assert_eq!(
         micromark("`code  \ntext`"),
@@ -83,40 +81,35 @@ fn hard_break_trailing() {
         "should support a line suffix after a replacement character"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*a*  \nbb"),
-    //     "<p><em>a</em><br />\nbb</p>",
-    //     "should support a hard break after a span"
-    // );
+    assert_eq!(
+        micromark("*a*  \nbb"),
+        "<p><em>a</em><br />\nbb</p>",
+        "should support a hard break after a span"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*a*\t\nbb"),
-    //     "<p><em>a</em>\nbb</p>",
-    //     "should support a line suffix after a span"
-    // );
+    assert_eq!(
+        micromark("*a*\t\nbb"),
+        "<p><em>a</em>\nbb</p>",
+        "should support a line suffix after a span"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*a*  \t\nbb"),
-    //     "<p><em>a</em>\nbb</p>",
-    //     "should support a mixed line suffix after a span (1)"
-    // );
+    assert_eq!(
+        micromark("*a*  \t\nbb"),
+        "<p><em>a</em>\nbb</p>",
+        "should support a mixed line suffix after a span (1)"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*a*\t  \nbb"),
-    //     "<p><em>a</em>\nbb</p>",
-    //     "should support a mixed line suffix after a span (2)"
-    // );
+    assert_eq!(
+        micromark("*a*\t  \nbb"),
+        "<p><em>a</em>\nbb</p>",
+        "should support a mixed line suffix after a span (2)"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("*a*  \t  \nbb"),
-    //     "<p><em>a</em>\nbb</p>",
-    //     "should support a mixed line suffix after a span (3)"
-    // );
+    assert_eq!(
+        micromark("*a*  \t  \nbb"),
+        "<p><em>a</em>\nbb</p>",
+        "should support a mixed line suffix after a span (3)"
+    );
 
     // // To do: turning things off.
     // assert_eq!(
diff --git a/tests/heading_atx.rs b/tests/heading_atx.rs
index ef5846a..c9aa803 100644
--- a/tests/heading_atx.rs
+++ b/tests/heading_atx.rs
@@ -62,12 +62,11 @@ fn heading_atx() {
         "should not support a heading for an escaped number sign"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("# foo *bar* \\*baz\\*"),
-    //     "<h1>foo <em>bar</em> *baz*</h1>",
-    //     "should support text content in headings"
-    // );
+    assert_eq!(
+        micromark("# foo *bar* \\*baz\\*"),
+        "<h1>foo <em>bar</em> *baz*</h1>",
+        "should support text content in headings"
+    );
 
     assert_eq!(
         micromark("#                  foo                     "),
diff --git a/tests/heading_setext.rs b/tests/heading_setext.rs
index e7ee9ff..3c8b892 100644
--- a/tests/heading_setext.rs
+++ b/tests/heading_setext.rs
@@ -3,33 +3,29 @@ use micromark::micromark;
 
 #[test]
 fn heading_setext() {
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("Foo *bar*\n========="),
-    //     "<h1>Foo <em>bar</em></h1>",
-    //     "should support a heading w/ an equals to (rank of 1)"
-    // );
+    assert_eq!(
+        micromark("Foo *bar*\n========="),
+        "<h1>Foo <em>bar</em></h1>",
+        "should support a heading w/ an equals to (rank of 1)"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("Foo *bar*\n---------"),
-    //     "<h2>Foo <em>bar</em></h2>",
-    //     "should support a heading w/ a dash (rank of 2)"
-    // );
+    assert_eq!(
+        micromark("Foo *bar*\n---------"),
+        "<h2>Foo <em>bar</em></h2>",
+        "should support a heading w/ a dash (rank of 2)"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("Foo *bar\nbaz*\n===="),
-    //     "<h1>Foo <em>bar\nbaz</em></h1>",
-    //     "should support line endings in setext headings"
-    // );
+    assert_eq!(
+        micromark("Foo *bar\nbaz*\n===="),
+        "<h1>Foo <em>bar\nbaz</em></h1>",
+        "should support line endings in setext headings"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("  Foo *bar\nbaz*\t\n===="),
-    //     "<h1>Foo <em>bar\nbaz</em></h1>",
-    //     "should not include initial and final whitespace around content"
-    // );
+    assert_eq!(
+        micromark("  Foo *bar\nbaz*\t\n===="),
+        "<h1>Foo <em>bar\nbaz</em></h1>",
+        "should not include initial and final whitespace around content"
+    );
 
     assert_eq!(
         micromark("Foo\n-------------------------"),
diff --git a/tests/html_flow.rs b/tests/html_flow.rs
index 3b69671..348da8d 100644
--- a/tests/html_flow.rs
+++ b/tests/html_flow.rs
@@ -98,12 +98,11 @@ p {color:blue;}
         "should support raw tags w/o ending"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<style>p{color:red;}</style>\n*foo*", DANGER),
-    //     "<style>p{color:red;}</style>\n<p><em>foo</em></p>",
-    //     "should support raw tags w/ start and end on a single line"
-    // );
+    assert_eq!(
+        micromark_with_options("<style>p{color:red;}</style>\n*foo*", DANGER),
+        "<style>p{color:red;}</style>\n<p><em>foo</em></p>",
+        "should support raw tags w/ start and end on a single line"
+    );
 
     assert_eq!(
         micromark_with_options("<script>\nfoo\n</script>1. *bar*", DANGER),
@@ -129,12 +128,11 @@ p {color:blue;}
         "should not support an eof after a self-closing slash"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<script/\n*asd*", DANGER),
-    //     "<p>&lt;script/\n<em>asd</em></p>",
-    //     "should not support a line ending after a self-closing slash"
-    // );
+    assert_eq!(
+        micromark_with_options("<script/\n*asd*", DANGER),
+        "<p>&lt;script/\n<em>asd</em></p>",
+        "should not support a line ending after a self-closing slash"
+    );
 
     assert_eq!(
         micromark_with_options("<script/>", DANGER),
@@ -195,12 +193,11 @@ fn html_flow_2_comment() {
         "should support comments (type 2)"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<!-- foo -->*bar*\n*baz*", DANGER),
-    //     "<!-- foo -->*bar*\n<p><em>baz</em></p>",
-    //     "should support comments w/ start and end on a single line"
-    // );
+    assert_eq!(
+        micromark_with_options("<!-- foo -->*bar*\n*baz*", DANGER),
+        "<!-- foo -->*bar*\n<p><em>baz</em></p>",
+        "should support comments w/ start and end on a single line"
+    );
 
     assert_eq!(
         micromark_with_options("<!-asd-->", DANGER),
@@ -455,15 +452,14 @@ fn html_flow_5_cdata() {
 
 #[test]
 fn html_flow_6_basic() {
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options(
-    //         "<table><tr><td>\n<pre>\n**Hello**,\n\n_world_.\n</pre>\n</td></tr></table>",
-    //         DANGER
-    //     ),
-    //     "<table><tr><td>\n<pre>\n**Hello**,\n<p><em>world</em>.\n</pre></p>\n</td></tr></table>",
-    //     "should support html (basic)"
-    // );
+    assert_eq!(
+        micromark_with_options(
+            "<table><tr><td>\n<pre>\n**Hello**,\n\n_world_.\n</pre>\n</td></tr></table>",
+            DANGER
+        ),
+        "<table><tr><td>\n<pre>\n**Hello**,\n<p><em>world</em>.\n</pre></p>\n</td></tr></table>",
+        "should support html (basic)"
+    );
 
     assert_eq!(
         micromark_with_options(
@@ -501,12 +497,11 @@ okay.",
         "should support html starting w/ a closing tag"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<DIV CLASS=\"foo\">\n\n*Markdown*\n\n</DIV>", DANGER),
-    //     "<DIV CLASS=\"foo\">\n<p><em>Markdown</em></p>\n</DIV>",
-    //     "should support html w/ markdown in between"
-    // );
+    assert_eq!(
+        micromark_with_options("<DIV CLASS=\"foo\">\n\n*Markdown*\n\n</DIV>", DANGER),
+        "<DIV CLASS=\"foo\">\n<p><em>Markdown</em></p>\n</DIV>",
+        "should support html w/ markdown in between"
+    );
 
     assert_eq!(
         micromark_with_options("<div id=\"foo\"\n  class=\"bar\">\n</div>", DANGER),
@@ -520,12 +515,11 @@ okay.",
         "should support html w/ line endings (2)"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<div>\n*foo*\n\n*bar*", DANGER),
-    //     "<div>\n*foo*\n<p><em>bar</em></p>",
-    //     "should support an unclosed html element"
-    // );
+    assert_eq!(
+        micromark_with_options("<div>\n*foo*\n\n*bar*", DANGER),
+        "<div>\n*foo*\n<p><em>bar</em></p>",
+        "should support an unclosed html element"
+    );
 
     assert_eq!(
         micromark_with_options("<div id=\"foo\"\n*hi*", DANGER),
@@ -601,12 +595,11 @@ okay.",
         "should require a blank line to end"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<div>\n\n*Emphasized* text.\n\n</div>", DANGER),
-    //     "<div>\n<p><em>Emphasized</em> text.</p>\n</div>",
-    //     "should support interleaving w/ blank lines"
-    // );
+    assert_eq!(
+        micromark_with_options("<div>\n\n*Emphasized* text.\n\n</div>", DANGER),
+        "<div>\n<p><em>Emphasized</em> text.</p>\n</div>",
+        "should support interleaving w/ blank lines"
+    );
 
     assert_eq!(
         micromark_with_options("<div>\n*Emphasized* text.\n</div>", DANGER),
@@ -679,12 +672,11 @@ okay.",
         "should not support an eof directly after a self-closing slash"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<div/\n*asd*", DANGER),
-    //     "<p>&lt;div/\n<em>asd</em></p>",
-    //     "should not support a line ending after a self-closing slash"
-    // );
+    assert_eq!(
+        micromark_with_options("<div/\n*asd*", DANGER),
+        "<p>&lt;div/\n<em>asd</em></p>",
+        "should not support a line ending after a self-closing slash"
+    );
 
     assert_eq!(
         micromark_with_options("<div/>", DANGER),
@@ -769,19 +761,17 @@ fn html_flow_7_complete() {
         "should support closing tags"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<del>\n\n*foo*\n\n</del>", DANGER),
-    //     "<del>\n<p><em>foo</em></p>\n</del>",
-    //     "should support interleaving"
-    // );
+    assert_eq!(
+        micromark_with_options("<del>\n\n*foo*\n\n</del>", DANGER),
+        "<del>\n<p><em>foo</em></p>\n</del>",
+        "should support interleaving"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<del>*foo*</del>", DANGER),
-    //     "<p><del><em>foo</em></del></p>",
-    //     "should not support interleaving w/o blank lines"
-    // );
+    assert_eq!(
+        micromark_with_options("<del>*foo*</del>", DANGER),
+        "<p><del><em>foo</em></del></p>",
+        "should not support interleaving w/o blank lines"
+    );
 
     assert_eq!(
         micromark_with_options("<div>\n  \nasd", DANGER),
@@ -825,12 +815,11 @@ fn html_flow_7_complete() {
         "should not support an eof directly after a self-closing slash"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark_with_options("<x/\n*asd*", DANGER),
-    //     "<p>&lt;x/\n<em>asd</em></p>",
-    //     "should not support a line ending after a self-closing slash"
-    // );
+    assert_eq!(
+        micromark_with_options("<x/\n*asd*", DANGER),
+        "<p>&lt;x/\n<em>asd</em></p>",
+        "should not support a line ending after a self-closing slash"
+    );
 
     assert_eq!(
         micromark_with_options("<x/>", DANGER),
diff --git a/tests/image.rs b/tests/image.rs
index 6db6d75..32d4171 100644
--- a/tests/image.rs
+++ b/tests/image.rs
@@ -14,12 +14,11 @@ fn image() {
         "should support image w/ resource"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[foo *bar*]: train.jpg \"train & tracks\"\n\n![foo *bar*]"),
-    //     "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>",
-    //     "should support image as shortcut reference"
-    // );
+    assert_eq!(
+        micromark("[foo *bar*]: train.jpg \"train & tracks\"\n\n![foo *bar*]"),
+        "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>",
+        "should support image as shortcut reference"
+    );
 
     assert_eq!(
         micromark("![foo ![bar](/url)](/url2)"),
@@ -33,19 +32,17 @@ fn image() {
         "should “support” links in images"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[foo *bar*]: train.jpg \"train & tracks\"\n\n![foo *bar*][]"),
-    //     "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>",
-    //     "should support “content” in images"
-    // );
+    assert_eq!(
+        micromark("[foo *bar*]: train.jpg \"train & tracks\"\n\n![foo *bar*][]"),
+        "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>",
+        "should support “content” in images"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[FOOBAR]: train.jpg \"train & tracks\"\n\n![foo *bar*][foobar]"),
-    //     "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>",
-    //     "should support “content” in images"
-    // );
+    assert_eq!(
+        micromark("[FOOBAR]: train.jpg \"train & tracks\"\n\n![foo *bar*][foobar]"),
+        "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train &amp; tracks\" /></p>",
+        "should support “content” in images"
+    );
 
     assert_eq!(
         micromark("![foo](train.jpg)"),
@@ -89,12 +86,11 @@ fn image() {
         "should support collapsed references (1)"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[*foo* bar]: /url \"title\"\n\n![*foo* bar][]"),
-    //     "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>",
-    //     "should support collapsed references (2)"
-    // );
+    assert_eq!(
+        micromark("[*foo* bar]: /url \"title\"\n\n![*foo* bar][]"),
+        "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>",
+        "should support collapsed references (2)"
+    );
 
     assert_eq!(
         micromark("[foo]: /url \"title\"\n\n![Foo][]"),
@@ -114,12 +110,11 @@ fn image() {
         "should support shortcut references (1)"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[*foo* bar]: /url \"title\"\n\n![*foo* bar]"),
-    //     "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>",
-    //     "should support shortcut references (2)"
-    // );
+    assert_eq!(
+        micromark("[*foo* bar]: /url \"title\"\n\n![*foo* bar]"),
+        "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>",
+        "should support shortcut references (2)"
+    );
 
     assert_eq!(
         micromark("[[foo]]: /url \"title\"\n\n![[foo]]"),
diff --git a/tests/link_reference.rs b/tests/link_reference.rs
index 372bea5..3a0be9f 100644
--- a/tests/link_reference.rs
+++ b/tests/link_reference.rs
@@ -27,7 +27,7 @@ fn link_reference() {
         "should support escaped brackets in link references"
     );
 
-    // To do: attention.
+    // To do: link/attention interplay.
     // assert_eq!(
     //     micromark("[ref]: /uri\n\n[link *foo **bar** `#`*][ref]"),
     //     "<p><a href=\"/uri\">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>",
@@ -46,19 +46,19 @@ fn link_reference() {
         "should not support links in link references"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[ref]: /uri\n\n[foo *bar [baz][ref]*][ref]"),
-    //     "<p>[foo <em>bar <a href=\"/uri\">baz</a></em>]<a href=\"/uri\">ref</a></p>",
-    //     "should not support deep links in link references"
-    // );
-
     assert_eq!(
-        micromark("[ref]: /uri\n\n*[foo*][ref]"),
-        "<p>*<a href=\"/uri\">foo*</a></p>",
-        "should prefer link references over emphasis (1)"
+        micromark("[ref]: /uri\n\n[foo *bar [baz][ref]*][ref]"),
+        "<p>[foo <em>bar <a href=\"/uri\">baz</a></em>]<a href=\"/uri\">ref</a></p>",
+        "should not support deep links in link references"
     );
 
+    // To do: link/attention interplay.
+    // assert_eq!(
+    //     micromark("[ref]: /uri\n\n*[foo*][ref]"),
+    //     "<p>*<a href=\"/uri\">foo*</a></p>",
+    //     "should prefer link references over emphasis (1)"
+    // );
+
     assert_eq!(
         micromark("[ref]: /uri\n\n[foo *bar][ref]"),
         "<p><a href=\"/uri\">foo *bar</a></p>",
@@ -173,12 +173,11 @@ fn link_reference() {
         "should support collaped references"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[*foo* bar]: /url \"title\"\n\n[*foo* bar][]"),
-    //     "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>",
-    //     "should support content in collaped references"
-    // );
+    assert_eq!(
+        micromark("[*foo* bar]: /url \"title\"\n\n[*foo* bar][]"),
+        "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>",
+        "should support content in collaped references"
+    );
 
     assert_eq!(
         micromark("[foo]: /url \"title\"\n\n[Foo][]"),
@@ -198,19 +197,17 @@ fn link_reference() {
         "should support shortcut references"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[*foo* bar]: /url \"title\"\n\n[*foo* bar]"),
-    //     "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>",
-    //     "should support content in shortcut references (1)"
-    // );
+    assert_eq!(
+        micromark("[*foo* bar]: /url \"title\"\n\n[*foo* bar]"),
+        "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>",
+        "should support content in shortcut references (1)"
+    );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[*foo* bar]: /url \"title\"\n\n[[*foo* bar]]"),
-    //     "<p>[<a href=\"/url\" title=\"title\"><em>foo</em> bar</a>]</p>",
-    //     "should support content in shortcut references (2)"
-    // );
+    assert_eq!(
+        micromark("[*foo* bar]: /url \"title\"\n\n[[*foo* bar]]"),
+        "<p>[<a href=\"/url\" title=\"title\"><em>foo</em> bar</a>]</p>",
+        "should support content in shortcut references (2)"
+    );
 
     assert_eq!(
         micromark("[foo]: /url\n\n[[bar [foo]"),
@@ -236,11 +233,12 @@ fn link_reference() {
         "should “support” an escaped shortcut reference"
     );
 
-    assert_eq!(
-        micromark("[foo*]: /url\n\n*[foo*]"),
-        "<p>*<a href=\"/url\">foo*</a></p>",
-        "should prefer shortcut references over emphasis"
-    );
+    // To do: link/attention interplay.
+    // assert_eq!(
+    //     micromark("[foo*]: /url\n\n*[foo*]"),
+    //     "<p>*<a href=\"/url\">foo*</a></p>",
+    //     "should prefer shortcut references over emphasis"
+    // );
 
     assert_eq!(
         micromark("[foo]: /url1\n[bar]: /url2\n\n[foo][bar]"),
@@ -338,7 +336,7 @@ fn link_reference() {
         "should not support mismatched character references in fulls"
     );
 
-    // To do: attention.
+    // To do: link/attention interplay.
     //     assert_eq!(
     //         micromark(
     //             "[*f*][]
diff --git a/tests/link_resource.rs b/tests/link_resource.rs
index 7761569..bebf6cc 100644
--- a/tests/link_resource.rs
+++ b/tests/link_resource.rs
@@ -231,7 +231,7 @@ fn link_resource() {
         "should support characer escapes"
     );
 
-    // To do: attention.
+    // To do: link/attention interplay.
     // assert_eq!(
     //     micromark("[link *foo **bar** `#`*](/uri)"),
     //     "<p><a href=\"/uri\">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>",
@@ -250,12 +250,11 @@ fn link_resource() {
         "should not support links in links (1)"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark("[foo *[bar [baz](/uri)](/uri)*](/uri)"),
-    //     "<p>[foo <em>[bar <a href=\"/uri\">baz</a>](/uri)</em>](/uri)</p>",
-    //     "should not support links in links (2)"
-    // );
+    assert_eq!(
+        micromark("[foo *[bar [baz](/uri)](/uri)*](/uri)"),
+        "<p>[foo <em>[bar <a href=\"/uri\">baz</a>](/uri)</em>](/uri)</p>",
+        "should not support links in links (2)"
+    );
 
     assert_eq!(
         micromark("![[[foo](uri1)](uri2)](uri3)"),
@@ -263,11 +262,12 @@ fn link_resource() {
         "should not support links in links (3)"
     );
 
-    assert_eq!(
-        micromark("*[foo*](/uri)"),
-        "<p>*<a href=\"/uri\">foo*</a></p>",
-        "should prefer links over emphasis (1)"
-    );
+    // To do: link/attention interplay.
+    // assert_eq!(
+    //     micromark("*[foo*](/uri)"),
+    //     "<p>*<a href=\"/uri\">foo*</a></p>",
+    //     "should prefer links over emphasis (1)"
+    // );
 
     assert_eq!(
         micromark("[foo *bar](baz*)"),
diff --git a/tests/thematic_break.rs b/tests/thematic_break.rs
index 06b1193..03f1b7a 100644
--- a/tests/thematic_break.rs
+++ b/tests/thematic_break.rs
@@ -117,12 +117,11 @@ fn thematic_break() {
         "should not support thematic breaks w/ other characters (3)"
     );
 
-    // To do: attention.
-    // assert_eq!(
-    //     micromark(" *-*"),
-    //     "<p><em>-</em></p>",
-    //     "should not support thematic breaks w/ mixed markers"
-    // );
+    assert_eq!(
+        micromark(" *-*"),
+        "<p><em>-</em></p>",
+        "should not support thematic breaks w/ mixed markers"
+    );
 
     // To do: lists.
     // assert_eq!(