gitlab-glfm-markdown 0.0.38-x86_64-linux-gnu → 0.0.40-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba881ded72921aedae7bbda8916417b7e850f196b1aead039d55ab167833edfc
-  data.tar.gz: f73354bfef3a9be98d22a57c694d12377277150897ec6f7482b2ad001c282b4c
+  metadata.gz: 727000a57ece814d001538de227bc994adf468b4c2123e46149e6712a8aac4c2
+  data.tar.gz: 5f811b021a68d56815164eefe376ea71dc0b7b4d34e2b79214759b06d6a2e506
 SHA512:
-  metadata.gz: 23b18b486e6f3afbd44a1f485fcde08601ebbab1df9e13540b23c8ea22e6c8ace3f178b50687a0d440b71c489bde5bd0b62eabbc52c670abeeb8dbae240424f6
-  data.tar.gz: 57494b03e5b71df8b240376544c5e6c651a5e82fc6f593e162b241eceffed44ac856e5a8bcf339f1153e9e11ea2710bf8f8f88853d88910b4f155cad683b2226
+  metadata.gz: 5b6a8d2636d11dbdd52f6ba5971b936b480242c2715cfc0a2355ecf39448d9c16a0085ac2c9102d6ee32f88104c84de0a292dad0b92f9b33d3b1c598d9bbe586
+  data.tar.gz: 3eb01a17583b2373a8b32b8d2b81b55bbfd0b50ae5e43ee97abf548033d851d9e842c84a15150e82694c29d6b8018102f7e2ecc5049bfae7f2e9ddba371b6a17

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.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/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)
+}