…
` on export, matching upstream so vimwiki's
/// stylesheet applies.
toc_header: String,
/// vimwiki `valid_html_tags`: inline HTML tag names passed through to
/// export verbatim (instead of escaping `<`/`>`). Empty = escape all.
/// `span` is always allowed so colour spans render.
valid_html_tags: Vec`. text_ignore_newline: bool, /// vimwiki `list_ignore_newline` (default `true`): a soft break in a list /// item renders as a space; `false` → `
`. list_ignore_newline: bool, } impl Default for HtmlRenderer { fn default() -> Self { Self::new() } } impl HtmlRenderer { pub fn new() -> Self { Self { link_resolver: Arc::new(default_link_resolver), template: None, vars: HashMap::new(), colors: HashMap::new(), color_template: "__CONTENT__".to_string(), header_numbering: 0, header_numbering_sym: String::new(), toc_header: String::new(), valid_html_tags: Vec::new(), emoji_enable: false, text_ignore_newline: true, list_ignore_newline: true, } } /// Set vimwiki `text_ignore_newline` / `list_ignore_newline`. When `false`, /// a soft line break in a paragraph / list item renders as `
` /// instead of a space. pub fn with_newline_handling(mut self, text_ignore: bool, list_ignore: bool) -> Self { self.text_ignore_newline = text_ignore; self.list_ignore_newline = list_ignore; self } /// Set the inline HTML tags allowed through export unescaped (vimwiki /// `valid_html_tags`). `span` is always added so colour spans render. pub fn with_valid_html_tags(mut self, mut tags: Vec
`, matching upstream so vimwiki's `.toc { … }`
// stylesheet rules apply. Kept in its simple form.
let is_toc = !self.toc_header.is_empty() && anchor.eq_ignore_ascii_case(&self.toc_header);
if is_toc {
w.write_all(b"")?;
if !number.is_empty() {
write_escaped(number, w)?;
}
self.render_inlines(&body, w)?;
write!(w, " ")?;
return writeln!(w);
}
// Regular heading: vimwiki's structure — a wrapping `
")?;
write!(w, "")?;
if !number.is_empty() {
write_escaped(number, w)?;
}
self.render_inlines(&body, w)?;
write!(w, "
")?;
return writeln!(w);
}
// Centered headings keep their `class="centered"` form.
if n.centered {
write!(w, "` carrying the
// hierarchical id, `class="header"` on the heading, and an in-heading
// self-anchor linking to that id. The heading keeps the flat id so
// existing intra-page TOC / `#anchor` links still resolve.
let hier = if hier_id.is_empty() { &anchor } else { hier_id };
w.write_all(b"")?;
writeln!(w)
}
fn render_paragraph(&self, n: &ParagraphNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"
\n") } fn render_blockquote(&self, n: &BlockquoteNode, w: &mut dyn Write) -> io::Result<()> { w.write_all(b"
")?;
let sb = if self.text_ignore_newline {
" "
} else {
"
"
};
self.render_inlines_break(&n.children, sb, w)?;
w.write_all(b"
\n") } fn render_blockquote(&self, n: &BlockquoteNode, w: &mut dyn Write) -> io::Result<()> { w.write_all(b"
\n")?; for child in &n.children { self.render_block(child, w)?; } w.write_all(b"\n") } fn render_preformatted(&self, n: &PreformattedNode, w: &mut dyn Write) -> io::Result<()> { // vimwiki drops the verbatim fence text into the `
` tag as raw
// attributes (`{{{python` → ``), with no inner ``.
// We mirror that so highlighters wired for vimwiki output still apply.
if n.attrs.is_empty() {
w.write_all(b"")?;
} else {
write!(w, "", n.attrs)?;
}
write_escaped(&n.content, w)?;
w.write_all(b"\n")
}
fn render_math_block(&self, n: &MathBlockNode, w: &mut dyn Write) -> io::Result<()> {
// No actual TeX rendering — caller is expected to run MathJax / KaTeX
// over the wrapped node. The delimiters match vimwiki convention.
match &n.environment {
Some(env) => writeln!(
w,
"\\begin{{{env}}}",
escape(env)
)?,
None => w.write_all(b"\\[\n")?,
}
write_escaped(&n.content, w)?;
match &n.environment {
Some(env) => write!(w, "\n\\end{{{env}}}\n", env = escape(env))?,
None => w.write_all(b"\n\\]\n")?,
}
Ok(())
}
fn render_list(&self, n: &ListNode, w: &mut dyn Write) -> io::Result<()> {
let tag = if n.ordered { "ol" } else { "ul" };
writeln!(w, "<{tag}>")?;
for item in &n.items {
self.render_list_item(item, w)?;
}
writeln!(w, "")
}
fn render_list_item(&self, n: &ListItemNode, w: &mut dyn Write) -> io::Result<()> {
match n.checkbox {
Some(state) => {
// vimwiki-compatible checkbox classes: `[ ]`→done0, `[.]`→done1,
// `[o]`→done2, `[O]`→done3, `[X]`→done4, `[-]`→rejected. The
// checkbox glyph/progress fill is drawn entirely by the
// stylesheet (`li.doneN::before`); vimwiki emits no ``,
// so neither do we — an input would double-render against it.
let class = match state {
CheckboxState::Empty => "done0",
CheckboxState::Quarter => "done1",
CheckboxState::Half => "done2",
CheckboxState::ThreeQuarters => "done3",
CheckboxState::Done => "done4",
CheckboxState::Rejected => "rejected",
};
write!(w, "")?;
}
None => w.write_all(b" ")?,
}
let sb = if self.list_ignore_newline {
" "
} else {
"
"
};
self.render_inlines_break(&n.children, sb, w)?;
if let Some(sublist) = &n.sublist {
w.write_all(b"\n")?;
self.render_list(sublist, w)?;
}
w.write_all(b" \n")
}
fn render_definition_list(&self, n: &DefinitionListNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"\n")?;
for item in &n.items {
self.render_definition_item(item, w)?;
}
w.write_all(b"
\n")
}
fn render_definition_item(&self, n: &DefinitionItemNode, w: &mut dyn Write) -> io::Result<()> {
if let Some(term) = &n.term {
w.write_all(b"")?;
self.render_inlines(term, w)?;
w.write_all(b" \n")?;
}
for def in &n.definitions {
w.write_all(b"")?;
self.render_inlines(def, w)?;
w.write_all(b" \n")?;
}
Ok(())
}
fn render_table(&self, n: &TableNode, w: &mut dyn Write) -> io::Result<()> {
// Pre-compute per-cell rowspan/colspan + suppression so we can
// emit valid HTML colspan/rowspan attributes instead of CSS
// class markers. `col_span` cells get folded into the colspan
// of the lead cell to their left; `row_span` cells get folded
// into the rowspan of the lead cell directly above.
let layout = table_spans(n);
w.write_all(b"\n")?;
let mut in_thead = false;
let mut in_tbody = false;
for (row_idx, row) in n.rows.iter().enumerate() {
if row.is_header {
if !in_thead {
w.write_all(b"\n")?;
in_thead = true;
}
} else {
if in_thead {
w.write_all(b"\n")?;
in_thead = false;
}
if !in_tbody {
w.write_all(b"\n")?;
in_tbody = true;
}
}
self.render_table_row(row, row_idx, &layout, &n.alignments, w)?;
}
if in_thead {
w.write_all(b"\n")?;
}
if in_tbody {
w.write_all(b"\n")?;
}
w.write_all(b"
\n")
}
fn render_table_row(
&self,
n: &TableRowNode,
row_idx: usize,
layout: &[Vec],
alignments: &[crate::ast::TableAlign],
w: &mut dyn Write,
) -> io::Result<()> {
w.write_all(b"")?;
for (col_idx, cell) in n.cells.iter().enumerate() {
let info = layout
.get(row_idx)
.and_then(|r| r.get(col_idx))
.copied()
.unwrap_or(CellLayout::Lead {
colspan: 1,
rowspan: 1,
});
match info {
CellLayout::Skip => continue,
CellLayout::Lead { colspan, rowspan } => {
let align = alignments
.get(col_idx)
.copied()
.unwrap_or(crate::ast::TableAlign::Default);
self.render_table_cell(cell, n.is_header, colspan, rowspan, align, w)?;
}
}
}
w.write_all(b" \n")
}
fn render_table_cell(
&self,
n: &TableCellNode,
is_header: bool,
colspan: u32,
rowspan: u32,
align: crate::ast::TableAlign,
w: &mut dyn Write,
) -> io::Result<()> {
let tag = if is_header { "th" } else { "td" };
write!(w, "<{tag}")?;
if colspan > 1 {
write!(w, " colspan=\"{colspan}\"")?;
}
if rowspan > 1 {
write!(w, " rowspan=\"{rowspan}\"")?;
}
let align_attr = match align {
crate::ast::TableAlign::Left => Some("left"),
crate::ast::TableAlign::Right => Some("right"),
crate::ast::TableAlign::Center => Some("center"),
crate::ast::TableAlign::Default => None,
};
if let Some(a) = align_attr {
write!(w, " style=\"text-align: {a};\"")?;
}
write!(w, ">")?;
self.render_inlines(&n.children, w)?;
write!(w, "")
}
fn render_comment(&self, n: &CommentNode, w: &mut dyn Write) -> io::Result<()> {
// Emit as an HTML comment so it survives round-trips through view-source
// but isn't rendered to the reader. `--` inside a comment is illegal
// in HTML, so collapse runs.
let safe = n.content.replace("--", "- -");
writeln!(w, "")
}
fn render_error(&self, n: &ErrorNode, w: &mut dyn Write) -> io::Result<()> {
write!(w, "")?;
write_escaped(&n.raw, w)?;
w.write_all(b"")
}
// ===== Inline =====
fn render_inlines(&self, nodes: &[InlineNode], w: &mut dyn Write) -> io::Result<()> {
for n in nodes {
self.render_inline(n, w)?;
}
Ok(())
}
/// Like [`render_inlines`] but renders top-level soft breaks as `soft_break`
/// (a space or `
`). Used by paragraphs / list items, which are the
/// only blocks that contain `SoftBreak` nodes.
fn render_inlines_break(
&self,
nodes: &[InlineNode],
soft_break: &str,
w: &mut dyn Write,
) -> io::Result<()> {
for n in nodes {
match n {
InlineNode::SoftBreak(_) => w.write_all(soft_break.as_bytes())?,
_ => self.render_inline(n, w)?,
}
}
Ok(())
}
fn render_inline(&self, n: &InlineNode, w: &mut dyn Write) -> io::Result<()> {
match n {
InlineNode::Text(t) => self.render_text(t, w),
InlineNode::Bold(t) => self.render_bold(t, w),
InlineNode::Italic(t) => self.render_italic(t, w),
InlineNode::BoldItalic(t) => self.render_bold_italic(t, w),
InlineNode::Strikethrough(t) => self.render_strikethrough(t, w),
InlineNode::Code(t) => self.render_code(t, w),
InlineNode::Superscript(t) => self.render_superscript(t, w),
InlineNode::Subscript(t) => self.render_subscript(t, w),
InlineNode::MathInline(t) => self.render_math_inline(t, w),
InlineNode::Keyword(t) => self.render_keyword(t, w),
InlineNode::Color(t) => self.render_color(t, w),
InlineNode::WikiLink(t) => self.render_wikilink(t, w),
InlineNode::ExternalLink(t) => self.render_external_link(t, w),
InlineNode::Transclusion(t) => self.render_transclusion(t, w),
InlineNode::RawUrl(t) => self.render_raw_url(t, w),
// Default rendering (e.g. inside a heading): a space. Paragraphs
// and list items use render_inlines_break for `
` support.
InlineNode::SoftBreak(_) => w.write_all(b" "),
}
}
fn render_text(&self, n: &TextNode, w: &mut dyn Write) -> io::Result<()> {
let content = if self.emoji_enable {
substitute_emoji(&n.content)
} else {
std::borrow::Cow::Borrowed(n.content.as_str())
};
if self.valid_html_tags.is_empty() {
write_escaped(&content, w)
} else {
write_escaped_allowing(&content, &self.valid_html_tags, w)
}
}
fn render_bold(&self, n: &BoldNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
self.render_inlines(&n.children, w)?;
w.write_all(b"")
}
fn render_italic(&self, n: &ItalicNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
self.render_inlines(&n.children, w)?;
w.write_all(b"")
}
fn render_bold_italic(&self, n: &BoldItalicNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
self.render_inlines(&n.children, w)?;
w.write_all(b"")
}
fn render_strikethrough(&self, n: &StrikethroughNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
self.render_inlines(&n.children, w)?;
w.write_all(b"")
}
fn render_code(&self, n: &CodeNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
write_escaped(&n.content, w)?;
w.write_all(b"")
}
fn render_superscript(&self, n: &SuperscriptNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
self.render_inlines(&n.children, w)?;
w.write_all(b"")
}
fn render_subscript(&self, n: &SubscriptNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
self.render_inlines(&n.children, w)?;
w.write_all(b"")
}
fn render_math_inline(&self, n: &MathInlineNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"\\(")?;
write_escaped(&n.content, w)?;
w.write_all(b"\\)")
}
fn render_keyword(&self, n: &KeywordNode, w: &mut dyn Write) -> io::Result<()> {
// One class per keyword so stylesheets can colour them independently
// (e.g. red TODO/FIXME/XXX vs green DONE/FIXED/STARTED). TODO keeps the
// vimwiki `todo` class so stock vimwiki CSS still styles it.
let class = match n.keyword {
Keyword::Todo => "todo",
Keyword::Done => "done",
Keyword::Started => "started",
Keyword::Fixme => "fixme",
Keyword::Fixed => "fixed",
Keyword::Xxx => "xxx",
Keyword::Stopped => "stopped",
};
write!(w, "{}", n.keyword.label())
}
fn render_color(&self, n: &ColorNode, w: &mut dyn Write) -> io::Result<()> {
// Render the inner content up front so it can be slotted into the
// colour template.
let mut content = Vec::new();
self.render_inlines(&n.children, &mut content)?;
let content = String::from_utf8_lossy(&content);
if let Some(css) = self.colors.get(&n.color) {
// Known colour name: expand `color_tag_template` with the resolved
// inline style and rendered content.
let mut style = b"color:".to_vec();
write_escaped(css, &mut style)?;
let style = String::from_utf8_lossy(&style);
let html = self
.color_template
.replace("__STYLE__", &style)
.replace("__CONTENT__", &content);
w.write_all(html.as_bytes())
} else {
// Unknown name: fall back to a class hook the stylesheet can target
// (the template only models the inline-style case).
w.write_all(b"")?;
w.write_all(content.as_bytes())?;
w.write_all(b"")
}
}
fn render_wikilink(&self, n: &WikiLinkNode, w: &mut dyn Write) -> io::Result<()> {
let href = (self.link_resolver)(&n.target);
w.write_all(b"")?;
match &n.description {
Some(desc) => self.render_inlines(desc, w)?,
None => {
let label = n
.target
.path
.clone()
.or_else(|| n.target.anchor.clone())
.unwrap_or_else(|| href.clone());
write_escaped(&label, w)?;
}
}
w.write_all(b"")
}
fn render_external_link(&self, n: &ExternalLinkNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
match &n.description {
Some(desc) => self.render_inlines(desc, w)?,
None => write_escaped(&n.url, w)?,
}
w.write_all(b"")
}
fn render_transclusion(&self, n: &TransclusionNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"![\"")?;](\"")?;)
= n.attrs.keys().collect();
keys.sort();
for k in keys {
let v = &n.attrs[k];
w.write_all(b" ")?;
write_escaped(k, w)?;
w.write_all(b"=\"")?;
write_escaped(v, w)?;
w.write_all(b"\"")?;
}
w.write_all(b">")
}
fn render_raw_url(&self, n: &RawUrlNode, w: &mut dyn Write) -> io::Result<()> {
w.write_all(b"")?;
write_escaped(&n.url, w)?;
w.write_all(b"")
}
}
// ===== Table colspan/rowspan layout =====
/// Per-cell render decision: emit a lead cell with the computed spans,
/// or skip (this cell is a continuation marker absorbed by its lead).
#[derive(Debug, Clone, Copy)]
enum CellLayout {
Lead { colspan: u32, rowspan: u32 },
Skip,
}
/// Walk every cell in the table and resolve `col_span` / `row_span`
/// markers into HTML `colspan="N"` / `rowspan="N"` attributes on the
/// preceding lead cell.
///
/// Rules:
/// - `col_span: true` (`>` in vimwiki source) bumps the colspan of
/// the lead cell to its *left* in the same row.
/// - `row_span: true` (`\\/` in vimwiki source) bumps the rowspan
/// of the lead cell *above* in the same column.
/// - Markers that don't have a valid lead cell (first column /
/// first row) render as a plain empty cell so the document still
/// parses cleanly.
fn table_spans(table: &TableNode) -> Vec> {
let rows = table.rows.len();
if rows == 0 {
return Vec::new();
}
let cols = table.rows.iter().map(|r| r.cells.len()).max().unwrap_or(0);
let mut layout: Vec> = (0..rows)
.map(|_| {
(0..cols)
.map(|_| CellLayout::Lead {
colspan: 1,
rowspan: 1,
})
.collect()
})
.collect();
for (ri, row) in table.rows.iter().enumerate() {
for (ci, cell) in row.cells.iter().enumerate() {
if cell.col_span {
// Find the lead cell to the left in this row (skipping
// already-skipped continuation slots) and bump it.
let mut k = ci;
while k > 0 {
k -= 1;
match layout[ri][k] {
CellLayout::Lead {
ref mut colspan, ..
} => {
*colspan += 1;
layout[ri][ci] = CellLayout::Skip;
break;
}
CellLayout::Skip => continue,
}
}
} else if cell.row_span {
// Walk up in the same column for the lead cell.
let mut k = ri;
while k > 0 {
k -= 1;
match layout[k][ci] {
CellLayout::Lead {
ref mut rowspan, ..
} => {
*rowspan += 1;
layout[ri][ci] = CellLayout::Skip;
break;
}
CellLayout::Skip => continue,
}
}
}
}
}
layout
}
// ===== Default link resolver =====
/// Default `LinkResolver`. Mirrors the vimwiki link conventions:
/// wiki pages become `path.html`; interwiki links land in sibling
/// directories; diary entries land under `diary/`; file/local schemes
/// use their literal path; anchor-only links collapse to a fragment.
/// Return a copy of `nodes` with every `Keyword` replaced by its literal text.
/// Used for heading content so a keyword in a title renders as plain text (with
/// the heading's own styling) rather than as an inline keyword badge.
fn flatten_keywords(nodes: &[InlineNode]) -> Vec {
nodes
.iter()
.map(|n| match n {
InlineNode::Keyword(k) => InlineNode::Text(TextNode {
span: k.span,
content: k.keyword.label().to_string(),
}),
InlineNode::Bold(b) => InlineNode::Bold(BoldNode {
span: b.span,
children: flatten_keywords(&b.children),
}),
InlineNode::Italic(i) => InlineNode::Italic(ItalicNode {
span: i.span,
children: flatten_keywords(&i.children),
}),
InlineNode::BoldItalic(b) => InlineNode::BoldItalic(BoldItalicNode {
span: b.span,
children: flatten_keywords(&b.children),
}),
InlineNode::Strikethrough(s) => InlineNode::Strikethrough(StrikethroughNode {
span: s.span,
children: flatten_keywords(&s.children),
}),
InlineNode::Superscript(s) => InlineNode::Superscript(SuperscriptNode {
span: s.span,
children: flatten_keywords(&s.children),
}),
InlineNode::Subscript(s) => InlineNode::Subscript(SubscriptNode {
span: s.span,
children: flatten_keywords(&s.children),
}),
InlineNode::Color(c) => InlineNode::Color(ColorNode {
span: c.span,
color: c.color.clone(),
children: flatten_keywords(&c.children),
}),
other => other.clone(),
})
.collect()
}
pub fn default_link_resolver(target: &LinkTarget) -> String {
if matches!(target.kind, LinkKind::AnchorOnly) {
return match &target.anchor {
Some(a) => format!("#{a}"),
None => String::new(),
};
}
let path = target.path.as_deref().unwrap_or("");
let mut out = String::new();
match target.kind {
LinkKind::Wiki => {
if target.is_absolute {
out.push('/');
}
out.push_str(path);
if target.is_directory {
out.push('/');
} else if !path.is_empty() {
out.push_str(".html");
}
}
LinkKind::Interwiki => {
if let Some(idx) = target.wiki_index {
out.push_str(&format!("../wiki{idx}/"));
} else if let Some(name) = &target.wiki_name {
out.push_str(&format!("../wn-{name}/"));
}
out.push_str(path);
if !target.is_directory {
out.push_str(".html");
}
}
LinkKind::Diary => {
out.push_str("diary/");
out.push_str(path);
out.push_str(".html");
}
LinkKind::File => {
out.push_str(path);
}
LinkKind::Local => {
out.push_str("file://");
if target.is_absolute && !path.starts_with('/') {
out.push('/');
}
out.push_str(path);
}
LinkKind::Raw => {
out.push_str(path);
}
LinkKind::AnchorOnly => unreachable!(),
}
if let Some(anchor) = &target.anchor {
out.push('#');
out.push_str(anchor);
}
out
}
// ===== HTML escaping =====
/// Escape `s` for HTML, but pass through inline tags whose name is in
/// `allowed` (vimwiki `valid_html_tags`) verbatim — mirroring upstream's
/// render-time `s:safe_html_line` regex rather than parsing raw HTML.
fn write_escaped_allowing(s: &str, allowed: &[String], w: &mut dyn Write) -> io::Result<()> {
let bytes = s.as_bytes();
let mut i = 0;
let mut last = 0;
while i < bytes.len() {
if bytes[i] == b'<' {
if let Some(end) = match_allowed_tag(bytes, i, allowed) {
write_escaped(&s[last..i], w)?;
w.write_all(&bytes[i..end])?;
i = end;
last = end;
continue;
}
}
i += 1;
}
write_escaped(&s[last..], w)
}
/// If `bytes[lt]` (`<`) begins a `` / `` whose name is in
/// `allowed`, return the index just past the closing `>`. Otherwise `None`.
fn match_allowed_tag(bytes: &[u8], lt: usize, allowed: &[String]) -> Option {
let mut p = lt + 1;
if bytes.get(p) == Some(&b'/') {
p += 1;
}
let name_begin = p;
while p < bytes.len() && (bytes[p] as char).is_ascii_alphabetic() {
p += 1;
}
if p == name_begin {
return None;
}
let name = std::str::from_utf8(&bytes[name_begin..p]).ok()?;
if !allowed.iter().any(|t| t.eq_ignore_ascii_case(name)) {
return None;
}
// Scan to the closing `>` (bail on a nested `<` — not a well-formed tag).
while p < bytes.len() && bytes[p] != b'>' {
if bytes[p] == b'<' {
return None;
}
p += 1;
}
if p >= bytes.len() {
return None;
}
Some(p + 1)
}
/// Replace `:alias:` emoji shortcodes with their glyph (vimwiki
/// `emoji_enable`). Only a curated common subset is supported; unknown
/// shortcodes are left untouched.
fn substitute_emoji(s: &str) -> std::borrow::Cow<'_, str> {
if !s.contains(':') {
return std::borrow::Cow::Borrowed(s);
}
let mut out = String::with_capacity(s.len());
let mut rest = s;
let mut changed = false;
while let Some(open) = rest.find(':') {
out.push_str(&rest[..open]);
let after = &rest[open + 1..];
if let Some(close) = after.find(':') {
let alias = &after[..close];
if !alias.is_empty()
&& alias
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '+' || c == '-')
{
if let Some(glyph) = emoji_for(alias) {
out.push_str(glyph);
rest = &after[close + 1..];
changed = true;
continue;
}
}
}
// Not a shortcode — keep the `:` and continue past it.
out.push(':');
rest = after;
}
out.push_str(rest);
if changed {
std::borrow::Cow::Owned(out)
} else {
std::borrow::Cow::Borrowed(s)
}
}
/// A curated subset of GitHub-style emoji shortcodes.
fn emoji_for(alias: &str) -> Option<&'static str> {
Some(match alias {
"smile" => "😄",
"smiley" => "😃",
"grin" => "😁",
"laughing" | "satisfied" => "😆",
"wink" => "😉",
"blush" => "😊",
"heart" => "❤️",
"broken_heart" => "💔",
"thumbsup" | "+1" => "👍",
"thumbsdown" | "-1" => "👎",
"ok_hand" => "👌",
"wave" => "👋",
"clap" => "👏",
"fire" => "🔥",
"star" => "⭐",
"sparkles" => "✨",
"zap" => "⚡",
"boom" => "💥",
"tada" => "🎉",
"rocket" => "🚀",
"bulb" => "💡",
"bug" => "🐛",
"warning" => "⚠️",
"white_check_mark" | "check" => "✅",
"x" => "❌",
"question" => "❓",
"exclamation" => "❗",
"eyes" => "👀",
"100" => "💯",
"pray" => "🙏",
"muscle" => "💪",
"coffee" => "☕",
"book" => "📖",
"memo" | "pencil" => "📝",
"lock" => "🔒",
"key" => "🔑",
"bell" => "🔔",
"hourglass" => "⌛",
"calendar" => "📅",
_ => return None,
})
}
fn write_escaped(s: &str, w: &mut dyn Write) -> io::Result<()> {
let bytes = s.as_bytes();
let mut last = 0;
for (i, &b) in bytes.iter().enumerate() {
let replacement: &[u8] = match b {
b'<' => b"<",
b'>' => b">",
b'&' => b"&",
b'"' => b""",
b'\'' => b"'",
_ => continue,
};
if i > last {
w.write_all(&bytes[last..i])?;
}
w.write_all(replacement)?;
last = i + 1;
}
if last < bytes.len() {
w.write_all(&bytes[last..])?;
}
Ok(())
}
fn escape(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'&' => out.push_str("&"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
c => out.push(c),
}
}
out
}