gitlab-glfm-markdown 0.0.38 → 0.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1912c815b560bc967a5627e3d676a697a7bf3eec232168c6a8ba9cdc554eb300
-  data.tar.gz: 3b36fb9b1f40453638d3ce053354dd9b047103d4c1d2e7be91f3e47a5961702e
+  metadata.gz: 958f895a64867a4cf0facd03a03f363398263613493019627df9ed9481dc0d74
+  data.tar.gz: c180c4b058f5c823b2dc00ad32bf63de261a070cba034326d0f29e1131ea6f53
 SHA512:
-  metadata.gz: 741e900eb21ba3f4035c4670febadfb7311b443f20b1cc1ccc6f5782b57158eb4a6fc623525a91c727cf4eafb0ac0ec004388efc4896ee6765c1591693dbb05b
-  data.tar.gz: '07567018fcd25a9448575f6cd2e164a9b4df7e0742c10e3d5c897d012765dfdf80ef5aed7a6b27b87f38f749ab94d2ce547e7345cd57381d1d59ae3dfc156560'
+  metadata.gz: f1887cab2213baf059cf86655333308a4cd021bed71438a16c32f6a234dde93c29cc0b87522bc6057d6f87acf4150634c712f98ce273032845a90899c6a4806f
+  data.tar.gz: e7c2789aa86e38930c55d9d31520d947bee79cb093338213259d0820b8015abe1d3419ba1ce282af35495ca73fa66846745f983fec574921d97b301f725d9b7a

data/Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "adler2"
@@ -221,9 +221,9 @@ checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
 name = "comrak"
-version = "0.46.0"
+version = "0.49.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc151d9c800c4fadd542c949b84c1dae6d1b424315ebcfd154e611d4f7910a97"
+checksum = "ab87129dce2f2d7e75e753b1df0e5093b27dec8fa5970b6eb51280faacb25bd6"
 dependencies = [
  "caseless",
  "emojis",
@@ -306,8 +306,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
-name = "glfm_markdown"
-version = "0.0.38"
+name = "gitlab-glfm-markdown"
+version = "0.0.40"
 dependencies = [
  "clap",
  "comrak",

data/README.md

@@ -4,7 +4,7 @@
 [![Latest Release](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/badges/release.svg)](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/releases)
 
 Implements GLFM (as used by GitLab) using the Rust-based Markdown parser
-[Comrak](https://github.com/kivikakk/comrak) (0.46.0), providing a Ruby interface.
+[Comrak](https://github.com/kivikakk/comrak) (0.49.0), providing a Ruby interface.
 
 This project is still in constant flux, so interfaces and functionality can change at any time.
 
@@ -26,7 +26,7 @@ Try on command line:
 rake compile
 bin/console
 
-require 'glfm_markdown'
+require 'gitlab-glfm-markdown'
 
 GLFMMarkdown.to_html('# header', options: { sourcepos: true })
 ```
@@ -37,9 +37,10 @@ GLFMMarkdown.to_html('# header', options: { sourcepos: true })
 |-------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `autolink`                    | Enable the `autolink` extension                                                                                                                                             |
 | `cjk_friendly_emphasis`       | Enable the [`cjk_friendly_emphasis` extension](https://github.com/tats-u/markdown-cjk-friendly)                                                                             |
+| `default_html`                | Disables any custom HTML, and returns default HTML from `comrak`                                                                                                            |
 | `description_lists`           | Enable the `description-lists` extension                                                                                                                                    |
-| `escape`                      | Escape raw HTML instead of clobbering it                                                                                                                                    |
 | `escape_char_spans`           | Wrap escaped characters in a `<span>` to allow any post-processing to recognize them                                                                                        |
+| `escape`                      | Escape raw HTML instead of clobbering it                                                                                                                                    |
 | `figure_with_caption`         | Render the image as a figure element with the title as its caption                                                                                                          |
 | `footnotes`                   | Enable the `footnotes` extension                                                                                                                                            |
 | `full_info_string`            | Enable full info strings for code blocks                                                                                                                                    |
@@ -48,6 +49,7 @@ GLFMMarkdown.to_html('# header', options: { sourcepos: true })
 | `github_pre_lang`             | Use GitHub-style `<pre lang>` for code blocks                                                                                                                               |
 | `greentext`                   | Enable the `greentext` extension - requires at least one space after a `>` character to generate a blockquote, and restarts blockquote nesting across unique lines of input |
 | `hardbreaks`                  | Treat newlines as hard line breaks                                                                                                                                          |
+| `header_accessibility`        | Use new header/anchor combination in HTML output, per [!112](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/merge_requests/112).                            |
 | `header_ids <PREFIX>`         | Enable the `header-id` extension, with the given ID prefix                                                                                                                  |
 | `ignore_empty_links`          | Ignore empty links in input                                                                                                                                                 |
 | `ignore_setext`               | Ignore setext headings in input                                                                                                                                             |
@@ -55,24 +57,24 @@ GLFMMarkdown.to_html('# header', options: { sourcepos: true })
 | `math_code`                   | Enables `math code` extension, using math code syntax                                                                                                                       |
 | `math_dollars`                | Enables `math dollars` extension, using math dollar syntax                                                                                                                  |
 | `multiline_block_quotes`      | Enable the `multiline-block-quotes` extension                                                                                                                               |
-| `default_html`                | Disables any custom HTML, and returns default HTML from `comrak`                                                                                                            |
+| `only_escape_chars <CHARS>`   | When the 'escaped_char_spans' render option is enabled, only emit `<span data-escaped-char>` around the given characters.                                                   |
 | `placeholder_detection`       | Detect placeholder variables in the format `%{placeholder}`                                                                                                                 |
 | `relaxed_autolinks`           | Enable relaxing of autolink parsing, allowing links to be recognized when in brackets, with any scheme, and with dot-less hostnames                                         |
 | `relaxed_tasklist_character`  | Enable relaxing which character is allowed in tasklists                                                                                                                     |
-| `sourcepos`                   | Include source mappings in HTML attributes                                                                                                                                  |
 | `smart`                       | Use smart punctuation                                                                                                                                                       |
+| `sourcepos`                   | Include source mappings in HTML attributes                                                                                                                                  |
 | `spoiler`                     | Enable the `spoiler` extension - use double vertical bars                                                                                                                   |
 | `strikethrough`               | Enable the `strikethrough` extension                                                                                                                                        |
 | `superscript`                 | Enable the `superscript` extension                                                                                                                                          |
 | `table`                       | Enable the `table` extension                                                                                                                                                |
 | `tagfilter`                   | Enable the `tagfilter` extension                                                                                                                                            |
-| `tasklist`                    | Enable the `tasklist` extension                                                                                                                                             |
 | `tasklist_classes`            | Output classes on tasklist elements so that they can be styled with CSS                                                                                                     |
+| `tasklist_in_table`           | Enables parsing tasklist items within tables when they're the only content of a table cell                                                                                  |
+| `tasklist`                    | Enable the `tasklist` extension                                                                                                                                             |
 | `underline`                   | Enables the `underline` extension - use double underscores                                                                                                                  |
 | `unsafe`                      | Allow raw HTML and dangerous URLs                                                                                                                                           |
 | `wikilinks_title_after_pipe`  | Enable the `wikilinks_title_after_pipe` extension                                                                                                                           |
 | `wikilinks_title_before_pipe` | Enable the `wikilinks_title_before_pipe` extension                                                                                                                          |
-| `debug`                       | Show debug information                                                                                                                                                      |
 
 ## Dingus / Demo
 
@@ -85,8 +87,8 @@ https://gitlab-org.gitlab.io/ruby/gems/gitlab-glfm-markdown
 A command line executable can be built for debugging.
 
 ```
-cargo run --bin glfm_markdown --features="cli" -- --help
-cargo run --bin glfm_markdown --features="cli" -- --sourcepos
+cargo run --bin gitlab-glfm-markdown --features="cli" -- --help
+cargo run --bin gitlab-glfm-markdown --features="cli" -- --sourcepos
 ```
 
 There is a VSCode workspace that allows you to `Debug executable`

data/ext/{glfm_markdown → gitlab_glfm_markdown}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "glfm_markdown"
-version = "0.0.38"
+name = "gitlab-glfm-markdown"
+version = "0.0.40"
 edition = "2021"
 authors = ["digitalmoksha <bwalker@gitlab.com>", "Asherah Connor <aconnor@gitlab.com>"]
 description = "GitLab Flavored Markdown parser and formatter. 100% CommonMark-compatible. Experimental."
@@ -10,12 +10,12 @@ publish = false
 crate-type = ["cdylib"]
 
 [[bin]]
-name = "glfm_markdown"
+name = "gitlab-glfm-markdown"
 required-features = ["cli"]
 
 [dependencies]
 clap = { version = "=4.4.18", optional = true, features = ["derive", "string"] }
-comrak = { version = "0.46.0", default-features = false, features = ["shortcodes"] }
+comrak = { version = "0.49.0", default-features = false, features = ["shortcodes"] }
 magnus = "0.8.2"
 rb-sys = { version = "0.9.117", default-features = false, features = ["stable-api-compiled-fallback"] }
 regex = "1.11.1"

data/ext/{glfm_markdown → gitlab_glfm_markdown}/extconf.rb

@@ -3,7 +3,7 @@
 require 'mkmf'
 require 'rb_sys/mkmf'
 
-create_rust_makefile('glfm_markdown/glfm_markdown') do |r|
+create_rust_makefile('gitlab_glfm_markdown/gitlab_glfm_markdown') do |r|
   r.auto_install_rust_toolchain = false
   # Ensure all Rust dependencies are pinned when building
   r.extra_cargo_args = ["--locked"]

data/ext/gitlab_glfm_markdown/src/formatter.rs

@@ -0,0 +1,456 @@
+use std::fmt::{self, Write};
+use std::sync::LazyLock;
+
+use comrak::html::{collect_text, format_node_default, render_sourcepos, ChildRendering, Context};
+use comrak::nodes::{ListType, NodeHeading, NodeLink, NodeList, NodeTaskItem, NodeValue};
+use comrak::{create_formatter, html, node_matches, Node};
+use regex::Regex;
+
+use crate::glfm::RenderOptions;
+
+static PLACEHOLDER_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"%\{(?:\w{1,30})}").unwrap());
+
+#[derive(Default)]
+pub struct RenderUserData {
+    pub default_html: bool,
+    pub inapplicable_tasks: bool,
+    pub placeholder_detection: bool,
+    pub only_escape_chars: Option<Vec<char>>,
+    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
+// `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.
+create_formatter!(CustomFormatter<RenderUserData>, {
+    NodeValue::Text(ref literal) => |context, node, entering| {
+        return render_text(context, node, entering, literal);
+    },
+    NodeValue::Link(ref nl) => |context, node, entering| {
+        return render_link(context, node, entering, nl);
+    },
+    NodeValue::Image(ref nl) => |context, node, entering| {
+        return render_image(context, node, entering, nl);
+    },
+    NodeValue::List(ref nl) => |context, node, entering| {
+        return render_list(context, node, entering, nl);
+    },
+    NodeValue::TaskItem(ref nti) => |context, node, entering| {
+        return render_task_item(context, node, entering, nti);
+    },
+    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_text(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    entering: bool,
+    literal: &str,
+) -> Result<ChildRendering, fmt::Error> {
+    if !(context.user.placeholder_detection && PLACEHOLDER_REGEX.is_match(literal)) {
+        return html::format_node_default(context, node, entering);
+    }
+
+    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()])?;
+            context.write_str("</span>")?;
+
+            cursor = mat.end();
+        }
+
+        if cursor < literal.len() {
+            context.escape(&literal[cursor..])?;
+        }
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
+fn render_link(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    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);
+    }
+
+    let parent_node = node.parent();
+
+    if !context.options.parse.relaxed_autolinks
+        || (parent_node.is_none()
+            || !matches!(
+                parent_node.unwrap().data.borrow().value,
+                NodeValue::Link(..)
+            ))
+    {
+        if entering {
+            context.write_str("<a")?;
+            html::render_sourcepos(context, node)?;
+            context.write_str(" href=\"")?;
+            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 {
+                    context.escape_href(&nl.url)?;
+                }
+            }
+            context.write_str("\"")?;
+
+            if !nl.title.is_empty() {
+                context.write_str(" title=\"")?;
+                context.escape(&nl.title)?;
+            }
+
+            // This path only taken if placeholder detection is enabled, and the regex matched.
+            context.write_str(" data-placeholder")?;
+
+            context.write_str(">")?;
+        } else {
+            context.write_str("</a>")?;
+        }
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
+fn render_image(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    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(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    entering: bool,
+    nl: &NodeList,
+) -> Result<ChildRendering, fmt::Error> {
+    if !entering || !context.options.render.tasklist_classes {
+        return html::format_node_default(context, node, entering);
+    }
+
+    context.cr()?;
+    match nl.list_type {
+        ListType::Bullet => {
+            context.write_str("<ul")?;
+            if nl.is_task_list {
+                context.write_str(" class=\"task-list\"")?;
+            }
+            html::render_sourcepos(context, node)?;
+            context.write_str(">\n")?;
+        }
+        ListType::Ordered => {
+            context.write_str("<ol")?;
+            if nl.is_task_list {
+                context.write_str(" class=\"task-list\"")?;
+            }
+            html::render_sourcepos(context, node)?;
+            if nl.start == 1 {
+                context.write_str(">\n")?;
+            } else {
+                writeln!(context, " start=\"{}\">", nl.start)?;
+            }
+        }
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
+// Overridden to:
+// 1. Detect inapplicable task list items; and,
+// 2. Output checkbox sourcepos.
+fn render_task_item(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    entering: bool,
+    nti: &NodeTaskItem,
+) -> Result<ChildRendering, fmt::Error> {
+    let write_li = node
+        .parent()
+        .map(|p| node_matches!(p, NodeValue::List(_)))
+        .unwrap_or_default();
+
+    if !entering {
+        if write_li {
+            context.write_str("</li>\n")?;
+        }
+        return Ok(ChildRendering::HTML);
+    }
+
+    match nti.symbol {
+        Some('~') => {
+            render_task_item_with(
+                context,
+                node,
+                nti,
+                if context.user.inapplicable_tasks {
+                    TaskItemState::Inapplicable
+                } else {
+                    TaskItemState::Checked
+                },
+                write_li,
+            )?;
+        }
+        None => {
+            render_task_item_with(context, node, nti, TaskItemState::Unchecked, write_li)?;
+        }
+        Some(ws) if ws.is_whitespace() => {
+            render_task_item_with(context, node, nti, TaskItemState::Unchecked, write_li)?;
+        }
+        Some('x' | 'X') => {
+            render_task_item_with(context, node, nti, TaskItemState::Checked, write_li)?;
+        }
+        Some(symbol) => {
+            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(">")?;
+            }
+            context.write_str("[")?;
+            context.escape(&symbol.to_string())?;
+            context.write_str("] ")?;
+        }
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
+#[derive(PartialEq)]
+enum TaskItemState {
+    Checked,
+    Unchecked,
+    Inapplicable,
+}
+
+fn render_task_item_with(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    nti: &NodeTaskItem,
+    state: TaskItemState,
+    write_li: bool,
+) -> fmt::Result {
+    context.cr()?;
+    if write_li {
+        context.write_str("<li")?;
+        if context.options.render.tasklist_classes {
+            context.write_str(" class=\"")?;
+            if state == TaskItemState::Inapplicable {
+                context.write_str("inapplicable ")?;
+            }
+            context.write_str("task-list-item\"")?;
+        }
+        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.sourcepos {
+        write!(
+            context,
+            " data-checkbox-sourcepos=\"{:?}\"",
+            nti.symbol_sourcepos
+        )?;
+    }
+
+    if context.options.render.tasklist_classes {
+        context.write_str(" class=\"task-list-item-checkbox\"")?;
+    }
+
+    match state {
+        TaskItemState::Checked => {
+            context.write_str(" checked=\"\"")?;
+        }
+        TaskItemState::Unchecked => {}
+        TaskItemState::Inapplicable => {
+            context.write_str(" data-inapplicable")?;
+        }
+    }
+    context.write_str(" disabled=\"\" /> ")?;
+
+    Ok(())
+}
+
+fn render_escaped(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    entering: bool,
+) -> Result<ChildRendering, fmt::Error> {
+    if !context.options.render.escaped_char_spans {
+        return Ok(ChildRendering::HTML);
+    }
+
+    if context
+        .user
+        .only_escape_chars
+        .as_ref()
+        .is_none_or(|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>")?;
+        }
+    }
+
+    Ok(ChildRendering::HTML)
+}
+
+fn render_heading(
+    context: &mut Context<RenderUserData>,
+    node: Node<'_>,
+    entering: bool,
+    nh: &NodeHeading,
+) -> Result<ChildRendering, fmt::Error> {
+    if !context.user.header_accessibility || context.plugins.render.heading_adapter.is_some() {
+        return format_node_default(context, node, entering);
+    }
+
+    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)
+}
+
+/// If the given node has a single text child, apply a function to the text content
+/// of that node. Otherwise, return the given default value.
+fn with_node_text_content<U, F>(node: Node<'_>, default: U, f: F) -> U
+where
+    F: FnOnce(&str) -> U,
+{
+    let Some(child) = node.first_child() else {
+        return default;
+    };
+    let Some(last_child) = node.last_child() else {
+        return default;
+    };
+    if !child.same_node(last_child) {
+        return default;
+    }
+    let NodeValue::Text(ref text) = child.data.borrow().value else {
+        return default;
+    };
+    f(text)
+}

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

@@ -10,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,
@@ -23,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,
@@ -42,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<'_> {
@@ -120,10 +104,11 @@ impl From<&RenderOptions> for comrak::Options<'_> {
         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.ignore_setext = options.ignore_setext;
+        comrak_options.parse.tasklist_in_table = options.tasklist_in_table;
 
         comrak_options
     }

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

@@ -14,6 +14,10 @@ struct Args {
     #[arg(value_name = "FILE")]
     file: Option<String>,
 
+    /// Write output to FILE instead of stdout
+    #[arg(short, long, value_name = "FILE")]
+    output: Option<String>,
+
     /// Enable 'alerts' extension
     #[arg(long)]
     alerts: bool,
@@ -22,6 +26,14 @@ struct Args {
     #[arg(long)]
     autolink: bool,
 
+    /// Enable 'cjk_friendly_emphasis' extension
+    #[arg(long)]
+    cjk_friendly_emphasis: bool,
+
+    /// Only use default comrak HTML formatting
+    #[arg(long)]
+    default_html: bool,
+
     /// Enable 'description-lists' extension
     #[arg(long)]
     description_lists: bool,
@@ -72,6 +84,11 @@ struct Args {
     #[arg(long)]
     hardbreaks: bool,
 
+    /// Use new header/anchor combination in HTML output, per
+    /// https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/merge_requests/112.
+    #[arg(long)]
+    header_accessibility: bool,
+
     /// Enable the 'header IDs' extension, with the given ID prefix
     #[arg(long, value_name = "PREFIX")]
     header_ids: Option<String>,
@@ -84,6 +101,10 @@ struct Args {
     #[arg(long)]
     ignore_setext: bool,
 
+    /// Detect inapplicable tasks (`- [~]`)
+    #[arg(long)]
+    inapplicable_tasks: bool,
+
     /// Enables `math code` extension, using math code syntax
     #[arg(long)]
     math_code: bool,
@@ -96,9 +117,15 @@ struct Args {
     #[arg(long)]
     multiline_block_quotes: bool,
 
-    /// Write output to FILE instead of stdout
-    #[arg(short, long, value_name = "FILE")]
-    output: Option<String>,
+    /// When the 'escaped_char_spans' render option is enabled, only emit `<span
+    /// data-escaped-char>` around the characters in the supplied string.
+    #[arg(long)]
+    only_escape_chars: Option<String>,
+
+    /// Detect and marks potential placeholder variables, which
+    /// have the format `%{PLACEHOLDER}`
+    #[arg(long)]
+    placeholder_detection: bool,
 
     /// Enable relaxing of autolink parsing, allowing links to be recognized when in brackets
     #[arg(long)]
@@ -108,14 +135,14 @@ struct Args {
     #[arg(long)]
     relaxed_tasklist_character: bool,
 
-    /// Include source mappings in HTML attributes
-    #[arg(long)]
-    sourcepos: bool,
-
     /// Use smart punctuation
     #[arg(long)]
     smart: bool,
 
+    /// Include source mappings in HTML attributes
+    #[arg(long)]
+    sourcepos: bool,
+
     /// Enables spoilers using double vertical bars
     #[arg(long)]
     spoiler: bool,
@@ -152,6 +179,10 @@ struct Args {
     #[arg(long)]
     tasklist_classes: bool,
 
+    /// Enables parsing tasklist items within tables when they're the only content of a table cell
+    #[arg(long)]
+    tasklist_in_table: bool,
+
     /// Enables underlines using double underscores
     #[arg(long)]
     underline: bool,
@@ -167,34 +198,6 @@ struct Args {
     /// Enable 'wikilink_title_before_pipe' extension
     #[arg(long)]
     wikilinks_title_before_pipe: bool,
-
-    /// Only use default comrak HTML formatting
-    #[arg(long)]
-    default_html: bool,
-
-    /// GLFM specific options
-
-    /// Detect inapplicable tasks (`- [~]`)
-    #[arg(long)]
-    inapplicable_tasks: bool,
-
-    /// Detect and marks potential placeholder variables, which
-    /// have the format `%{PLACEHOLDER}`
-    #[arg(long)]
-    placeholder_detection: bool,
-
-    /// When the 'escaped_char_spans' render option is enabled, only emit `<span
-    /// data-escaped-char>` around the characters in the supplied string.
-    #[arg(long)]
-    only_escape_chars: Option<String>,
-
-    /// Enable 'cjk_friendly_emphasis' extension
-    #[arg(long)]
-    cjk_friendly_emphasis: bool,
-
-    /// Show debug information
-    #[arg(long)]
-    debug: bool,
 }
 
 fn main() {
@@ -216,6 +219,7 @@ fn main() {
         autolink: cli.autolink,
         cjk_friendly_emphasis: cli.cjk_friendly_emphasis,
         // default_info_string:
+        default_html: cli.default_html,
         description_lists: cli.description_lists,
         escape: cli.escape,
         escaped_char_spans: cli.escaped_char_spans,
@@ -228,6 +232,7 @@ fn main() {
         github_pre_lang: cli.github_pre_lang,
         greentext: cli.greentext,
         hardbreaks: cli.hardbreaks,
+        header_accessibility: cli.header_accessibility,
         header_ids: cli.header_ids,
         ignore_empty_links: cli.ignore_empty_links,
         ignore_setext: cli.ignore_setext,
@@ -235,10 +240,12 @@ fn main() {
         math_code: cli.math_code,
         math_dollars: cli.math_dollars,
         multiline_block_quotes: cli.multiline_block_quotes,
+        only_escape_chars: cli.only_escape_chars.map(|s| s.chars().collect()),
+        placeholder_detection: cli.placeholder_detection,
         relaxed_autolinks: cli.relaxed_autolinks,
         relaxed_tasklist_character: cli.relaxed_tasklist_character,
-        sourcepos: cli.sourcepos,
         smart: cli.smart,
+        sourcepos: cli.sourcepos,
         spoiler: cli.spoiler,
         strikethrough: cli.strikethrough,
         subscript: cli.subscript,
@@ -248,15 +255,11 @@ fn main() {
         tagfilter: cli.tagfilter,
         tasklist: cli.tasklist,
         tasklist_classes: cli.tasklist_classes,
+        tasklist_in_table: cli.tasklist_in_table,
         underline: cli.underline,
         r#unsafe: cli.r#unsafe,
         wikilinks_title_after_pipe: cli.wikilinks_title_after_pipe,
         wikilinks_title_before_pipe: cli.wikilinks_title_before_pipe,
-
-        default_html: cli.default_html,
-        placeholder_detection: cli.placeholder_detection,
-        only_escape_chars: cli.only_escape_chars.map(|s| s.chars().collect()),
-        debug: cli.debug,
     };
 
     let result = render(&source, &options);

data/lib/{glfm_markdown.rb → gitlab-glfm-markdown.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'glfm_markdown/version'
-require_relative 'glfm_markdown/loader'
+require_relative 'gitlab_glfm_markdown/version'
+require_relative 'gitlab_glfm_markdown/loader'
 
 load_rust_extension
 
@@ -27,9 +27,7 @@ module GLFMMarkdown
     tagfilter: false,
     tasklist: true,
     tasklist_classes: true,
-    unsafe: true,
-
-    debug: false
+    unsafe: true
   }.freeze
 
   class << self

data/lib/{glfm_markdown → gitlab_glfm_markdown}/loader.rb

@@ -2,7 +2,7 @@
 
 def load_rust_extension
   ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
-  require "glfm_markdown/#{ruby_version}/glfm_markdown"
+  require "gitlab_glfm_markdown/#{ruby_version}/gitlab_glfm_markdown"
 rescue LoadError
-  require 'glfm_markdown/glfm_markdown'
+  require 'gitlab_glfm_markdown/gitlab_glfm_markdown'
 end

data/lib/{glfm_markdown → gitlab_glfm_markdown}/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GLFMMarkdown
-  VERSION = '0.0.38'
+  VERSION = '0.0.40'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-glfm-markdown
 version: !ruby/object:Gem::Version
-  version: 0.0.38
+  version: 0.0.40
 platform: ruby
 authors:
 - Brett Walker
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-29 00:00:00.000000000 Z
+date: 2025-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -59,22 +59,22 @@ email:
 - aconnor@gitlab.com
 executables: []
 extensions:
-- ext/glfm_markdown/extconf.rb
+- ext/gitlab_glfm_markdown/extconf.rb
 extra_rdoc_files: []
 files:
 - Cargo.lock
 - LICENSE
 - README.md
-- ext/glfm_markdown/Cargo.lock
-- ext/glfm_markdown/Cargo.toml
-- ext/glfm_markdown/extconf.rb
-- ext/glfm_markdown/src/formatter.rs
-- ext/glfm_markdown/src/glfm.rs
-- ext/glfm_markdown/src/lib.rs
-- ext/glfm_markdown/src/main.rs
-- lib/glfm_markdown.rb
-- lib/glfm_markdown/loader.rb
-- lib/glfm_markdown/version.rb
+- ext/gitlab_glfm_markdown/Cargo.lock
+- ext/gitlab_glfm_markdown/Cargo.toml
+- ext/gitlab_glfm_markdown/extconf.rb
+- ext/gitlab_glfm_markdown/src/formatter.rs
+- ext/gitlab_glfm_markdown/src/glfm.rs
+- ext/gitlab_glfm_markdown/src/lib.rs
+- ext/gitlab_glfm_markdown/src/main.rs
+- lib/gitlab-glfm-markdown.rb
+- lib/gitlab_glfm_markdown/loader.rb
+- lib/gitlab_glfm_markdown/version.rb
 homepage: https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown
 licenses:
 - MIT

data/ext/glfm_markdown/src/formatter.rs

@@ -1,366 +0,0 @@
-use std::fmt::{self, Write};
-
-use comrak::html::{render_sourcepos, ChildRendering, Context};
-use comrak::nodes::{AstNode, ListType, NodeValue};
-use comrak::{create_formatter, html};
-use lazy_static::lazy_static;
-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();
-}
-
-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,
-}
-
-// 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
-// `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`.
-create_formatter!(CustomFormatter<RenderUserData>, {
-    NodeValue::Text(_) => |context, node, entering| {
-        return render_text(context, node, entering);
-    },
-    NodeValue::Link(_) => |context, node, entering| {
-        return render_link(context, node, entering);
-    },
-    NodeValue::Image(_) => |context, node, entering| {
-        return render_image(context, node, entering);
-    },
-    NodeValue::List(_) => |context, node, entering| {
-        return render_list(context, node, entering);
-    },
-    NodeValue::TaskItem(_) => |context, node, entering| {
-        return render_task_item(context, node, entering);
-    },
-    NodeValue::Escaped => |context, node, entering| {
-        return render_escaped(context, node, entering);
-    },
-});
-
-fn render_image<'a>(
-    context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
-    entering: bool,
-) -> 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)) {
-        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("\"")?;
-
-        if PLACEHOLDER_REGEX.is_match(&nl.url) {
-            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)
-}
-
-fn render_link<'a>(
-    context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
-    entering: bool,
-) -> 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);
-    }
-
-    let parent_node = node.parent();
-
-    if !context.options.parse.relaxed_autolinks
-        || (parent_node.is_none()
-            || !matches!(
-                parent_node.unwrap().data.borrow().value,
-                NodeValue::Link(..)
-            ))
-    {
-        if entering {
-            context.write_str("<a")?;
-            html::render_sourcepos(context, node)?;
-            context.write_str(" href=\"")?;
-            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 {
-                    context.escape_href(&nl.url)?;
-                }
-            }
-            context.write_str("\"")?;
-
-            if !nl.title.is_empty() {
-                context.write_str(" title=\"")?;
-                context.escape(&nl.title)?;
-            }
-
-            if PLACEHOLDER_REGEX.is_match(&nl.url) {
-                context.write_str(" data-placeholder")?;
-            }
-
-            context.write_str(">")?;
-        } else {
-            context.write_str("</a>")?;
-        }
-    }
-
-    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,
-) -> 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 => {
-            context.write_str("<ul")?;
-            if nl.is_task_list {
-                context.write_str(" class=\"task-list\"")?;
-            }
-            html::render_sourcepos(context, node)?;
-            context.write_str(">\n")?;
-        }
-        ListType::Ordered => {
-            context.write_str("<ol")?;
-            if nl.is_task_list {
-                context.write_str(" class=\"task-list\"")?;
-            }
-            html::render_sourcepos(context, node)?;
-            if nl.start == 1 {
-                context.write_str(">\n")?;
-            } else {
-                writeln!(context, " start=\"{}\">", nl.start)?;
-            }
-        }
-    }
-
-    Ok(ChildRendering::HTML)
-}
-
-// Overridden to detect inapplicable task list items
-fn render_task_item<'a>(
-    context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
-    entering: bool,
-) -> 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!()
-    };
-
-    if symbol.is_none() || matches!(symbol, Some('x' | 'X')) {
-        return html::format_node_default(context, node, entering);
-    }
-
-    if entering {
-        // Handle an inapplicable task symbol.
-        if matches!(symbol, Some('~')) {
-            context.cr()?;
-            context.write_str("<li")?;
-            context.write_str(" class=\"inapplicable")?;
-
-            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("<input type=\"checkbox\"")?;
-
-            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
-            context.cr()?;
-            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(">")?;
-            context.write_str("[")?;
-            context.escape(&symbol.unwrap().to_string())?;
-            context.write_str("] ")?;
-        }
-    } else {
-        context.write_str("</li>\n")?;
-    }
-
-    Ok(ChildRendering::HTML)
-}
-
-fn render_text<'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 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()])?;
-            context.write_str("</span>")?;
-
-            cursor = mat.end();
-        }
-
-        if cursor < literal.len() {
-            context.escape(&literal[cursor..literal.len()])?;
-        }
-    }
-
-    Ok(ChildRendering::HTML)
-}
-
-fn render_escaped<'a>(
-    context: &mut Context<RenderUserData>,
-    node: &'a AstNode<'a>,
-    entering: bool,
-) -> Result<ChildRendering, fmt::Error> {
-    if !context.options.render.escaped_char_spans {
-        return Ok(ChildRendering::HTML);
-    }
-
-    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>")?;
-        }
-    }
-
-    Ok(ChildRendering::HTML)
-}
-
-/// If the given node has a single text child, apply a function to the text content
-/// of that node. Otherwise, return the given default value.
-fn with_node_text_content<'a, U, F>(node: &'a AstNode<'a>, default: U, f: F) -> U
-where
-    F: FnOnce(&str) -> U,
-{
-    let Some(child) = node.first_child() else {
-        return default;
-    };
-    let Some(last_child) = node.last_child() else {
-        return default;
-    };
-    if !child.same_node(last_child) {
-        return default;
-    }
-    let NodeValue::Text(ref text) = child.data.borrow().value else {
-        return default;
-    };
-    f(text)
-}