diff --git a/src/NoteBookmark.BlazorApp.Tests/Tests/NewsFeedServiceTests.cs b/src/NoteBookmark.BlazorApp.Tests/Tests/NewsFeedServiceTests.cs
new file mode 100644
index 0000000..7b7fbe5
--- /dev/null
+++ b/src/NoteBookmark.BlazorApp.Tests/Tests/NewsFeedServiceTests.cs
@@ -0,0 +1,152 @@
+using System.Net;
+using System.Text;
+using Bunit;
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NoteBookmark.BlazorApp.Components.Pages;
+using NoteBookmark.BlazorApp.Tests.Helpers;
+
+namespace NoteBookmark.BlazorApp.Tests.Tests;
+
+public sealed class NewsFeedServiceTests : BunitContext
+{
+    [Fact]
+    public async Task GetHtmlAsync_RendersMarkdownRewritesRelativeAssetsAndSanitizesUrls()
+    {
+        var requestedUrls = new List<string>();
+        var handler = new DelegateHttpMessageHandler(request =>
+        {
+            requestedUrls.Add(request.RequestUri!.AbsoluteUri);
+            return new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(
+                    "# Product Updates\n\n![Logo](assets/logo.png)\n\n![Chart](./assets/sub/chart(1).png)\n\n![External](https://example.com/banner.png)\n\n<script>alert(1)</script>\n\n[Safe](https://example.com) [Email](mailto:test@example.com) [Unsafe](javascript:alert(1))",
+                    Encoding.UTF8,
+                    "text/plain")
+            };
+        });
+        var service = CreateService(handler);
+
+        var html = await service.GetHtmlAsync();
+
+        requestedUrls.Should().Equal("https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/news.md");
+        html.Should().Contain("<h1>Product Updates</h1>");
+        html.Should().Contain("src=\"https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/assets/logo.png\" alt=\"Logo\"");
+        html.Should().Contain("src=\"https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/assets/sub/chart%281%29.png\" alt=\"Chart\"");
+        html.Should().Contain("src=\"https://example.com/banner.png\" alt=\"External\"");
+        html.Should().NotContain("<script>");
+        html.Should().Contain("href=\"https://example.com\"");
+        html.Should().Contain("href=\"mailto:test@example.com\"");
+        html.Should().Contain("href=\"#\"");
+    }
+
+    [Fact]
+    public async Task GetHtmlAsync_CachesRenderedFeedAcrossCalls()
+    {
+        var callCount = 0;
+        var handler = new DelegateHttpMessageHandler(_ =>
+        {
+            callCount++;
+            return new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent("# Cached Update", Encoding.UTF8, "text/plain")
+            };
+        });
+        var service = CreateService(handler);
+
+        var first = await service.GetHtmlAsync();
+        var second = await service.GetHtmlAsync();
+
+        first.Should().Contain("<h1>Cached Update</h1>");
+        second.Should().Be(first);
+        callCount.Should().Be(1);
+    }
+
+    [Fact]
+    public async Task GetHtmlAsync_WhenFetchFails_ReturnsFriendlyFallbackWithoutCachingFailure()
+    {
+        var shouldFail = true;
+        var handler = new DelegateHttpMessageHandler(_ =>
+        {
+            if (shouldFail)
+            {
+                throw new HttpRequestException("Network error");
+            }
+
+            return new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent("# Recovered Feed", Encoding.UTF8, "text/plain")
+            };
+        });
+        var service = CreateService(handler);
+
+        var fallbackHtml = await service.GetHtmlAsync();
+        shouldFail = false;
+        var recoveredHtml = await service.GetHtmlAsync();
+
+        fallbackHtml.Should().Be("<p>Welcome to NoteBookmark! Check back here for product updates.</p>");
+        recoveredHtml.Should().Contain("<h1>Recovered Feed</h1>");
+    }
+
+    [Fact]
+    public async Task GetHtmlAsync_IgnoresImageSyntaxInsideCodeBlocksAndDisallowsTraversalPaths()
+    {
+        var handler = new DelegateHttpMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new StringContent(
+                "```markdown\n![CodeImage](assets/code.png)\n```\n\n![Traversal](assets/../secret.png)",
+                Encoding.UTF8,
+                "text/plain")
+        });
+        var service = CreateService(handler);
+
+        var html = await service.GetHtmlAsync();
+
+        html.Should().Contain("![CodeImage](assets/code.png)");
+        html.Should().Contain("src=\"assets/../secret.png\"");
+        html.Should().NotContain("https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/assets/code.png");
+        html.Should().NotContain("https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/assets/secret.png");
+    }
+
+    [Fact]
+    public void Home_RendersNewsAndUpdatesSectionFromService()
+    {
+        this.AddFluentUI();
+        var newsFeedMock = new Mock<INewsFeedService>();
+        newsFeedMock.Setup(s => s.GetHtmlAsync()).ReturnsAsync("<p>Latest release notes</p>");
+        Services.AddSingleton(newsFeedMock.Object);
+
+        var cut = Render<Home>();
+
+        var section = cut.Find("section.news-section");
+        section.GetAttribute("aria-labelledby").Should().Be("news-heading");
+        cut.Find("#news-heading").TextContent.Should().Be("News & Updates");
+        cut.Find(".news-content").InnerHtml.Should().Be("<p>Latest release notes</p>");
+    }
+
+    [Fact]
+    public void Home_WhenNewsFeedReturnsFallback_DisplaysWelcomeMessage()
+    {
+        this.AddFluentUI();
+        var service = CreateService(new DelegateHttpMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.NotFound)));
+        Services.AddSingleton<INewsFeedService>(service);
+
+        var cut = Render<Home>();
+
+        cut.Find(".news-content").TextContent.Should().Contain("Welcome to NoteBookmark! Check back here for product updates.");
+    }
+
+    private static NewsFeedService CreateService(HttpMessageHandler handler)
+    {
+        var logger = new Mock<ILogger<NewsFeedService>>();
+        return new NewsFeedService(new HttpClient(handler), logger.Object);
+    }
+
+    private sealed class DelegateHttpMessageHandler(Func<HttpRequestMessage, HttpResponseMessage> responder) : HttpMessageHandler
+    {
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) =>
+            Task.FromResult(responder(request));
+    }
+}
diff --git a/src/NoteBookmark.BlazorApp/Components/Pages/Home.razor b/src/NoteBookmark.BlazorApp/Components/Pages/Home.razor
index 4e72fd5..6a3ac83 100644
--- a/src/NoteBookmark.BlazorApp/Components/Pages/Home.razor
+++ b/src/NoteBookmark.BlazorApp/Components/Pages/Home.razor
@@ -3,6 +3,7 @@
 @using Microsoft.AspNetCore.Authorization
 @using Microsoft.FluentUI.AspNetCore.Components
 @inject NavigationManager Navigation
+@inject INewsFeedService NewsFeed
 
 <PageTitle>Home - NoteBookmark</PageTitle>
 
@@ -40,6 +41,13 @@
         </FluentCard>
     </FluentStack>
 
+    <FluentCard Width="932px">
+        <section class="news-section" aria-labelledby="news-heading">
+            <h3 id="news-heading">News &amp; Updates</h3>
+            <div class="news-content">@((MarkupString)newsHtml)</div>
+        </section>
+    </FluentCard>
+
     <FluentDivider />
 
     <FluentStack Orientation="Orientation.Vertical" VerticalGap="8">
@@ -65,4 +73,13 @@
             </a>
         </FluentStack>
     </FluentStack>
-</FluentStack>
\ No newline at end of file
+</FluentStack>
+
+@code {
+    private string newsHtml = NewsFeedMarkdownRenderer.FallbackHtml;
+
+    protected override async Task OnInitializedAsync()
+    {
+        newsHtml = await NewsFeed.GetHtmlAsync();
+    }
+}
diff --git a/src/NoteBookmark.BlazorApp/INewsFeedService.cs b/src/NoteBookmark.BlazorApp/INewsFeedService.cs
new file mode 100644
index 0000000..d6e1aac
--- /dev/null
+++ b/src/NoteBookmark.BlazorApp/INewsFeedService.cs
@@ -0,0 +1,8 @@
+using System.Threading.Tasks;
+
+namespace NoteBookmark.BlazorApp;
+
+public interface INewsFeedService
+{
+    Task<string> GetHtmlAsync();
+}
diff --git a/src/NoteBookmark.BlazorApp/NewsFeedService.cs b/src/NoteBookmark.BlazorApp/NewsFeedService.cs
new file mode 100644
index 0000000..bd995ce
--- /dev/null
+++ b/src/NoteBookmark.BlazorApp/NewsFeedService.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using NoteBookmark.SharedUI;
+
+namespace NoteBookmark.BlazorApp;
+
+public sealed class NewsFeedService : INewsFeedService
+{
+    private readonly HttpClient _httpClient;
+    private readonly ILogger<NewsFeedService> _logger;
+    private readonly string _newsFeedUrl;
+    private readonly string _newsAssetsUrl;
+    private readonly SemaphoreSlim _loadLock = new(1, 1);
+    private string? _cachedHtml;
+
+    public NewsFeedService(
+        HttpClient httpClient,
+        ILogger<NewsFeedService> logger,
+        string newsFeedUrl = NewsFeedMarkdownRenderer.DefaultNewsFeedUrl,
+        string newsAssetsUrl = NewsFeedMarkdownRenderer.DefaultNewsAssetsUrl)
+    {
+        _httpClient = httpClient;
+        _logger = logger;
+        _newsFeedUrl = newsFeedUrl;
+        _newsAssetsUrl = newsAssetsUrl;
+    }
+
+    public async Task<string> GetHtmlAsync()
+    {
+        if (_cachedHtml is not null)
+        {
+            return _cachedHtml;
+        }
+
+        await _loadLock.WaitAsync();
+        try
+        {
+            if (_cachedHtml is not null)
+            {
+                return _cachedHtml;
+            }
+
+            var markdown = await _httpClient.GetStringAsync(_newsFeedUrl);
+            if (string.IsNullOrWhiteSpace(markdown))
+            {
+                return NewsFeedMarkdownRenderer.FallbackHtml;
+            }
+
+            _cachedHtml = NewsFeedMarkdownRenderer.RenderToHtml(
+                markdown,
+                relativePath => NewsFeedMarkdownRenderer.BuildAssetUrl(relativePath, _newsAssetsUrl));
+
+            return _cachedHtml;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Unable to download the news feed; showing the welcome message.");
+            return NewsFeedMarkdownRenderer.FallbackHtml;
+        }
+        finally
+        {
+            _loadLock.Release();
+        }
+    }
+}
diff --git a/src/NoteBookmark.BlazorApp/Program.cs b/src/NoteBookmark.BlazorApp/Program.cs
index 06f72ef..a1b3d69 100644
--- a/src/NoteBookmark.BlazorApp/Program.cs
+++ b/src/NoteBookmark.BlazorApp/Program.cs
@@ -19,6 +19,10 @@
             });
 builder.Services.AddTransient<IDataService>(sp => sp.GetRequiredService<PostNoteClient>());
 builder.Services.AddScoped<IUrlLauncher, JsUrlLauncher>();
+builder.Services.AddHttpClient(nameof(NewsFeedService));
+builder.Services.AddSingleton<INewsFeedService>(sp => new NewsFeedService(
+    sp.GetRequiredService<IHttpClientFactory>().CreateClient(nameof(NewsFeedService)),
+    sp.GetRequiredService<ILogger<NewsFeedService>>()));
 
 // Register server-side AI settings provider (direct database access, unmasked)
 builder.Services.AddScoped<AISettingsProvider>();
diff --git a/src/NoteBookmark.MauiApp/Data/NewsFeedService.cs b/src/NoteBookmark.MauiApp/Data/NewsFeedService.cs
index 4c0ec73..39f617d 100644
--- a/src/NoteBookmark.MauiApp/Data/NewsFeedService.cs
+++ b/src/NoteBookmark.MauiApp/Data/NewsFeedService.cs
@@ -2,28 +2,18 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Net;
 using System.Net.Http;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
-using Markdig;
-using Markdig.Syntax;
-using Markdig.Syntax.Inlines;
 using Microsoft.Extensions.Logging;
+using NoteBookmark.SharedUI;
 
 namespace NoteBookmark.MauiApp.Data;
 
 public sealed class NewsFeedService : INewsFeedService
 {
-    private const string NewsFeedUrl = "https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/news.md";
-    private const string NewsAssetsUrl = "https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/assets/";
-    private const string FallbackHtml = "<p>Welcome to NoteBookmark! Check back here for product updates.</p>";
-    private static readonly Regex HtmlUrlAttributePattern = new(
-        @"(?<attribute>href|src)=""(?<value>[^""]*)""",
-        RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
-    private static readonly MarkdownPipeline MarkdownPipeline = new MarkdownPipelineBuilder()
-        .DisableHtml()
-        .Build();
+    private const string NewsFeedUrl = NewsFeedMarkdownRenderer.DefaultNewsFeedUrl;
+    private const string NewsAssetsUrl = NewsFeedMarkdownRenderer.DefaultNewsAssetsUrl;
+    private const string FallbackHtml = NewsFeedMarkdownRenderer.FallbackHtml;
 
     private readonly HttpClient _httpClient;
     private readonly ILogger<NewsFeedService> _logger;
@@ -49,8 +39,8 @@ public async Task RefreshAsync()
         try
         {
             var markdown = await _httpClient.GetStringAsync(NewsFeedUrl);
-            var images = GetImages(Markdown.Parse(markdown, MarkdownPipeline))
-                .Select(image => TryGetAssetRelativePath(image.Url))
+            var images = NewsFeedMarkdownRenderer.GetImages(NewsFeedMarkdownRenderer.Parse(markdown))
+                .Select(image => NewsFeedMarkdownRenderer.TryGetAssetRelativePath(image.Url))
                 .Where(path => path is not null)
                 .Cast<string>()
                 .Distinct(StringComparer.OrdinalIgnoreCase)
@@ -59,9 +49,7 @@ public async Task RefreshAsync()
 
             foreach (var relativePath in images)
             {
-                var url = NewsAssetsUrl + string.Join(
-                    "/",
-                    relativePath.Split('/').Select(Uri.EscapeDataString));
+                var url = NewsFeedMarkdownRenderer.BuildAssetUrl(relativePath, NewsAssetsUrl);
                 var content = await _httpClient.GetByteArrayAsync(url);
                 downloadedAssets.Add((GetAssetFilePath(relativePath), content));
             }
@@ -104,10 +92,10 @@ public async Task<string> GetHtmlAsync()
         try
         {
             var markdown = await File.ReadAllTextAsync(_newsFilePath);
-            var document = Markdown.Parse(markdown, MarkdownPipeline);
-            foreach (var image in GetImages(document))
+            var document = NewsFeedMarkdownRenderer.Parse(markdown);
+            foreach (var image in NewsFeedMarkdownRenderer.GetImages(document))
             {
-                var relativePath = TryGetAssetRelativePath(image.Url);
+                var relativePath = NewsFeedMarkdownRenderer.TryGetAssetRelativePath(image.Url);
                 if (relativePath is null)
                 {
                     continue;
@@ -123,8 +111,7 @@ public async Task<string> GetHtmlAsync()
                 image.Url = $"data:{GetImageMimeType(filePath)};base64,{Convert.ToBase64String(imageBytes)}";
             }
 
-            var html = document.ToHtml(MarkdownPipeline);
-            return SanitizeGeneratedHtml(html);
+            return NewsFeedMarkdownRenderer.RenderToHtml(document, _ => null);
         }
         catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
         {
@@ -133,27 +120,6 @@ public async Task<string> GetHtmlAsync()
         }
     }
 
-    private static string SanitizeGeneratedHtml(string html) =>
-        HtmlUrlAttributePattern.Replace(html, match =>
-        {
-            var attribute = match.Groups["attribute"].Value;
-            var value = WebUtility.HtmlDecode(match.Groups["value"].Value);
-            if (!Uri.TryCreate(value, UriKind.Absolute, out var uri))
-            {
-                return match.Value;
-            }
-
-            var isAllowed = uri.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase)
-                || uri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)
-                || (attribute.Equals("href", StringComparison.OrdinalIgnoreCase)
-                    && uri.Scheme.Equals("mailto", StringComparison.OrdinalIgnoreCase))
-                || (attribute.Equals("src", StringComparison.OrdinalIgnoreCase)
-                    && uri.Scheme.Equals("data", StringComparison.OrdinalIgnoreCase)
-                    && value.StartsWith("data:image/", StringComparison.OrdinalIgnoreCase));
-
-            return isAllowed ? match.Value : $"{attribute}=\"#\"";
-        });
-
     private string GetAssetFilePath(string relativePath)
     {
         var path = Path.GetFullPath(Path.Combine(_assetsDirectory, relativePath.Replace('/', Path.DirectorySeparatorChar)));
@@ -166,39 +132,6 @@ private string GetAssetFilePath(string relativePath)
         return path;
     }
 
-    // Uses Markdig's parse tree so inline and reference-style images are found exactly as they render,
-    // and image syntax shown inside code blocks is ignored.
-    private static IEnumerable<LinkInline> GetImages(MarkdownDocument document) =>
-        document.Descendants<LinkInline>().Where(link => link.IsImage);
-
-    private static string? TryGetAssetRelativePath(string? imagePath)
-    {
-        if (string.IsNullOrWhiteSpace(imagePath) || Uri.TryCreate(imagePath, UriKind.Absolute, out _))
-        {
-            return null;
-        }
-
-        var path = Uri.UnescapeDataString(imagePath).Replace('\\', '/');
-        if (path.StartsWith("./", StringComparison.Ordinal))
-        {
-            path = path[2..];
-        }
-
-        if (!path.StartsWith("assets/", StringComparison.OrdinalIgnoreCase))
-        {
-            return null;
-        }
-
-        var relativePath = path["assets/".Length..];
-        var segments = relativePath.Split('/');
-        if (segments.Length == 0 || segments.Any(segment => string.IsNullOrWhiteSpace(segment) || segment is "." or ".."))
-        {
-            return null;
-        }
-
-        return relativePath;
-    }
-
     private static string GetImageMimeType(string path) =>
         Path.GetExtension(path).ToLowerInvariant() switch
         {
diff --git a/src/NoteBookmark.SharedUI/NewsFeedMarkdownRenderer.cs b/src/NoteBookmark.SharedUI/NewsFeedMarkdownRenderer.cs
new file mode 100644
index 0000000..724cd97
--- /dev/null
+++ b/src/NoteBookmark.SharedUI/NewsFeedMarkdownRenderer.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+using Markdig;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+
+namespace NoteBookmark.SharedUI;
+
+public static class NewsFeedMarkdownRenderer
+{
+    public const string DefaultNewsFeedUrl = "https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/news.md";
+    public const string DefaultNewsAssetsUrl = "https://raw.githubusercontent.com/fboucher/NoteBookmark/main/docs/assets/";
+    public const string FallbackHtml = "<p>Welcome to NoteBookmark! Check back here for product updates.</p>";
+
+    private static readonly Regex HtmlUrlAttributePattern = new(
+        @"(?<attribute>href|src)=""(?<value>[^""]*)""",
+        RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+
+    public static MarkdownPipeline Pipeline { get; } = new MarkdownPipelineBuilder()
+        .DisableHtml()
+        .Build();
+
+    public static MarkdownDocument Parse(string markdown) =>
+        Markdown.Parse(markdown, Pipeline);
+
+    // Uses Markdig's parse tree so inline and reference-style images are found exactly as they render,
+    // and image syntax shown inside code blocks is ignored.
+    public static IEnumerable<LinkInline> GetImages(MarkdownDocument document) =>
+        document.Descendants<LinkInline>().Where(link => link.IsImage);
+
+    public static string? TryGetAssetRelativePath(string? imagePath)
+    {
+        if (string.IsNullOrWhiteSpace(imagePath) || Uri.TryCreate(imagePath, UriKind.Absolute, out _))
+        {
+            return null;
+        }
+
+        var path = Uri.UnescapeDataString(imagePath).Replace('\\', '/');
+        if (path.StartsWith("./", StringComparison.Ordinal))
+        {
+            path = path[2..];
+        }
+
+        if (!path.StartsWith("assets/", StringComparison.OrdinalIgnoreCase))
+        {
+            return null;
+        }
+
+        var relativePath = path["assets/".Length..];
+        var segments = relativePath.Split('/');
+        if (segments.Length == 0 || segments.Any(segment => string.IsNullOrWhiteSpace(segment) || segment is "." or ".."))
+        {
+            return null;
+        }
+
+        return relativePath;
+    }
+
+    public static string BuildAssetUrl(string relativePath, string assetsBaseUrl = DefaultNewsAssetsUrl) =>
+        assetsBaseUrl + string.Join("/", relativePath.Split('/').Select(Uri.EscapeDataString));
+
+    public static string RenderToHtml(string markdown, Func<string, string?>? resolveAssetUrl = null)
+    {
+        var document = Parse(markdown);
+        return RenderToHtml(document, resolveAssetUrl);
+    }
+
+    public static string RenderToHtml(MarkdownDocument document, Func<string, string?>? resolveAssetUrl = null)
+    {
+        resolveAssetUrl ??= relativePath => BuildAssetUrl(relativePath);
+
+        foreach (var image in GetImages(document))
+        {
+            var relativePath = TryGetAssetRelativePath(image.Url);
+            if (relativePath is null)
+            {
+                continue;
+            }
+
+            var resolvedUrl = resolveAssetUrl(relativePath);
+            if (resolvedUrl is not null)
+            {
+                image.Url = resolvedUrl;
+            }
+        }
+
+        var html = document.ToHtml(Pipeline);
+        return SanitizeGeneratedHtml(html);
+    }
+
+    public static string SanitizeGeneratedHtml(string html) =>
+        HtmlUrlAttributePattern.Replace(html, match =>
+        {
+            var attribute = match.Groups["attribute"].Value;
+            var value = WebUtility.HtmlDecode(match.Groups["value"].Value);
+            if (!Uri.TryCreate(value, UriKind.Absolute, out var uri))
+            {
+                return match.Value;
+            }
+
+            var isAllowed = uri.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase)
+                || uri.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase)
+                || (attribute.Equals("href", StringComparison.OrdinalIgnoreCase)
+                    && uri.Scheme.Equals("mailto", StringComparison.OrdinalIgnoreCase))
+                || (attribute.Equals("src", StringComparison.OrdinalIgnoreCase)
+                    && uri.Scheme.Equals("data", StringComparison.OrdinalIgnoreCase)
+                    && value.StartsWith("data:image/", StringComparison.OrdinalIgnoreCase));
+
+            return isAllowed ? match.Value : $"{attribute}=\"#\"";
+        });
+}