gitlab-glfm-markdown 0.0.37 → 0.0.39

data/ext/{glfm_markdown → gitlab_glfm_markdown}/src/formatter.rs

@@ -1,104 +1,99 @@
 use std::fmt::{self, Write};
+use std::sync::LazyLock;
 
-use comrak::html::{render_sourcepos, ChildRendering, Context};
-use comrak::nodes::{AstNode, ListType, NodeValue};
-use comrak::{create_formatter, html};
-use lazy_static::lazy_static;
+use comrak::html::{collect_text, format_node_default, render_sourcepos, ChildRendering, Context};
+use comrak::nodes::{AstNode, ListType, NodeHeading, NodeLink, NodeList, NodeValue};
+use comrak::{create_formatter, html, node_matches};
 use regex::Regex;
 
-// TODO: Use std::sync:LazyLock once we're on 1.80+.
-// https://doc.rust-lang.org/std/sync/struct.LazyLock.html
-lazy_static! {
-    static ref PLACEHOLDER_REGEX: Regex = Regex::new(r"%(\{|%7B)(\w{1,30})(}|%7D)").unwrap();
-}
+use crate::glfm::RenderOptions;
+
+static PLACEHOLDER_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"%\{(?:\w{1,30})}").unwrap());
 
 pub struct RenderUserData {
     pub default_html: bool,
     pub inapplicable_tasks: bool,
     pub placeholder_detection: bool,
     pub only_escape_chars: Option<Vec<char>>,
-    pub debug: bool,
+    pub header_accessibility: bool,
+
+    last_heading: Option<String>,
+}
+
+impl From<&RenderOptions> for RenderUserData {
+    fn from(options: &RenderOptions) -> Self {
+        RenderUserData {
+            default_html: options.default_html,
+            inapplicable_tasks: options.inapplicable_tasks,
+            placeholder_detection: options.placeholder_detection,
+            only_escape_chars: options.only_escape_chars.clone(),
+            header_accessibility: options.header_accessibility,
+            last_heading: None,
+        }
+    }
 }
 
 // The important thing to remember is that this overrides the default behavior of the
 // specified nodes. If we do override a node, then it's our responsibility to ensure that
-// any changes in the `comrak` code for those nodes is backported to here, such as when
+// any changes in the Comrak code for those nodes is backported to here, such as when
 // `figcaption` support was added.
+//
 // One idea to limit that would be having the ability to specify attributes that would
 // be inserted when a node is rendered. That would allow us to (in many cases) just
-// inject the changes we need. Such a feature would need to be added to `comrak`.
+// inject the changes we need. Such a feature would need to be added to Comrak.
 create_formatter!(CustomFormatter<RenderUserData>, {
-    NodeValue::Text(_) => |context, node, entering| {
-        return render_text(context, node, entering);
+    NodeValue::Text(ref literal) => |context, node, entering| {
+        return render_text(context, node, entering, literal);
     },
-    NodeValue::Link(_) => |context, node, entering| {
-        return render_link(context, node, entering);
+    NodeValue::Link(ref nl) => |context, node, entering| {
+        return render_link(context, node, entering, nl);
     },
-    NodeValue::Image(_) => |context, node, entering| {
-        return render_image(context, node, entering);
+    NodeValue::Image(ref nl) => |context, node, entering| {
+        return render_image(context, node, entering, nl);
     },
-    NodeValue::List(_) => |context, node, entering| {
-        return render_list(context, node, entering);
+    NodeValue::List(ref nl) => |context, node, entering| {
+        return render_list(context, node, entering, nl);
     },
-    NodeValue::TaskItem(_) => |context, node, entering| {
-        return render_task_item(context, node, entering);
+    NodeValue::TaskItem(symbol) => |context, node, entering| {
+        return render_task_item(context, node, entering, symbol);
     },
     NodeValue::Escaped => |context, node, entering| {
         return render_escaped(context, node, entering);
     },
+    NodeValue::Heading(ref nh) => |context, node, entering| {
+        return render_heading(context, node, entering, nh);
+    },
 });
 
-fn render_image<'a>(
+fn render_text<'a>(
     context: &mut Context<RenderUserData>,
     node: &'a AstNode<'a>,
     entering: bool,
+    literal: &str,
 ) -> Result<ChildRendering, fmt::Error> {
-    let NodeValue::Image(ref nl) = node.data.borrow().value else {
-        unreachable!()
-    };
-
-    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(&nl.url)) {
+    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(literal)) {
         return html::format_node_default(context, node, entering);
     }
 
     if entering {
-        if context.options.render.figure_with_caption {
-            context.write_str("<figure>")?;
-        }
-        context.write_str("<img")?;
-        html::render_sourcepos(context, node)?;
-        context.write_str(" src=\"")?;
-        if context.options.render.unsafe_ || !html::dangerous_url(&nl.url) {
-            if let Some(rewriter) = &context.options.extension.image_url_rewriter {
-                context.escape_href(&rewriter.to_html(&nl.url))?;
-            } else {
-                context.escape_href(&nl.url)?;
+        let mut cursor: usize = 0;
+
+        for mat in PLACEHOLDER_REGEX.find_iter(literal) {
+            if mat.start() > cursor {
+                context.escape(&literal[cursor..mat.start()])?;
             }
-        }
 
-        context.write_str("\"")?;
+            context.write_str("<span data-placeholder>")?;
+            context.escape(&literal[mat.start()..mat.end()])?;
+            context.write_str("</span>")?;
 
-        if PLACEHOLDER_REGEX.is_match(&nl.url) {
-            context.write_str(" data-placeholder")?;
+            cursor = mat.end();
         }
 
-        context.write_str(" alt=\"")?;
-
-        return Ok(ChildRendering::Plain);
-    } else {
-        if !nl.title.is_empty() {
-            context.write_str("\" title=\"")?;
-            context.escape(&nl.title)?;
+        if cursor < literal.len() {
+            context.escape(&literal[cursor..])?;
         }
-        context.write_str("\" />")?;
-        if context.options.render.figure_with_caption {
-            if !nl.title.is_empty() {
-                context.write_str("<figcaption>")?;
-                context.escape(&nl.title)?;
-                context.write_str("</figcaption>")?;
-            }
-            context.write_str("</figure>")?;
-        };
     }
 
     Ok(ChildRendering::HTML)
@@ -108,11 +103,8 @@ fn render_link<'a>(
     context: &mut Context<RenderUserData>,
     node: &'a AstNode<'a>,
     entering: bool,
+    nl: &NodeLink,
 ) -> Result<ChildRendering, fmt::Error> {
-    let NodeValue::Link(ref nl) = node.data.borrow().value else {
-        unreachable!()
-    };
-
     if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(&nl.url)) {
         return html::format_node_default(context, node, entering);
     }
@@ -130,7 +122,7 @@ fn render_link<'a>(
             context.write_str("<a")?;
             html::render_sourcepos(context, node)?;
             context.write_str(" href=\"")?;
-            if context.options.render.unsafe_ || !html::dangerous_url(&nl.url) {
+            if context.options.render.r#unsafe || !html::dangerous_url(&nl.url) {
                 if let Some(rewriter) = &context.options.extension.link_url_rewriter {
                     context.escape_href(&rewriter.to_html(&nl.url))?;
                 } else {
@@ -144,9 +136,8 @@ fn render_link<'a>(
                 context.escape(&nl.title)?;
             }
 
-            if PLACEHOLDER_REGEX.is_match(&nl.url) {
-                context.write_str(" data-placeholder")?;
-            }
+            // This path only taken if placeholder detection is enabled, and the regex matched.
+            context.write_str(" data-placeholder")?;
 
             context.write_str(">")?;
         } else {
@@ -157,21 +148,70 @@ fn render_link<'a>(
     Ok(ChildRendering::HTML)
 }
 
+fn render_image<'a>(
+    context: &mut Context<RenderUserData>,
+    node: &'a AstNode<'a>,
+    entering: bool,
+    nl: &NodeLink,
+) -> Result<ChildRendering, fmt::Error> {
+    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(&nl.url)) {
+        return html::format_node_default(context, node, entering);
+    }
+
+    if entering {
+        if context.options.render.figure_with_caption {
+            context.write_str("<figure>")?;
+        }
+        context.write_str("<img")?;
+        html::render_sourcepos(context, node)?;
+        context.write_str(" src=\"")?;
+        if context.options.render.r#unsafe || !html::dangerous_url(&nl.url) {
+            if let Some(rewriter) = &context.options.extension.image_url_rewriter {
+                context.escape_href(&rewriter.to_html(&nl.url))?;
+            } else {
+                context.escape_href(&nl.url)?;
+            }
+        }
+
+        context.write_str("\"")?;
+
+        // This path only taken if placeholder detection is enabled, and the regex matched.
+        context.write_str(" data-placeholder")?;
+
+        context.write_str(" alt=\"")?;
+
+        return Ok(ChildRendering::Plain);
+    } else {
+        if !nl.title.is_empty() {
+            context.write_str("\" title=\"")?;
+            context.escape(&nl.title)?;
+        }
+        context.write_str("\" />")?;
+        if context.options.render.figure_with_caption {
+            if !nl.title.is_empty() {
+                context.write_str("<figcaption>")?;
+                context.escape(&nl.title)?;
+                context.write_str("</figcaption>")?;
+            }
+            context.write_str("</figure>")?;
+        };
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
 // Overridden to use class `task-list` instead of `contains-task-list`
 // to align with GitLab class usage
 fn render_list<'a>(
     context: &mut Context<RenderUserData>,
     node: &'a AstNode<'a>,
     entering: bool,
+    nl: &NodeList,
 ) -> Result<ChildRendering, fmt::Error> {
     if !entering || !context.options.render.tasklist_classes {
         return html::format_node_default(context, node, entering);
     }
 
-    let NodeValue::List(ref nl) = node.data.borrow().value else {
-        unreachable!()
-    };
-
     context.cr()?;
     match nl.list_type {
         ListType::Bullet => {
@@ -204,143 +244,172 @@ fn render_task_item<'a>(
     context: &mut Context<RenderUserData>,
     node: &'a AstNode<'a>,
     entering: bool,
+    symbol: Option<char>,
 ) -> Result<ChildRendering, fmt::Error> {
     if !context.user.inapplicable_tasks {
         return html::format_node_default(context, node, entering);
     }
 
-    let NodeValue::TaskItem(symbol) = node.data.borrow().value else {
-        unreachable!()
+    let Some(symbol) = symbol else {
+        return html::format_node_default(context, node, entering);
     };
 
-    if symbol.is_none() || matches!(symbol, Some('x' | 'X')) {
+    if symbol == 'x' || symbol == 'X' {
         return html::format_node_default(context, node, entering);
     }
 
+    // We only proceed past this point if:
+    //
+    // * inapplicable_tasks is enabled; and,
+    // * the symbol is present (the tasklist didn't contain a ' '), and isn't 'x' or 'X'.
+    //
+    // There are three possibilities remaining:
+    //
+    // * the symbol is '~': we write out an inapplicable task item.
+    // * the symbol is a different Unicode whitespace: we write out an incomplete task item,
+    //   per Comrak.
+    // * the symbol is something else: we write out the source Markdown that would've been entered,
+    //   to act like a non-match.
+    //
+    // TODO: have Comrak accept a list of acceptable tasklist symbols instead. :)
+
+    let write_li = node
+        .parent()
+        .map(|p| node_matches!(p, NodeValue::List(_)))
+        .unwrap_or_default();
+
     if entering {
-        // Handle an inapplicable task symbol.
-        if matches!(symbol, Some('~')) {
+        if symbol == '~' {
             context.cr()?;
-            context.write_str("<li")?;
-            context.write_str(" class=\"inapplicable")?;
+            if write_li {
+                context.write_str("<li")?;
+                context.write_str(" class=\"inapplicable")?;
 
-            if context.options.render.tasklist_classes {
-                context.write_str(" task-list-item")?;
+                if context.options.render.tasklist_classes {
+                    context.write_str(" task-list-item")?;
+                }
+                context.write_str("\"")?;
+                html::render_sourcepos(context, node)?;
+                context.write_str(">")?;
             }
-            context.write_str("\"")?;
-
-            html::render_sourcepos(context, node)?;
-            context.write_str(">")?;
             context.write_str("<input type=\"checkbox\"")?;
-
+            if !write_li {
+                html::render_sourcepos(context, node)?;
+            }
             if context.options.render.tasklist_classes {
                 context.write_str(" class=\"task-list-item-checkbox\"")?;
             }
 
             context.write_str(" data-inapplicable disabled=\"\"> ")?;
-        } else {
-            // Don't allow unsupported symbols to render a checkbox
+        } else if symbol.is_whitespace() {
             context.cr()?;
-            context.write_str("<li")?;
-
+            if write_li {
+                context.write_str("<li")?;
+                if context.options.render.tasklist_classes {
+                    context.write_str(" class=\"task-list-item\"")?;
+                }
+                render_sourcepos(context, node)?;
+                context.write_str(">")?;
+            }
+            context.write_str("<input type=\"checkbox\"")?;
+            if !write_li {
+                render_sourcepos(context, node)?;
+            }
             if context.options.render.tasklist_classes {
-                context.write_str(" class=\"task-list-item\"")?;
+                context.write_str(" class=\"task-list-item-checkbox\"")?;
+            }
+            context.write_str(" disabled=\"\" /> ")?;
+        } else {
+            context.cr()?;
+            if write_li {
+                context.write_str("<li")?;
+                if context.options.render.tasklist_classes {
+                    context.write_str(" class=\"task-list-item\"")?;
+                }
+                html::render_sourcepos(context, node)?;
+                context.write_str(">")?;
             }
-
-            html::render_sourcepos(context, node)?;
-            context.write_str(">")?;
             context.write_str("[")?;
-            context.escape(&symbol.unwrap().to_string())?;
+            context.escape(&symbol.to_string())?;
             context.write_str("] ")?;
         }
-    } else {
+    } else if write_li {
         context.write_str("</li>\n")?;
     }
 
     Ok(ChildRendering::HTML)
 }
 
-fn render_text<'a>(
+fn render_escaped<'a>(
     context: &mut Context<RenderUserData>,
     node: &'a AstNode<'a>,
     entering: bool,
 ) -> Result<ChildRendering, fmt::Error> {
-    let NodeValue::Text(ref literal) = node.data.borrow().value else {
-        unreachable!()
-    };
-
-    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(literal)) {
-        return html::format_node_default(context, node, entering);
-    }
-
-    // Don't currently support placeholders in the text inside links or images.
-    // If the text has an underscore in it, then the parser will not combine
-    // the multiple text nodes in `comrak`'s `postprocess_text_nodes`, breaking up
-    // the placeholder into multiple text nodes.
-    // For example, `[%{a_b}](link)`.
-    let parent = node.parent().unwrap();
-    if matches!(
-        parent.data.borrow().value,
-        NodeValue::Link(_) | NodeValue::Image(_)
-    ) {
-        return html::format_node_default(context, node, entering);
+    if !context.options.render.escaped_char_spans {
+        return Ok(ChildRendering::HTML);
     }
 
-    if entering {
-        let mut cursor: usize = 0;
-
-        for mat in PLACEHOLDER_REGEX.find_iter(literal) {
-            if mat.start() > cursor {
-                context.escape(&literal[cursor..mat.start()])?;
-            }
-
-            context.write_str("<span data-placeholder>")?;
-            context.escape(&literal[mat.start()..mat.end()])?;
+    if context
+        .user
+        .only_escape_chars
+        .as_ref()
+        .map_or(true, |only_escape_chars| {
+            with_node_text_content(node, false, |content| {
+                content.chars().count() == 1
+                    && only_escape_chars.contains(&content.chars().next().unwrap())
+            })
+        })
+    {
+        if entering {
+            context.write_str("<span data-escaped-char")?;
+            render_sourcepos(context, node)?;
+            context.write_str(">")?;
+        } else {
             context.write_str("</span>")?;
-
-            cursor = mat.end();
-        }
-
-        if cursor < literal.len() {
-            context.escape(&literal[cursor..literal.len()])?;
         }
     }
 
     Ok(ChildRendering::HTML)
 }
 
-fn render_escaped<'a>(
+fn render_heading<'a>(
     context: &mut Context<RenderUserData>,
     node: &'a AstNode<'a>,
     entering: bool,
+    nh: &NodeHeading,
 ) -> Result<ChildRendering, fmt::Error> {
-    if !context.options.render.escaped_char_spans {
-        return Ok(ChildRendering::HTML);
+    if !context.user.header_accessibility || context.plugins.render.heading_adapter.is_some() {
+        return format_node_default(context, node, entering);
     }
 
-    if context.user.only_escape_chars.is_none()
-        || with_node_text_content(node, false, |content| {
-            if content.len() != 1 {
-                return false;
-            }
-            let c = content.chars().next().unwrap();
-            context
-                .user
-                .only_escape_chars
-                .as_ref()
-                .unwrap()
-                .contains(&c)
-        })
-    {
-        if entering {
-            context.write_str("<span data-escaped-char")?;
-            render_sourcepos(context, node)?;
-            context.write_str(">")?;
-        } else {
-            context.write_str("</span>")?;
+    if entering {
+        context.cr()?;
+        write!(context, "<h{}", nh.level)?;
+
+        if let Some(ref prefix) = context.options.extension.header_ids {
+            let text_content = collect_text(node);
+            let id = context.anchorizer.anchorize(&text_content);
+            write!(context, r##" id="{prefix}{id}""##)?;
+            context.user.last_heading = Some(id);
         }
-    }
 
+        render_sourcepos(context, node)?;
+        context.write_str(">")?;
+    } else {
+        if context.options.extension.header_ids.is_some() {
+            let id = context.user.last_heading.take().unwrap();
+            let text_content = collect_text(node);
+            write!(
+                context,
+                r##"<a href="#{id}" aria-label="Link to heading '"##
+            )?;
+            context.escape(&text_content)?;
+            context.write_str(r#"'" data-heading-content=""#)?;
+            context.escape(&text_content)?;
+            context.write_str(r#"" class="anchor"></a>"#)?;
+        }
+        writeln!(context, "</h{}>", nh.level)?;
+    }
     Ok(ChildRendering::HTML)
 }
 

data/ext/{glfm_markdown → gitlab_glfm_markdown}/src/glfm.rs

@@ -1,4 +1,5 @@
-use comrak::{parse_document, Arena, Plugins};
+use comrak::options::Plugins;
+use comrak::{parse_document, Arena};
 use serde::Deserialize;
 
 use crate::formatter::{CustomFormatter, RenderUserData};
@@ -9,6 +10,8 @@ pub struct RenderOptions {
     pub alerts: bool,
     pub autolink: bool,
     pub cjk_friendly_emphasis: bool,
+    /// Only use default comrak HTML formatting
+    pub default_html: bool,
     // pub default_info_string: String,
     pub description_lists: bool,
     pub escape: bool,
@@ -22,16 +25,27 @@ pub struct RenderOptions {
     pub github_pre_lang: bool,
     pub greentext: bool,
     pub hardbreaks: bool,
+    /// Use new header/anchor combination in HTML output, per
+    /// https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/merge_requests/112.
+    pub header_accessibility: bool,
     pub header_ids: Option<String>,
     pub ignore_empty_links: bool,
     pub ignore_setext: bool,
+    /// Detect inapplicable tasks (`- [~]`)
+    pub inapplicable_tasks: bool,
     pub math_code: bool,
     pub math_dollars: bool,
     pub multiline_block_quotes: bool,
+    /// When the 'escaped_char_spans' render option is enabled, only emit `<span
+    /// data-escaped-char>` around the given characters.
+    pub only_escape_chars: Option<Vec<char>>,
+    /// Detect and mark potential placeholder variables, which
+    /// have the format `%{PLACEHOLDER}`
+    pub placeholder_detection: bool,
     pub relaxed_autolinks: bool,
     pub relaxed_tasklist_character: bool,
-    pub sourcepos: bool,
     pub smart: bool,
+    pub sourcepos: bool,
     pub spoiler: bool,
     pub strikethrough: bool,
     pub subscript: bool,
@@ -41,40 +55,11 @@ pub struct RenderOptions {
     pub tagfilter: bool,
     pub tasklist: bool,
     pub tasklist_classes: bool,
+    pub tasklist_in_table: bool,
     pub underline: bool,
     pub r#unsafe: bool,
     pub wikilinks_title_after_pipe: bool,
     pub wikilinks_title_before_pipe: bool,
-
-    /// GLFM specific options
-
-    /// Only use default comrak HTML formatting
-    pub default_html: bool,
-
-    /// Detect inapplicable tasks (`- [~]`)
-    pub inapplicable_tasks: bool,
-
-    /// Detect and mark potential placeholder variables, which
-    /// have the format `%{PLACEHOLDER}`
-    pub placeholder_detection: bool,
-
-    /// When the 'escaped_char_spans' render option is enabled, only emit `<span
-    /// data-escaped-char>` around the given characters.
-    pub only_escape_chars: Option<Vec<char>>,
-
-    pub debug: bool,
-}
-
-impl From<&RenderOptions> for RenderUserData {
-    fn from(options: &RenderOptions) -> Self {
-        RenderUserData {
-            default_html: options.default_html,
-            inapplicable_tasks: options.inapplicable_tasks,
-            placeholder_detection: options.placeholder_detection,
-            only_escape_chars: options.only_escape_chars.clone(),
-            debug: options.debug,
-        }
-    }
 }
 
 impl From<&RenderOptions> for comrak::Options<'_> {
@@ -112,24 +97,25 @@ impl From<&RenderOptions> for comrak::Options<'_> {
         comrak_options.render.github_pre_lang = options.github_pre_lang;
         comrak_options.render.hardbreaks = options.hardbreaks;
         comrak_options.render.ignore_empty_links = options.ignore_empty_links;
-        comrak_options.render.ignore_setext = options.ignore_setext;
         comrak_options.render.sourcepos = options.sourcepos;
         comrak_options.render.tasklist_classes = options.tasklist_classes;
         // comrak_options.render.syntax_highlighting = options.syntax_highlighting;
 
-        comrak_options.render.unsafe_ = options.r#unsafe;
+        comrak_options.render.r#unsafe = options.r#unsafe;
 
         // comrak_options.parse.default_info_string = options.default_info_string;
+        comrak_options.parse.ignore_setext = options.ignore_setext;
         comrak_options.parse.relaxed_autolinks = options.relaxed_autolinks;
         comrak_options.parse.relaxed_tasklist_matching = options.relaxed_tasklist_character;
         comrak_options.parse.smart = options.smart;
+        comrak_options.parse.tasklist_in_table = options.tasklist_in_table;
 
         comrak_options
     }
 }
 
 pub fn render(text: &str, options: &RenderOptions) -> String {
-    render_with_plugins(text, options, &comrak::Plugins::default())
+    render_with_plugins(text, options, &Plugins::default())
 }
 
 fn render_with_plugins(text: &str, render_options: &RenderOptions, plugins: &Plugins) -> String {

data/ext/{glfm_markdown → gitlab_glfm_markdown}/src/lib.rs

@@ -1,13 +1,13 @@
 use comrak::{escape_commonmark_inline, escape_commonmark_link_destination};
-use magnus::{define_module, function, prelude::*, Error, RHash, RString};
+use magnus::{function, prelude::*, Error, RHash, RString, Ruby};
 use serde_magnus::deserialize;
 
 mod formatter;
 mod glfm;
 use glfm::{render, RenderOptions};
 
-pub fn render_to_html_rs(text: RString, options: RHash) -> Result<String, Error> {
-    let render_options: RenderOptions = deserialize(options)?;
+pub fn render_to_html_rs(ruby: &Ruby, text: RString, options: RHash) -> Result<String, Error> {
+    let render_options: RenderOptions = deserialize(ruby, options)?;
 
     // SAFETY: `RString::as_str` returns a reference directly to Ruby memory.
     // We do not hold onto or save the `&str`, or otherwise permit Ruby to GC or
@@ -35,8 +35,8 @@ pub fn escape_commonmark_link_destination_rs(text: RString) -> Result<String, Er
 }
 
 #[magnus::init]
-fn init() -> Result<(), Error> {
-    let module = define_module("GLFMMarkdown")?;
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("GLFMMarkdown")?;
 
     module.define_singleton_method("render_to_html_rs", function!(render_to_html_rs, 2))?;
     module.define_singleton_method(