9ff79c92e0
This makes sure the AngleSharp owner document is only created once per application lifecycle, and replaces all async calls with their synchronous counterparts (since the input is already loaded in memory, using async for this just creates overhead)
493 lines
14 KiB
C#
493 lines
14 KiB
C#
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using AngleSharp;
|
|
using AngleSharp.Dom;
|
|
using AngleSharp.Html.Dom;
|
|
using Iceshrimp.Backend.Core.Configuration;
|
|
using Iceshrimp.Backend.Core.Database.Tables;
|
|
using Iceshrimp.Backend.Core.Extensions;
|
|
using Iceshrimp.Backend.Core.Helpers.LibMfm.Parsing;
|
|
using Iceshrimp.MfmSharp;
|
|
using Iceshrimp.Backend.Core.Services;
|
|
using Iceshrimp.MfmSharp.Helpers;
|
|
using Microsoft.Extensions.Options;
|
|
using MfmHtmlParser = Iceshrimp.Backend.Core.Helpers.LibMfm.Parsing.HtmlParser;
|
|
using HtmlParser = AngleSharp.Html.Parser.HtmlParser;
|
|
|
|
namespace Iceshrimp.Backend.Core.Helpers.LibMfm.Conversion;
|
|
|
|
public readonly record struct MfmInlineMedia(MfmInlineMedia.MediaType Type, string Src, string? Alt)
|
|
{
|
|
public enum MediaType
|
|
{
|
|
Other,
|
|
Image,
|
|
Video,
|
|
Audio
|
|
}
|
|
|
|
public static MediaType GetType(string mime)
|
|
{
|
|
if (mime.StartsWith("image/")) return MediaType.Image;
|
|
if (mime.StartsWith("video/")) return MediaType.Video;
|
|
if (mime.StartsWith("audio/")) return MediaType.Audio;
|
|
|
|
return MediaType.Other;
|
|
}
|
|
}
|
|
|
|
/// <summary>Resulting data after HTML to MFM conversion</summary>
|
|
public readonly record struct HtmlMfmData(string Mfm, List<MfmInlineMedia> InlineMedia);
|
|
|
|
/// <summary>Resulting data after MFM to HTML conversion</summary>
|
|
public readonly record struct MfmHtmlData(string Html, List<MfmInlineMedia> InlineMedia);
|
|
|
|
public class MfmConverter(
|
|
IOptions<Config.InstanceSection> config,
|
|
MediaProxyService mediaProxy,
|
|
FlagService flags
|
|
) : ISingletonService
|
|
{
|
|
private static readonly HtmlParser Parser = new();
|
|
|
|
private static readonly Lazy<IHtmlDocument> OwnerDocument =
|
|
new(() => Parser.ParseDocument(ReadOnlyMemory<char>.Empty));
|
|
|
|
private static IElement CreateElement(string name) => OwnerDocument.Value.CreateElement(name);
|
|
private static IText CreateTextNode(string data) => OwnerDocument.Value.CreateTextNode(data);
|
|
|
|
public static HtmlMfmData FromHtml(
|
|
string? html, List<Note.MentionedUser>? mentions = null, List<string>? hashtags = null
|
|
)
|
|
{
|
|
var media = new List<MfmInlineMedia>();
|
|
if (html == null) return new HtmlMfmData("", media);
|
|
|
|
// Ensure compatibility with AP servers that send both <br> as well as newlines
|
|
var regex = new Regex(@"<br\s?\/?>(?:\r?\n)?", RegexOptions.IgnoreCase);
|
|
html = regex.Replace(html, "\n");
|
|
|
|
// Ensure compatibility with AP servers that send non-breaking space characters instead of regular spaces
|
|
html = html.Replace("\u00A0", " ");
|
|
|
|
// Ensure compatibility with AP servers that send CRLF or CR instead of LF-style newlines
|
|
html = html.ReplaceLineEndings("\n");
|
|
|
|
var dom = Parser.ParseDocument(html);
|
|
if (dom.Body == null) return new HtmlMfmData("", media);
|
|
|
|
var sb = new StringBuilder();
|
|
var parser = new MfmHtmlParser(mentions ?? [], hashtags ?? [], media);
|
|
dom.Body.ChildNodes.Select(parser.ParseNode).ToList().ForEach(s => sb.Append(s));
|
|
return new HtmlMfmData(sb.ToString().Trim(), media);
|
|
}
|
|
|
|
public static List<string> ExtractMentionsFromHtml(string? html)
|
|
{
|
|
if (html == null) return [];
|
|
|
|
// Ensure compatibility with AP servers that send both <br> as well as newlines
|
|
var regex = new Regex(@"<br\s?\/?>\r?\n", RegexOptions.IgnoreCase);
|
|
html = regex.Replace(html, "\n");
|
|
|
|
var dom = Parser.ParseDocument(html);
|
|
if (dom.Body == null) return [];
|
|
|
|
var parser = new HtmlMentionsExtractor();
|
|
foreach (var node in dom.Body.ChildNodes)
|
|
parser.ParseChildren(node);
|
|
|
|
return parser.Mentions;
|
|
}
|
|
|
|
public MfmHtmlData ToHtml(
|
|
IMfmNode[] nodes, List<Note.MentionedUser> mentions, string? host, string? quoteUri = null,
|
|
bool quoteInaccessible = false, bool replyInaccessible = false, string rootElement = "p",
|
|
List<Emoji>? emoji = null, List<MfmInlineMedia>? media = null
|
|
)
|
|
{
|
|
var element = CreateElement(rootElement);
|
|
var hasContent = nodes.Length > 0;
|
|
|
|
if (replyInaccessible)
|
|
{
|
|
var wrapper = CreateElement("span");
|
|
var re = CreateElement("span");
|
|
re.TextContent = "RE: \ud83d\udd12"; // lock emoji
|
|
wrapper.AppendChild(re);
|
|
|
|
if (hasContent)
|
|
{
|
|
wrapper.AppendChild(CreateElement("br"));
|
|
wrapper.AppendChild(CreateElement("br"));
|
|
}
|
|
|
|
element.AppendChild(wrapper);
|
|
}
|
|
|
|
var usedMedia = new List<MfmInlineMedia>();
|
|
foreach (var node in nodes)
|
|
element.AppendNodes(FromMfmNode(node, mentions, host, usedMedia, emoji, media));
|
|
|
|
if (quoteUri != null)
|
|
{
|
|
var a = CreateElement("a");
|
|
a.SetAttribute("href", quoteUri);
|
|
a.TextContent = quoteUri.StartsWith("https://") ? quoteUri[8..] : quoteUri[7..];
|
|
var quote = CreateElement("span");
|
|
quote.ClassList.Add("quote-inline");
|
|
|
|
if (hasContent)
|
|
{
|
|
quote.AppendChild(CreateElement("br"));
|
|
quote.AppendChild(CreateElement("br"));
|
|
}
|
|
|
|
var re = CreateElement("span");
|
|
re.TextContent = "RE: ";
|
|
quote.AppendChild(re);
|
|
quote.AppendChild(a);
|
|
element.AppendChild(quote);
|
|
}
|
|
else if (quoteInaccessible)
|
|
{
|
|
var wrapper = CreateElement("span");
|
|
var re = CreateElement("span");
|
|
re.TextContent = "RE: \ud83d\udd12"; // lock emoji
|
|
|
|
if (hasContent)
|
|
{
|
|
wrapper.AppendChild(CreateElement("br"));
|
|
wrapper.AppendChild(CreateElement("br"));
|
|
}
|
|
|
|
wrapper.AppendChild(re);
|
|
element.AppendChild(wrapper);
|
|
}
|
|
|
|
return new MfmHtmlData(element.ToHtml(), usedMedia);
|
|
}
|
|
|
|
public MfmHtmlData ToHtml(
|
|
string mfm, List<Note.MentionedUser> mentions, string? host, string? quoteUri = null,
|
|
bool quoteInaccessible = false, bool replyInaccessible = false, string rootElement = "p",
|
|
List<Emoji>? emoji = null, List<MfmInlineMedia>? media = null
|
|
)
|
|
{
|
|
var nodes = MfmParser.Parse(mfm);
|
|
return ToHtml(nodes, mentions, host, quoteUri, quoteInaccessible, replyInaccessible, rootElement, emoji, media);
|
|
}
|
|
|
|
public string ProfileFieldToHtml(MfmUrlNode node)
|
|
{
|
|
var parsed = FromMfmNode(node, [], null, []);
|
|
if (parsed is not IHtmlAnchorElement el)
|
|
return parsed.ToHtml();
|
|
|
|
el.SetAttribute("rel", "me nofollow noopener");
|
|
el.SetAttribute("target", "_blank");
|
|
|
|
return el.ToHtml();
|
|
}
|
|
|
|
private INode FromMfmNode(
|
|
IMfmNode node, List<Note.MentionedUser> mentions, string? host, List<MfmInlineMedia> usedMedia,
|
|
List<Emoji>? emoji = null, List<MfmInlineMedia>? media = null
|
|
)
|
|
{
|
|
switch (node)
|
|
{
|
|
case MfmFnNode { Name: "media" } fn when media is { Count: > 0 }:
|
|
{
|
|
var urlNode = fn.Children.FirstOrDefault();
|
|
if (urlNode is MfmUrlNode url)
|
|
{
|
|
MfmInlineMedia? maybeCurrent = media.FirstOrDefault(m => m.Src == url.Url);
|
|
if (maybeCurrent is { } current)
|
|
{
|
|
usedMedia.Add(current);
|
|
|
|
if (!flags.SupportsInlineMedia.Value || current.Type == MfmInlineMedia.MediaType.Other)
|
|
{
|
|
var el = CreateElement("a");
|
|
el.SetAttribute("href", current.Src);
|
|
|
|
if (current.Type == MfmInlineMedia.MediaType.Other)
|
|
el.SetAttribute("download", "true");
|
|
|
|
var icon = current.Type switch
|
|
{
|
|
MfmInlineMedia.MediaType.Image => "\ud83d\uddbc\ufe0f", // framed picture emoji
|
|
MfmInlineMedia.MediaType.Video => "\ud83c\udfac", // clapperboard emoji
|
|
MfmInlineMedia.MediaType.Audio => "\ud83c\udfb5", // music note emoji
|
|
_ => "\ud83d\udcbe", // floppy disk emoji
|
|
};
|
|
|
|
el.TextContent = $"[{icon} {current.Alt ?? current.Src}]";
|
|
return el;
|
|
}
|
|
else
|
|
{
|
|
var nodeName = current.Type switch
|
|
{
|
|
MfmInlineMedia.MediaType.Image => "img",
|
|
MfmInlineMedia.MediaType.Video => "video",
|
|
MfmInlineMedia.MediaType.Audio => "audio",
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
|
|
var el = CreateElement(nodeName);
|
|
el.SetAttribute("src", current.Src);
|
|
el.SetAttribute("alt", current.Alt);
|
|
return el;
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
var el = CreateInlineFormattingElement("i");
|
|
AddHtmlMarkup(el, "*");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
AddHtmlMarkup(el, "*");
|
|
return el;
|
|
}
|
|
}
|
|
case MfmFnNode { Name: "unixtime" } fn:
|
|
{
|
|
var el = CreateInlineFormattingElement("i");
|
|
|
|
if (fn.Children.Length != 1 || fn.Children.FirstOrDefault() is not MfmTextNode textNode)
|
|
return Fallback();
|
|
|
|
double timestamp;
|
|
if (!double.TryParse(textNode.Text, out timestamp)) return Fallback();
|
|
|
|
var date = DateTime.UnixEpoch.AddSeconds(timestamp);
|
|
el.TextContent = date.ToString("HH:mm, d MMM yyyy") + " UTC";
|
|
|
|
return el;
|
|
|
|
IElement Fallback()
|
|
{
|
|
AddHtmlMarkup(el, "*");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
AddHtmlMarkup(el, "*");
|
|
return el;
|
|
}
|
|
}
|
|
case MfmBoldNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("b");
|
|
AddHtmlMarkup(el, "**");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
AddHtmlMarkup(el, "**");
|
|
return el;
|
|
}
|
|
case MfmSmallNode:
|
|
{
|
|
var el = CreateElement("small");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
return el;
|
|
}
|
|
case MfmStrikeNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("del");
|
|
AddHtmlMarkup(el, "~~");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
AddHtmlMarkup(el, "~~");
|
|
return el;
|
|
}
|
|
case MfmItalicNode:
|
|
case MfmFnNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("i");
|
|
AddHtmlMarkup(el, "*");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
AddHtmlMarkup(el, "*");
|
|
return el;
|
|
}
|
|
case MfmCodeBlockNode codeBlockNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("pre");
|
|
var inner = CreateInlineFormattingElement("code");
|
|
inner.TextContent = codeBlockNode.Code;
|
|
el.AppendNodes(inner);
|
|
return el;
|
|
}
|
|
case MfmCenterNode:
|
|
{
|
|
var el = CreateElement("div");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
return el;
|
|
}
|
|
case MfmEmojiCodeNode emojiCodeNode:
|
|
{
|
|
var punyHost = host?.ToPunycodeLower();
|
|
if (emoji?.FirstOrDefault(p => p.Name == emojiCodeNode.Name && p.Host == punyHost) is { } hit)
|
|
{
|
|
var el = CreateElement("span");
|
|
var inner = CreateElement("img");
|
|
inner.SetAttribute("src", mediaProxy.GetProxyUrl(hit));
|
|
inner.SetAttribute("alt", hit.Name);
|
|
el.AppendChild(inner);
|
|
el.ClassList.Add("emoji");
|
|
return el;
|
|
}
|
|
|
|
return CreateTextNode($"\u200B:{emojiCodeNode.Name}:\u200B");
|
|
}
|
|
case MfmHashtagNode hashtagNode:
|
|
{
|
|
var el = CreateElement("a");
|
|
el.SetAttribute("href", $"https://{config.Value.WebDomain}/tags/{hashtagNode.Hashtag}");
|
|
el.TextContent = $"#{hashtagNode.Hashtag}";
|
|
el.SetAttribute("rel", "tag");
|
|
el.ClassList.Add("hashtag");
|
|
return el;
|
|
}
|
|
case MfmInlineCodeNode inlineCodeNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("code");
|
|
el.TextContent = inlineCodeNode.Code;
|
|
return el;
|
|
}
|
|
case MfmInlineMathNode inlineMathNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("code");
|
|
el.TextContent = inlineMathNode.Formula;
|
|
return el;
|
|
}
|
|
case MfmMathBlockNode mathBlockNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("code");
|
|
el.TextContent = mathBlockNode.Formula;
|
|
return el;
|
|
}
|
|
case MfmLinkNode linkNode:
|
|
{
|
|
var el = CreateElement("a");
|
|
el.SetAttribute("href", linkNode.Url);
|
|
el.TextContent = linkNode.Text;
|
|
return el;
|
|
}
|
|
case MfmMentionNode mentionNode:
|
|
{
|
|
var el = CreateElement("span");
|
|
|
|
// Fall back to object host, as localpart-only mentions are relative to the instance the note originated from
|
|
var finalHost = mentionNode.Host ?? host ?? config.Value.AccountDomain;
|
|
|
|
if (finalHost == config.Value.WebDomain)
|
|
finalHost = config.Value.AccountDomain;
|
|
|
|
Func<Note.MentionedUser, bool> predicate = finalHost == config.Value.AccountDomain
|
|
? p => p.Username.EqualsIgnoreCase(mentionNode.User)
|
|
&& (p.Host.EqualsIgnoreCase(finalHost) || p.Host == null)
|
|
: p => p.Username.EqualsIgnoreCase(mentionNode.User) && p.Host.EqualsIgnoreCase(finalHost);
|
|
|
|
if (mentions.FirstOrDefault(predicate) is not { } mention)
|
|
{
|
|
el.TextContent = $"@{mentionNode.Acct}";
|
|
}
|
|
else
|
|
{
|
|
el.ClassList.Add("h-card");
|
|
el.SetAttribute("translate", "no");
|
|
var a = CreateElement("a");
|
|
a.ClassList.Add("u-url", "mention");
|
|
a.SetAttribute("href", mention.Url ?? mention.Uri);
|
|
var span = CreateElement("span");
|
|
span.TextContent = $"@{mention.Username}";
|
|
a.AppendChild(span);
|
|
el.AppendChild(a);
|
|
}
|
|
|
|
return el;
|
|
}
|
|
case MfmQuoteNode:
|
|
{
|
|
var el = CreateInlineFormattingElement("blockquote");
|
|
AddHtmlMarkup(el, "> ");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
AddHtmlMarkupTag(el, "br");
|
|
AddHtmlMarkupTag(el, "br");
|
|
return el;
|
|
}
|
|
case MfmTextNode textNode:
|
|
{
|
|
var el = CreateElement("span");
|
|
var nodes = textNode.Text.Split("\r\n")
|
|
.SelectMany(p => p.Split('\r'))
|
|
.SelectMany(p => p.Split('\n'))
|
|
.Select(CreateTextNode);
|
|
|
|
foreach (var htmlNode in nodes)
|
|
{
|
|
el.AppendNodes(htmlNode);
|
|
el.AppendNodes(CreateElement("br"));
|
|
}
|
|
|
|
if (el.LastChild != null)
|
|
el.RemoveChild(el.LastChild);
|
|
return el;
|
|
}
|
|
case MfmUrlNode urlNode:
|
|
{
|
|
if (
|
|
!Uri.TryCreate(urlNode.Url, UriKind.Absolute, out var uri)
|
|
|| uri is not { Scheme: "http" or "https" }
|
|
)
|
|
{
|
|
var fallbackEl = CreateElement("span");
|
|
fallbackEl.TextContent = urlNode.Url;
|
|
return fallbackEl;
|
|
}
|
|
|
|
var el = CreateElement("a");
|
|
el.SetAttribute("href", urlNode.Url);
|
|
el.TextContent = uri.ToMfmDisplayString();
|
|
return el;
|
|
}
|
|
case MfmPlainNode:
|
|
{
|
|
var el = CreateElement("span");
|
|
AppendChildren(el, node, mentions, host, usedMedia);
|
|
return el;
|
|
}
|
|
default:
|
|
{
|
|
throw new NotImplementedException("Unsupported MfmNode type");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AppendChildren(
|
|
INode element, IMfmNode parent,
|
|
List<Note.MentionedUser> mentions, string? host, List<MfmInlineMedia> usedMedia,
|
|
List<Emoji>? emoji = null, List<MfmInlineMedia>? media = null
|
|
)
|
|
{
|
|
foreach (var node in parent.Children)
|
|
element.AppendNodes(FromMfmNode(node, mentions, host, usedMedia, emoji, media));
|
|
}
|
|
|
|
private IElement CreateInlineFormattingElement(string name)
|
|
{
|
|
return CreateElement(flags.SupportsHtmlFormatting.Value ? name : "span");
|
|
}
|
|
|
|
private void AddHtmlMarkup(IElement node, string chars)
|
|
{
|
|
if (flags.SupportsHtmlFormatting.Value) return;
|
|
var el = CreateElement("span");
|
|
el.AppendChild(CreateTextNode(chars));
|
|
node.AppendChild(el);
|
|
}
|
|
|
|
private void AddHtmlMarkupTag(IElement node, string tag)
|
|
{
|
|
if (flags.SupportsHtmlFormatting.Value) return;
|
|
var el = CreateElement(tag);
|
|
node.AppendChild(el);
|
|
}
|
|
}
|