| foo | bar |
or at empty lines + pub child_index: Option
")?;
+
+ // Track offset mapping for code content
+ let char_start = self.last_char_offset;
+ let text_char_len = escape_html_body_text_with_char_count(&mut self.writer, &text)?;
+ let char_end = char_start + text_char_len;
+
+ // Record offset mapping (code content is visible)
+ self.record_mapping(range.clone(), char_start..char_end);
+ self.last_char_offset = char_end;
+
+ self.write("")?;
+
+ // Emit closing backtick
+ if range.start < range.end {
+ let raw_text = &self.source[range];
+ if raw_text.ends_with('`') {
+ self.write("`")?;
+ }
+ }
+ }
+ InlineMath(text) => {
+ // Emit opening $
+ if range.start < range.end {
+ let raw_text = &self.source[range.clone()];
+ if raw_text.starts_with('$') {
+ self.write("$")?;
+ }
+ }
+
+ self.write(r#""#)?;
+ escape_html(&mut self.writer, &text)?;
+ self.write("")?;
+
+ // Emit closing $
+ if range.start < range.end {
+ let raw_text = &self.source[range];
+ if raw_text.ends_with('$') {
+ self.write("$")?;
+ }
+ }
+ }
+ DisplayMath(text) => {
+ // Emit opening $$
+ if range.start < range.end {
+ let raw_text = &self.source[range.clone()];
+ if raw_text.starts_with("$$") {
+ self.write("$$")?;
+ }
+ }
+
+ self.write(r#""#)?;
+ escape_html(&mut self.writer, &text)?;
+ self.write("")?;
+
+ // Emit closing $$
+ if range.start < range.end {
+ let raw_text = &self.source[range];
+ if raw_text.ends_with("$$") {
+ self.write("$$")?;
+ }
+ }
+ }
+ Html(html) | InlineHtml(html) => {
+ // Track offset mapping for raw HTML
+ let char_start = self.last_char_offset;
+ let html_char_len = html.chars().count();
+ let char_end = char_start + html_char_len;
+
+ self.write(&html)?;
+
+ // Record mapping for inline HTML
+ self.record_mapping(range.clone(), char_start..char_end);
+ self.last_char_offset = char_end;
+ }
+ SoftBreak => self.write_newline()?,
+ HardBreak => {
+ // Emit the two spaces as visible (dimmed) text, then + let gap = &self.source[range.clone()]; + if gap.ends_with('\n') { + let spaces = &gap[..gap.len() - 1]; // everything except the \n + let char_start = byte_to_char(self.source, range.start); + let spaces_char_len = spaces.chars().count(); + + // Emit and map the visible spaces + self.write("")?; + escape_html(&mut self.writer, spaces)?; + self.write("")?; + + // Count this span as a child + self.current_node_child_count += 1; + + self.record_mapping( + range.start..range.start + spaces.len(), + char_start..char_start + spaces_char_len, + ); + + // Now the actual line break
+ self.write("
")?; + + // Count the
as a child + self.current_node_child_count += 1; + + // Map the newline to an element-based position (after the
) + // The binary search is end-inclusive, so cursor at position N+1 + // will match a mapping with range N..N+1 + if let Some(ref node_id) = self.current_node_id { + let newline_char_offset = char_start + spaces_char_len; + let mapping = OffsetMapping { + byte_range: range.start + spaces.len()..range.end, + char_range: newline_char_offset..newline_char_offset + 1, + node_id: node_id.clone(), + char_offset_in_node: 0, + child_index: Some(self.current_node_child_count), + utf16_len: 0, + }; + self.offset_maps.push(mapping); + } + + self.last_char_offset = char_start + spaces_char_len + 1; // +1 for \n + } else { + // Fallback: just
+ self.write("
")?; + } + } + Rule => { + if !self.end_newline { + self.write("\n")?; + } + + // Emit syntax span before the rendered element + if range.start < range.end { + let raw_text = &self.source[range]; + let trimmed = raw_text.trim(); + if !trimmed.is_empty() { + self.write("")?; + escape_html(&mut self.writer, trimmed)?; + self.write("\n")?; + } + } + + // Wrap
in toggle-block for future cursor-based toggling + self.write("
", node_id)?; + } else { + write!(&mut self.writer, "\n
", node_id)?; + } + self.begin_node(node_id.clone()); + + // Map the start position of the paragraph (before any content) + // This allows cursor to be placed at the very beginning + let para_start_char = self.last_char_offset; + let mapping = OffsetMapping { + byte_range: range.start..range.start, + char_range: para_start_char..para_start_char, + node_id, + char_offset_in_node: 0, + child_index: Some(0), // position before first child + utf16_len: 0, + }; + self.offset_maps.push(mapping); + + // Emit > syntax if we're inside a blockquote + if let Some(bq_range) = self.pending_blockquote_range.take() { + if bq_range.start < bq_range.end { + let raw_text = &self.source[bq_range]; + if let Some(gt_pos) = raw_text.find('>') { + // Extract > [!NOTE] or just > + let after_gt = &raw_text[gt_pos + 1..]; + let syntax_end = if after_gt.trim_start().starts_with("[!") { + // Find the closing ] + if let Some(close_bracket) = after_gt.find(']') { + gt_pos + 1 + close_bracket + 1 + } else { + gt_pos + 1 + } + } else { + // Just > and maybe a space + (gt_pos + 2).min(raw_text.len()) + }; + + let syntax = &raw_text[gt_pos..syntax_end]; + self.write("")?; + escape_html(&mut self.writer, syntax)?; + self.write(" ")?; // Add space after + } + } + } + Ok(()) + } + Tag::Heading { + level, + id, + classes, + attrs, + } => { + if !self.end_newline { + self.write("\n")?; + } + + // Generate node ID for offset tracking + let node_id = self.gen_node_id(); + + self.write("<")?; + write!(&mut self.writer, "{}", level)?; + + // Add our tracking ID as data attribute (preserve user's id if present) + self.write(" data-node-id=\"")?; + self.write(&node_id)?; + self.write("\"")?; + + if let Some(id) = id { + self.write(" id=\"")?; + escape_html(&mut self.writer, &id)?; + self.write("\"")?; + } + if !classes.is_empty() { + self.write(" class=\"")?; + for (i, class) in classes.iter().enumerate() { + if i > 0 { + self.write(" ")?; + } + escape_html(&mut self.writer, class)?; + } + self.write("\"")?; + } + for (attr, value) in attrs { + self.write(" ")?; + escape_html(&mut self.writer, &attr)?; + if let Some(val) = value { + self.write("=\"")?; + escape_html(&mut self.writer, &val)?; + self.write("\"")?; + } else { + self.write("=\"\"")?; + } + } + self.write(">")?; + + // Begin node tracking for offset mapping + self.begin_node(node_id); + + // Emit # syntax inside the heading tag + if range.start < range.end { + let raw_text = &self.source[range]; + let count = level as usize; + let pattern = "#".repeat(count); + + // Find where the # actually starts (might have leading whitespace) + if let Some(hash_pos) = raw_text.find(&pattern) { + // Extract "# " or "## " etc + let syntax_start = hash_pos; + let syntax_end = (hash_pos + count + 1).min(raw_text.len()); + let syntax = &raw_text[syntax_start..syntax_end]; + + self.write("")?; + escape_html(&mut self.writer, syntax)?; + self.write("")?; + } + } + Ok(()) + } + Tag::Table(alignments) => { + if self.render_tables_as_markdown { + // Store start offset and skip HTML rendering + self.table_start_offset = Some(range.start); + self.in_non_writing_block = true; // Suppress content output + Ok(()) + } else { + self.table_alignments = alignments; + self.write("
")?;
+ escape_html_body_text(&mut self.writer, &buffer)?;
+ self.write("")?;
+ escape_html_body_text(&mut self.writer, &buffer)?;
+ self.write("