Cleanup

2026-03-06 23:16:07 +00:00 · 2021-02-22 03:15:09 +02:00
parent bed0ade732
commit ebe4d58a42
101 changed files with 330 additions and 310 deletions
--- a/DiscordChatExporter.Core/Discord/AuthToken.cs
+++ b/DiscordChatExporter.Core/Discord/AuthToken.cs
@@ -0,0 +1,27 @@
+using System.Net.Http.Headers;
+
+namespace DiscordChatExporter.Core.Discord
+{
+    public enum AuthTokenType { User, Bot }
+
+    public class AuthToken
+    {
+        public AuthTokenType Type { get; }
+
+        public string Value { get; }
+
+        public AuthToken(AuthTokenType type, string value)
+        {
+            Type = type;
+            Value = value;
+        }
+
+        public AuthenticationHeaderValue GetAuthenticationHeader() => Type switch
+        {
+            AuthTokenType.Bot => new AuthenticationHeaderValue("Bot", Value),
+            _ => new AuthenticationHeaderValue(Value)
+        };
+
+        public override string ToString() => Value;
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Attachment.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Attachment.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#attachment-object
+    public partial class Attachment : IHasId
+    {
+        public Snowflake Id { get; }
+
+        public string Url { get; }
+
+        public string FileName { get; }
+
+        public int? Width { get; }
+
+        public int? Height { get; }
+
+        public bool IsImage => ImageFileExtensions.Contains(Path.GetExtension(FileName));
+
+        public bool IsVideo => VideoFileExtensions.Contains(Path.GetExtension(FileName));
+
+        public bool IsAudio => AudioFileExtensions.Contains(Path.GetExtension(FileName));
+
+        public bool IsSpoiler =>
+            (IsImage || IsVideo || IsAudio) && FileName.StartsWith("SPOILER_", StringComparison.Ordinal);
+
+        public FileSize FileSize { get; }
+
+        public Attachment(
+            Snowflake id,
+            string url,
+            string fileName,
+            int? width,
+            int? height,
+            FileSize fileSize)
+        {
+            Id = id;
+            Url = url;
+            FileName = fileName;
+            Width = width;
+            Height = height;
+            FileSize = fileSize;
+        }
+
+        public override string ToString() => FileName;
+    }
+
+    public partial class Attachment
+    {
+        private static readonly HashSet<string> ImageFileExtensions = new(StringComparer.OrdinalIgnoreCase)
+            {".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp"};
+
+        private static readonly HashSet<string> VideoFileExtensions = new(StringComparer.OrdinalIgnoreCase)
+            {".mp4", ".webm"};
+
+        private static readonly HashSet<string> AudioFileExtensions = new(StringComparer.OrdinalIgnoreCase)
+            {".mp3", ".wav", ".ogg", ".flac", ".m4a"};
+
+        public static Attachment Parse(JsonElement json)
+        {
+            var id = json.GetProperty("id").GetString().Pipe(Snowflake.Parse);
+            var url = json.GetProperty("url").GetString();
+            var width = json.GetPropertyOrNull("width")?.GetInt32();
+            var height = json.GetPropertyOrNull("height")?.GetInt32();
+            var fileName = json.GetProperty("filename").GetString();
+            var fileSize = json.GetProperty("size").GetInt64().Pipe(FileSize.FromBytes);
+
+            return new Attachment(id, url, fileName, width, height, fileSize);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Channel.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Channel.cs
@@ -0,0 +1,111 @@
+using System.Linq;
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#channel-object-channel-types
+    // Order of enum fields needs to match the order in the docs.
+    public enum ChannelType
+    {
+        GuildTextChat,
+        DirectTextChat,
+        GuildVoiceChat,
+        DirectGroupTextChat,
+        GuildCategory,
+        GuildNews,
+        GuildStore
+    }
+
+    // https://discord.com/developers/docs/resources/channel#channel-object
+    public partial class Channel : IHasId, IHasPosition
+    {
+        public Snowflake Id { get; }
+
+        public ChannelType Type { get; }
+
+        public bool IsTextChannel =>
+            Type == ChannelType.GuildTextChat ||
+            Type == ChannelType.DirectTextChat ||
+            Type == ChannelType.DirectGroupTextChat ||
+            Type == ChannelType.GuildNews ||
+            Type == ChannelType.GuildStore;
+
+        public Snowflake GuildId { get; }
+
+        public ChannelCategory Category { get; }
+
+        public string Name { get; }
+
+        public int? Position { get; }
+
+        public string? Topic { get; }
+
+        public Channel(
+            Snowflake id,
+            ChannelType type,
+            Snowflake guildId,
+            ChannelCategory? category,
+            string name,
+            int? position,
+            string? topic)
+        {
+            Id = id;
+            Type = type;
+            GuildId = guildId;
+            Category = category ?? GetFallbackCategory(type);
+            Name = name;
+            Position = position;
+            Topic = topic;
+        }
+
+        public override string ToString() => Name;
+
+    }
+
+    public partial class Channel
+    {
+        private static ChannelCategory GetFallbackCategory(ChannelType channelType) => new(
+            Snowflake.Zero,
+            channelType switch
+            {
+                ChannelType.GuildTextChat => "Text",
+                ChannelType.DirectTextChat => "Private",
+                ChannelType.DirectGroupTextChat => "Group",
+                ChannelType.GuildNews => "News",
+                ChannelType.GuildStore => "Store",
+                _ => "Default"
+            },
+            0
+        );
+
+        public static Channel Parse(JsonElement json, ChannelCategory? category = null, int? position = null)
+        {
+            var id = json.GetProperty("id").GetString().Pipe(Snowflake.Parse);
+            var guildId = json.GetPropertyOrNull("guild_id")?.GetString().Pipe(Snowflake.Parse);
+            var topic = json.GetPropertyOrNull("topic")?.GetString();
+
+            var type = (ChannelType) json.GetProperty("type").GetInt32();
+
+            var name =
+                json.GetPropertyOrNull("name")?.GetString() ??
+                json.GetPropertyOrNull("recipients")?.EnumerateArray().Select(User.Parse).Select(u => u.Name).JoinToString(", ") ??
+                id.ToString();
+
+            position ??= json.GetPropertyOrNull("position")?.GetInt32();
+
+            return new Channel(
+                id,
+                type,
+                guildId ?? Guild.DirectMessages.Id,
+                category ?? GetFallbackCategory(type),
+                name,
+                position,
+                topic
+            );
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/ChannelCategory.cs
+++ b/DiscordChatExporter.Core/Discord/Data/ChannelCategory.cs
@@ -0,0 +1,49 @@
+using System.Linq;
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    public partial class ChannelCategory : IHasId, IHasPosition
+    {
+        public Snowflake Id { get; }
+
+        public string Name { get; }
+
+        public int? Position { get; }
+
+        public ChannelCategory(Snowflake id, string name, int? position)
+        {
+            Id = id;
+            Name = name;
+            Position = position;
+        }
+
+        public override string ToString() => Name;
+
+    }
+
+    public partial class ChannelCategory
+    {
+        public static ChannelCategory Parse(JsonElement json, int? position = null)
+        {
+            var id = json.GetProperty("id").GetString().Pipe(Snowflake.Parse);
+            position ??= json.GetPropertyOrNull("position")?.GetInt32();
+
+            var name = json.GetPropertyOrNull("name")?.GetString() ??
+                json.GetPropertyOrNull("recipients")?.EnumerateArray().Select(User.Parse).Select(u => u.Name).JoinToString(", ") ??
+                id.ToString();
+
+            return new ChannelCategory(
+                id,
+                name,
+                position
+            );
+        }
+
+        public static ChannelCategory Empty { get; } = new(Snowflake.Zero, "<unknown category>", 0);
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Common/FileSize.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Common/FileSize.cs
@@ -0,0 +1,65 @@
+using System;
+
+namespace DiscordChatExporter.Core.Discord.Data.Common
+{
+    // Loosely based on https://github.com/omar/ByteSize (MIT license)
+    public readonly partial struct FileSize
+    {
+        public long TotalBytes { get; }
+
+        public double TotalKiloBytes => TotalBytes / 1024.0;
+        public double TotalMegaBytes => TotalKiloBytes / 1024.0;
+        public double TotalGigaBytes => TotalMegaBytes / 1024.0;
+        public double TotalTeraBytes => TotalGigaBytes / 1024.0;
+        public double TotalPetaBytes => TotalTeraBytes / 1024.0;
+
+        public FileSize(long bytes) => TotalBytes = bytes;
+
+        private double GetLargestWholeNumberValue()
+        {
+            if (Math.Abs(TotalPetaBytes) >= 1)
+                return TotalPetaBytes;
+
+            if (Math.Abs(TotalTeraBytes) >= 1)
+                return TotalTeraBytes;
+
+            if (Math.Abs(TotalGigaBytes) >= 1)
+                return TotalGigaBytes;
+
+            if (Math.Abs(TotalMegaBytes) >= 1)
+                return TotalMegaBytes;
+
+            if (Math.Abs(TotalKiloBytes) >= 1)
+                return TotalKiloBytes;
+
+            return TotalBytes;
+        }
+
+        private string GetLargestWholeNumberSymbol()
+        {
+            if (Math.Abs(TotalPetaBytes) >= 1)
+                return "PB";
+
+            if (Math.Abs(TotalTeraBytes) >= 1)
+                return "TB";
+
+            if (Math.Abs(TotalGigaBytes) >= 1)
+                return "GB";
+
+            if (Math.Abs(TotalMegaBytes) >= 1)
+                return "MB";
+
+            if (Math.Abs(TotalKiloBytes) >= 1)
+                return "KB";
+
+            return "bytes";
+        }
+
+        public override string ToString() => $"{GetLargestWholeNumberValue():0.##} {GetLargestWholeNumberSymbol()}";
+    }
+
+    public partial struct FileSize
+    {
+        public static FileSize FromBytes(long bytes) => new(bytes);
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Common/IHasId.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Common/IHasId.cs
@@ -0,0 +1,7 @@
+namespace DiscordChatExporter.Core.Discord.Data.Common
+{
+    public interface IHasId
+    {
+        Snowflake Id { get; }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Common/IHasPosition.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Common/IHasPosition.cs
@@ -0,0 +1,7 @@
+namespace DiscordChatExporter.Core.Discord.Data.Common
+{
+    public interface IHasPosition
+    {
+        int? Position { get; }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Common/IdBasedEqualityComparer.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Common/IdBasedEqualityComparer.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Discord.Data.Common
+{
+    public partial class IdBasedEqualityComparer : IEqualityComparer<IHasId>
+    {
+        public bool Equals(IHasId? x, IHasId? y) => x?.Id == y?.Id;
+
+        public int GetHashCode(IHasId obj) => obj.Id.GetHashCode();
+    }
+
+    public partial class IdBasedEqualityComparer
+    {
+        public static IdBasedEqualityComparer Instance { get; } = new();
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Embed.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Embed.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text.Json;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#embed-object
+    public partial class Embed
+    {
+        public string? Title { get; }
+
+        public string? Url { get; }
+
+        public DateTimeOffset? Timestamp { get; }
+
+        public Color? Color { get; }
+
+        public EmbedAuthor? Author { get; }
+
+        public string? Description { get; }
+
+        public IReadOnlyList<EmbedField> Fields { get; }
+
+        public EmbedImage? Thumbnail { get; }
+
+        public EmbedImage? Image { get; }
+
+        public EmbedFooter? Footer { get; }
+
+        public Embed(
+            string? title,
+            string? url,
+            DateTimeOffset? timestamp,
+            Color? color,
+            EmbedAuthor? author,
+            string? description,
+            IReadOnlyList<EmbedField> fields,
+            EmbedImage? thumbnail,
+            EmbedImage? image,
+            EmbedFooter? footer)
+        {
+            Title = title;
+            Url = url;
+            Timestamp = timestamp;
+            Color = color;
+            Author = author;
+            Description = description;
+            Fields = fields;
+            Thumbnail = thumbnail;
+            Image = image;
+            Footer = footer;
+        }
+
+        public override string ToString() => Title ?? "<untitled embed>";
+    }
+
+    public partial class Embed
+    {
+        public static Embed Parse(JsonElement json)
+        {
+            var title = json.GetPropertyOrNull("title")?.GetString();
+            var description = json.GetPropertyOrNull("description")?.GetString();
+            var url = json.GetPropertyOrNull("url")?.GetString();
+            var timestamp = json.GetPropertyOrNull("timestamp")?.GetDateTimeOffset();
+            var color = json.GetPropertyOrNull("color")?.GetInt32().Pipe(System.Drawing.Color.FromArgb).ResetAlpha();
+
+            var author = json.GetPropertyOrNull("author")?.Pipe(EmbedAuthor.Parse);
+            var thumbnail = json.GetPropertyOrNull("thumbnail")?.Pipe(EmbedImage.Parse);
+            var image = json.GetPropertyOrNull("image")?.Pipe(EmbedImage.Parse);
+            var footer = json.GetPropertyOrNull("footer")?.Pipe(EmbedFooter.Parse);
+
+            var fields =
+                json.GetPropertyOrNull("fields")?.EnumerateArray().Select(EmbedField.Parse).ToArray() ??
+                Array.Empty<EmbedField>();
+
+            return new Embed(
+                title,
+                url,
+                timestamp,
+                color,
+                author,
+                description,
+                fields,
+                thumbnail,
+                image,
+                footer
+            );
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/EmbedAuthor.cs
+++ b/DiscordChatExporter.Core/Discord/Data/EmbedAuthor.cs
@@ -0,0 +1,36 @@
+using System.Text.Json;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#embed-object-embed-author-structure
+    public partial class EmbedAuthor
+    {
+        public string? Name { get; }
+
+        public string? Url { get; }
+
+        public string? IconUrl { get; }
+
+        public EmbedAuthor(string? name, string? url, string? iconUrl)
+        {
+            Name = name;
+            Url = url;
+            IconUrl = iconUrl;
+        }
+
+        public override string ToString() => Name ?? "<unnamed author>";
+    }
+
+    public partial class EmbedAuthor
+    {
+        public static EmbedAuthor Parse(JsonElement json)
+        {
+            var name = json.GetPropertyOrNull("name")?.GetString();
+            var url = json.GetPropertyOrNull("url")?.GetString();
+            var iconUrl = json.GetPropertyOrNull("icon_url")?.GetString();
+
+            return new EmbedAuthor(name, url, iconUrl);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/EmbedField.cs
+++ b/DiscordChatExporter.Core/Discord/Data/EmbedField.cs
@@ -0,0 +1,36 @@
+using System.Text.Json;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#embed-object-embed-field-structure
+    public partial class EmbedField
+    {
+        public string Name { get; }
+
+        public string Value { get; }
+
+        public bool IsInline { get; }
+
+        public EmbedField(string name, string value, bool isInline)
+        {
+            Name = name;
+            Value = value;
+            IsInline = isInline;
+        }
+
+        public override string ToString() => $"{Name} | {Value}";
+    }
+
+    public partial class EmbedField
+    {
+        public static EmbedField Parse(JsonElement json)
+        {
+            var name = json.GetProperty("name").GetString();
+            var value = json.GetProperty("value").GetString();
+            var isInline = json.GetPropertyOrNull("inline")?.GetBoolean() ?? false;
+
+            return new EmbedField(name, value, isInline);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/EmbedFooter.cs
+++ b/DiscordChatExporter.Core/Discord/Data/EmbedFooter.cs
@@ -0,0 +1,32 @@
+using System.Text.Json;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#embed-object-embed-footer-structure
+    public partial class EmbedFooter
+    {
+        public string Text { get; }
+
+        public string? IconUrl { get; }
+
+        public EmbedFooter(string text, string? iconUrl)
+        {
+            Text = text;
+            IconUrl = iconUrl;
+        }
+
+        public override string ToString() => Text;
+    }
+
+    public partial class EmbedFooter
+    {
+        public static EmbedFooter Parse(JsonElement json)
+        {
+            var text = json.GetProperty("text").GetString();
+            var iconUrl = json.GetPropertyOrNull("icon_url")?.GetString();
+
+            return new EmbedFooter(text, iconUrl);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/EmbedImage.cs
+++ b/DiscordChatExporter.Core/Discord/Data/EmbedImage.cs
@@ -0,0 +1,34 @@
+using System.Text.Json;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#embed-object-embed-image-structure
+    public partial class EmbedImage
+    {
+        public string? Url { get; }
+
+        public int? Width { get; }
+
+        public int? Height { get; }
+
+        public EmbedImage(string? url, int? width, int? height)
+        {
+            Url = url;
+            Height = height;
+            Width = width;
+        }
+    }
+
+    public partial class EmbedImage
+    {
+        public static EmbedImage Parse(JsonElement json)
+        {
+            var url = json.GetPropertyOrNull("url")?.GetString();
+            var width = json.GetPropertyOrNull("width")?.GetInt32();
+            var height = json.GetPropertyOrNull("height")?.GetInt32();
+
+            return new EmbedImage(url, width, height);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Emoji.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Emoji.cs
@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using JsonExtensions.Reading;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/emoji#emoji-object
+    public partial class Emoji
+    {
+        public string? Id { get; }
+
+        public string Name { get; }
+
+        public bool IsAnimated { get; }
+
+        public string ImageUrl { get; }
+
+        public Emoji(string? id, string name, bool isAnimated)
+        {
+            Id = id;
+            Name = name;
+            IsAnimated = isAnimated;
+
+            ImageUrl = GetImageUrl(id, name, isAnimated);
+        }
+
+        public override string ToString() => Name;
+    }
+
+    public partial class Emoji
+    {
+        private static IEnumerable<Rune> GetRunes(string emoji)
+        {
+            var lastIndex = 0;
+            while (lastIndex < emoji.Length && Rune.TryGetRuneAt(emoji, lastIndex, out var rune))
+            {
+                // Skip variant selector rune
+                if (rune.Value != 0xfe0f)
+                    yield return rune;
+
+                lastIndex += rune.Utf16SequenceLength;
+            }
+        }
+
+        private static string GetTwemojiName(IEnumerable<Rune> runes) =>
+            runes.Select(r => r.Value.ToString("x")).JoinToString("-");
+
+        public static string GetImageUrl(string? id, string name, bool isAnimated)
+        {
+            // Custom emoji
+            if (!string.IsNullOrWhiteSpace(id))
+            {
+                // Animated
+                if (isAnimated)
+                    return $"https://cdn.discordapp.com/emojis/{id}.gif";
+
+                // Non-animated
+                return $"https://cdn.discordapp.com/emojis/{id}.png";
+            }
+
+            // Standard emoji
+            var emojiRunes = GetRunes(name).ToArray();
+            var twemojiName = GetTwemojiName(emojiRunes);
+            return $"https://twemoji.maxcdn.com/2/72x72/{twemojiName}.png";
+        }
+
+        public static Emoji Parse(JsonElement json)
+        {
+            var id = json.GetPropertyOrNull("id")?.GetString();
+            var name = json.GetProperty("name").GetString();
+            var isAnimated = json.GetPropertyOrNull("animated")?.GetBoolean() ?? false;
+
+            return new Emoji(id, name, isAnimated);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Guild.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Guild.cs
@@ -0,0 +1,53 @@
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/guild#guild-object
+    public partial class Guild : IHasId
+    {
+        public Snowflake Id { get; }
+
+        public string Name { get; }
+
+        public string IconUrl { get; }
+
+        public Guild(Snowflake id, string name, string iconUrl)
+        {
+            Id = id;
+            Name = name;
+            IconUrl = iconUrl;
+        }
+
+        public override string ToString() => Name;
+    }
+
+    public partial class Guild
+    {
+        public static Guild DirectMessages { get; } = new(
+            Snowflake.Zero,
+            "Direct Messages",
+            GetDefaultIconUrl()
+        );
+
+        private static string GetDefaultIconUrl() =>
+            "https://cdn.discordapp.com/embed/avatars/0.png";
+
+        private static string GetIconUrl(Snowflake id, string iconHash) =>
+            $"https://cdn.discordapp.com/icons/{id}/{iconHash}.png";
+
+        public static Guild Parse(JsonElement json)
+        {
+            var id = json.GetProperty("id").GetString().Pipe(Snowflake.Parse);
+            var name = json.GetProperty("name").GetString();
+            var iconHash = json.GetProperty("icon").GetString();
+
+            var iconUrl = !string.IsNullOrWhiteSpace(iconHash)
+                ? GetIconUrl(id, iconHash)
+                : GetDefaultIconUrl();
+
+            return new Guild(id, name, iconUrl);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Member.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Member.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/guild#guild-member-object
+    public partial class Member : IHasId
+    {
+        public Snowflake Id => User.Id;
+
+        public User User { get; }
+
+        public string Nick { get; }
+
+        public IReadOnlyList<Snowflake> RoleIds { get; }
+
+        public Member(User user, string? nick, IReadOnlyList<Snowflake> roleIds)
+        {
+            User = user;
+            Nick = nick ?? user.Name;
+            RoleIds = roleIds;
+        }
+
+        public override string ToString() => Nick;
+    }
+
+    public partial class Member
+    {
+        public static Member CreateForUser(User user) => new(
+            user,
+            null,
+            Array.Empty<Snowflake>()
+        );
+
+        public static Member Parse(JsonElement json)
+        {
+            var user = json.GetProperty("user").Pipe(User.Parse);
+            var nick = json.GetPropertyOrNull("nick")?.GetString();
+
+            var roleIds =
+                json.GetPropertyOrNull("roles")?.EnumerateArray().Select(j => j.GetString().Pipe(Snowflake.Parse)).ToArray() ??
+                Array.Empty<Snowflake>();
+
+            return new Member(
+                user,
+                nick,
+                roleIds
+            );
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Message.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Message.cs
@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#message-object-message-types
+    public enum MessageType
+    {
+        Default = 0,
+        RecipientAdd = 1,
+        RecipientRemove = 2,
+        Call = 3,
+        ChannelNameChange = 4,
+        ChannelIconChange = 5,
+        ChannelPinnedMessage = 6,
+        GuildMemberJoin = 7,
+        Reply = 19
+    }
+
+    // https://discord.com/developers/docs/resources/channel#message-object
+    public partial class Message : IHasId
+    {
+        public Snowflake Id { get; }
+
+        public MessageType Type { get; }
+
+        public User Author { get; }
+
+        public DateTimeOffset Timestamp { get; }
+
+        public DateTimeOffset? EditedTimestamp { get; }
+
+        public DateTimeOffset? CallEndedTimestamp { get; }
+
+        public bool IsPinned { get; }
+
+        public string Content { get; }
+
+        public IReadOnlyList<Attachment> Attachments { get; }
+
+        public IReadOnlyList<Embed> Embeds { get; }
+
+        public IReadOnlyList<Reaction> Reactions { get; }
+
+        public IReadOnlyList<User> MentionedUsers { get; }
+
+        public MessageReference? Reference { get; }
+
+        public Message? ReferencedMessage { get; }
+
+        public Message(
+            Snowflake id,
+            MessageType type,
+            User author,
+            DateTimeOffset timestamp,
+            DateTimeOffset? editedTimestamp,
+            DateTimeOffset? callEndedTimestamp,
+            bool isPinned,
+            string content,
+            IReadOnlyList<Attachment> attachments,
+            IReadOnlyList<Embed> embeds,
+            IReadOnlyList<Reaction> reactions,
+            IReadOnlyList<User> mentionedUsers,
+            MessageReference? messageReference,
+            Message? referencedMessage)
+        {
+            Id = id;
+            Type = type;
+            Author = author;
+            Timestamp = timestamp;
+            EditedTimestamp = editedTimestamp;
+            CallEndedTimestamp = callEndedTimestamp;
+            IsPinned = isPinned;
+            Content = content;
+            Attachments = attachments;
+            Embeds = embeds;
+            Reactions = reactions;
+            MentionedUsers = mentionedUsers;
+            Reference = messageReference;
+            ReferencedMessage = referencedMessage;
+        }
+
+        public override string ToString() => Content;
+    }
+
+    public partial class Message
+    {
+        public static Message Parse(JsonElement json)
+        {
+            var id = json.GetProperty("id").GetString().Pipe(Snowflake.Parse);
+            var author = json.GetProperty("author").Pipe(User.Parse);
+            var timestamp = json.GetProperty("timestamp").GetDateTimeOffset();
+            var editedTimestamp = json.GetPropertyOrNull("edited_timestamp")?.GetDateTimeOffset();
+            var callEndedTimestamp = json.GetPropertyOrNull("call")?.GetPropertyOrNull("ended_timestamp")?.GetDateTimeOffset();
+            var type = (MessageType) json.GetProperty("type").GetInt32();
+            var isPinned = json.GetPropertyOrNull("pinned")?.GetBoolean() ?? false;
+            var messageReference = json.GetPropertyOrNull("message_reference")?.Pipe(MessageReference.Parse);
+            var referencedMessage = json.GetPropertyOrNull("referenced_message")?.Pipe(Message.Parse);
+
+            var content = type switch
+            {
+                MessageType.RecipientAdd => "Added a recipient.",
+                MessageType.RecipientRemove => "Removed a recipient.",
+                MessageType.Call =>
+                    $"Started a call that lasted {callEndedTimestamp?.Pipe(t => t - timestamp).Pipe(t => (int) t.TotalMinutes) ?? 0} minutes.",
+                MessageType.ChannelNameChange => "Changed the channel name.",
+                MessageType.ChannelIconChange => "Changed the channel icon.",
+                MessageType.ChannelPinnedMessage => "Pinned a message.",
+                MessageType.GuildMemberJoin => "Joined the server.",
+                _ => json.GetPropertyOrNull("content")?.GetString() ?? ""
+            };
+
+            var attachments =
+                json.GetPropertyOrNull("attachments")?.EnumerateArray().Select(Attachment.Parse).ToArray() ??
+                Array.Empty<Attachment>();
+
+            var embeds =
+                json.GetPropertyOrNull("embeds")?.EnumerateArray().Select(Embed.Parse).ToArray() ??
+                Array.Empty<Embed>();
+
+            var reactions =
+                json.GetPropertyOrNull("reactions")?.EnumerateArray().Select(Reaction.Parse).ToArray() ??
+                Array.Empty<Reaction>();
+
+            var mentionedUsers =
+                json.GetPropertyOrNull("mentions")?.EnumerateArray().Select(User.Parse).ToArray() ??
+                Array.Empty<User>();
+
+            return new Message(
+                id,
+                type,
+                author,
+                timestamp,
+                editedTimestamp,
+                callEndedTimestamp,
+                isPinned,
+                content,
+                attachments,
+                embeds,
+                reactions,
+                mentionedUsers,
+                messageReference,
+                referencedMessage
+            );
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/MessageReference.cs
+++ b/DiscordChatExporter.Core/Discord/Data/MessageReference.cs
@@ -0,0 +1,37 @@
+using System.Text.Json;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#message-object-message-reference-structure
+    public partial class MessageReference
+    {
+        public Snowflake? MessageId { get; }
+
+        public Snowflake? ChannelId { get; }
+
+        public Snowflake? GuildId { get; }
+
+        public MessageReference(Snowflake? messageId, Snowflake? channelId, Snowflake? guildId)
+        {
+            MessageId = messageId;
+            ChannelId = channelId;
+            GuildId = guildId;
+        }
+
+        public override string ToString() => MessageId?.ToString() ?? "<unknown reference>";
+    }
+
+    public partial class MessageReference
+    {
+        public static MessageReference Parse(JsonElement json)
+        {
+            var messageId = json.GetPropertyOrNull("message_id")?.GetString().Pipe(Snowflake.Parse);
+            var channelId = json.GetPropertyOrNull("channel_id")?.GetString().Pipe(Snowflake.Parse);
+            var guildId = json.GetPropertyOrNull("guild_id")?.GetString().Pipe(Snowflake.Parse);
+
+            return new MessageReference(messageId, channelId, guildId);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Reaction.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Reaction.cs
@@ -0,0 +1,32 @@
+using System.Text.Json;
+using DiscordChatExporter.Core.Utils.Extensions;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/channel#reaction-object
+    public partial class Reaction
+    {
+        public Emoji Emoji { get; }
+
+        public int Count { get; }
+
+        public Reaction(Emoji emoji, int count)
+        {
+            Emoji = emoji;
+            Count = count;
+        }
+
+        public override string ToString() => $"{Emoji} ({Count})";
+    }
+
+    public partial class Reaction
+    {
+        public static Reaction Parse(JsonElement json)
+        {
+            var count = json.GetProperty("count").GetInt32();
+            var emoji = json.GetProperty("emoji").Pipe(Emoji.Parse);
+
+            return new Reaction(emoji, count);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/Role.cs
+++ b/DiscordChatExporter.Core/Discord/Data/Role.cs
@@ -0,0 +1,52 @@
+using System.Drawing;
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/topics/permissions#role-object
+    public partial class Role : IHasId
+    {
+        public Snowflake Id { get; }
+
+        public string Name { get; }
+
+        public int Position { get; }
+
+        public Color? Color { get; }
+
+        public Role(
+            Snowflake id,
+            string name,
+            int position,
+            Color? color)
+        {
+            Id = id;
+            Name = name;
+            Position = position;
+            Color = color;
+        }
+
+        public override string ToString() => Name;
+    }
+
+    public partial class Role
+    {
+        public static Role Parse(JsonElement json)
+        {
+            var id = json.GetProperty("id").GetString().Pipe(Snowflake.Parse);
+            var name = json.GetProperty("name").GetString();
+            var position = json.GetProperty("position").GetInt32();
+
+            var color = json.GetPropertyOrNull("color")?
+                .GetInt32()
+                .Pipe(System.Drawing.Color.FromArgb)
+                .ResetAlpha()
+                .NullIf(c => c.ToRgb() <= 0);
+
+            return new Role(id, name, position, color);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Data/User.cs
+++ b/DiscordChatExporter.Core/Discord/Data/User.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Text.Json;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord.Data
+{
+    // https://discord.com/developers/docs/resources/user#user-object
+    public partial class User : IHasId
+    {
+        public Snowflake Id { get; }
+
+        public bool IsBot { get; }
+
+        public int Discriminator { get; }
+
+        public string Name { get; }
+
+        public string FullName => $"{Name}#{Discriminator:0000}";
+
+        public string AvatarUrl { get; }
+
+        public User(
+            Snowflake id,
+            bool isBot,
+            int discriminator,
+            string name,
+            string avatarUrl)
+        {
+            Id = id;
+            IsBot = isBot;
+            Discriminator = discriminator;
+            Name = name;
+            AvatarUrl = avatarUrl;
+        }
+
+        public override string ToString() => FullName;
+    }
+
+    public partial class User
+    {
+        private static string GetDefaultAvatarUrl(int discriminator) =>
+            $"https://cdn.discordapp.com/embed/avatars/{discriminator % 5}.png";
+
+        private static string GetAvatarUrl(Snowflake id, string avatarHash)
+        {
+            // Animated
+            if (avatarHash.StartsWith("a_", StringComparison.Ordinal))
+                return $"https://cdn.discordapp.com/avatars/{id}/{avatarHash}.gif";
+
+            // Non-animated
+            return $"https://cdn.discordapp.com/avatars/{id}/{avatarHash}.png";
+        }
+
+        public static User Parse(JsonElement json)
+        {
+            var id = json.GetProperty("id").GetString().Pipe(Snowflake.Parse);
+            var discriminator = json.GetProperty("discriminator").GetString().Pipe(int.Parse);
+            var name = json.GetProperty("username").GetString();
+            var avatarHash = json.GetProperty("avatar").GetString();
+            var isBot = json.GetPropertyOrNull("bot")?.GetBoolean() ?? false;
+
+            var avatarUrl = !string.IsNullOrWhiteSpace(avatarHash)
+                ? GetAvatarUrl(id, avatarHash)
+                : GetDefaultAvatarUrl(discriminator);
+
+            return new User(id, isBot, discriminator, name, avatarUrl);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/DiscordClient.cs
+++ b/DiscordChatExporter.Core/Discord/DiscordClient.cs
@@ -0,0 +1,274 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Exceptions;
+using DiscordChatExporter.Core.Utils;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Http;
+using JsonExtensions.Reading;
+
+namespace DiscordChatExporter.Core.Discord
+{
+    public class DiscordClient
+    {
+        private readonly HttpClient _httpClient;
+        private readonly AuthToken _token;
+
+        private readonly Uri _baseUri = new("https://discord.com/api/v8/", UriKind.Absolute);
+
+        public DiscordClient(HttpClient httpClient, AuthToken token)
+        {
+            _httpClient = httpClient;
+            _token = token;
+        }
+
+        public DiscordClient(AuthToken token)
+            : this(Http.Client, token) {}
+
+        private async ValueTask<HttpResponseMessage> GetResponseAsync(string url) =>
+            await Http.ResponsePolicy.ExecuteAsync(async () =>
+            {
+                using var request = new HttpRequestMessage(HttpMethod.Get, new Uri(_baseUri, url));
+                request.Headers.Authorization = _token.GetAuthenticationHeader();
+
+                return await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+            });
+
+        private async ValueTask<JsonElement> GetJsonResponseAsync(string url)
+        {
+            using var response = await GetResponseAsync(url);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw response.StatusCode switch
+                {
+                    HttpStatusCode.Unauthorized => DiscordChatExporterException.Unauthorized(),
+                    HttpStatusCode.Forbidden => DiscordChatExporterException.Forbidden(),
+                    HttpStatusCode.NotFound => DiscordChatExporterException.NotFound(),
+                    _ => DiscordChatExporterException.FailedHttpRequest(response)
+                };
+            }
+
+            return await response.Content.ReadAsJsonAsync();
+        }
+
+        private async ValueTask<JsonElement?> TryGetJsonResponseAsync(string url)
+        {
+            using var response = await GetResponseAsync(url);
+
+            return response.IsSuccessStatusCode
+                ? await response.Content.ReadAsJsonAsync()
+                : (JsonElement?) null;
+        }
+
+        public async IAsyncEnumerable<Guild> GetUserGuildsAsync()
+        {
+            yield return Guild.DirectMessages;
+
+            var currentAfter = Snowflake.Zero;
+
+            while (true)
+            {
+                var url = new UrlBuilder()
+                    .SetPath("users/@me/guilds")
+                    .SetQueryParameter("limit", "100")
+                    .SetQueryParameter("after", currentAfter.ToString())
+                    .Build();
+
+                var response = await GetJsonResponseAsync(url);
+
+                var isEmpty = true;
+                foreach (var guild in response.EnumerateArray().Select(Guild.Parse))
+                {
+                    yield return guild;
+
+                    currentAfter = guild.Id;
+                    isEmpty = false;
+                }
+
+                if (isEmpty)
+                    yield break;
+            }
+        }
+
+        public async ValueTask<Guild> GetGuildAsync(Snowflake guildId)
+        {
+            if (guildId == Guild.DirectMessages.Id)
+                return Guild.DirectMessages;
+
+            var response = await GetJsonResponseAsync($"guilds/{guildId}");
+            return Guild.Parse(response);
+        }
+
+        public async IAsyncEnumerable<Channel> GetGuildChannelsAsync(Snowflake guildId)
+        {
+            if (guildId == Guild.DirectMessages.Id)
+            {
+                var response = await GetJsonResponseAsync("users/@me/channels");
+                foreach (var channelJson in response.EnumerateArray())
+                    yield return Channel.Parse(channelJson);
+            }
+            else
+            {
+                var response = await GetJsonResponseAsync($"guilds/{guildId}/channels");
+
+                var orderedResponse = response
+                    .EnumerateArray()
+                    .OrderBy(j => j.GetProperty("position").GetInt32())
+                    .ThenBy(j => ulong.Parse(j.GetProperty("id").GetString()))
+                    .ToArray();
+
+                var categories = orderedResponse
+                    .Where(j => j.GetProperty("type").GetInt32() == (int)ChannelType.GuildCategory)
+                    .Select((j, index) => ChannelCategory.Parse(j, index + 1))
+                    .ToDictionary(j => j.Id.ToString());
+
+                var position = 0;
+
+                foreach (var channelJson in orderedResponse)
+                {
+                    var parentId = channelJson.GetPropertyOrNull("parent_id")?.GetString();
+                    var category = !string.IsNullOrWhiteSpace(parentId)
+                        ? categories.GetValueOrDefault(parentId)
+                        : null;
+
+                    var channel = Channel.Parse(channelJson, category, position);
+
+                    // Skip non-text channels
+                    if (!channel.IsTextChannel)
+                        continue;
+
+                    position++;
+
+                    yield return channel;
+                }
+            }
+        }
+
+        public async IAsyncEnumerable<Role> GetGuildRolesAsync(Snowflake guildId)
+        {
+            if (guildId == Guild.DirectMessages.Id)
+                yield break;
+
+            var response = await GetJsonResponseAsync($"guilds/{guildId}/roles");
+
+            foreach (var roleJson in response.EnumerateArray())
+                yield return Role.Parse(roleJson);
+        }
+
+        public async ValueTask<Member?> TryGetGuildMemberAsync(Snowflake guildId, User user)
+        {
+            if (guildId == Guild.DirectMessages.Id)
+                return Member.CreateForUser(user);
+
+            var response = await TryGetJsonResponseAsync($"guilds/{guildId}/members/{user.Id}");
+            return response?.Pipe(Member.Parse);
+        }
+
+        public async ValueTask<ChannelCategory> GetChannelCategoryAsync(Snowflake channelId)
+        {
+            try
+            {
+                var response = await GetJsonResponseAsync($"channels/{channelId}");
+                return ChannelCategory.Parse(response);
+            }
+            /***
+             * In some cases, the Discord API returns an empty body when requesting some channel category info.
+             * Instead, we use an empty channel category as a fallback.
+             */
+            catch (DiscordChatExporterException)
+            {
+                return ChannelCategory.Empty;
+            }
+
+        }
+
+        public async ValueTask<Channel> GetChannelAsync(Snowflake channelId)
+        {
+            var response = await GetJsonResponseAsync($"channels/{channelId}");
+
+            var parentId = response.GetPropertyOrNull("parent_id")?.GetString().Pipe(Snowflake.Parse);
+
+            var category = parentId != null
+                ? await GetChannelCategoryAsync(parentId.Value)
+                : null;
+
+            return Channel.Parse(response, category);
+        }
+
+        private async ValueTask<Message?> TryGetLastMessageAsync(Snowflake channelId, Snowflake? before = null)
+        {
+            var url = new UrlBuilder()
+                .SetPath($"channels/{channelId}/messages")
+                .SetQueryParameter("limit", "1")
+                .SetQueryParameter("before", before?.ToString())
+                .Build();
+
+            var response = await GetJsonResponseAsync(url);
+            return response.EnumerateArray().Select(Message.Parse).LastOrDefault();
+        }
+
+        public async IAsyncEnumerable<Message> GetMessagesAsync(
+            Snowflake channelId,
+            Snowflake? after = null,
+            Snowflake? before = null,
+            IProgress<double>? progress = null)
+        {
+            // Get the last message in the specified range.
+            // This snapshots the boundaries, which means that messages posted after the exported started
+            // will not appear in the output.
+            // Additionally, it provides the date of the last message, which is used to calculate progress.
+            var lastMessage = await TryGetLastMessageAsync(channelId, before);
+            if (lastMessage == null || lastMessage.Timestamp < after?.ToDate())
+                yield break;
+
+            // Keep track of first message in range in order to calculate progress
+            var firstMessage = default(Message);
+            var currentAfter = after ?? Snowflake.Zero;
+
+            while (true)
+            {
+                var url = new UrlBuilder()
+                    .SetPath($"channels/{channelId}/messages")
+                    .SetQueryParameter("limit", "100")
+                    .SetQueryParameter("after", currentAfter.ToString())
+                    .Build();
+
+                var response = await GetJsonResponseAsync(url);
+
+                var messages = response
+                    .EnumerateArray()
+                    .Select(Message.Parse)
+                    .Reverse() // reverse because messages appear newest first
+                    .ToArray();
+
+                // Break if there are no messages (can happen if messages are deleted during execution)
+                if (!messages.Any())
+                    yield break;
+
+                foreach (var message in messages)
+                {
+                    firstMessage ??= message;
+
+                    // Ensure messages are in range (take into account that last message could have been deleted)
+                    if (message.Timestamp > lastMessage.Timestamp)
+                        yield break;
+
+                    // Report progress based on the duration of parsed messages divided by total
+                    progress?.Report(
+                        (message.Timestamp - firstMessage.Timestamp) /
+                        (lastMessage.Timestamp - firstMessage.Timestamp)
+                    );
+
+                    yield return message;
+                    currentAfter = message.Id;
+                }
+            }
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Discord/Snowflake.cs
+++ b/DiscordChatExporter.Core/Discord/Snowflake.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace DiscordChatExporter.Core.Discord
+{
+    public readonly partial struct Snowflake
+    {
+        public ulong Value { get; }
+
+        public Snowflake(ulong value) => Value = value;
+
+        public DateTimeOffset ToDate() =>
+            DateTimeOffset.FromUnixTimeMilliseconds((long) ((Value >> 22) + 1420070400000UL)).ToLocalTime();
+
+        public override string ToString() => Value.ToString(CultureInfo.InvariantCulture);
+    }
+
+    public partial struct Snowflake
+    {
+        public static Snowflake Zero { get; } = new(0);
+
+        public static Snowflake FromDate(DateTimeOffset date)
+        {
+            var value = ((ulong) date.ToUnixTimeMilliseconds() - 1420070400000UL) << 22;
+            return new Snowflake(value);
+        }
+
+        public static Snowflake? TryParse(string? str, IFormatProvider? formatProvider = null)
+        {
+            if (string.IsNullOrWhiteSpace(str))
+                return null;
+
+            // As number
+            if (Regex.IsMatch(str, @"^\d+$") &&
+                ulong.TryParse(str, NumberStyles.Number, formatProvider, out var value))
+            {
+                return new Snowflake(value);
+            }
+
+            // As date
+            if (DateTimeOffset.TryParse(str, formatProvider, DateTimeStyles.None, out var date))
+            {
+                return FromDate(date);
+            }
+
+            return null;
+        }
+
+        public static Snowflake Parse(string str, IFormatProvider? formatProvider) =>
+            TryParse(str, formatProvider) ?? throw new FormatException($"Invalid snowflake: {str}.");
+
+        public static Snowflake Parse(string str) => Parse(str, null);
+    }
+
+    public partial struct Snowflake : IEquatable<Snowflake>
+    {
+        public bool Equals(Snowflake other) => Value == other.Value;
+
+        public override bool Equals(object? obj) => obj is Snowflake other && Equals(other);
+
+        public override int GetHashCode() => Value.GetHashCode();
+
+        public static bool operator ==(Snowflake left, Snowflake right) => left.Equals(right);
+
+        public static bool operator !=(Snowflake left, Snowflake right) => !(left == right);
+    }
+}
--- a/DiscordChatExporter.Core/DiscordChatExporter.Core.csproj
+++ b/DiscordChatExporter.Core/DiscordChatExporter.Core.csproj
@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="JsonExtensions" Version="1.0.1" />
+    <PackageReference Include="MiniRazor" Version="2.0.3" />
+    <PackageReference Include="Polly" Version="7.2.1" />
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="Exporting\Writers\Html\Core.css" />
+    <EmbeddedResource Include="Exporting\Writers\Html\Dark.css" />
+    <EmbeddedResource Include="Exporting\Writers\Html\Light.css" />
+    <AdditionalFiles Include="Exporting\Writers\Html\PreambleTemplate.cshtml" IsRazorTemplate="true" />
+    <AdditionalFiles Include="Exporting\Writers\Html\PostambleTemplate.cshtml" IsRazorTemplate="true" />
+    <AdditionalFiles Include="Exporting\Writers\Html\MessageGroupTemplate.cshtml" IsRazorTemplate="true" />
+  </ItemGroup>
+
+</Project>
--- a/DiscordChatExporter.Core/Exceptions/DiscordChatExporterException.cs
+++ b/DiscordChatExporter.Core/Exceptions/DiscordChatExporterException.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Net.Http;
+
+namespace DiscordChatExporter.Core.Exceptions
+{
+    public partial class DiscordChatExporterException : Exception
+    {
+        public bool IsCritical { get; }
+
+        public DiscordChatExporterException(string message, bool isCritical = false)
+            : base(message)
+        {
+            IsCritical = isCritical;
+        }
+    }
+
+    public partial class DiscordChatExporterException
+    {
+        internal static DiscordChatExporterException FailedHttpRequest(HttpResponseMessage response)
+        {
+            var message = $@"
+Failed to perform an HTTP request.
+
+{response.RequestMessage}
+
+{response}";
+
+            return new DiscordChatExporterException(message.Trim(), true);
+        }
+
+        internal static DiscordChatExporterException Unauthorized()
+        {
+            const string message = "Authentication token is invalid.";
+            return new DiscordChatExporterException(message);
+        }
+
+        internal static DiscordChatExporterException Forbidden()
+        {
+            const string message = "Access is forbidden.";
+            return new DiscordChatExporterException(message);
+        }
+
+        internal static DiscordChatExporterException NotFound()
+        {
+            const string message = "Requested resource does not exist.";
+            return new DiscordChatExporterException(message);
+        }
+
+        internal static DiscordChatExporterException ChannelIsEmpty()
+        {
+            var message = $"No messages for the specified period.";
+            return new DiscordChatExporterException(message);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/ChannelExporter.cs
+++ b/DiscordChatExporter.Core/Exporting/ChannelExporter.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Discord.Data.Common;
+using DiscordChatExporter.Core.Exceptions;
+using DiscordChatExporter.Core.Utils.Extensions;
+
+namespace DiscordChatExporter.Core.Exporting
+{
+    public class ChannelExporter
+    {
+        private readonly DiscordClient _discord;
+
+        public ChannelExporter(DiscordClient discord) => _discord = discord;
+
+        public ChannelExporter(AuthToken token) : this(new DiscordClient(token)) {}
+
+        public async ValueTask ExportChannelAsync(ExportRequest request, IProgress<double>? progress = null)
+        {
+            // Build context
+            var contextMembers = new HashSet<Member>(IdBasedEqualityComparer.Instance);
+            var contextChannels = await _discord.GetGuildChannelsAsync(request.Guild.Id);
+            var contextRoles = await _discord.GetGuildRolesAsync(request.Guild.Id);
+
+            var context = new ExportContext(
+                request,
+                contextMembers,
+                contextChannels,
+                contextRoles
+            );
+
+            // Export messages
+            await using var messageExporter = new MessageExporter(context);
+
+            var exportedAnything = false;
+            var encounteredUsers = new HashSet<User>(IdBasedEqualityComparer.Instance);
+            await foreach (var message in _discord.GetMessagesAsync(request.Channel.Id, request.After, request.Before, progress))
+            {
+                // Resolve members for referenced users
+                foreach (var referencedUser in message.MentionedUsers.Prepend(message.Author))
+                {
+                    if (!encounteredUsers.Add(referencedUser))
+                        continue;
+
+                    var member =
+                        await _discord.TryGetGuildMemberAsync(request.Guild.Id, referencedUser) ??
+                        Member.CreateForUser(referencedUser);
+
+                    contextMembers.Add(member);
+                }
+
+                // Export message
+                await messageExporter.ExportMessageAsync(message);
+                exportedAnything = true;
+            }
+
+            // Throw if no messages were exported
+            if (!exportedAnything)
+                throw DiscordChatExporterException.ChannelIsEmpty();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/ExportContext.cs
+++ b/DiscordChatExporter.Core/Exporting/ExportContext.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Utils.Extensions;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Exporting
+{
+    internal class ExportContext
+    {
+        private readonly MediaDownloader _mediaDownloader;
+
+        public ExportRequest Request { get; }
+
+        public IReadOnlyCollection<Member> Members { get; }
+
+        public IReadOnlyCollection<Channel> Channels { get; }
+
+        public IReadOnlyCollection<Role> Roles { get; }
+
+        public ExportContext(
+            ExportRequest request,
+            IReadOnlyCollection<Member> members,
+            IReadOnlyCollection<Channel> channels,
+            IReadOnlyCollection<Role> roles)
+        {
+            Request = request;
+            Members = members;
+            Channels = channels;
+            Roles = roles;
+
+            _mediaDownloader = new MediaDownloader(request.OutputMediaDirPath, request.ShouldReuseMedia);
+        }
+
+        public string FormatDate(DateTimeOffset date) => Request.DateFormat switch
+        {
+            "unix" => date.ToUnixTimeSeconds().ToString(),
+            "unixms" => date.ToUnixTimeMilliseconds().ToString(),
+            var dateFormat => date.ToLocalString(dateFormat)
+        };
+
+        public Member? TryGetMember(Snowflake id) => Members.FirstOrDefault(m => m.Id == id);
+
+        public Channel? TryGetChannel(Snowflake id) => Channels.FirstOrDefault(c => c.Id == id);
+
+        public Role? TryGetRole(Snowflake id) => Roles.FirstOrDefault(r => r.Id == id);
+
+        public Color? TryGetUserColor(Snowflake id)
+        {
+            var member = TryGetMember(id);
+            var roles = member?.RoleIds.Join(Roles, i => i, r => r.Id, (_, role) => role);
+
+            return roles?
+                .Where(r => r.Color != null)
+                .OrderByDescending(r => r.Position)
+                .Select(r => r.Color)
+                .FirstOrDefault();
+        }
+
+        public async ValueTask<string> ResolveMediaUrlAsync(string url)
+        {
+            if (!Request.ShouldDownloadMedia)
+                return url;
+
+            try
+            {
+                var filePath = await _mediaDownloader.DownloadAsync(url);
+
+                // We want relative path so that the output files can be copied around without breaking.
+                // Base directory path may be null if the file is stored at the root or relative to working directory.
+                var relativeFilePath = !string.IsNullOrWhiteSpace(Request.OutputBaseDirPath)
+                    ? Path.GetRelativePath(Request.OutputBaseDirPath, filePath)
+                    : filePath;
+
+                // HACK: for HTML, we need to format the URL properly
+                if (Request.Format == ExportFormat.HtmlDark || Request.Format == ExportFormat.HtmlLight)
+                {
+                    // Need to escape each path segment while keeping the directory separators intact
+                    return relativeFilePath
+                        .Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
+                        .Select(Uri.EscapeDataString)
+                        .JoinToString(Path.AltDirectorySeparatorChar.ToString());
+                }
+
+                return relativeFilePath;
+            }
+            // Try to catch only exceptions related to failed HTTP requests
+            // https://github.com/Tyrrrz/DiscordChatExporter/issues/332
+            // https://github.com/Tyrrrz/DiscordChatExporter/issues/372
+            catch (Exception ex) when (ex is HttpRequestException || ex is OperationCanceledException)
+            {
+                // TODO: add logging so we can be more liberal with catching exceptions
+                // We don't want this to crash the exporting process in case of failure
+                return url;
+            }
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/ExportFormat.cs
+++ b/DiscordChatExporter.Core/Exporting/ExportFormat.cs
@@ -0,0 +1,36 @@
+using System;
+
+namespace DiscordChatExporter.Core.Exporting
+{
+    public enum ExportFormat
+    {
+        PlainText,
+        HtmlDark,
+        HtmlLight,
+        Csv,
+        Json
+    }
+
+    public static class ExportFormatExtensions
+    {
+        public static string GetFileExtension(this ExportFormat format) => format switch
+        {
+            ExportFormat.PlainText => "txt",
+            ExportFormat.HtmlDark => "html",
+            ExportFormat.HtmlLight => "html",
+            ExportFormat.Csv => "csv",
+            ExportFormat.Json => "json",
+            _ => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+
+        public static string GetDisplayName(this ExportFormat format) => format switch
+        {
+            ExportFormat.PlainText => "TXT",
+            ExportFormat.HtmlDark => "HTML (Dark)",
+            ExportFormat.HtmlLight => "HTML (Light)",
+            ExportFormat.Csv => "CSV",
+            ExportFormat.Json => "JSON",
+            _ => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/ExportRequest.cs
+++ b/DiscordChatExporter.Core/Exporting/ExportRequest.cs
@@ -0,0 +1,162 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+using DiscordChatExporter.Core.Discord;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Utils;
+
+namespace DiscordChatExporter.Core.Exporting
+{
+    public partial class ExportRequest
+    {
+        public Guild Guild { get; }
+
+        public Channel Channel { get; }
+
+        public string OutputPath { get; }
+
+        public string OutputBaseFilePath { get; }
+
+        public string OutputBaseDirPath { get; }
+
+        public string OutputMediaDirPath { get; }
+
+        public ExportFormat Format { get; }
+
+        public Snowflake? After { get; }
+
+        public Snowflake? Before { get; }
+
+        public int? PartitionLimit { get; }
+
+        public bool ShouldDownloadMedia { get; }
+
+        public bool ShouldReuseMedia { get; }
+
+        public string DateFormat { get; }
+
+        public ExportRequest(
+            Guild guild,
+            Channel channel,
+            string outputPath,
+            ExportFormat format,
+            Snowflake? after,
+            Snowflake? before,
+            int? partitionLimit,
+            bool shouldDownloadMedia,
+            bool shouldReuseMedia,
+            string dateFormat)
+        {
+            Guild = guild;
+            Channel = channel;
+            OutputPath = outputPath;
+            Format = format;
+            After = after;
+            Before = before;
+            PartitionLimit = partitionLimit;
+            ShouldDownloadMedia = shouldDownloadMedia;
+            ShouldReuseMedia = shouldReuseMedia;
+            DateFormat = dateFormat;
+
+            OutputBaseFilePath = GetOutputBaseFilePath(
+                guild,
+                channel,
+                outputPath,
+                format,
+                after,
+                before
+            );
+
+            OutputBaseDirPath = Path.GetDirectoryName(OutputBaseFilePath) ?? OutputPath;
+            OutputMediaDirPath = $"{OutputBaseFilePath}_Files{Path.DirectorySeparatorChar}";
+        }
+    }
+
+    public partial class ExportRequest
+    {
+        private static string GetOutputBaseFilePath(
+            Guild guild,
+            Channel channel,
+            string outputPath,
+            ExportFormat format,
+            Snowflake? after = null,
+            Snowflake? before = null)
+        {
+
+            // Formats path
+            outputPath = Regex.Replace(outputPath, "%.", m =>
+                PathEx.EscapePath(m.Value switch
+                {
+                    "%g" => guild.Id.ToString(),
+                    "%G" => guild.Name,
+                    "%t" => channel.Category.Id.ToString(),
+                    "%T" => channel.Category.Name,
+                    "%c" => channel.Id.ToString(),
+                    "%C" => channel.Name,
+                    "%p" => channel.Position?.ToString() ?? "0",
+                    "%P" => channel.Category.Position?.ToString() ?? "0",
+                    "%a" => (after ?? Snowflake.Zero).ToDate().ToString("yyyy-MM-dd"),
+                    "%b" => (before?.ToDate() ?? DateTime.Now).ToString("yyyy-MM-dd"),
+                    "%%" => "%",
+                    _ => m.Value
+                })
+            );
+
+            // Output is a directory
+            if (Directory.Exists(outputPath) || string.IsNullOrWhiteSpace(Path.GetExtension(outputPath)))
+            {
+                var fileName = GetDefaultOutputFileName(guild, channel, format, after, before);
+                return Path.Combine(outputPath, fileName);
+            }
+
+            // Output is a file
+            return outputPath;
+        }
+
+        public static string GetDefaultOutputFileName(
+            Guild guild,
+            Channel channel,
+            ExportFormat format,
+            Snowflake? after = null,
+            Snowflake? before = null)
+        {
+            var buffer = new StringBuilder();
+
+            // Guild and channel names
+            buffer.Append($"{guild.Name} - {channel.Category.Name} - {channel.Name} [{channel.Id}]");
+
+            // Date range
+            if (after != null || before != null)
+            {
+                buffer.Append(" (");
+
+                // Both 'after' and 'before' are set
+                if (after != null && before != null)
+                {
+                    buffer.Append($"{after?.ToDate():yyyy-MM-dd} to {before?.ToDate():yyyy-MM-dd}");
+                }
+                // Only 'after' is set
+                else if (after != null)
+                {
+                    buffer.Append($"after {after?.ToDate():yyyy-MM-dd}");
+                }
+                // Only 'before' is set
+                else
+                {
+                    buffer.Append($"before {before?.ToDate():yyyy-MM-dd}");
+                }
+
+                buffer.Append(")");
+            }
+
+            // File extension
+            buffer.Append($".{format.GetFileExtension()}");
+
+            // Replace invalid chars
+            PathEx.EscapePath(buffer);
+
+            return buffer.ToString();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/MediaDownloader.cs
+++ b/DiscordChatExporter.Core/Exporting/MediaDownloader.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Net.Http;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Utils;
+using DiscordChatExporter.Core.Utils.Extensions;
+
+namespace DiscordChatExporter.Core.Exporting
+{
+    internal partial class MediaDownloader
+    {
+        private readonly HttpClient _httpClient;
+        private readonly string _workingDirPath;
+        private readonly bool _reuseMedia;
+
+        // URL -> Local file path
+        private readonly Dictionary<string, string> _pathCache = new(StringComparer.Ordinal);
+
+        public MediaDownloader(HttpClient httpClient, string workingDirPath, bool reuseMedia)
+        {
+            _httpClient = httpClient;
+            _workingDirPath = workingDirPath;
+            _reuseMedia = reuseMedia;
+        }
+
+        public MediaDownloader(string workingDirPath, bool reuseMedia)
+            : this(Http.Client, workingDirPath, reuseMedia) {}
+
+        public async ValueTask<string> DownloadAsync(string url)
+        {
+            if (_pathCache.TryGetValue(url, out var cachedFilePath))
+                return cachedFilePath;
+
+            var fileName = GetFileNameFromUrl(url);
+            var filePath = Path.Combine(_workingDirPath, fileName);
+
+            // Reuse existing files if we're allowed to
+            if (_reuseMedia && File.Exists(filePath))
+                return _pathCache[url] = filePath;
+
+            Directory.CreateDirectory(_workingDirPath);
+
+            // This catches IOExceptions which is dangerous as we're working also with files
+            await Http.ExceptionPolicy.ExecuteAsync(async () =>
+            {
+                // Download the file
+                using var response = await _httpClient.GetAsync(url);
+                await using (var output = File.Create(filePath))
+                {
+                    await response.Content.CopyToAsync(output);
+                }
+
+                // Try to set the file date according to the last-modified header
+                var lastModified = response.Content.Headers.TryGetValue("Last-Modified")?.Pipe(s =>
+                    DateTimeOffset.TryParse(s, CultureInfo.InvariantCulture, DateTimeStyles.None, out var date)
+                        ? date
+                        : (DateTimeOffset?) null
+                );
+
+                if (lastModified != null)
+                {
+                    File.SetCreationTimeUtc(filePath, lastModified.Value.UtcDateTime);
+                    File.SetLastWriteTimeUtc(filePath, lastModified.Value.UtcDateTime);
+                    File.SetLastAccessTimeUtc(filePath, lastModified.Value.UtcDateTime);
+                }
+            });
+
+            return _pathCache[url] = filePath;
+        }
+    }
+
+    internal partial class MediaDownloader
+    {
+        private static string GetUrlHash(string url)
+        {
+            using var hash = SHA256.Create();
+
+            var data = hash.ComputeHash(Encoding.UTF8.GetBytes(url));
+            return data.ToHex().Truncate(5); // 5 chars ought to be enough for anybody
+        }
+
+        private static string GetFileNameFromUrl(string url)
+        {
+            var urlHash = GetUrlHash(url);
+
+            // Try to extract file name from URL
+            var fileName = Regex.Match(url, @".+/([^?]*)").Groups[1].Value;
+
+            // If it's not there, just use the URL hash as the file name
+            if (string.IsNullOrWhiteSpace(fileName))
+                return urlHash;
+
+            // Otherwise, use the original file name but inject the hash in the middle
+            var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
+            var fileExtension = Path.GetExtension(fileName);
+
+            return PathEx.EscapePath(fileNameWithoutExtension.Truncate(42) + '-' + urlHash + fileExtension);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/MessageExporter.cs
+++ b/DiscordChatExporter.Core/Exporting/MessageExporter.cs
@@ -0,0 +1,113 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Exporting.Writers;
+
+namespace DiscordChatExporter.Core.Exporting
+{
+    internal partial class MessageExporter : IAsyncDisposable
+    {
+        private readonly ExportContext _context;
+
+        private long _messageCount;
+        private int _partitionIndex;
+        private MessageWriter? _writer;
+
+        public MessageExporter(ExportContext context)
+        {
+            _context = context;
+        }
+
+        private bool IsPartitionLimitReached() =>
+            _messageCount > 0 &&
+            _context.Request.PartitionLimit != null &&
+            _context.Request.PartitionLimit != 0 &&
+            _messageCount % _context.Request.PartitionLimit == 0;
+
+        private async ValueTask ResetWriterAsync()
+        {
+            if (_writer != null)
+            {
+                await _writer.WritePostambleAsync();
+                await _writer.DisposeAsync();
+                _writer = null;
+            }
+        }
+
+        private async ValueTask<MessageWriter> GetWriterAsync()
+        {
+            // Ensure partition limit has not been exceeded
+            if (IsPartitionLimitReached())
+            {
+                await ResetWriterAsync();
+                _partitionIndex++;
+            }
+
+            // Writer is still valid - return
+            if (_writer != null)
+                return _writer;
+
+            var filePath = GetPartitionFilePath(_context.Request.OutputBaseFilePath, _partitionIndex);
+
+            var dirPath = Path.GetDirectoryName(_context.Request.OutputBaseFilePath);
+            if (!string.IsNullOrWhiteSpace(dirPath))
+                Directory.CreateDirectory(dirPath);
+
+            var writer = CreateMessageWriter(filePath, _context.Request.Format, _context);
+            await writer.WritePreambleAsync();
+
+            return _writer = writer;
+        }
+
+        public async ValueTask ExportMessageAsync(Message message)
+        {
+            var writer = await GetWriterAsync();
+            await writer.WriteMessageAsync(message);
+            _messageCount++;
+        }
+
+        public async ValueTask DisposeAsync() => await ResetWriterAsync();
+    }
+
+    internal partial class MessageExporter
+    {
+        private static string GetPartitionFilePath(
+            string baseFilePath,
+            int partitionIndex)
+        {
+            // First partition - don't change file name
+            if (partitionIndex <= 0)
+                return baseFilePath;
+
+            // Inject partition index into file name
+            var fileNameWithoutExt = Path.GetFileNameWithoutExtension(baseFilePath);
+            var fileExt = Path.GetExtension(baseFilePath);
+            var fileName = $"{fileNameWithoutExt} [part {partitionIndex + 1}]{fileExt}";
+            var dirPath = Path.GetDirectoryName(baseFilePath);
+
+            return !string.IsNullOrWhiteSpace(dirPath)
+                ? Path.Combine(dirPath, fileName)
+                : fileName;
+        }
+
+        private static MessageWriter CreateMessageWriter(
+            string filePath,
+            ExportFormat format,
+            ExportContext context)
+        {
+            // Stream will be disposed by the underlying writer
+            var stream = File.Create(filePath);
+
+            return format switch
+            {
+                ExportFormat.PlainText => new PlainTextMessageWriter(stream, context),
+                ExportFormat.Csv => new CsvMessageWriter(stream, context),
+                ExportFormat.HtmlDark => new HtmlMessageWriter(stream, context, "Dark"),
+                ExportFormat.HtmlLight => new HtmlMessageWriter(stream, context, "Light"),
+                ExportFormat.Json => new JsonMessageWriter(stream, context),
+                _ => throw new ArgumentOutOfRangeException(nameof(format), $"Unknown export format '{format}'.")
+            };
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/CsvMessageWriter.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/CsvMessageWriter.cs
@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Exporting.Writers.MarkdownVisitors;
+using DiscordChatExporter.Core.Utils.Extensions;
+
+namespace DiscordChatExporter.Core.Exporting.Writers
+{
+    internal partial class CsvMessageWriter : MessageWriter
+    {
+        private readonly TextWriter _writer;
+
+        public CsvMessageWriter(Stream stream, ExportContext context)
+            : base(stream, context)
+        {
+            _writer = new StreamWriter(stream);
+        }
+
+        private string FormatMarkdown(string? markdown) =>
+            PlainTextMarkdownVisitor.Format(Context, markdown ?? "");
+
+        public override async ValueTask WritePreambleAsync() =>
+            await _writer.WriteLineAsync("AuthorID,Author,Date,Content,Attachments,Reactions");
+
+        private async ValueTask WriteAttachmentsAsync(IReadOnlyList<Attachment> attachments)
+        {
+            var buffer = new StringBuilder();
+
+            foreach (var attachment in attachments)
+            {
+                buffer
+                    .AppendIfNotEmpty(',')
+                    .Append(await Context.ResolveMediaUrlAsync(attachment.Url));
+            }
+
+            await _writer.WriteAsync(CsvEncode(buffer.ToString()));
+        }
+
+        private async ValueTask WriteReactionsAsync(IReadOnlyList<Reaction> reactions)
+        {
+            var buffer = new StringBuilder();
+
+            foreach (var reaction in reactions)
+            {
+                buffer
+                    .AppendIfNotEmpty(',')
+                    .Append(reaction.Emoji.Name)
+                    .Append(' ')
+                    .Append('(')
+                    .Append(reaction.Count)
+                    .Append(')');
+            }
+
+            await _writer.WriteAsync(CsvEncode(buffer.ToString()));
+        }
+
+        public override async ValueTask WriteMessageAsync(Message message)
+        {
+            // Author ID
+            await _writer.WriteAsync(CsvEncode(message.Author.Id.ToString()));
+            await _writer.WriteAsync(',');
+
+            // Author name
+            await _writer.WriteAsync(CsvEncode(message.Author.FullName));
+            await _writer.WriteAsync(',');
+
+            // Message timestamp
+            await _writer.WriteAsync(CsvEncode(Context.FormatDate(message.Timestamp)));
+            await _writer.WriteAsync(',');
+
+            // Message content
+            await _writer.WriteAsync(CsvEncode(FormatMarkdown(message.Content)));
+            await _writer.WriteAsync(',');
+
+            // Attachments
+            await WriteAttachmentsAsync(message.Attachments);
+            await _writer.WriteAsync(',');
+
+            // Reactions
+            await WriteReactionsAsync(message.Reactions);
+
+            // Finish row
+            await _writer.WriteLineAsync();
+        }
+
+        public override async ValueTask DisposeAsync()
+        {
+            await _writer.DisposeAsync();
+            await base.DisposeAsync();
+        }
+    }
+
+    internal partial class CsvMessageWriter
+    {
+        private static string CsvEncode(string value)
+        {
+            value = value.Replace("\"", "\"\"");
+            return $"\"{value}\"";
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/Core.css
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/Core.css
@@ -0,0 +1,525 @@
+/* General */
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://cdn.jsdelivr.net/gh/Tyrrrz/DiscordFonts@master/whitney-300.woff);
+    font-weight: 300;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://cdn.jsdelivr.net/gh/Tyrrrz/DiscordFonts@master/whitney-400.woff);
+    font-weight: 400;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://cdn.jsdelivr.net/gh/Tyrrrz/DiscordFonts@master/whitney-500.woff);
+    font-weight: 500;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://cdn.jsdelivr.net/gh/Tyrrrz/DiscordFonts@master/whitney-600.woff);
+    font-weight: 600;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://cdn.jsdelivr.net/gh/Tyrrrz/DiscordFonts@master/whitney-700.woff);
+    font-weight: 700;
+}
+
+body {
+    font-family: "Whitney", "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 17px;
+}
+
+a {
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+img {
+    object-fit: contain;
+}
+
+.markdown {
+    max-width: 100%;
+    line-height: 1.3;
+    overflow-wrap: break-word;
+}
+
+.preserve-whitespace {
+    white-space: pre-wrap;
+}
+
+.spoiler {
+    /* width: fit-content; */
+    display: inline-block;
+    /* This is more consistent across browsers, the old attribute worked well under Chrome but not FireFox. */
+}
+
+.spoiler--hidden {
+    cursor: pointer;
+}
+
+.spoiler-text {
+    border-radius: 3px;
+}
+
+.spoiler--hidden .spoiler-text {
+    color: rgba(0, 0, 0, 0);
+}
+
+.spoiler--hidden .spoiler-text::selection {
+    color: rgba(0, 0, 0, 0);
+}
+
+.spoiler-image {
+    position: relative;
+    overflow: hidden;
+    border-radius: 3px;
+}
+
+.spoiler--hidden .spoiler-image {
+    box-shadow: 0 0 1px 1px rgba(0, 0, 0, 0.1);
+}
+
+.spoiler--hidden .spoiler-image * {
+    filter: blur(44px);
+}
+
+.spoiler--hidden .spoiler-image:after {
+    content: "SPOILER";
+    color: #dcddde;
+    background-color: rgba(0, 0, 0, 0.6);
+    position: absolute;
+    left: 50%;
+    top: 50%;
+    transform: translate(-50%, -50%);
+    font-weight: 600;
+    padding: 100%;
+    border-radius: 20px;
+    letter-spacing: 0.05em;
+    font-size: 0.9em;
+}
+
+.spoiler--hidden:hover .spoiler-image:after {
+    color: #fff;
+    background-color: rgba(0, 0, 0, 0.9);
+}
+
+.quote {
+    margin: 0.1em 0;
+    padding-left: 0.6em;
+    border-left: 4px solid;
+    border-radius: 3px;
+}
+
+.pre {
+    font-family: "Consolas", "Courier New", Courier, monospace;
+}
+
+.pre--multiline {
+    margin-top: 0.25em;
+    padding: 0.5em;
+    border: 2px solid;
+    border-radius: 5px;
+}
+
+.pre--inline {
+    padding: 2px;
+    border-radius: 3px;
+    font-size: 0.85em;
+}
+
+.mention {
+    border-radius: 3px;
+    padding: 0 2px;
+    color: #7289da;
+    background: rgba(114, 137, 218, .1);
+    font-weight: 500;
+}
+
+.emoji {
+    width: 1.25em;
+    height: 1.25em;
+    margin: 0 0.06em;
+    vertical-align: -0.4em;
+}
+
+.emoji--small {
+    width: 1em;
+    height: 1em;
+}
+
+.emoji--large {
+    width: 2.8em;
+    height: 2.8em;
+}
+
+/* Preamble */
+
+.preamble {
+    display: grid;
+    margin: 0 0.3em 0.6em 0.3em;
+    max-width: 100%;
+    grid-template-columns: auto 1fr;
+}
+
+.preamble__guild-icon-container {
+    grid-column: 1;
+}
+
+.preamble__guild-icon {
+    max-width: 88px;
+    max-height: 88px;
+}
+
+.preamble__entries-container {
+    grid-column: 2;
+    margin-left: 0.6em;
+}
+
+.preamble__entry {
+    font-size: 1.4em;
+}
+
+.preamble__entry--small {
+    font-size: 1em;
+}
+
+/* Chatlog */
+
+.chatlog {
+    max-width: 100%;
+}
+
+.chatlog__message-group {
+    display: grid;
+    margin: 0 0.6em;
+    padding: 0.9em 0;
+    border-top: 1px solid;
+    grid-template-columns: auto 1fr;
+}
+
+.chatlog__reference-symbol {
+    grid-column: 1;
+    border-style: solid;
+    border-width: 2px 0 0 2px;
+    border-radius: 8px 0 0 0;
+    margin-left: 16px;
+    margin-top: 8px;
+}
+
+.chatlog__reference {
+    display: flex;
+    grid-column: 2;
+    margin-left: 1.2em;
+    margin-bottom: 0.25em;
+    font-size: 0.875em;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    align-items: center;
+}
+
+.chatlog__reference-avatar {
+    border-radius: 50%;
+    height: 16px;
+    width: 16px;
+    margin-right: 0.25em;
+}
+
+.chatlog__reference-name {
+    margin-right: 0.25em;
+    font-weight: 600;
+}
+
+.chatlog__reference-link {
+    flex-grow: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.chatlog__reference-link:hover {
+    text-decoration: none;
+}
+
+.chatlog__reference-content > * {
+    display: inline;
+}
+
+.chatlog__reference-edited-timestamp {
+    margin-left: 0.25em;
+    font-size: 0.8em;
+}
+
+.chatlog__author-avatar-container {
+    grid-column: 1;
+    width: 40px;
+    height: 40px;
+}
+
+.chatlog__author-avatar {
+    border-radius: 50%;
+    height: 40px;
+    width: 40px;
+}
+
+.chatlog__messages {
+    grid-column: 2;
+    margin-left: 1.2em;
+    min-width: 50%;
+}
+
+.chatlog__author-name {
+    font-weight: 500;
+}
+
+.chatlog__timestamp {
+    margin-left: 0.3em;
+    font-size: 0.75em;
+}
+
+.chatlog__message {
+    padding: 0.1em 0.3em;
+    margin: 0 -0.3em;
+    background-color: transparent;
+    transition: background-color 1s ease;
+}
+
+.chatlog__content {
+    font-size: 0.95em;
+    word-wrap: break-word;
+}
+
+.chatlog__edited-timestamp {
+    margin-left: 0.15em;
+    font-size: 0.8em;
+}
+
+.chatlog__attachment {
+    margin-top: 0.3em;
+}
+
+.chatlog__attachment-thumbnail {
+    vertical-align: top;
+    max-width: 45vw;
+    max-height: 500px;
+    border-radius: 3px;
+}
+
+.chatlog__attachment-container {
+    height: 40px;
+    width: 100%;
+    max-width: 520px;
+    padding: 10px;
+    border: 1px solid;
+    border-radius: 3px;
+    overflow: hidden;
+}
+
+.chatlog__attachment-icon {
+    float: left;
+    height: 100%;
+    margin-right: 10px;
+}
+
+.chatlog__attachment-icon > .a {
+    fill: #f4f5fb;
+    d: path("M50,935a25,25,0,0,1-25-25V50A25,25,0,0,1,50,25H519.6L695,201.32V910a25,25,0,0,1-25,25Z");
+}
+
+.chatlog__attachment-icon > .b {
+    fill: #7789c4;
+    d: path("M509.21,50,670,211.63V910H50V50H509.21M530,0H50A50,50,0,0,0,0,50V910a50,50,0,0,0,50,50H670a50,50,0,0,0,50-50h0V191Z");
+}
+
+.chatlog__attachment-icon > .c {
+    fill: #f4f5fb;
+    d: path("M530,215a25,25,0,0,1-25-25V50a25,25,0,0,1,16.23-23.41L693.41,198.77A25,25,0,0,1,670,215Z");
+}
+
+.chatlog__attachment-icon > .d {
+    fill: #7789c4;
+    d: path("M530,70.71,649.29,190H530V70.71M530,0a50,50,0,0,0-50,50V190a50,50,0,0,0,50,50H670a50,50,0,0,0,50-50Z");
+}
+
+.chatlog__attachment-filesize {
+    color: #72767d;
+    font-size: 12px;
+}
+
+.chatlog__attachment-filename {
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+}
+
+.chatlog__embed {
+    display: flex;
+    margin-top: 0.3em;
+    max-width: 520px;
+}
+
+.chatlog__embed-color-pill {
+    flex-shrink: 0;
+    width: 0.25em;
+    border-top-left-radius: 3px;
+    border-bottom-left-radius: 3px;
+}
+
+.chatlog__embed-content-container {
+    display: flex;
+    flex-direction: column;
+    padding: 0.5em 0.6em;
+    border: 1px solid;
+    border-top-right-radius: 3px;
+    border-bottom-right-radius: 3px;
+}
+
+.chatlog__embed-content {
+    display: flex;
+    width: 100%;
+}
+
+.chatlog__embed-text {
+    flex: 1;
+}
+
+.chatlog__embed-author {
+    display: flex;
+    margin-bottom: 0.3em;
+    align-items: center;
+}
+
+.chatlog__embed-author-icon {
+    margin-right: 0.5em;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+}
+
+.chatlog__embed-author-name {
+    font-size: 0.875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-title {
+    margin-bottom: 0.2em;
+    font-size: 0.875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-description {
+    font-weight: 500;
+    font-size: 0.85em;
+}
+
+.chatlog__embed-fields {
+    display: flex;
+    flex-wrap: wrap;
+}
+
+.chatlog__embed-field {
+    flex: 0;
+    min-width: 100%;
+    max-width: 506px;
+    padding-top: 0.6em;
+    font-size: 0.875em;
+}
+
+.chatlog__embed-field--inline {
+    flex: 1;
+    flex-basis: auto;
+    min-width: 150px;
+}
+
+.chatlog__embed-field-name {
+    margin-bottom: 0.2em;
+    font-weight: 600;
+}
+
+.chatlog__embed-field-value {
+    font-weight: 500;
+}
+
+.chatlog__embed-thumbnail {
+    flex: 0;
+    margin-left: 1.2em;
+    max-width: 80px;
+    max-height: 80px;
+    border-radius: 3px;
+}
+
+.chatlog__embed-image-container {
+    margin-top: 0.6em;
+}
+
+.chatlog__embed-image {
+    max-width: 500px;
+    max-height: 400px;
+    border-radius: 3px;
+}
+
+.chatlog__embed-footer {
+    margin-top: 0.6em;
+}
+
+.chatlog__embed-footer-icon {
+    margin-right: 0.2em;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    vertical-align: middle;
+}
+
+.chatlog__embed-footer-text {
+    font-size: 0.75em;
+    font-weight: 500;
+}
+
+.chatlog__reactions {
+    display: flex;
+}
+
+.chatlog__reaction {
+    display: flex;
+    align-items: center;
+    margin: 0.35em 0.1em 0.1em 0.1em;
+    padding: 0.2em 0.35em;
+    border-radius: 3px;
+}
+
+.chatlog__reaction-count {
+    min-width: 9px;
+    margin-left: 0.35em;
+    font-size: 0.875em;
+}
+
+.chatlog__bot-tag {
+    position: relative;
+    top: -.2em;
+    margin-left: 0.3em;
+    padding: 0.05em 0.3em;
+    border-radius: 3px;
+    vertical-align: middle;
+    line-height: 1.3;
+    background: #7289da;
+    color: #ffffff;
+    font-size: 0.625em;
+    font-weight: 500;
+}
+
+/* Postamble */
+
+.postamble {
+    margin: 1.4em 0.3em 0.6em 0.3em;
+    padding: 1em;
+    border-top: 1px solid;
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/Dark.css
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/Dark.css
@@ -0,0 +1,147 @@
+/* General */
+
+body {
+    background-color: #36393e;
+    color: #dcddde;
+}
+
+a {
+    color: #0096cf;
+}
+
+.spoiler-text {
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+.spoiler--hidden .spoiler-text {
+    background-color: #202225;
+}
+
+.spoiler--hidden:hover .spoiler-text {
+    background-color: rgba(32, 34, 37, 0.8);
+}
+
+.quote {
+    border-color: #4f545c;
+}
+
+.pre {
+    background-color: #2f3136 !important;
+}
+
+.pre--multiline {
+    border-color: #282b30 !important;
+    color: #b9bbbe !important;
+}
+
+/* === Preamble === */
+
+.preamble__entry {
+    color: #ffffff;
+}
+
+/* Chatlog */
+
+.chatlog__message-group {
+    border-color: rgba(255, 255, 255, 0.1);
+}
+
+.chatlog__reference-symbol {
+    border-color: #4f545c;
+}
+
+.chatlog__reference {
+    color: #b5b6b8;
+}
+
+.chatlog__reference-link {
+    color: #b5b6b8;
+}
+
+.chatlog__reference-link:hover {
+    color: #ffffff;
+}
+
+.chatlog__reference-edited-timestamp {
+    color: rgba(255, 255, 255, 0.2);
+}
+
+.chatlog__author-name {
+    color: #ffffff;
+}
+
+.chatlog__timestamp {
+    color: rgba(255, 255, 255, 0.2);
+}
+
+.chatlog__message--highlighted {
+    background-color: rgba(114, 137, 218, 0.2) !important;
+}
+
+.chatlog__message--pinned {
+    background-color: rgba(249, 168, 37, 0.05);
+}
+
+.chatlog__attachment-container {
+    background-color: #2f3136;
+    border-color: #292b2f;
+}
+
+.chatlog__edited-timestamp {
+    color: rgba(255, 255, 255, 0.2);
+}
+
+.chatlog__embed-color-pill--default {
+    background-color: rgba(79, 84, 92, 1);
+}
+
+.chatlog__embed-content-container {
+    background-color: rgba(46, 48, 54, 0.3);
+    border-color: rgba(46, 48, 54, 0.6);
+}
+
+.chatlog__embed-author-name {
+    color: #ffffff;
+}
+
+.chatlog__embed-author-name-link {
+    color: #ffffff;
+}
+
+.chatlog__embed-title {
+    color: #ffffff;
+}
+
+.chatlog__embed-description {
+    color: rgba(255, 255, 255, 0.6);
+}
+
+.chatlog__embed-field-name {
+    color: #ffffff;
+}
+
+.chatlog__embed-field-value {
+    color: rgba(255, 255, 255, 0.6);
+}
+
+.chatlog__embed-footer {
+    color: rgba(255, 255, 255, 0.6);
+}
+
+.chatlog__reaction {
+    background-color: rgba(255, 255, 255, 0.05);
+}
+
+.chatlog__reaction-count {
+    color: rgba(255, 255, 255, 0.3);
+}
+
+/* Postamble */
+
+.postamble {
+    border-color: rgba(255, 255, 255, 0.1);
+}
+
+.postamble__entry {
+    color: #ffffff;
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/LayoutTemplateContext.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/LayoutTemplateContext.cs
@@ -0,0 +1,18 @@
+namespace DiscordChatExporter.Core.Exporting.Writers.Html
+{
+    internal class LayoutTemplateContext
+    {
+        public ExportContext ExportContext { get; }
+
+        public string ThemeName { get; }
+
+        public long MessageCount { get; }
+
+        public LayoutTemplateContext(ExportContext exportContext, string themeName, long messageCount)
+        {
+            ExportContext = exportContext;
+            ThemeName = themeName;
+            MessageCount = messageCount;
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/Light.css
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/Light.css
@@ -0,0 +1,149 @@
+/* General */
+
+body {
+    background-color: #ffffff;
+    color: #23262a;
+    font-weight: 500;
+}
+
+a {
+    color: #00b0f4;
+}
+
+.spoiler-text {
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+.spoiler--hidden .spoiler-text {
+    background-color: #b9bbbe;
+}
+
+.spoiler--hidden:hover .spoiler-text {
+    background-color: rgba(185, 187, 190, 0.8);
+}
+
+.quote {
+    border-color: #c7ccd1;
+}
+
+.pre {
+    background-color: #f9f9f9 !important;
+}
+
+.pre--multiline {
+    border-color: #f3f3f3 !important;
+    color: #657b83 !important;
+}
+
+/* Preamble */
+
+.preamble__entry {
+    color: #2f3136;
+}
+
+/* Chatlog */
+
+.chatlog__message-group {
+    border-color: #eceeef;
+}
+
+.chatlog__reference-symbol {
+    border-color: #c7ccd1;
+}
+
+.chatlog__reference {
+    color: #5f5f60;
+}
+
+.chatlog__reference-link {
+    color: #5f5f60;
+}
+
+.chatlog__reference-link:hover {
+    color: #2f3136;
+}
+
+.chatlog__reference-edited-timestamp {
+    color: #747f8d;
+}
+
+.chatlog__author-name {
+    font-weight: 600;
+    color: #2f3136;
+}
+
+.chatlog__timestamp {
+    color: #747f8d;
+}
+
+.chatlog__message--highlighted {
+    background-color: rgba(114, 137, 218, 0.2) !important;
+}
+
+.chatlog__message--pinned {
+    background-color: rgba(249, 168, 37, 0.05);
+}
+
+.chatlog__attachment-container {
+    background-color: #f2f3f5;
+    border-color: #ebedef;
+}
+
+.chatlog__edited-timestamp {
+    color: #747f8d;
+}
+
+.chatlog__embed-color-pill--default {
+    background-color: rgba(227, 229, 232, 1);
+}
+
+.chatlog__embed-content-container {
+    background-color: rgba(249, 249, 249, 0.3);
+    border-color: rgba(204, 204, 204, 0.3);
+}
+
+.chatlog__embed-author-name {
+    color: #4f545c;
+}
+
+.chatlog__embed-author-name-link {
+    color: #4f545c;
+}
+
+.chatlog__embed-title {
+    color: #4f545c;
+}
+
+.chatlog__embed-description {
+    color: #737f8d;
+}
+
+.chatlog__embed-field-name {
+    color: #36393e;
+}
+
+.chatlog__embed-field-value {
+    color: #737f8d;
+}
+
+.chatlog__embed-footer {
+    color: rgba(79, 83, 91, 0.6);
+}
+
+.chatlog__reaction {
+    background-color: rgba(79, 84, 92, 0.06);
+}
+
+.chatlog__reaction-count {
+    color: #747f8d;
+}
+
+/* Postamble */
+
+.postamble {
+    border-color: #eceeef;
+}
+
+.postamble__entry {
+    color: #2f3136;
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/MessageGroup.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/MessageGroup.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using DiscordChatExporter.Core.Discord.Data;
+
+namespace DiscordChatExporter.Core.Exporting.Writers.Html
+{
+    // Used for grouping contiguous messages in HTML export
+    internal partial class MessageGroup
+    {
+        public User Author { get; }
+
+        public DateTimeOffset Timestamp { get; }
+
+        public IReadOnlyList<Message> Messages { get; }
+
+        public MessageReference? Reference { get; }
+
+        public Message? ReferencedMessage {get; }
+
+        public MessageGroup(
+            User author,
+            DateTimeOffset timestamp,
+            MessageReference? reference,
+            Message? referencedMessage,
+            IReadOnlyList<Message> messages)
+        {
+            Author = author;
+            Timestamp = timestamp;
+            Reference = reference;
+            ReferencedMessage = referencedMessage;
+            Messages = messages;
+        }
+    }
+
+    internal partial class MessageGroup
+    {
+        public static bool CanJoin(Message message1, Message message2) =>
+            message1.Author.Id == message2.Author.Id &&
+            string.Equals(message1.Author.FullName, message2.Author.FullName, StringComparison.Ordinal) &&
+            (message2.Timestamp - message1.Timestamp).Duration().TotalMinutes <= 7 &&
+            message2.Reference is null;
+
+        public static MessageGroup Join(IReadOnlyList<Message> messages)
+        {
+            var first = messages.First();
+
+            return new MessageGroup(
+                first.Author,
+                first.Timestamp,
+                first.Reference,
+                first.ReferencedMessage,
+                messages
+            );
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/MessageGroupTemplate.cshtml
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/MessageGroupTemplate.cshtml
@@ -0,0 +1,316 @@
+@using System
+@using System.Linq
+@using System.Threading.Tasks
+@namespace DiscordChatExporter.Core.Exporting.Writers.Html
+@inherits MiniRazor.TemplateBase<DiscordChatExporter.Core.Exporting.Writers.Html.MessageGroupTemplateContext>
+
+@{
+    string FormatDate(DateTimeOffset date) => Model.ExportContext.FormatDate(date);
+
+    string FormatMarkdown(string markdown) => Model.FormatMarkdown(markdown);
+
+    string FormatEmbedMarkdown(string markdown) => Model.FormatMarkdown(markdown, false);
+
+    ValueTask<string> ResolveUrlAsync(string url) => Model.ExportContext.ResolveMediaUrlAsync(url);
+
+    var userMember = Model.ExportContext.TryGetMember(Model.MessageGroup.Author.Id);
+
+    var userColor = Model.ExportContext.TryGetUserColor(Model.MessageGroup.Author.Id);
+
+    var userColorStyle = userColor != null
+        ? $"color: rgb({userColor?.R},{userColor?.G},{userColor?.B})"
+        : null;
+
+    var userNick = Model.MessageGroup.Author.IsBot
+        ? Model.MessageGroup.Author.Name
+        : userMember?.Nick ?? Model.MessageGroup.Author.Name;
+
+    var referencedUserMember = Model.MessageGroup.ReferencedMessage != null
+        ? Model.ExportContext.TryGetMember(Model.MessageGroup.ReferencedMessage.Author.Id)
+        : null;
+
+    var referencedUserColor = Model.MessageGroup.ReferencedMessage != null
+        ? Model.ExportContext.TryGetUserColor(Model.MessageGroup.ReferencedMessage.Author.Id)
+        : null;
+
+    var referencedUserColorStyle = referencedUserColor != null
+        ? $"color: rgb({referencedUserColor?.R},{referencedUserColor?.G},{referencedUserColor?.B})"
+        : null;
+
+    var referencedUserNick = Model.MessageGroup.ReferencedMessage != null
+        ? Model.MessageGroup.ReferencedMessage.Author.IsBot
+            ? Model.MessageGroup.ReferencedMessage.Author.Name
+            : referencedUserMember?.Nick ?? Model.MessageGroup.ReferencedMessage.Author.Name
+        : null;
+}
+
+<div class="chatlog__message-group">
+    @if (Model.MessageGroup.Reference != null)
+    {
+        <div class="chatlog__reference-symbol">
+        </div>
+        <div class="chatlog__reference">
+            @if (Model.MessageGroup.ReferencedMessage != null)
+            {
+                <img class="chatlog__reference-avatar" src="@await ResolveUrlAsync(Model.MessageGroup.ReferencedMessage.Author.AvatarUrl)" alt="Avatar">
+                <span class="chatlog__reference-name" title="@Model.MessageGroup.ReferencedMessage.Author.FullName" style="@referencedUserColorStyle">@referencedUserNick</span>
+                <a class="chatlog__reference-link" href="#" onclick="scrollToMessage(event, '@Model.MessageGroup.ReferencedMessage.Id')">
+                    <span class="chatlog__reference-content">
+                        @if (!string.IsNullOrWhiteSpace(Model.MessageGroup.ReferencedMessage.Content))
+                        {
+                            @Raw(FormatMarkdown(Model.MessageGroup.ReferencedMessage.Content))
+                        }
+                        else
+                        {
+                            <em>Click to see original message</em>
+                        }
+                    </span>
+
+                    @if (Model.MessageGroup.ReferencedMessage.EditedTimestamp != null)
+                    {
+                        <span class="chatlog__reference-edited-timestamp" title="@FormatDate(Model.MessageGroup.ReferencedMessage.EditedTimestamp.Value)">(edited)</span>
+                    }
+                </a>
+            }
+            else
+            {
+                <span class="chatlog__reference-unknown">
+                    Original message was deleted.
+                </span>
+            }
+        </div>
+    }
+    <div class="chatlog__author-avatar-container">
+        <img class="chatlog__author-avatar" src="@await ResolveUrlAsync(Model.MessageGroup.Author.AvatarUrl)" alt="Avatar">
+    </div>
+    <div class="chatlog__messages">
+        <span class="chatlog__author-name" title="@Model.MessageGroup.Author.FullName" data-user-id="@Model.MessageGroup.Author.Id" style="@userColorStyle">@userNick</span>
+
+        @if (Model.MessageGroup.Author.IsBot)
+        {
+            <span class="chatlog__bot-tag">BOT</span>
+        }
+
+        <span class="chatlog__timestamp">@FormatDate(Model.MessageGroup.Timestamp)</span>
+
+        @foreach (var message in Model.MessageGroup.Messages)
+        {
+            var isPinnedStyle = message.IsPinned ? "chatlog__message--pinned" : null;
+
+            <div class="chatlog__message @isPinnedStyle" data-message-id="@message.Id" id="message-@message.Id">
+                @if (!string.IsNullOrWhiteSpace(message.Content) || message.EditedTimestamp != null)
+                {
+                    <div class="chatlog__content">
+                        <div class="markdown">
+                            <span class="preserve-whitespace">@Raw(FormatMarkdown(message.Content))</span>
+
+                            @if (message.EditedTimestamp != null)
+                            {
+                                <span class="chatlog__edited-timestamp" title="@FormatDate(message.EditedTimestamp.Value)">(edited)</span>
+                            }
+                        </div>
+                    </div>
+                }
+
+                @foreach (var attachment in message.Attachments)
+                {
+                    <div class="chatlog__attachment">
+                        <div class="@(attachment.IsSpoiler ? "spoiler spoiler--hidden" : "")" onclick="@(attachment.IsSpoiler ? "showSpoiler(event, this)" : "")">
+                            <div class="@(attachment.IsSpoiler ? "spoiler-image" : "")">
+                                @if (attachment.IsImage)
+                                {
+                                    <a href="@await ResolveUrlAsync(attachment.Url)">
+                                        <img class="chatlog__attachment-thumbnail" src="@await ResolveUrlAsync(attachment.Url)" alt="Image attachment" title="@($"Image: {attachment.FileName} ({attachment.FileSize})")">
+                                    </a>
+                                }
+                                else if (attachment.IsVideo)
+                                {
+                                    <video controls class="chatlog__attachment-thumbnail">
+                                        <source src="@await ResolveUrlAsync(attachment.Url)" alt="Video attachment" title="@($"Video: {attachment.FileName} ({attachment.FileSize})")">
+                                    </video>
+                                }
+                                else if (attachment.IsAudio)
+                                {
+                                    <audio controls class="chatlog__attachment-thumbnail">
+                                        <source src="@await ResolveUrlAsync(attachment.Url)" alt="Audio attachment" title="@($"Audio: {attachment.FileName} ({attachment.FileSize})")">
+                                    </audio>
+                                }
+                                else
+                                {
+                                    <div class="chatlog__attachment-container">
+                                        <svg class="chatlog__attachment-icon" viewBox="0 0 720 960">
+                                            <path class="a"/>
+                                            <path class="b"/>
+                                            <path class="c"/>
+                                            <path class="d"/>
+                                        </svg>
+                                        <div class="chatlog__attachment-filename">
+                                            <a href="@await ResolveUrlAsync(attachment.Url)">
+                                                @attachment.FileName
+                                            </a>
+                                        </div>
+                                        <div class="chatlog__attachment-filesize">
+                                            @attachment.FileSize
+                                        </div>
+                                    </div>
+                                }
+                            </div>
+                        </div>
+                    </div>
+                }
+
+                @foreach (var embed in message.Embeds)
+                {
+                    <div class="chatlog__embed">
+                        @if (embed.Color != null)
+                        {
+                            var embedColorStyle = $"background-color: rgba({embed.Color?.R},{embed.Color?.G},{embed.Color?.B},{embed.Color?.A})";
+                            <div class="chatlog__embed-color-pill" style="@embedColorStyle"></div>
+                        }
+                        else
+                        {
+                            <div class="chatlog__embed-color-pill chatlog__embed-color-pill--default"></div>
+                        }
+
+                        <div class="chatlog__embed-content-container">
+                            <div class="chatlog__embed-content">
+                                <div class="chatlog__embed-text">
+                                    @if (embed.Author != null)
+                                    {
+                                        <div class="chatlog__embed-author">
+                                            @if (!string.IsNullOrWhiteSpace(embed.Author.IconUrl))
+                                            {
+                                                <img class="chatlog__embed-author-icon" src="@await ResolveUrlAsync(embed.Author.IconUrl)" alt="Author icon">
+                                            }
+
+                                            @if (!string.IsNullOrWhiteSpace(embed.Author.Name))
+                                            {
+                                                <span class="chatlog__embed-author-name">
+                                                    @if (!string.IsNullOrWhiteSpace(embed.Author.Url))
+                                                    {
+                                                        <a class="chatlog__embed-author-name-link" href="@embed.Author.Url">@embed.Author.Name</a>
+                                                    }
+                                                    else
+                                                    {
+                                                        @embed.Author.Name
+                                                    }
+                                                </span>
+                                            }
+                                        </div>
+                                    }
+
+                                    @if (!string.IsNullOrWhiteSpace(embed.Title))
+                                    {
+                                        <div class="chatlog__embed-title">
+                                            @if (!string.IsNullOrWhiteSpace(embed.Url))
+                                            {
+                                                <a class="chatlog__embed-title-link" href="@embed.Url">
+                                                    <div class="markdown preserve-whitespace">@Raw(FormatEmbedMarkdown(embed.Title))</div>
+                                                </a>
+                                            }
+                                            else
+                                            {
+                                                <div class="markdown preserve-whitespace">@Raw(FormatEmbedMarkdown(embed.Title))</div>
+                                            }
+                                        </div>
+                                    }
+
+                                    @if (!string.IsNullOrWhiteSpace(embed.Description))
+                                    {
+                                        <div class="chatlog__embed-description">
+                                            <div class="markdown preserve-whitespace">@Raw(FormatEmbedMarkdown(embed.Description))</div>
+                                        </div>
+                                    }
+
+                                    @if (embed.Fields.Any())
+                                    {
+                                        <div class="chatlog__embed-fields">
+                                            @foreach (var field in embed.Fields)
+                                            {
+                                                var isInlineStyle = field.IsInline ? "chatlog__embed-field--inline" : null;
+
+                                                <div class="chatlog__embed-field @isInlineStyle">
+                                                    @if (!string.IsNullOrWhiteSpace(field.Name))
+                                                    {
+                                                        <div class="chatlog__embed-field-name">
+                                                            <div class="markdown preserve-whitespace">@Raw(FormatEmbedMarkdown(field.Name))</div>
+                                                        </div>
+                                                    }
+
+                                                    @if (!string.IsNullOrWhiteSpace(field.Value))
+                                                    {
+                                                        <div class="chatlog__embed-field-value">
+                                                            <div class="markdown preserve-whitespace">@Raw(FormatEmbedMarkdown(field.Value))</div>
+                                                        </div>
+                                                    }
+                                                </div>
+                                            }
+                                        </div>
+                                    }
+                                </div>
+
+                                @if (embed.Thumbnail != null)
+                                {
+                                    <div class="chatlog__embed-thumbnail-container">
+                                        <a class="chatlog__embed-thumbnail-link" href="@await ResolveUrlAsync(embed.Thumbnail.Url)">
+                                            <img class="chatlog__embed-thumbnail" src="@await ResolveUrlAsync(embed.Thumbnail.Url)" alt="Thumbnail">
+                                        </a>
+                                    </div>
+                                }
+                            </div>
+
+                            @if (embed.Image != null)
+                            {
+                                <div class="chatlog__embed-image-container">
+                                    <a class="chatlog__embed-image-link" href="@await ResolveUrlAsync(embed.Image.Url)">
+                                        <img class="chatlog__embed-image" src="@await ResolveUrlAsync(embed.Image.Url)" alt="Image">
+                                    </a>
+                                </div>
+                            }
+
+                            @if (embed.Footer != null || embed.Timestamp != null)
+                            {
+                                <div class="chatlog__embed-footer">
+                                    @if (!string.IsNullOrWhiteSpace(embed.Footer?.IconUrl))
+                                    {
+                                        <img class="chatlog__embed-footer-icon" src="@await ResolveUrlAsync(embed.Footer.IconUrl)" alt="Footer icon">
+                                    }
+
+                                    <span class="chatlog__embed-footer-text">
+                                        @if (!string.IsNullOrWhiteSpace(embed.Footer?.Text))
+                                        {
+                                            @embed.Footer.Text
+                                        }
+
+                                        @if (!string.IsNullOrWhiteSpace(embed.Footer?.Text) && embed.Timestamp != null)
+                                        {
+                                            @(" • ")
+                                        }
+
+                                        @if (embed.Timestamp != null)
+                                        {
+                                            @FormatDate(embed.Timestamp.Value)
+                                        }
+                                    </span>
+                                </div>
+                            }
+                        </div>
+                    </div>
+                }
+
+                @if (message.Reactions.Any())
+                {
+                    <div class="chatlog__reactions">
+                        @foreach (var reaction in message.Reactions)
+                        {
+                            <div class="chatlog__reaction">
+                                <img class="emoji emoji--small" alt="@reaction.Emoji.Name" title="@reaction.Emoji.Name" src="@await ResolveUrlAsync(reaction.Emoji.ImageUrl)">
+                                <span class="chatlog__reaction-count">@reaction.Count</span>
+                            </div>
+                        }
+                    </div>
+                }
+            </div>
+        }
+    </div>
+</div>
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/MessageGroupTemplateContext.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/MessageGroupTemplateContext.cs
@@ -0,0 +1,20 @@
+using DiscordChatExporter.Core.Exporting.Writers.MarkdownVisitors;
+
+namespace DiscordChatExporter.Core.Exporting.Writers.Html
+{
+    internal class MessageGroupTemplateContext
+    {
+        public ExportContext ExportContext { get; }
+
+        public MessageGroup MessageGroup { get; }
+
+        public MessageGroupTemplateContext(ExportContext exportContext, MessageGroup messageGroup)
+        {
+            ExportContext = exportContext;
+            MessageGroup = messageGroup;
+        }
+
+        public string FormatMarkdown(string? markdown, bool isJumboAllowed = true) =>
+            HtmlMarkdownVisitor.Format(ExportContext, markdown ?? "", isJumboAllowed);
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/PostambleTemplate.cshtml
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/PostambleTemplate.cshtml
@@ -0,0 +1,12 @@
+@namespace DiscordChatExporter.Core.Exporting.Writers.Html
+@inherits MiniRazor.TemplateBase<DiscordChatExporter.Core.Exporting.Writers.Html.LayoutTemplateContext>
+
+</div>
+
+<div class="postamble">
+    <div class="postamble__entry">Exported @Model.MessageCount.ToString("N0") message(s)</div>
+</div>
+
+</body>
+
+</html>
--- a/DiscordChatExporter.Core/Exporting/Writers/Html/PreambleTemplate.cshtml
+++ b/DiscordChatExporter.Core/Exporting/Writers/Html/PreambleTemplate.cshtml
@@ -0,0 +1,101 @@
+@using System
+@using System.Threading.Tasks
+@using Tyrrrz.Extensions
+@namespace DiscordChatExporter.Core.Exporting.Writers.Html
+@inherits MiniRazor.TemplateBase<DiscordChatExporter.Core.Exporting.Writers.Html.LayoutTemplateContext>
+
+@{
+    string FormatDate(DateTimeOffset date) => Model.ExportContext.FormatDate(date);
+
+    ValueTask<string> ResolveUrlAsync(string url) => Model.ExportContext.ResolveMediaUrlAsync(url);
+
+    string GetStyleSheet(string name) => Model.GetType().Assembly.GetManifestResourceString($"DiscordChatExporter.Core.Exporting.Writers.Html.{name}.css");
+}
+
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <title>@Model.ExportContext.Request.Guild.Name - @Model.ExportContext.Request.Channel.Name</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+
+    <style>
+        @Raw(GetStyleSheet("Core"))
+    </style>
+    <style>
+        @Raw(GetStyleSheet(Model.ThemeName))
+    </style>
+
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.6/styles/solarized-@(Model.ThemeName.ToLowerInvariant()).min.css">
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.6/highlight.min.js"></script>
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            document.querySelectorAll('.pre--multiline').forEach(block => hljs.highlightBlock(block));
+        });
+    </script>
+
+    <script>
+        function scrollToMessage(event, id) {
+            var element = document.getElementById('message-' + id);
+
+            if (element) {
+                event.preventDefault();
+
+                element.classList.add('chatlog__message--highlighted');
+
+                window.scrollTo({
+                    top: element.getBoundingClientRect().top - document.body.getBoundingClientRect().top - (window.innerHeight / 2),
+                    behavior: 'smooth'
+                });
+
+                window.setTimeout(function() {
+                    element.classList.remove('chatlog__message--highlighted');
+                }, 2000);
+            }
+        }
+
+        function showSpoiler(event, element) {
+            if (element && element.classList.contains('spoiler--hidden')) {
+                event.preventDefault();
+                element.classList.remove('spoiler--hidden');
+            }
+        }
+    </script>
+</head>
+<body>
+
+<div class="preamble">
+    <div class="preamble__guild-icon-container">
+        <img class="preamble__guild-icon" src="@await ResolveUrlAsync(Model.ExportContext.Request.Guild.IconUrl)" alt="Guild icon">
+    </div>
+    <div class="preamble__entries-container">
+        <div class="preamble__entry">@Model.ExportContext.Request.Guild.Name</div>
+        <div class="preamble__entry">@Model.ExportContext.Request.Channel.Category / @Model.ExportContext.Request.Channel.Name</div>
+
+        @if (!string.IsNullOrWhiteSpace(Model.ExportContext.Request.Channel.Topic))
+        {
+            <div class="preamble__entry preamble__entry--small">@Model.ExportContext.Request.Channel.Topic</div>
+        }
+
+        @if (Model.ExportContext.Request.After != null || Model.ExportContext.Request.Before != null)
+        {
+            <div class="preamble__entry preamble__entry--small">
+            @if (Model.ExportContext.Request.After != null && Model.ExportContext.Request.Before != null)
+            {
+                @($"Between {FormatDate(Model.ExportContext.Request.After.Value.ToDate())} and {FormatDate(Model.ExportContext.Request.Before.Value.ToDate())}")
+            }
+            else if (Model.ExportContext.Request.After != null)
+            {
+                @($"After {FormatDate(Model.ExportContext.Request.After.Value.ToDate())}")
+            }
+            else if (Model.ExportContext.Request.Before != null)
+            {
+                @($"Before {FormatDate(Model.ExportContext.Request.Before.Value.ToDate())}")
+            }
+            </div>
+        }
+    </div>
+</div>
+
+<div class="chatlog">
--- a/DiscordChatExporter.Core/Exporting/Writers/HtmlMessageWriter.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/HtmlMessageWriter.cs
@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Exporting.Writers.Html;
+
+namespace DiscordChatExporter.Core.Exporting.Writers
+{
+    internal class HtmlMessageWriter : MessageWriter
+    {
+        private readonly TextWriter _writer;
+        private readonly string _themeName;
+
+        private readonly List<Message> _messageGroupBuffer = new();
+
+        private long _messageCount;
+
+        public HtmlMessageWriter(Stream stream, ExportContext context, string themeName)
+            : base(stream, context)
+        {
+            _writer = new StreamWriter(stream);
+            _themeName = themeName;
+        }
+
+        public override async ValueTask WritePreambleAsync()
+        {
+            var templateContext = new LayoutTemplateContext(Context, _themeName, _messageCount);
+
+            await _writer.WriteLineAsync(
+                await PreambleTemplate.RenderAsync(templateContext)
+            );
+        }
+
+        private async ValueTask WriteMessageGroupAsync(MessageGroup messageGroup)
+        {
+            var templateContext = new MessageGroupTemplateContext(Context, messageGroup);
+
+            await _writer.WriteLineAsync(
+                await MessageGroupTemplate.RenderAsync(templateContext)
+            );
+        }
+
+        public override async ValueTask WriteMessageAsync(Message message)
+        {
+            // If message group is empty or the given message can be grouped, buffer the given message
+            if (!_messageGroupBuffer.Any() || MessageGroup.CanJoin(_messageGroupBuffer.Last(), message))
+            {
+                _messageGroupBuffer.Add(message);
+            }
+            // Otherwise, flush the group and render messages
+            else
+            {
+                await WriteMessageGroupAsync(MessageGroup.Join(_messageGroupBuffer));
+
+                _messageGroupBuffer.Clear();
+                _messageGroupBuffer.Add(message);
+            }
+
+            // Increment message count
+            _messageCount++;
+        }
+
+        public override async ValueTask WritePostambleAsync()
+        {
+            // Flush current message group
+            if (_messageGroupBuffer.Any())
+                await WriteMessageGroupAsync(MessageGroup.Join(_messageGroupBuffer));
+
+            var templateContext = new LayoutTemplateContext(Context, _themeName, _messageCount);
+
+            await _writer.WriteLineAsync(
+                await PostambleTemplate.RenderAsync(templateContext)
+            );
+        }
+
+        public override async ValueTask DisposeAsync()
+        {
+            await _writer.DisposeAsync();
+            await base.DisposeAsync();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/JsonMessageWriter.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/JsonMessageWriter.cs
@@ -0,0 +1,302 @@
+using System.IO;
+using System.Text.Encodings.Web;
+using System.Text.Json;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Exporting.Writers.MarkdownVisitors;
+using DiscordChatExporter.Core.Utils.Extensions;
+using JsonExtensions.Writing;
+
+namespace DiscordChatExporter.Core.Exporting.Writers
+{
+    internal class JsonMessageWriter : MessageWriter
+    {
+        private readonly Utf8JsonWriter _writer;
+
+        private long _messageCount;
+
+        public JsonMessageWriter(Stream stream, ExportContext context)
+            : base(stream, context)
+        {
+            _writer = new Utf8JsonWriter(stream, new JsonWriterOptions
+            {
+                Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+                Indented = true,
+                SkipValidation = true
+            });
+        }
+
+        private string FormatMarkdown(string? markdown) =>
+            PlainTextMarkdownVisitor.Format(Context, markdown ?? "");
+
+        private async ValueTask WriteAttachmentAsync(Attachment attachment)
+        {
+            _writer.WriteStartObject();
+
+            _writer.WriteString("id", attachment.Id.ToString());
+            _writer.WriteString("url", await Context.ResolveMediaUrlAsync(attachment.Url));
+            _writer.WriteString("fileName", attachment.FileName);
+            _writer.WriteNumber("fileSizeBytes", attachment.FileSize.TotalBytes);
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteEmbedAuthorAsync(EmbedAuthor embedAuthor)
+        {
+            _writer.WriteStartObject("author");
+
+            _writer.WriteString("name", embedAuthor.Name);
+            _writer.WriteString("url", embedAuthor.Url);
+
+            if (!string.IsNullOrWhiteSpace(embedAuthor.IconUrl))
+                _writer.WriteString("iconUrl", await Context.ResolveMediaUrlAsync(embedAuthor.IconUrl));
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteEmbedThumbnailAsync(EmbedImage embedThumbnail)
+        {
+            _writer.WriteStartObject("thumbnail");
+
+            if (!string.IsNullOrWhiteSpace(embedThumbnail.Url))
+                _writer.WriteString("url", await Context.ResolveMediaUrlAsync(embedThumbnail.Url));
+
+            _writer.WriteNumber("width", embedThumbnail.Width);
+            _writer.WriteNumber("height", embedThumbnail.Height);
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteEmbedImageAsync(EmbedImage embedImage)
+        {
+            _writer.WriteStartObject("image");
+
+            if (!string.IsNullOrWhiteSpace(embedImage.Url))
+                _writer.WriteString("url", await Context.ResolveMediaUrlAsync(embedImage.Url));
+
+            _writer.WriteNumber("width", embedImage.Width);
+            _writer.WriteNumber("height", embedImage.Height);
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteEmbedFooterAsync(EmbedFooter embedFooter)
+        {
+            _writer.WriteStartObject("footer");
+
+            _writer.WriteString("text", embedFooter.Text);
+
+            if (!string.IsNullOrWhiteSpace(embedFooter.IconUrl))
+                _writer.WriteString("iconUrl", await Context.ResolveMediaUrlAsync(embedFooter.IconUrl));
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteEmbedFieldAsync(EmbedField embedField)
+        {
+            _writer.WriteStartObject();
+
+            _writer.WriteString("name", FormatMarkdown(embedField.Name));
+            _writer.WriteString("value", FormatMarkdown(embedField.Value));
+            _writer.WriteBoolean("isInline", embedField.IsInline);
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteEmbedAsync(Embed embed)
+        {
+            _writer.WriteStartObject();
+
+            _writer.WriteString("title", FormatMarkdown(embed.Title));
+            _writer.WriteString("url", embed.Url);
+            _writer.WriteString("timestamp", embed.Timestamp);
+            _writer.WriteString("description", FormatMarkdown(embed.Description));
+
+            if (embed.Color != null)
+                _writer.WriteString("color", embed.Color.Value.ToHex());
+
+            if (embed.Author != null)
+                await WriteEmbedAuthorAsync(embed.Author);
+
+            if (embed.Thumbnail != null)
+                await WriteEmbedThumbnailAsync(embed.Thumbnail);
+
+            if (embed.Image != null)
+                await WriteEmbedImageAsync(embed.Image);
+
+            if (embed.Footer != null)
+                await WriteEmbedFooterAsync(embed.Footer);
+
+            // Fields
+            _writer.WriteStartArray("fields");
+
+            foreach (var field in embed.Fields)
+                await WriteEmbedFieldAsync(field);
+
+            _writer.WriteEndArray();
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteReactionAsync(Reaction reaction)
+        {
+            _writer.WriteStartObject();
+
+            // Emoji
+            _writer.WriteStartObject("emoji");
+            _writer.WriteString("id", reaction.Emoji.Id);
+            _writer.WriteString("name", reaction.Emoji.Name);
+            _writer.WriteBoolean("isAnimated", reaction.Emoji.IsAnimated);
+            _writer.WriteString("imageUrl", await Context.ResolveMediaUrlAsync(reaction.Emoji.ImageUrl));
+            _writer.WriteEndObject();
+
+            _writer.WriteNumber("count", reaction.Count);
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        private async ValueTask WriteMentionAsync(User mentionedUser)
+        {
+            _writer.WriteStartObject();
+
+            _writer.WriteString("id", mentionedUser.Id.ToString());
+            _writer.WriteString("name", mentionedUser.Name);
+            _writer.WriteNumber("discriminator", mentionedUser.Discriminator);
+            _writer.WriteString("nickname", Context.TryGetMember(mentionedUser.Id)?.Nick ?? mentionedUser.Name);
+            _writer.WriteBoolean("isBot", mentionedUser.IsBot);
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        public override async ValueTask WritePreambleAsync()
+        {
+            // Root object (start)
+            _writer.WriteStartObject();
+
+            // Guild
+            _writer.WriteStartObject("guild");
+            _writer.WriteString("id", Context.Request.Guild.Id.ToString());
+            _writer.WriteString("name", Context.Request.Guild.Name);
+            _writer.WriteString("iconUrl", await Context.ResolveMediaUrlAsync(Context.Request.Guild.IconUrl));
+            _writer.WriteEndObject();
+
+            // Channel
+            _writer.WriteStartObject("channel");
+            _writer.WriteString("id", Context.Request.Channel.Id.ToString());
+            _writer.WriteString("type", Context.Request.Channel.Type.ToString());
+            _writer.WriteString("category", Context.Request.Channel.Category.Name);
+            _writer.WriteString("name", Context.Request.Channel.Name);
+            _writer.WriteString("topic", Context.Request.Channel.Topic);
+            _writer.WriteEndObject();
+
+            // Date range
+            _writer.WriteStartObject("dateRange");
+            _writer.WriteString("after", Context.Request.After?.ToDate());
+            _writer.WriteString("before", Context.Request.Before?.ToDate());
+            _writer.WriteEndObject();
+
+            // Message array (start)
+            _writer.WriteStartArray("messages");
+            await _writer.FlushAsync();
+        }
+
+        public override async ValueTask WriteMessageAsync(Message message)
+        {
+            _writer.WriteStartObject();
+
+            // Metadata
+            _writer.WriteString("id", message.Id.ToString());
+            _writer.WriteString("type", message.Type.ToString());
+            _writer.WriteString("timestamp", message.Timestamp);
+            _writer.WriteString("timestampEdited", message.EditedTimestamp);
+            _writer.WriteString("callEndedTimestamp", message.CallEndedTimestamp);
+            _writer.WriteBoolean("isPinned", message.IsPinned);
+
+            // Content
+            _writer.WriteString("content", FormatMarkdown(message.Content));
+
+            // Author
+            _writer.WriteStartObject("author");
+            _writer.WriteString("id", message.Author.Id.ToString());
+            _writer.WriteString("name", message.Author.Name);
+            _writer.WriteString("discriminator", $"{message.Author.Discriminator:0000}");
+            _writer.WriteBoolean("isBot", message.Author.IsBot);
+            _writer.WriteString("avatarUrl", await Context.ResolveMediaUrlAsync(message.Author.AvatarUrl));
+            _writer.WriteEndObject();
+
+            // Attachments
+            _writer.WriteStartArray("attachments");
+
+            foreach (var attachment in message.Attachments)
+                await WriteAttachmentAsync(attachment);
+
+            _writer.WriteEndArray();
+
+            // Embeds
+            _writer.WriteStartArray("embeds");
+
+            foreach (var embed in message.Embeds)
+                await WriteEmbedAsync(embed);
+
+            _writer.WriteEndArray();
+
+            // Reactions
+            _writer.WriteStartArray("reactions");
+
+            foreach (var reaction in message.Reactions)
+                await WriteReactionAsync(reaction);
+
+            _writer.WriteEndArray();
+
+            // Mentions
+            _writer.WriteStartArray("mentions");
+
+            foreach (var mention in message.MentionedUsers)
+                await WriteMentionAsync(mention);
+
+            _writer.WriteEndArray();
+
+            // Message reference
+            if (message.Reference != null)
+            {
+                _writer.WriteStartObject("reference");
+                _writer.WriteString("messageId", message.Reference.MessageId?.ToString());
+                _writer.WriteString("channelId", message.Reference.ChannelId?.ToString());
+                _writer.WriteString("guildId", message.Reference.GuildId?.ToString());
+                _writer.WriteEndObject();
+            }
+
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+
+            _messageCount++;
+        }
+
+        public override async ValueTask WritePostambleAsync()
+        {
+            // Message array (end)
+            _writer.WriteEndArray();
+
+            _writer.WriteNumber("messageCount", _messageCount);
+
+            // Root object (end)
+            _writer.WriteEndObject();
+            await _writer.FlushAsync();
+        }
+
+        public override async ValueTask DisposeAsync()
+        {
+            await _writer.DisposeAsync();
+            await base.DisposeAsync();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/MarkdownVisitors/HtmlMarkdownVisitor.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/MarkdownVisitors/HtmlMarkdownVisitor.cs
@@ -0,0 +1,182 @@
+using System;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using DiscordChatExporter.Core.Discord;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Markdown.Ast;
+using DiscordChatExporter.Core.Utils.Extensions;
+
+namespace DiscordChatExporter.Core.Exporting.Writers.MarkdownVisitors
+{
+    internal partial class HtmlMarkdownVisitor : MarkdownVisitor
+    {
+        private readonly ExportContext _context;
+        private readonly StringBuilder _buffer;
+        private readonly bool _isJumbo;
+
+        public HtmlMarkdownVisitor(ExportContext context, StringBuilder buffer, bool isJumbo)
+        {
+            _context = context;
+            _buffer = buffer;
+            _isJumbo = isJumbo;
+        }
+
+        protected override MarkdownNode VisitText(TextNode text)
+        {
+            _buffer.Append(HtmlEncode(text.Text));
+            return base.VisitText(text);
+        }
+
+        protected override MarkdownNode VisitFormatted(FormattedNode formatted)
+        {
+            var (tagOpen, tagClose) = formatted.Formatting switch
+            {
+                TextFormatting.Bold => ("<strong>", "</strong>"),
+                TextFormatting.Italic => ("<em>", "</em>"),
+                TextFormatting.Underline => ("<u>", "</u>"),
+                TextFormatting.Strikethrough => ("<s>", "</s>"),
+                TextFormatting.Spoiler => (
+                    "<span class=\"spoiler spoiler--hidden\" onclick=\"showSpoiler(event, this)\"><span class=\"spoiler-text\">", "</span></span>"),
+                TextFormatting.Quote => ("<div class=\"quote\">", "</div>"),
+                _ => throw new ArgumentOutOfRangeException(nameof(formatted.Formatting))
+            };
+
+            _buffer.Append(tagOpen);
+            var result = base.VisitFormatted(formatted);
+            _buffer.Append(tagClose);
+
+            return result;
+        }
+
+        protected override MarkdownNode VisitInlineCodeBlock(InlineCodeBlockNode inlineCodeBlock)
+        {
+            _buffer
+                .Append("<span class=\"pre pre--inline\">")
+                .Append(HtmlEncode(inlineCodeBlock.Code))
+                .Append("</span>");
+
+            return base.VisitInlineCodeBlock(inlineCodeBlock);
+        }
+
+        protected override MarkdownNode VisitMultiLineCodeBlock(MultiLineCodeBlockNode multiLineCodeBlock)
+        {
+            var highlightCssClass = !string.IsNullOrWhiteSpace(multiLineCodeBlock.Language)
+                ? $"language-{multiLineCodeBlock.Language}"
+                : "nohighlight";
+
+            _buffer
+                .Append($"<div class=\"pre pre--multiline {highlightCssClass}\">")
+                .Append(HtmlEncode(multiLineCodeBlock.Code))
+                .Append("</div>");
+
+            return base.VisitMultiLineCodeBlock(multiLineCodeBlock);
+        }
+
+        protected override MarkdownNode VisitMention(MentionNode mention)
+        {
+            var mentionId = Snowflake.TryParse(mention.Id);
+            if (mention.Type == MentionType.Meta)
+            {
+                _buffer
+                    .Append("<span class=\"mention\">")
+                    .Append("@").Append(HtmlEncode(mention.Id))
+                    .Append("</span>");
+            }
+            else if (mention.Type == MentionType.User)
+            {
+                var member = mentionId?.Pipe(_context.TryGetMember);
+                var fullName = member?.User.FullName ?? "Unknown";
+                var nick = member?.Nick ?? "Unknown";
+
+                _buffer
+                    .Append($"<span class=\"mention\" title=\"{HtmlEncode(fullName)}\">")
+                    .Append("@").Append(HtmlEncode(nick))
+                    .Append("</span>");
+            }
+            else if (mention.Type == MentionType.Channel)
+            {
+                var channel = mentionId?.Pipe(_context.TryGetChannel);
+                var name = channel?.Name ?? "deleted-channel";
+
+                _buffer
+                    .Append("<span class=\"mention\">")
+                    .Append("#").Append(HtmlEncode(name))
+                    .Append("</span>");
+            }
+            else if (mention.Type == MentionType.Role)
+            {
+                var role = mentionId?.Pipe(_context.TryGetRole);
+                var name = role?.Name ?? "deleted-role";
+                var color = role?.Color;
+
+                var style = color != null
+                    ? $"color: rgb({color?.R}, {color?.G}, {color?.B}); background-color: rgba({color?.R}, {color?.G}, {color?.B}, 0.1);"
+                    : "";
+
+                _buffer
+                    .Append($"<span class=\"mention\" style=\"{style}\">")
+                    .Append("@").Append(HtmlEncode(name))
+                    .Append("</span>");
+            }
+
+            return base.VisitMention(mention);
+        }
+
+        protected override MarkdownNode VisitEmoji(EmojiNode emoji)
+        {
+            var emojiImageUrl = Emoji.GetImageUrl(emoji.Id, emoji.Name, emoji.IsAnimated);
+            var jumboClass = _isJumbo ? "emoji--large" : "";
+
+            _buffer
+                .Append($"<img class=\"emoji {jumboClass}\" alt=\"{emoji.Name}\" title=\"{emoji.Name}\" src=\"{emojiImageUrl}\">");
+
+            return base.VisitEmoji(emoji);
+        }
+
+        protected override MarkdownNode VisitLink(LinkNode link)
+        {
+            // Extract message ID if the link points to a Discord message
+            var linkedMessageId = Regex.Match(link.Url, "^https?://(?:discord|discordapp).com/channels/.*?/(\\d+)/?$").Groups[1].Value;
+
+            if (!string.IsNullOrWhiteSpace(linkedMessageId))
+            {
+                _buffer
+                    .Append($"<a href=\"{Uri.EscapeUriString(link.Url)}\" onclick=\"scrollToMessage(event, '{linkedMessageId}')\">")
+                    .Append(HtmlEncode(link.Title))
+                    .Append("</a>");
+            }
+            else
+            {
+                _buffer
+                    .Append($"<a href=\"{Uri.EscapeUriString(link.Url)}\">")
+                    .Append(HtmlEncode(link.Title))
+                    .Append("</a>");
+            }
+
+            return base.VisitLink(link);
+        }
+    }
+
+    internal partial class HtmlMarkdownVisitor
+    {
+        private static string HtmlEncode(string text) => WebUtility.HtmlEncode(text);
+
+        public static string Format(ExportContext context, string markdown, bool isJumboAllowed = true)
+        {
+            var nodes = MarkdownParser.Parse(markdown);
+
+            var isJumbo =
+                isJumboAllowed &&
+                nodes.All(n => n is EmojiNode || n is TextNode textNode && string.IsNullOrWhiteSpace(textNode.Text));
+
+            var buffer = new StringBuilder();
+
+            new HtmlMarkdownVisitor(context, buffer, isJumbo).Visit(nodes);
+
+            return buffer.ToString();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/MarkdownVisitors/PlainTextMarkdownVisitor.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/MarkdownVisitors/PlainTextMarkdownVisitor.cs
@@ -0,0 +1,82 @@
+using System.Text;
+using DiscordChatExporter.Core.Discord;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Markdown.Ast;
+using DiscordChatExporter.Core.Utils.Extensions;
+
+namespace DiscordChatExporter.Core.Exporting.Writers.MarkdownVisitors
+{
+    internal partial class PlainTextMarkdownVisitor : MarkdownVisitor
+    {
+        private readonly ExportContext _context;
+        private readonly StringBuilder _buffer;
+
+        public PlainTextMarkdownVisitor(ExportContext context, StringBuilder buffer)
+        {
+            _context = context;
+            _buffer = buffer;
+        }
+
+        protected override MarkdownNode VisitText(TextNode text)
+        {
+            _buffer.Append(text.Text);
+            return base.VisitText(text);
+        }
+
+        protected override MarkdownNode VisitMention(MentionNode mention)
+        {
+            var mentionId = Snowflake.TryParse(mention.Id);
+            if (mention.Type == MentionType.Meta)
+            {
+                _buffer.Append($"@{mention.Id}");
+            }
+            else if (mention.Type == MentionType.User)
+            {
+                var member = mentionId?.Pipe(_context.TryGetMember);
+                var name = member?.User.Name ?? "Unknown";
+
+                _buffer.Append($"@{name}");
+            }
+            else if (mention.Type == MentionType.Channel)
+            {
+                var channel = mentionId?.Pipe(_context.TryGetChannel);
+                var name = channel?.Name ?? "deleted-channel";
+
+                _buffer.Append($"#{name}");
+            }
+            else if (mention.Type == MentionType.Role)
+            {
+                var role = mentionId?.Pipe(_context.TryGetRole);
+                var name = role?.Name ?? "deleted-role";
+
+                _buffer.Append($"@{name}");
+            }
+
+            return base.VisitMention(mention);
+        }
+
+        protected override MarkdownNode VisitEmoji(EmojiNode emoji)
+        {
+            _buffer.Append(
+                emoji.IsCustomEmoji
+                    ? $":{emoji.Name}:"
+                    : emoji.Name
+            );
+
+            return base.VisitEmoji(emoji);
+        }
+    }
+
+    internal partial class PlainTextMarkdownVisitor
+    {
+        public static string Format(ExportContext context, string markdown)
+        {
+            var nodes = MarkdownParser.ParseMinimal(markdown);
+            var buffer = new StringBuilder();
+
+            new PlainTextMarkdownVisitor(context, buffer).Visit(nodes);
+
+            return buffer.ToString();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/MessageWriter.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/MessageWriter.cs
@@ -0,0 +1,28 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord.Data;
+
+namespace DiscordChatExporter.Core.Exporting.Writers
+{
+    internal abstract class MessageWriter : IAsyncDisposable
+    {
+        protected Stream Stream { get; }
+
+        protected ExportContext Context { get; }
+
+        protected MessageWriter(Stream stream, ExportContext context)
+        {
+            Stream = stream;
+            Context = context;
+        }
+
+        public virtual ValueTask WritePreambleAsync() => default;
+
+        public abstract ValueTask WriteMessageAsync(Message message);
+
+        public virtual ValueTask WritePostambleAsync() => default;
+
+        public virtual async ValueTask DisposeAsync() => await Stream.DisposeAsync();
+    }
+}
--- a/DiscordChatExporter.Core/Exporting/Writers/PlainTextMessageWriter.cs
+++ b/DiscordChatExporter.Core/Exporting/Writers/PlainTextMessageWriter.cs
@@ -0,0 +1,162 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Discord.Data;
+using DiscordChatExporter.Core.Exporting.Writers.MarkdownVisitors;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Exporting.Writers
+{
+    internal class PlainTextMessageWriter : MessageWriter
+    {
+        private readonly TextWriter _writer;
+
+        private long _messageCount;
+
+        public PlainTextMessageWriter(Stream stream, ExportContext context)
+            : base(stream, context)
+        {
+            _writer = new StreamWriter(stream);
+        }
+
+        private string FormatMarkdown(string? markdown) =>
+            PlainTextMarkdownVisitor.Format(Context, markdown ?? "");
+
+        private async ValueTask WriteMessageHeaderAsync(Message message)
+        {
+            // Timestamp & author
+            await _writer.WriteAsync($"[{Context.FormatDate(message.Timestamp)}]");
+            await _writer.WriteAsync($" {message.Author.FullName}");
+
+            // Whether the message is pinned
+            if (message.IsPinned)
+                await _writer.WriteAsync(" (pinned)");
+
+            await _writer.WriteLineAsync();
+        }
+
+        private async ValueTask WriteAttachmentsAsync(IReadOnlyList<Attachment> attachments)
+        {
+            if (!attachments.Any())
+                return;
+
+            await _writer.WriteLineAsync("{Attachments}");
+
+            foreach (var attachment in attachments)
+                await _writer.WriteLineAsync(await Context.ResolveMediaUrlAsync(attachment.Url));
+
+            await _writer.WriteLineAsync();
+        }
+
+        private async ValueTask WriteEmbedsAsync(IReadOnlyList<Embed> embeds)
+        {
+            foreach (var embed in embeds)
+            {
+                await _writer.WriteLineAsync("{Embed}");
+
+                if (!string.IsNullOrWhiteSpace(embed.Author?.Name))
+                    await _writer.WriteLineAsync(embed.Author.Name);
+
+                if (!string.IsNullOrWhiteSpace(embed.Url))
+                    await _writer.WriteLineAsync(embed.Url);
+
+                if (!string.IsNullOrWhiteSpace(embed.Title))
+                    await _writer.WriteLineAsync(FormatMarkdown(embed.Title));
+
+                if (!string.IsNullOrWhiteSpace(embed.Description))
+                    await _writer.WriteLineAsync(FormatMarkdown(embed.Description));
+
+                foreach (var field in embed.Fields)
+                {
+                    if (!string.IsNullOrWhiteSpace(field.Name))
+                        await _writer.WriteLineAsync(FormatMarkdown(field.Name));
+
+                    if (!string.IsNullOrWhiteSpace(field.Value))
+                        await _writer.WriteLineAsync(FormatMarkdown(field.Value));
+                }
+
+                if (!string.IsNullOrWhiteSpace(embed.Thumbnail?.Url))
+                    await _writer.WriteLineAsync(await Context.ResolveMediaUrlAsync(embed.Thumbnail.Url));
+
+                if (!string.IsNullOrWhiteSpace(embed.Image?.Url))
+                    await _writer.WriteLineAsync(await Context.ResolveMediaUrlAsync(embed.Image.Url));
+
+                if (!string.IsNullOrWhiteSpace(embed.Footer?.Text))
+                    await _writer.WriteLineAsync(embed.Footer.Text);
+
+                await _writer.WriteLineAsync();
+            }
+        }
+
+        private async ValueTask WriteReactionsAsync(IReadOnlyList<Reaction> reactions)
+        {
+            if (!reactions.Any())
+                return;
+
+            await _writer.WriteLineAsync("{Reactions}");
+
+            foreach (var reaction in reactions)
+            {
+                await _writer.WriteAsync(reaction.Emoji.Name);
+
+                if (reaction.Count > 1)
+                    await _writer.WriteAsync($" ({reaction.Count})");
+
+                await _writer.WriteAsync(' ');
+            }
+
+            await _writer.WriteLineAsync();
+        }
+
+        public override async ValueTask WritePreambleAsync()
+        {
+            await _writer.WriteLineAsync('='.Repeat(62));
+            await _writer.WriteLineAsync($"Guild: {Context.Request.Guild.Name}");
+            await _writer.WriteLineAsync($"Channel: {Context.Request.Channel.Category.Name} / {Context.Request.Channel.Name}");
+
+            if (!string.IsNullOrWhiteSpace(Context.Request.Channel.Topic))
+                await _writer.WriteLineAsync($"Topic: {Context.Request.Channel.Topic}");
+
+            if (Context.Request.After != null)
+                await _writer.WriteLineAsync($"After: {Context.FormatDate(Context.Request.After.Value.ToDate())}");
+
+            if (Context.Request.Before != null)
+                await _writer.WriteLineAsync($"Before: {Context.FormatDate(Context.Request.Before.Value.ToDate())}");
+
+            await _writer.WriteLineAsync('='.Repeat(62));
+            await _writer.WriteLineAsync();
+        }
+
+        public override async ValueTask WriteMessageAsync(Message message)
+        {
+            await WriteMessageHeaderAsync(message);
+
+            if (!string.IsNullOrWhiteSpace(message.Content))
+                await _writer.WriteLineAsync(FormatMarkdown(message.Content));
+
+            await _writer.WriteLineAsync();
+
+            await WriteAttachmentsAsync(message.Attachments);
+            await WriteEmbedsAsync(message.Embeds);
+            await WriteReactionsAsync(message.Reactions);
+
+            await _writer.WriteLineAsync();
+
+            _messageCount++;
+        }
+
+        public override async ValueTask WritePostambleAsync()
+        {
+            await _writer.WriteLineAsync('='.Repeat(62));
+            await _writer.WriteLineAsync($"Exported {_messageCount:N0} message(s)");
+            await _writer.WriteLineAsync('='.Repeat(62));
+        }
+
+        public override async ValueTask DisposeAsync()
+        {
+            await _writer.DisposeAsync();
+            await base.DisposeAsync();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/EmojiNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/EmojiNode.cs
@@ -0,0 +1,27 @@
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal class EmojiNode : MarkdownNode
+    {
+        public string? Id { get; }
+
+        public string Name { get; }
+
+        public bool IsAnimated { get; }
+
+        public bool IsCustomEmoji => !string.IsNullOrWhiteSpace(Id);
+
+        public EmojiNode(string? id, string name, bool isAnimated)
+        {
+            Id = id;
+            Name = name;
+            IsAnimated = isAnimated;
+        }
+
+        public EmojiNode(string name)
+            : this(null, name, false)
+        {
+        }
+
+        public override string ToString() => $"<Emoji> {Name}";
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/FormattedNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/FormattedNode.cs
@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal enum TextFormatting
+    {
+        Bold,
+        Italic,
+        Underline,
+        Strikethrough,
+        Spoiler,
+        Quote
+    }
+
+    internal class FormattedNode : MarkdownNode
+    {
+        public TextFormatting Formatting { get; }
+
+        public IReadOnlyList<MarkdownNode> Children { get; }
+
+        public FormattedNode(TextFormatting formatting, IReadOnlyList<MarkdownNode> children)
+        {
+            Formatting = formatting;
+            Children = children;
+        }
+
+        public override string ToString() => $"<{Formatting}> (+{Children.Count})";
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/InlineCodeBlockNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/InlineCodeBlockNode.cs
@@ -0,0 +1,14 @@
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal class InlineCodeBlockNode : MarkdownNode
+    {
+        public string Code { get; }
+
+        public InlineCodeBlockNode(string code)
+        {
+            Code = code;
+        }
+
+        public override string ToString() => $"<Code> {Code}";
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/LinkNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/LinkNode.cs
@@ -0,0 +1,22 @@
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal class LinkNode : MarkdownNode
+    {
+        public string Url { get; }
+
+        public string Title { get; }
+
+        public LinkNode(string url, string title)
+        {
+            Url = url;
+            Title = title;
+        }
+
+        public LinkNode(string url)
+            : this(url, url)
+        {
+        }
+
+        public override string ToString() => $"<Link> {Title}";
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/MarkdownNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/MarkdownNode.cs
@@ -0,0 +1,6 @@
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal abstract class MarkdownNode
+    {
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/MentionNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/MentionNode.cs
@@ -0,0 +1,25 @@
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal enum MentionType
+    {
+        Meta,
+        User,
+        Channel,
+        Role
+    }
+
+    internal class MentionNode : MarkdownNode
+    {
+        public string Id { get; }
+
+        public MentionType Type { get; }
+
+        public MentionNode(string id, MentionType type)
+        {
+            Id = id;
+            Type = type;
+        }
+
+        public override string ToString() => $"<{Type} mention> {Id}";
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/MultiLineCodeBlockNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/MultiLineCodeBlockNode.cs
@@ -0,0 +1,17 @@
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal class MultiLineCodeBlockNode : MarkdownNode
+    {
+        public string Language { get; }
+
+        public string Code { get; }
+
+        public MultiLineCodeBlockNode(string language, string code)
+        {
+            Language = language;
+            Code = code;
+        }
+
+        public override string ToString() => $"<{Language}> {Code}";
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Ast/TextNode.cs
+++ b/DiscordChatExporter.Core/Markdown/Ast/TextNode.cs
@@ -0,0 +1,14 @@
+namespace DiscordChatExporter.Core.Markdown.Ast
+{
+    internal class TextNode : MarkdownNode
+    {
+        public string Text { get; }
+
+        public TextNode(string text)
+        {
+            Text = text;
+        }
+
+        public override string ToString() => Text;
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/MarkdownParser.cs
+++ b/DiscordChatExporter.Core/Markdown/MarkdownParser.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using DiscordChatExporter.Core.Markdown.Ast;
+using DiscordChatExporter.Core.Markdown.Matching;
+
+namespace DiscordChatExporter.Core.Markdown
+{
+    // The following parsing logic is meant to replicate Discord's markdown grammar as close as possible
+    internal static partial class MarkdownParser
+    {
+        private const RegexOptions DefaultRegexOptions =
+            RegexOptions.Compiled |
+            RegexOptions.CultureInvariant |
+            RegexOptions.Multiline;
+
+        /* Formatting */
+
+        // Capture any character until the earliest double asterisk not followed by an asterisk
+        private static readonly IMatcher<MarkdownNode> BoldFormattedNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("\\*\\*(.+?)\\*\\*(?!\\*)", DefaultRegexOptions | RegexOptions.Singleline),
+            (p, m) => new FormattedNode(TextFormatting.Bold, Parse(p.Slice(m.Groups[1])))
+        );
+
+        // Capture any character until the earliest single asterisk not preceded or followed by an asterisk
+        // Opening asterisk must not be followed by whitespace
+        // Closing asterisk must not be preceded by whitespace
+        private static readonly IMatcher<MarkdownNode> ItalicFormattedNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("\\*(?!\\s)(.+?)(?<!\\s|\\*)\\*(?!\\*)", DefaultRegexOptions | RegexOptions.Singleline),
+            (p, m) => new FormattedNode(TextFormatting.Italic, Parse(p.Slice(m.Groups[1])))
+        );
+
+        // Capture any character until the earliest triple asterisk not followed by an asterisk
+        private static readonly IMatcher<MarkdownNode> ItalicBoldFormattedNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("\\*(\\*\\*.+?\\*\\*)\\*(?!\\*)", DefaultRegexOptions | RegexOptions.Singleline),
+            (p, m) => new FormattedNode(TextFormatting.Italic, Parse(p.Slice(m.Groups[1]), BoldFormattedNodeMatcher))
+        );
+
+        // Capture any character except underscore until an underscore
+        // Closing underscore must not be followed by a word character
+        private static readonly IMatcher<MarkdownNode> ItalicAltFormattedNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("_([^_]+)_(?!\\w)", DefaultRegexOptions | RegexOptions.Singleline),
+            (p, m) => new FormattedNode(TextFormatting.Italic, Parse(p.Slice(m.Groups[1])))
+        );
+
+        // Capture any character until the earliest double underscore not followed by an underscore
+        private static readonly IMatcher<MarkdownNode> UnderlineFormattedNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("__(.+?)__(?!_)", DefaultRegexOptions | RegexOptions.Singleline),
+            (p, m) => new FormattedNode(TextFormatting.Underline, Parse(p.Slice(m.Groups[1])))
+        );
+
+        // Capture any character until the earliest triple underscore not followed by an underscore
+        private static readonly IMatcher<MarkdownNode> ItalicUnderlineFormattedNodeMatcher =
+            new RegexMatcher<MarkdownNode>(
+                new Regex("_(__.+?__)_(?!_)", DefaultRegexOptions | RegexOptions.Singleline),
+                (p, m) => new FormattedNode(TextFormatting.Italic,
+                    Parse(p.Slice(m.Groups[1]), UnderlineFormattedNodeMatcher))
+            );
+
+        // Capture any character until the earliest double tilde
+        private static readonly IMatcher<MarkdownNode> StrikethroughFormattedNodeMatcher =
+            new RegexMatcher<MarkdownNode>(
+                new Regex("~~(.+?)~~", DefaultRegexOptions | RegexOptions.Singleline),
+                (p, m) => new FormattedNode(TextFormatting.Strikethrough, Parse(p.Slice(m.Groups[1])))
+            );
+
+        // Capture any character until the earliest double pipe
+        private static readonly IMatcher<MarkdownNode> SpoilerFormattedNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("\\|\\|(.+?)\\|\\|", DefaultRegexOptions | RegexOptions.Singleline),
+            (p, m) => new FormattedNode(TextFormatting.Spoiler, Parse(p.Slice(m.Groups[1])))
+        );
+
+        // Capture any character until the end of the line
+        // Opening 'greater than' character must be followed by whitespace
+        private static readonly IMatcher<MarkdownNode> SingleLineQuoteNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("^>\\s(.+\n?)", DefaultRegexOptions),
+            (p, m) => new FormattedNode(TextFormatting.Quote, Parse(p.Slice(m.Groups[1])))
+        );
+
+        // Repeatedly capture any character until the end of the line
+        // This one is tricky as it ends up producing multiple separate captures which need to be joined
+        private static readonly IMatcher<MarkdownNode> RepeatedSingleLineQuoteNodeMatcher =
+            new RegexMatcher<MarkdownNode>(
+                new Regex("(?:^>\\s(.+\n?)){2,}", DefaultRegexOptions),
+                (_, m) =>
+                {
+                    var content = string.Concat(m.Groups[1].Captures.Select(c => c.Value));
+                    return new FormattedNode(TextFormatting.Quote, Parse(content));
+                }
+            );
+
+        // Capture any character until the end of the input
+        // Opening 'greater than' characters must be followed by whitespace
+        private static readonly IMatcher<MarkdownNode> MultiLineQuoteNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("^>>>\\s(.+)", DefaultRegexOptions | RegexOptions.Singleline),
+            (p, m) => new FormattedNode(TextFormatting.Quote, Parse(p.Slice(m.Groups[1])))
+        );
+
+        /* Code blocks */
+
+        // Capture any character except backtick until a backtick
+        // Blank lines at the beginning and end of content are trimmed
+        // There can be either one or two backticks, but equal number on both sides
+        private static readonly IMatcher<MarkdownNode> InlineCodeBlockNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("(`{1,2})([^`]+)\\1", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new InlineCodeBlockNode(m.Groups[2].Value.Trim('\r', '\n'))
+        );
+
+        // Capture language identifier and then any character until the earliest triple backtick
+        // Language identifier is one word immediately after opening backticks, followed immediately by newline
+        // Blank lines at the beginning and end of content are trimmed
+        private static readonly IMatcher<MarkdownNode> MultiLineCodeBlockNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("```(?:(\\w*)\\n)?(.+?)```", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new MultiLineCodeBlockNode(m.Groups[1].Value, m.Groups[2].Value.Trim('\r', '\n'))
+        );
+
+        /* Mentions */
+
+        // Capture @everyone
+        private static readonly IMatcher<MarkdownNode> EveryoneMentionNodeMatcher = new StringMatcher<MarkdownNode>(
+            "@everyone",
+            _ => new MentionNode("everyone", MentionType.Meta)
+        );
+
+        // Capture @here
+        private static readonly IMatcher<MarkdownNode> HereMentionNodeMatcher = new StringMatcher<MarkdownNode>(
+            "@here",
+            _ => new MentionNode("here", MentionType.Meta)
+        );
+
+        // Capture <@123456> or <@!123456>
+        private static readonly IMatcher<MarkdownNode> UserMentionNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("<@!?(\\d+)>", DefaultRegexOptions),
+            m => new MentionNode(m.Groups[1].Value, MentionType.User)
+        );
+
+        // Capture <#123456>
+        private static readonly IMatcher<MarkdownNode> ChannelMentionNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("<#(\\d+)>", DefaultRegexOptions),
+            m => new MentionNode(m.Groups[1].Value, MentionType.Channel)
+        );
+
+        // Capture <@&123456>
+        private static readonly IMatcher<MarkdownNode> RoleMentionNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("<@&(\\d+)>", DefaultRegexOptions),
+            m => new MentionNode(m.Groups[1].Value, MentionType.Role)
+        );
+
+        /* Emojis */
+
+        // Capture any country flag emoji (two regional indicator surrogate pairs)
+        // ... or "miscellaneous symbol" character
+        // ... or surrogate pair
+        // ... or digit followed by enclosing mark
+        // (this does not match all emojis in Discord but it's reasonably accurate enough)
+        private static readonly IMatcher<MarkdownNode> StandardEmojiNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("((?:[\\uD83C][\\uDDE6-\\uDDFF]){2}|[\\u2600-\\u26FF]|\\p{Cs}{2}|\\d\\p{Me})",
+                DefaultRegexOptions),
+            m => new EmojiNode(m.Groups[1].Value)
+        );
+
+        // Capture <:lul:123456> or <a:lul:123456>
+        private static readonly IMatcher<MarkdownNode> CustomEmojiNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("<(a)?:(.+?):(\\d+?)>", DefaultRegexOptions),
+            m => new EmojiNode(m.Groups[3].Value, m.Groups[2].Value, !string.IsNullOrWhiteSpace(m.Groups[1].Value))
+        );
+
+        /* Links */
+
+        // Capture [title](link)
+        private static readonly IMatcher<MarkdownNode> TitledLinkNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("\\[(.+?)\\]\\((.+?)\\)", DefaultRegexOptions),
+            m => new LinkNode(m.Groups[2].Value, m.Groups[1].Value)
+        );
+
+        // Capture any non-whitespace character after http:// or https:// until the last punctuation character or whitespace
+        private static readonly IMatcher<MarkdownNode> AutoLinkNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("(https?://\\S*[^\\.,:;\"\'\\s])", DefaultRegexOptions),
+            m => new LinkNode(m.Groups[1].Value)
+        );
+
+        // Same as auto link but also surrounded by angular brackets
+        private static readonly IMatcher<MarkdownNode> HiddenLinkNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("<(https?://\\S*[^\\.,:;\"\'\\s])>", DefaultRegexOptions),
+            m => new LinkNode(m.Groups[1].Value)
+        );
+
+        /* Text */
+
+        // Capture the shrug emoticon
+        // This escapes it from matching for formatting
+        private static readonly IMatcher<MarkdownNode> ShrugTextNodeMatcher = new StringMatcher<MarkdownNode>(
+            @"¯\_(ツ)_/¯",
+            p => new TextNode(p.ToString())
+        );
+
+        // Capture some specific emojis that don't get rendered
+        // This escapes it from matching for emoji
+        private static readonly IMatcher<MarkdownNode> IgnoredEmojiTextNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("(\\u26A7|\\u2640|\\u2642|\\u2695|\\u267E|\\u00A9|\\u00AE|\\u2122)", DefaultRegexOptions),
+            m => new TextNode(m.Groups[1].Value)
+        );
+
+        // Capture any "symbol/other" character or surrogate pair preceded by a backslash
+        // This escapes it from matching for emoji
+        private static readonly IMatcher<MarkdownNode> EscapedSymbolTextNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("\\\\(\\p{So}|\\p{Cs}{2})", DefaultRegexOptions),
+            m => new TextNode(m.Groups[1].Value)
+        );
+
+        // Capture any non-whitespace, non latin alphanumeric character preceded by a backslash
+        // This escapes it from matching for formatting or other tokens
+        private static readonly IMatcher<MarkdownNode> EscapedCharacterTextNodeMatcher = new RegexMatcher<MarkdownNode>(
+            new Regex("\\\\([^a-zA-Z0-9\\s])", DefaultRegexOptions),
+            m => new TextNode(m.Groups[1].Value)
+        );
+
+        // Combine all matchers into one
+        // Matchers that have similar patterns are ordered from most specific to least specific
+        private static readonly IMatcher<MarkdownNode> AggregateNodeMatcher = new AggregateMatcher<MarkdownNode>(
+            // Escaped text
+            ShrugTextNodeMatcher,
+            IgnoredEmojiTextNodeMatcher,
+            EscapedSymbolTextNodeMatcher,
+            EscapedCharacterTextNodeMatcher,
+
+            // Formatting
+            ItalicBoldFormattedNodeMatcher,
+            ItalicUnderlineFormattedNodeMatcher,
+            BoldFormattedNodeMatcher,
+            ItalicFormattedNodeMatcher,
+            UnderlineFormattedNodeMatcher,
+            ItalicAltFormattedNodeMatcher,
+            StrikethroughFormattedNodeMatcher,
+            SpoilerFormattedNodeMatcher,
+            MultiLineQuoteNodeMatcher,
+            RepeatedSingleLineQuoteNodeMatcher,
+            SingleLineQuoteNodeMatcher,
+
+            // Code blocks
+            MultiLineCodeBlockNodeMatcher,
+            InlineCodeBlockNodeMatcher,
+
+            // Mentions
+            EveryoneMentionNodeMatcher,
+            HereMentionNodeMatcher,
+            UserMentionNodeMatcher,
+            ChannelMentionNodeMatcher,
+            RoleMentionNodeMatcher,
+
+            // Links
+            TitledLinkNodeMatcher,
+            AutoLinkNodeMatcher,
+            HiddenLinkNodeMatcher,
+
+            // Emoji
+            StandardEmojiNodeMatcher,
+            CustomEmojiNodeMatcher
+        );
+
+        // Minimal set of matchers for non-multimedia formats (e.g. plain text)
+        private static readonly IMatcher<MarkdownNode> MinimalAggregateNodeMatcher = new AggregateMatcher<MarkdownNode>(
+            // Mentions
+            EveryoneMentionNodeMatcher,
+            HereMentionNodeMatcher,
+            UserMentionNodeMatcher,
+            ChannelMentionNodeMatcher,
+            RoleMentionNodeMatcher,
+
+            // Emoji
+            CustomEmojiNodeMatcher
+        );
+
+        private static IReadOnlyList<MarkdownNode> Parse(StringPart stringPart, IMatcher<MarkdownNode> matcher) =>
+            matcher
+                .MatchAll(stringPart, p => new TextNode(p.ToString()))
+                .Select(r => r.Value)
+                .ToArray();
+    }
+
+    internal static partial class MarkdownParser
+    {
+        private static IReadOnlyList<MarkdownNode> Parse(StringPart stringPart) => Parse(stringPart, AggregateNodeMatcher);
+
+        private static IReadOnlyList<MarkdownNode> ParseMinimal(StringPart stringPart) => Parse(stringPart, MinimalAggregateNodeMatcher);
+
+        public static IReadOnlyList<MarkdownNode> Parse(string input) => Parse(new StringPart(input));
+
+        public static IReadOnlyList<MarkdownNode> ParseMinimal(string input) => ParseMinimal(new StringPart(input));
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/MarkdownVisitor.cs
+++ b/DiscordChatExporter.Core/Markdown/MarkdownVisitor.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using DiscordChatExporter.Core.Markdown.Ast;
+
+namespace DiscordChatExporter.Core.Markdown
+{
+    internal abstract class MarkdownVisitor
+    {
+        protected virtual MarkdownNode VisitText(TextNode text) => text;
+
+        protected virtual MarkdownNode VisitFormatted(FormattedNode formatted)
+        {
+            Visit(formatted.Children);
+            return formatted;
+        }
+
+        protected virtual MarkdownNode VisitInlineCodeBlock(InlineCodeBlockNode inlineCodeBlock) => inlineCodeBlock;
+
+        protected virtual MarkdownNode VisitMultiLineCodeBlock(MultiLineCodeBlockNode multiLineCodeBlock) => multiLineCodeBlock;
+
+        protected virtual MarkdownNode VisitLink(LinkNode link) => link;
+
+        protected virtual MarkdownNode VisitEmoji(EmojiNode emoji) => emoji;
+
+        protected virtual MarkdownNode VisitMention(MentionNode mention) => mention;
+
+        public MarkdownNode Visit(MarkdownNode node) => node switch
+        {
+            TextNode text => VisitText(text),
+            FormattedNode formatted => VisitFormatted(formatted),
+            InlineCodeBlockNode inlineCodeBlock => VisitInlineCodeBlock(inlineCodeBlock),
+            MultiLineCodeBlockNode multiLineCodeBlock => VisitMultiLineCodeBlock(multiLineCodeBlock),
+            LinkNode link => VisitLink(link),
+            EmojiNode emoji => VisitEmoji(emoji),
+            MentionNode mention => VisitMention(mention),
+            _ => throw new ArgumentOutOfRangeException(nameof(node))
+        };
+
+        public void Visit(IEnumerable<MarkdownNode> nodes)
+        {
+            foreach (var node in nodes)
+                Visit(node);
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Matching/AggregateMatcher.cs
+++ b/DiscordChatExporter.Core/Markdown/Matching/AggregateMatcher.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Markdown.Matching
+{
+    internal class AggregateMatcher<T> : IMatcher<T>
+    {
+        private readonly IReadOnlyList<IMatcher<T>> _matchers;
+
+        public AggregateMatcher(IReadOnlyList<IMatcher<T>> matchers)
+        {
+            _matchers = matchers;
+        }
+
+        public AggregateMatcher(params IMatcher<T>[] matchers)
+            : this((IReadOnlyList<IMatcher<T>>) matchers)
+        {
+        }
+
+        public ParsedMatch<T>? TryMatch(StringPart stringPart)
+        {
+            ParsedMatch<T>? earliestMatch = null;
+
+            // Try to match the input with each matcher and get the match with the lowest start index
+            foreach (var matcher in _matchers)
+            {
+                // Try to match
+                var match = matcher.TryMatch(stringPart);
+
+                // If there's no match - continue
+                if (match == null)
+                    continue;
+
+                // If this match is earlier than previous earliest - replace
+                if (earliestMatch == null || match.StringPart.StartIndex < earliestMatch.StringPart.StartIndex)
+                    earliestMatch = match;
+
+                // If the earliest match starts at the very beginning - break,
+                // because it's impossible to find a match earlier than that
+                if (earliestMatch.StringPart.StartIndex == stringPart.StartIndex)
+                    break;
+            }
+
+            return earliestMatch;
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Matching/IMatcher.cs
+++ b/DiscordChatExporter.Core/Markdown/Matching/IMatcher.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Markdown.Matching
+{
+    internal interface IMatcher<T>
+    {
+        ParsedMatch<T>? TryMatch(StringPart stringPart);
+    }
+
+    internal static class MatcherExtensions
+    {
+        public static IEnumerable<ParsedMatch<T>> MatchAll<T>(this IMatcher<T> matcher,
+            StringPart stringPart, Func<StringPart, T> transformFallback)
+        {
+            // Loop through segments divided by individual matches
+            var currentIndex = stringPart.StartIndex;
+            while (currentIndex < stringPart.EndIndex)
+            {
+                // Find a match within this segment
+                var match = matcher.TryMatch(stringPart.Slice(currentIndex, stringPart.EndIndex - currentIndex));
+
+                // If there's no match - break
+                if (match == null)
+                    break;
+
+                // If this match doesn't start immediately at current index - transform and yield fallback first
+                if (match.StringPart.StartIndex > currentIndex)
+                {
+                    var fallbackPart = stringPart.Slice(currentIndex, match.StringPart.StartIndex - currentIndex);
+                    yield return new ParsedMatch<T>(fallbackPart, transformFallback(fallbackPart));
+                }
+
+                // Yield match
+                yield return match;
+
+                // Shift current index to the end of the match
+                currentIndex = match.StringPart.StartIndex + match.StringPart.Length;
+            }
+
+            // If EOL wasn't reached - transform and yield remaining part as fallback
+            if (currentIndex < stringPart.EndIndex)
+            {
+                var fallbackPart = stringPart.Slice(currentIndex);
+                yield return new ParsedMatch<T>(fallbackPart, transformFallback(fallbackPart));
+            }
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Matching/ParsedMatch.cs
+++ b/DiscordChatExporter.Core/Markdown/Matching/ParsedMatch.cs
@@ -0,0 +1,15 @@
+namespace DiscordChatExporter.Core.Markdown.Matching
+{
+    internal class ParsedMatch<T>
+    {
+        public StringPart StringPart { get; }
+
+        public T Value { get; }
+
+        public ParsedMatch(StringPart stringPart, T value)
+        {
+            StringPart = stringPart;
+            Value = value;
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Matching/RegexMatcher.cs
+++ b/DiscordChatExporter.Core/Markdown/Matching/RegexMatcher.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace DiscordChatExporter.Core.Markdown.Matching
+{
+    internal class RegexMatcher<T> : IMatcher<T>
+    {
+        private readonly Regex _regex;
+        private readonly Func<StringPart, Match, T> _transform;
+
+        public RegexMatcher(Regex regex, Func<StringPart, Match, T> transform)
+        {
+            _regex = regex;
+            _transform = transform;
+        }
+
+        public RegexMatcher(Regex regex, Func<Match, T> transform)
+            : this(regex, (p, m) => transform(m))
+        {
+        }
+
+        public ParsedMatch<T>? TryMatch(StringPart stringPart)
+        {
+            var match = _regex.Match(stringPart.Target, stringPart.StartIndex, stringPart.Length);
+            if (!match.Success)
+                return null;
+
+            // Overload regex.Match(string, int, int) doesn't take the whole string into account,
+            // it effectively functions as a match check on a substring.
+            // Which is super weird because regex.Match(string, int) takes the whole input in context.
+            // So in order to properly account for ^/$ regex tokens, we need to make sure that
+            // the expression also matches on the bigger part of the input.
+            if (!_regex.IsMatch(stringPart.Target.Substring(0, stringPart.EndIndex), stringPart.StartIndex))
+                return null;
+
+            var stringPartMatch = stringPart.Slice(match.Index, match.Length);
+            return new ParsedMatch<T>(stringPartMatch, _transform(stringPartMatch, match));
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Matching/StringMatcher.cs
+++ b/DiscordChatExporter.Core/Markdown/Matching/StringMatcher.cs
@@ -0,0 +1,36 @@
+using System;
+
+namespace DiscordChatExporter.Core.Markdown.Matching
+{
+    internal class StringMatcher<T> : IMatcher<T>
+    {
+        private readonly string _needle;
+        private readonly StringComparison _comparison;
+        private readonly Func<StringPart, T> _transform;
+
+        public StringMatcher(string needle, StringComparison comparison, Func<StringPart, T> transform)
+        {
+            _needle = needle;
+            _comparison = comparison;
+            _transform = transform;
+        }
+
+        public StringMatcher(string needle, Func<StringPart, T> transform)
+            : this(needle, StringComparison.Ordinal, transform)
+        {
+        }
+
+        public ParsedMatch<T>? TryMatch(StringPart stringPart)
+        {
+            var index = stringPart.Target.IndexOf(_needle, stringPart.StartIndex, stringPart.Length, _comparison);
+
+            if (index >= 0)
+            {
+                var stringPartMatch = stringPart.Slice(index, _needle.Length);
+                return new ParsedMatch<T>(stringPartMatch, _transform(stringPartMatch));
+            }
+
+            return null;
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Markdown/Matching/StringPart.cs
+++ b/DiscordChatExporter.Core/Markdown/Matching/StringPart.cs
@@ -0,0 +1,36 @@
+using System.Text.RegularExpressions;
+
+namespace DiscordChatExporter.Core.Markdown.Matching
+{
+    internal readonly struct StringPart
+    {
+        public string Target { get; }
+
+        public int StartIndex { get; }
+
+        public int Length { get; }
+
+        public int EndIndex { get; }
+
+        public StringPart(string target, int startIndex, int length)
+        {
+            Target = target;
+            StartIndex = startIndex;
+            Length = length;
+            EndIndex = startIndex + length;
+        }
+
+        public StringPart(string target)
+            : this(target, 0, target.Length)
+        {
+        }
+
+        public StringPart Slice(int newStartIndex, int newLength) => new(Target, newStartIndex, newLength);
+
+        public StringPart Slice(int newStartIndex) => Slice(newStartIndex, EndIndex - newStartIndex);
+
+        public StringPart Slice(Capture capture) => Slice(capture.Index, capture.Length);
+
+        public override string ToString() => Target.Substring(StartIndex, Length);
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Extensions/AsyncExtensions.cs
+++ b/DiscordChatExporter.Core/Utils/Extensions/AsyncExtensions.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DiscordChatExporter.Core.Utils.Extensions
+{
+    public static class AsyncExtensions
+    {
+        private static async ValueTask<IReadOnlyList<T>> AggregateAsync<T>(
+            this IAsyncEnumerable<T> asyncEnumerable)
+        {
+            var list = new List<T>();
+
+            await foreach (var i in asyncEnumerable)
+                list.Add(i);
+
+            return list;
+        }
+
+        public static ValueTaskAwaiter<IReadOnlyList<T>> GetAwaiter<T>(
+            this IAsyncEnumerable<T> asyncEnumerable) =>
+            asyncEnumerable.AggregateAsync().GetAwaiter();
+
+        public static async ValueTask ParallelForEachAsync<T>(
+            this IEnumerable<T> source,
+            Func<T, ValueTask> handleAsync,
+            int degreeOfParallelism)
+        {
+            using var semaphore = new SemaphoreSlim(degreeOfParallelism);
+
+            await Task.WhenAll(source.Select(async item =>
+            {
+                // ReSharper disable once AccessToDisposedClosure
+                await semaphore.WaitAsync();
+
+                try
+                {
+                    await handleAsync(item);
+                }
+                finally
+                {
+                    // ReSharper disable once AccessToDisposedClosure
+                    semaphore.Release();
+                }
+            }));
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Extensions/BinaryExtensions.cs
+++ b/DiscordChatExporter.Core/Utils/Extensions/BinaryExtensions.cs
@@ -0,0 +1,19 @@
+using System.Text;
+
+namespace DiscordChatExporter.Core.Utils.Extensions
+{
+    public static class BinaryExtensions
+    {
+        public static string ToHex(this byte[] data)
+        {
+            var buffer = new StringBuilder();
+
+            foreach (var t in data)
+            {
+                buffer.Append(t.ToString("X2"));
+            }
+
+            return buffer.ToString();
+        }
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Extensions/ColorExtensions.cs
+++ b/DiscordChatExporter.Core/Utils/Extensions/ColorExtensions.cs
@@ -0,0 +1,15 @@
+using System.Drawing;
+
+namespace DiscordChatExporter.Core.Utils.Extensions
+{
+    public static class ColorExtensions
+    {
+        public static Color WithAlpha(this Color color, int alpha) => Color.FromArgb(alpha, color);
+
+        public static Color ResetAlpha(this Color color) => color.WithAlpha(255);
+
+        public static int ToRgb(this Color color) => color.ToArgb() & 0xffffff;
+
+        public static string ToHex(this Color color) => $"#{color.R:X2}{color.G:X2}{color.B:X2}";
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Extensions/DateExtensions.cs
+++ b/DiscordChatExporter.Core/Utils/Extensions/DateExtensions.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Globalization;
+
+namespace DiscordChatExporter.Core.Utils.Extensions
+{
+    public static class DateExtensions
+    {
+        public static string ToLocalString(this DateTimeOffset dateTime, string format) =>
+            dateTime.ToLocalTime().ToString(format, CultureInfo.InvariantCulture);
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Extensions/GenericExtensions.cs
+++ b/DiscordChatExporter.Core/Utils/Extensions/GenericExtensions.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace DiscordChatExporter.Core.Utils.Extensions
+{
+    public static class GenericExtensions
+    {
+        public static TOut Pipe<TIn, TOut>(this TIn input, Func<TIn, TOut> transform) => transform(input);
+
+        public static T? NullIf<T>(this T value, Func<T, bool> predicate) where T : struct =>
+            !predicate(value)
+                ? value
+                : (T?) null;
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Extensions/HttpExtensions.cs
+++ b/DiscordChatExporter.Core/Utils/Extensions/HttpExtensions.cs
@@ -0,0 +1,12 @@
+using System.Net.Http.Headers;
+
+namespace DiscordChatExporter.Core.Utils.Extensions
+{
+    public static class HttpExtensions
+    {
+        public static string? TryGetValue(this HttpContentHeaders headers, string name) =>
+            headers.TryGetValues(name, out var values)
+                ? string.Concat(values)
+                : null;
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Extensions/StringExtensions.cs
+++ b/DiscordChatExporter.Core/Utils/Extensions/StringExtensions.cs
@@ -0,0 +1,17 @@
+using System.Text;
+
+namespace DiscordChatExporter.Core.Utils.Extensions
+{
+    public static class StringExtensions
+    {
+        public static string Truncate(this string str, int charCount) =>
+            str.Length > charCount
+                ? str.Substring(0, charCount)
+                : str;
+
+        public static StringBuilder AppendIfNotEmpty(this StringBuilder builder, char value) =>
+            builder.Length > 0
+                ? builder.Append(value)
+                : builder;
+    }
+}
--- a/DiscordChatExporter.Core/Utils/Http.cs
+++ b/DiscordChatExporter.Core/Utils/Http.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Polly;
+
+namespace DiscordChatExporter.Core.Utils
+{
+    public static class Http
+    {
+        public static HttpClient Client { get; } = new();
+
+        public static IAsyncPolicy<HttpResponseMessage> ResponsePolicy { get; } =
+            Policy
+                .Handle<IOException>()
+                .Or<HttpRequestException>()
+                .OrResult<HttpResponseMessage>(m => m.StatusCode == HttpStatusCode.TooManyRequests)
+                .OrResult(m => m.StatusCode == HttpStatusCode.RequestTimeout)
+                .OrResult(m => m.StatusCode >= HttpStatusCode.InternalServerError)
+                .WaitAndRetryAsync(8,
+                    (i, result, _) =>
+                    {
+                        // If rate-limited, use retry-after as a guide
+                        if (result.Result?.StatusCode == HttpStatusCode.TooManyRequests)
+                        {
+                            // Only start respecting retry-after after a few attempts.
+                            // The reason is that Discord often sends unreasonable (20+ minutes) retry-after
+                            // on the very first request.
+                            if (i > 3)
+                            {
+                                var retryAfterDelay = result.Result.Headers.RetryAfter.Delta;
+                                if (retryAfterDelay != null)
+                                    return retryAfterDelay.Value + TimeSpan.FromSeconds(1); // margin just in case
+                            }
+                        }
+
+                        return TimeSpan.FromSeconds(Math.Pow(2, i) + 1);
+                    },
+                    (_, _, _, _) => Task.CompletedTask);
+
+        private static HttpStatusCode? TryGetStatusCodeFromException(HttpRequestException ex)
+        {
+            // This is extremely frail, but there's no other way
+            var statusCodeRaw = Regex.Match(ex.Message, @": (\d+) \(").Groups[1].Value;
+            return !string.IsNullOrWhiteSpace(statusCodeRaw)
+                ? (HttpStatusCode) int.Parse(statusCodeRaw, CultureInfo.InvariantCulture)
+                : (HttpStatusCode?) null;
+        }
+
+        public static IAsyncPolicy ExceptionPolicy { get; } =
+            Policy
+                .Handle<IOException>() // dangerous
+                .Or<HttpRequestException>(ex => TryGetStatusCodeFromException(ex) == HttpStatusCode.TooManyRequests)
+                .Or<HttpRequestException>(ex => TryGetStatusCodeFromException(ex) == HttpStatusCode.RequestTimeout)
+                .Or<HttpRequestException>(ex => TryGetStatusCodeFromException(ex) >= HttpStatusCode.InternalServerError)
+                .WaitAndRetryAsync(4, i => TimeSpan.FromSeconds(Math.Pow(2, i) + 1));
+    }
+}
--- a/DiscordChatExporter.Core/Utils/PathEx.cs
+++ b/DiscordChatExporter.Core/Utils/PathEx.cs
@@ -0,0 +1,18 @@
+using System.IO;
+using System.Text;
+
+namespace DiscordChatExporter.Core.Utils
+{
+    public static class PathEx
+    {
+        public static StringBuilder EscapePath(StringBuilder pathBuffer)
+        {
+            foreach (var invalidChar in Path.GetInvalidFileNameChars())
+                pathBuffer.Replace(invalidChar, '_');
+
+            return pathBuffer;
+        }
+
+        public static string EscapePath(string path) => EscapePath(new StringBuilder(path)).ToString();
+    }
+}
--- a/DiscordChatExporter.Core/Utils/UrlBuilder.cs
+++ b/DiscordChatExporter.Core/Utils/UrlBuilder.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+
+namespace DiscordChatExporter.Core.Utils
+{
+    public class UrlBuilder
+    {
+        private string _path = "";
+
+        private readonly Dictionary<string, string?> _queryParameters = new(StringComparer.OrdinalIgnoreCase);
+
+        public UrlBuilder SetPath(string path)
+        {
+            _path = path;
+            return this;
+        }
+
+        public UrlBuilder SetQueryParameter(string key, string? value, bool ignoreUnsetValue = true)
+        {
+            if (ignoreUnsetValue && string.IsNullOrWhiteSpace(value))
+                return this;
+
+            var keyEncoded = WebUtility.UrlEncode(key);
+            var valueEncoded = WebUtility.UrlEncode(value);
+            _queryParameters[keyEncoded] = valueEncoded;
+
+            return this;
+        }
+
+        public string Build()
+        {
+            var buffer = new StringBuilder();
+
+            buffer.Append(_path);
+
+            if (_queryParameters.Any())
+                buffer.Append('?').AppendJoin('&', _queryParameters.Select(kvp => $"{kvp.Key}={kvp.Value}"));
+
+            return buffer.ToString();
+        }
+    }
+}