Adding support for subscript, highlighted and underlined text

README.md

@@ -94,7 +94,7 @@ Options:
           Multiple extensions can be delimited with ",", e.g. --extension strikethrough,table
 
           [possible values: strikethrough, tagfilter, table, autolink, tasklist, superscript,
-          footnotes, description-lists]
+          footnotes, description-lists, subscript, highlight]
 
   -t, --to <FORMAT>
           Specify output format
@@ -222,6 +222,8 @@ Comrak additionally supports its own extensions, which are yet to be specced out
 - Description lists
 - Front matter
 - Shortcodes
+- Subscript
+- Highlight
 
 By default none are enabled; they are individually enabled with each parse by setting the appropriate values in the
 [`ComrakOptions` struct](https://docs.rs/comrak/newest/comrak/struct.ComrakOptions.html).

src/cm.rs

@@ -359,6 +359,8 @@ impl<'a, 'o> CommonMarkFormatter<'a, 'o> {
             NodeValue::FootnoteReference(ref r) => {
                 self.format_footnote_reference(r.as_bytes(), entering)
             }
+            NodeValue::Subscript => self.format_subscript(),
+            NodeValue::Highlight => self.format_highlight(),
         };
         true
     }
@@ -631,13 +633,21 @@ impl<'a, 'o> CommonMarkFormatter<'a, 'o> {
     }
 
     fn format_strikethrough(&mut self) {
-        write!(self, "~").unwrap();
+        write!(self, "~~").unwrap();
     }
 
     fn format_superscript(&mut self) {
         write!(self, "^").unwrap();
     }
 
+    fn format_subscript(&mut self) {
+        write!(self, "~").unwrap();
+    }
+
+    fn format_highlight(&mut self) {
+        write!(self, "==").unwrap();
+    }
+
     fn format_link(&mut self, node: &'a AstNode<'a>, nl: &NodeLink, entering: bool) -> bool {
         if is_autolink(node, nl) {
             if entering {

src/html.rs

@@ -979,6 +979,24 @@ impl<'o> HtmlFormatter<'o> {
                     self.output.write_all(b"</li>\n")?;
                 }
             }
+            NodeValue::Subscript => {
+                if entering {
+                    self.output.write_all(b"<sub")?;
+                    self.render_sourcepos(node)?;
+                    self.output.write_all(b">")?;
+                } else {
+                    self.output.write_all(b"</sub>")?;
+                }
+            }
+            NodeValue::Highlight => {
+                if entering {
+                    self.output.write_all(b"<mark")?;
+                    self.render_sourcepos(node)?;
+                    self.output.write_all(b">")?;
+                } else {
+                    self.output.write_all(b"</mark>")?;
+                }
+            }
         }
         Ok(false)
     }

src/main.rs

@@ -142,6 +142,8 @@ enum Extension {
     Superscript,
     Footnotes,
     DescriptionLists,
+    Subscript,
+    Highlight
 }
 
 #[derive(Clone, Copy, Debug, ValueEnum)]
@@ -209,6 +211,8 @@ fn main() -> Result<(), Box<dyn Error>> {
             front_matter_delimiter: cli.front_matter_delimiter,
             #[cfg(feature = "shortcodes")]
             shortcodes: cli.gemojis,
+            subscript: exts.contains(&Extension::Subscript),
+            highlight: exts.contains(&Extension::Highlight)
         },
         parse: ComrakParseOptions {
             smart: cli.smart,

src/nodes.rs

@@ -135,7 +135,7 @@ pub enum NodeValue {
     /// per the GFM spec.
     Strikethrough,
 
-    /// **Inline**.  Superscript.  Enabled with `ext_superscript` option.
+    /// **Inline**.  Superscript.
     Superscript,
 
     /// **Inline**.  A [link](https://github.github.com/gfm/#links) to some URL, with possible
@@ -151,6 +151,12 @@ pub enum NodeValue {
     #[cfg(feature = "shortcodes")]
     /// **Inline**. An Emoji character generated from a shortcode. Enable with feature "shortcodes".
     ShortCode(NodeShortCode),
+
+    /// **Inline**.  Supscript.
+    Subscript,
+
+    /// **Inline**.  Highlight.
+    Highlight,
 }
 
 /// Alignment of a single table cell.
@@ -425,6 +431,8 @@ impl NodeValue {
             NodeValue::FootnoteReference(_) => "footnote_reference",
             #[cfg(feature = "shortcodes")]
             NodeValue::ShortCode(_) => "shortcode",
+            NodeValue::Subscript => "subscript",
+            NodeValue::Highlight => "highlight"
         }
     }
 }

src/parser/inlines.rs

@@ -145,13 +145,20 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
             s.special_chars[b'~' as usize] = true;
             s.skip_chars[b'~' as usize] = true;
         }
+        if options.extension.subscript {
+            s.special_chars[b'~' as usize] = true;
+        }
         if options.extension.superscript {
             s.special_chars[b'^' as usize] = true;
         }
         #[cfg(feature = "shortcodes")]
         if options.extension.shortcodes {
             s.special_chars[b':' as usize] = true;
         }
+        if options.extension.highlight {
+            s.special_chars[b'=' as usize] = true;
+            s.skip_chars[b'=' as usize] = true;
+        }
         for &c in &[b'"', b'\'', b'.', b'-'] {
             s.smart_chars[c as usize] = true;
         }
@@ -210,10 +217,9 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
                     ))
                 }
             }
-            '~' if self.options.extension.strikethrough => Some(self.handle_delim(b'~')),
-            '^' if self.options.extension.superscript && !self.within_brackets => {
-                Some(self.handle_delim(b'^'))
-            }
+            '~' if (self.options.extension.subscript && !self.within_brackets) || self.options.extension.strikethrough => Some(self.handle_delim(b'~')),
+            '^' if self.options.extension.superscript && !self.within_brackets => Some(self.handle_delim(b'^')),
+            '=' if self.options.extension.highlight => Some(self.handle_delim(b'=')),
             _ => {
                 let endpos = self.find_special_char();
                 let mut contents = self.input[self.pos..endpos].to_vec();
@@ -337,10 +343,11 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
                 let ix = match c.delim_char {
                     b'~' => 0,
                     b'^' => 1,
-                    b'"' => 2,
-                    b'\'' => 3,
-                    b'_' => 4,
-                    b'*' => 5 + (if c.can_open { 3 } else { 0 }) + (c.length % 3),
+                    b'=' => 2,
+                    b'"' => 3,
+                    b'\'' => 4,
+                    b'_' => 5,
+                    b'*' => 6 + (if c.can_open { 2 } else { 0 }) + (c.length % 3),
                     _ => unreachable!(),
                 };
 
@@ -387,8 +394,9 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
                 // both get passed.
                 if c.delim_char == b'*'
                     || c.delim_char == b'_'
-                    || (self.options.extension.strikethrough && c.delim_char == b'~')
+                    || ((self.options.extension.strikethrough || self.options.extension.subscript) && c.delim_char == b'~')
                     || (self.options.extension.superscript && c.delim_char == b'^')
+                    || (self.options.extension.highlight && c.delim_char == b'=')
                 {
                     if opener_found {
                         // Finally, here's the happy case where the delimiters
@@ -837,13 +845,6 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
         opener_num_chars -= use_delims;
         closer_num_chars -= use_delims;
 
-        if self.options.extension.strikethrough
-            && opener_char == b'~'
-            && (opener_num_chars != closer_num_chars || opener_num_chars > 0)
-        {
-            return None;
-        }
-
         opener
             .inl
             .data
@@ -870,9 +871,13 @@ impl<'a, 'r, 'o, 'd, 'i, 'c, 'subj> Subject<'a, 'r, 'o, 'd, 'i, 'c, 'subj> {
         }
 
         let emph = self.make_inline(
-            if self.options.extension.strikethrough && opener_char == b'~' {
+            if self.options.extension.highlight && opener_char == b'=' && use_delims == 2 {
+                NodeValue::Highlight
+            } else if self.options.extension.strikethrough && opener_char == b'~' && use_delims == 2 {
                 NodeValue::Strikethrough
-            } else if self.options.extension.superscript && opener_char == b'^' {
+            } else if self.options.extension.subscript && opener_char == b'~' && use_delims == 1 {
+                NodeValue::Subscript
+            } else if self.options.extension.superscript && opener_char == b'^' && use_delims == 1 {
                 NodeValue::Superscript
             } else if use_delims == 1 {
                 NodeValue::Emph

src/parser/mod.rs

@@ -343,6 +343,28 @@ pub struct ComrakExtensionOptions {
     ///            "<p>Happy Friday! 😄</p>\n");
     /// ```
     pub shortcodes: bool,
+
+    /// Enables the subscript Comrak extension.
+    ///
+    /// ```
+    /// # use comrak::{markdown_to_html, ComrakOptions};
+    /// let mut options = ComrakOptions::default();
+    /// options.extension.subscript = true;
+    /// assert_eq!(markdown_to_html("Water is H~2~O.\n", &options),
+    ///            "<p><p>Water is H<sup>2</sup>O.</p></p>\n");
+    /// ```
+    pub subscript: bool,
+
+    /// Enables the highlight Comrak extension.
+    ///
+    /// ```
+    /// # use comrak::{markdown_to_html, ComrakOptions};
+    /// let mut options = ComrakOptions::default();
+    /// options.extension.highlight = true;
+    /// assert_eq!(markdown_to_html("This is an ==important== word.\n", &options),
+    ///            "<p>This is an <mark>important</mark> word.</p>\n");
+    /// ```
+    pub highlight: bool,
 }
 
 #[derive(Default, Debug, Clone)]

src/tests.rs

@@ -11,12 +11,14 @@ mod description_lists;
 mod footnotes;
 mod fuzz;
 mod header_ids;
+mod highlight;
 mod options;
 mod plugins;
 mod propfuzz;
 mod regressions;
 mod shortcodes;
 mod strikethrough;
+mod subscript;
 mod superscript;
 mod table;
 mod tagfilter;

src/tests/api.rs

@@ -48,6 +48,8 @@ fn exercise_full_api() {
             front_matter_delimiter: None,
             #[cfg(feature = "shortcodes")]
             shortcodes: true,
+            highlight: false,
+            subscript: false
         },
         parse: ComrakParseOptions {
             smart: false,
@@ -210,5 +212,7 @@ fn exercise_full_api() {
         nodes::NodeValue::FootnoteReference(name) => {
             let _: &String = name;
         }
+        nodes::NodeValue::Subscript => {}
+        nodes::NodeValue::Highlight => {}
     }
 }

src/tests/highlight.rs

@@ -0,0 +1,10 @@
+use super::*;
+
+#[test]
+fn highlight() {
+    html_opts!(
+        [extension.highlight],
+        concat!("This is an ==important== word.\n"),
+        concat!("<p>This is an <mark>important</mark> word.</p>\n"),
+    );
+}

src/tests/propfuzz.rs

@@ -20,6 +20,8 @@ fn propfuzz_doesnt_crash(md: String) {
             front_matter_delimiter: None,
             #[cfg(feature = "shortcodes")]
             shortcodes: true,
+            highlight: true,
+            subscript: true
         },
         parse: ComrakParseOptions {
             smart: true,

src/tests/strikethrough.rs

@@ -5,7 +5,7 @@ fn strikethrough() {
     html_opts!(
         [extension.strikethrough],
         concat!(
-            "This is ~strikethrough~.\n",
+            "This is ~~strikethrough~~.\n",
             "\n",
             "As is ~~this, okay~~?\n"
         ),

src/tests/subscript.rs

@@ -0,0 +1,10 @@
+use super::*;
+
+#[test]
+fn subscript() {
+    html_opts!(
+        [extension.subscript],
+        concat!("Water is H~2~O.\n"),
+        concat!("<p>Water is H<sub>2</sub>O.</p>\n"),
+    );
+}

src/xml.rs

@@ -250,6 +250,9 @@ impl<'o> XmlFormatter<'o> {
                     self.escape(nsc.shortcode().as_bytes())?;
                     self.output.write_all(b"\"")?;
                 }
+
+                NodeValue::Subscript => {}
+                NodeValue::Highlight => {}
             }
 
             if node.first_child().is_some() {