Update version

Fixes #125
Closes #177

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+github: Tyrrrz
+patreon: Tyrrrz
+custom: ['buymeacoffee.com/Tyrrrz', 'tyrrrz.me/donate']

.github/workflows/CD.yml

@@ -0,0 +1,64 @@
+name: CD
+
+on:
+  push:
+    tags:
+    - '*'
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: 3.1.100
+
+    - name: Build & publish (CLI)
+      run: dotnet publish DiscordChatExporter.Cli/ -o DiscordChatExporter.Cli/bin/Publish/ --configuration Release
+
+    - name: Build & publish (GUI)
+      run: dotnet publish DiscordChatExporter.Gui/ -o DiscordChatExporter.Gui/bin/Publish/ --configuration Release
+
+    - name: Pack (CLI)
+      run: Compress-Archive -Path DiscordChatExporter.Cli/bin/Publish/* -DestinationPath DiscordChatExporter.Cli/bin/Publish/Archive.zip -Force
+      shell: pwsh
+
+    - name: Pack (GUI)
+      run: Compress-Archive -Path DiscordChatExporter.Gui/bin/Publish/* -DestinationPath DiscordChatExporter.Gui/bin/Publish/Archive.zip -Force
+      shell: pwsh
+
+    - name: Create release
+      id: create_release
+      uses: actions/create-release@v1.0.0
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ github.ref }}
+        release_name: ${{ github.ref }}
+        draft: false
+        prerelease: false
+
+    - name: Upload release asset (CLI)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: DiscordChatExporter.Cli/bin/Publish/Archive.zip
+        asset_name: DiscordChatExporter.CLI.zip
+        asset_content_type: application/zip
+
+    - name: Upload release asset (GUI)
+      uses: actions/upload-release-asset@v1.0.1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: DiscordChatExporter.Gui/bin/Publish/Archive.zip
+        asset_name: DiscordChatExporter.zip
+        asset_content_type: application/zip

.github/workflows/CI.yml

@@ -0,0 +1,34 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: 3.1.100
+
+    - name: Build & publish (CLI)
+      run: dotnet publish DiscordChatExporter.Cli/ -o DiscordChatExporter.Cli/bin/Publish/ --configuration Release
+
+    - name: Build & publish (GUI)
+      run: dotnet publish DiscordChatExporter.Gui/ -o DiscordChatExporter.Gui/bin/Publish/ --configuration Release
+
+    - name: Upload build artifacts (CLI)
+      uses: actions/upload-artifact@master
+      with:
+        name: DiscordChatExporter.CLI
+        path: DiscordChatExporter.Cli/bin/Publish/
+
+    - name: Upload build artifact (GUI)
+      uses: actions/upload-artifact@master
+      with:
+        name: DiscordChatExporter
+        path: DiscordChatExporter.Gui/bin/Publish/

.gitignore

@@ -258,7 +258,4 @@ paket-files/
 
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
-*.pyc
-
-# Ammy auto-generated XAML
-*.g.xaml
+*.pyc

Changelog.md

@@ -1,3 +1,154 @@
+### v2.16 (08-Dec-2019)
+
+- Migrated from .NET Framework to .NET Core. To run this and future versions of DiscordChatExporter you will need [.NET Core runtime for desktop apps](https://dotnet.microsoft.com/download/dotnet-core/3.1/runtime) (for GUI/CLI version on Windows) or [.NET Core base runtime](https://dotnet.microsoft.com/download/dotnet-core/3.1) (for CLI version on Windows, Linux or macOS).
+- Reworked the exporter engine to render output using streaming data source. This means that only a very small portion of messages are cached in memory when exporting. In other words, you are only limited by storage space and not how much RAM you have, so you can now export terrabytes of chat logs without hitting out of memory exceptions. I still recommend using partitions if you're exporting very large chat logs (250k+ messages) to HTML, unless you want your computer to catch fire when you try to open the export in browser.
+- Added a warning about automating user accounts to the usage guide in both GUI and CLI versions.
+- Added support for announcement (news) channels. You will now be able to see them in the list and export them.
+- Fixed various issues that resulted in exceptions during export process.
+- [HTML] Changed default color of the embed color pill to match the theme.
+- [HTML] Changed emoji parser to be less greedy. As a result it should match fewer character sequences that look like emojis but really aren't, but on the other hand it might miss some actual emojis. This means that some standard emojis (i.e. not custom server emojis) may not look like in Discord. This is a compromise I'm willing to take because detecting emojis in text is really hard to get right and not worth it at all.
+- [HTML] Some other minor styling adjustments.
+- [CSV] Replaced semicolons (;) with (,) as separators.
+
+Please note that CSV export is most likely not going to receive future updates and will remain only as an option for those who wish to use it for text analysis. In other words, it won't contain any of the rich media features like embeds. If you're currently using CSV as a structured output to feed into your program, JSON output will replace that in the future.
+
+### v2.15 (15-Sep-2019)
+
+- Improved markdown parser and made it even faster for non-HTML formats.
+- [HTML] Added support for block quotes.
+- [HTML] Links pointing to a Discord message will now navigate to the linked message inside exported chat log if it's there.
+- [HTML] Updated light theme to match how it looks in Discord after recent changes.
+- [HTML] Added indication for when a message is pinned. Pinned messages now have a tinted background.
+- [HTML] Fixed an issue where multiline code blocks sometimes had incorrect formatting applied to them.
+- [TXT] Added indication for when a message is pinned. Pinned messages now have `(pinned)` next to timestamp and author.
+- [CSV] Added message author's user ID to output.
+- [GUI] Streamlined auto-update process a bit.
+- [GUI] Added some tooltips.
+
+### v2.14 (15-Jun-2019)
+
+- [TXT] Added support for embeds.
+- [TXT] Added support for reactions.
+- [CSV] Added support for reactions.
+- [TXT] Changed how attachments are rendered.
+
+### v2.13.1 (06-Jun-2019)
+
+- Fixed an issue where the app sometimes crashed when exporting due to `System.InvalidCastException`.
+- [HTML] Added `data-user-id` attribute to `span.chatlog__author-name`. The value of this attribute is author's Discord user ID.
+
+### v2.13 (15-May-2019)
+
+- Updated usage instructions.
+- [HTML] Added BOT tags to messages posted by bots.
+- [GUI] UI will now be disabled when exporting.
+- [GUI] Notification informing that the export has completed will now appear after all exports have completed, instead of each of them separately.
+
+### v2.12.1 (12-Apr-2019)
+
+- [GUI] Fixed an issue where the app crashed when trying to export multiple channels.
+- [HTML] Fixed an issue where some of the emojis were rendered via Twemoji while Discord renders them as plain text.
+- [HTML] Fixed an issue where emojis weren't jumbo if there were more than one of them.
+
+### v2.12 (11-Apr-2019)
+
+- Improved markdown parsing performance which speeds up the final stage of exporting by around 4.5 times.
+- Improved performance when exporting as PlainText or CSV.
+- [GUI] Fixed an issue where the app would freeze up and report as "not responding" during the final stage of exporting.
+- [CLI] Fixed an issue where it would say "Completed" after exporting a chat log, even if the process failed.
+
+### v2.11 (14-Mar-2019)
+
+- [HTML] Added syntax highlighting for multiline code blocks via Highlight.js.
+- Added retry policy for all 5xx status codes to prevent random crashes.
+
+### v2.10.2 (10-Mar-2019)
+
+- [HTML] Updated message grouping algorithm to make it the same as in Discord. Removed "message group limit" setting and parameter.
+- [HTML] Added small margin at the end of the chatlog so it doesn't look like it was truncated.
+- [CLI] Fixed an issue where the app would crash if stdout was redirected. Progress will not be reported in such cases.
+
+### v2.10.1 (06-Mar-2019)
+
+- [HTML] Fixed an issue where multiple emojis on a single line would get rendered as one emoji.
+- [HTML] Fixed an issue where an open square bracket character would incorrectly render as an emoji.
+- [HTML] Added alt text to emoji images so that they will be rendered using default font when Twemoji images are not available.
+
+### v2.10 (03-Mar-2019)
+
+- [HTML] Reworked the entire markdown parsing engine which fixes numerous rendering inconsistencies (over 15 issues fixed).
+- [HTML] Added support for animated emojis.
+- [HTML] Standard emojis are now rendered using Twemoji, the same image set that Discord uses.
+- [HTML] Fixed an issue where video attachments would render incorrectly.
+- [HTML] Minor fixes in styling.
+- [GUI] Aggregated export progress is now shown in the taskbar.
+- [GUI] Checkmarks are now displayed next to channels that are selected.
+- [CLI] Added progress reporting when exporting chat logs.
+
+### v2.9.1 (10-Feb-2019)
+
+- Fixed an issue where some of the last messages in a channel would sometimes not get exported.
+
+### v2.9 (09-Feb-2019)
+
+- Added categories to channel list in GUI. Channels are now also grouped by category.
+- Added ability to export multiple channels at once in GUI by selecting them with shift or ctrl keys.
+- Added CLI command to export all available channels in a guild (`exportguild`).
+- Added CLI command to export all direct message channels (`exportdm`).
+- Added retry policy for 503 status code errors to prevent random crashes.
+- Changed how channels are exported in GUI. Now you need to select them first and then click a button to export. You can also double click a single channel to export it as before.
+- Improved default file name generation by adding date ranges and channel ID to the file name.
+- Improved naming of files exported with partitioning.
+- Improved usage instructions.
+- Improved GUI layout and styling.
+- Fixed an issue where dialogs would sometimes appear over other windows.
+- Fixed an issue where launching DiscordChatExporter from Windows Start Menu would make it crash.
+
+### v2.8 (03-Nov-2018)
+
+- Added support for partitioning which lets you split the output into multiple files by setting the partition message limit (`-p` parameter for CLI).
+- Exported file will no longer open automatically on completion.
+- Reduced amount of memory used during exporting.
+- Disabled message grouping in PlainText export.
+- Improved encoding of newlines in CSV export.
+- Improved error messages in the GUI app during crashes.
+
+### v2.7 (14-Sep-2018)
+
+- Updated instructions on how to obtain the user token.
+- Expanded CLI with new commands: `channels` (get a list of channels in a guild), `dm` (get a list of DM channels), `guilds` (get a list of guilds), on top of `export` (export chatlog).
+- Improved help text and error messages in CLI.
+- In CLI, the file name will be automatically generated if the provided output file path is a directory.
+
+### v2.6 (25-Jul-2018)
+
+- Added support for bot tokens as an alternative to user tokens. For GUI, use the button in the top-left to switch between user and bot token. For CLI, pass the `--bot` switch to indicate that the given token is a bot token.
+- Added support for animated avatars.
+
+### v2.5.1 (01-Jul-2018)
+
+- Fixed a bug that would prevent timestamps from rendering properly in CSV and PlainText exports.
+- Fixed incorrect layout in CSV export.
+- Improved readability of PlainText export.
+
+### v2.5 (28-Jun-2018)
+
+- Added support for embeds and webhooks (HTML only).
+- Implemented progress reporting when downloading messages.
+- Added support for reactions (HTML only).
+- Selected date range is now shown in the export (HTML and PlainText).
+- Added placeholders for guild icons to display while the icons are loading.
+- Added support for jumbo emojis (custom emojis only).
+- Added basic retry policy for 429 error responses.
+- Added validation for from/to dates in the UI which prevents choosing invalid date ranges.
+- Added an error message when trying to export a deleted channel.
+
+### v2.4.1 (15-Apr-2018)
+
+- Added CSV export format.
+- Channels are now ordered by name in the UI.
+- Exported file is now always opened upon completion.
+
 ### v2.4 (08-Apr-2018)
 
 - Added channel topic to output.

Deploy/Prepare.ps1

@@ -1,11 +0,0 @@
-New-Item "$PSScriptRoot\bin" -ItemType Directory -Force
-
-# GUI
-$files = @()
-$files += Get-ChildItem -Path "$PSScriptRoot\..\DiscordChatExporter.Gui\bin\Release\*" -Include "*.exe", "*.dll", "*.config"
-$files | Compress-Archive -DestinationPath "$PSScriptRoot\bin\DiscordChatExporter.zip" -Force
-
-# CLI
-$files = @()
-$files += Get-ChildItem -Path "$PSScriptRoot\..\DiscordChatExporter.Cli\bin\Release\net461\*" -Include "*.exe", "*.dll", "*.config"
-$files | Compress-Archive -DestinationPath "$PSScriptRoot\bin\DiscordChatExporter.Cli.zip" -Force

DiscordChatExporter.Cli/CliOptions.cs

@@ -1,24 +0,0 @@
-using System;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Cli
-{
-    public class CliOptions
-    {
-        public string Token { get; set; }
-
-        public string ChannelId { get; set; }
-
-        public ExportFormat ExportFormat { get; set; }
-
-        public string FilePath { get; set; }
-
-        public DateTime? From { get; set; }
-
-        public DateTime? To { get; set; }
-
-        public string DateFormat { get; set; }
-
-        public int MessageGroupLimit { get; set; }
-    }
-}

DiscordChatExporter.Cli/Commands/ExportChannelCommand.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Services;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    [Command("export", Description = "Export a channel.")]
+    public class ExportChannelCommand : ExportCommandBase
+    {
+        [CommandOption("channel", 'c', IsRequired = true, Description= "Channel ID.")]
+        public string ChannelId { get; set; }
+
+        public ExportChannelCommand(SettingsService settingsService, DataService dataService, ExportService exportService)
+            : base(settingsService, dataService, exportService)
+        {
+        }
+
+        public override async Task ExecuteAsync(IConsole console) => await ExportAsync(console, ChannelId);
+    }
+}

DiscordChatExporter.Cli/Commands/ExportCommandBase.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Services;
+using CliFx.Utilities;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    public abstract class ExportCommandBase : TokenCommandBase
+    {
+        protected SettingsService SettingsService { get; }
+
+        protected ExportService ExportService { get; }
+
+        [CommandOption("format", 'f', Description = "Output file format.")]
+        public ExportFormat ExportFormat { get; set; } = ExportFormat.HtmlDark;
+
+        [CommandOption("output", 'o', Description = "Output file or directory path.")]
+        public string? OutputPath { get; set; }
+
+        [CommandOption("after", Description = "Limit to messages sent after this date.")]
+        public DateTimeOffset? After { get; set; }
+
+        [CommandOption("before", Description = "Limit to messages sent before this date.")]
+        public DateTimeOffset? Before { get; set; }
+
+        [CommandOption("partition", 'p', Description = "Split output into partitions limited to this number of messages.")]
+        public int? PartitionLimit { get; set; }
+
+        [CommandOption("dateformat", Description = "Date format used in output.")]
+        public string? DateFormat { get; set; }
+
+        protected ExportCommandBase(SettingsService settingsService, DataService dataService, ExportService exportService)
+            : base(dataService)
+        {
+            SettingsService = settingsService;
+            ExportService = exportService;
+        }
+
+        protected async Task ExportAsync(IConsole console, Guild guild, Channel channel)
+        {
+            if (!string.IsNullOrWhiteSpace(DateFormat))
+                SettingsService.DateFormat = DateFormat;
+
+            console.Output.Write($"Exporting channel [{channel.Name}]... ");
+            var progress = console.CreateProgressTicker();
+
+            var outputPath = OutputPath ?? Directory.GetCurrentDirectory();
+            await ExportService.ExportChatLogAsync(GetToken(), guild, channel,
+                outputPath, ExportFormat, PartitionLimit,
+                After, Before, progress);
+
+            console.Output.WriteLine();
+        }
+
+        protected async Task ExportAsync(IConsole console, Channel channel)
+        {
+            var guild = await DataService.GetGuildAsync(GetToken(), channel.GuildId);
+            await ExportAsync(console, guild, channel);
+        }
+
+        protected async Task ExportAsync(IConsole console, string channelId)
+        {
+            var channel = await DataService.GetChannelAsync(GetToken(), channelId);
+            await ExportAsync(console, channel);
+        }
+    }
+}

DiscordChatExporter.Cli/Commands/ExportDirectMessagesCommand.cs

@@ -0,0 +1,45 @@
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Services;
+using DiscordChatExporter.Core.Services;
+using DiscordChatExporter.Core.Services.Exceptions;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    [Command("exportdm", Description = "Export all direct message channels.")]
+    public class ExportDirectMessagesCommand : ExportCommandBase
+    {
+        public ExportDirectMessagesCommand(SettingsService settingsService, DataService dataService, ExportService exportService)
+            : base(settingsService, dataService, exportService)
+        {
+        }
+
+        public override async Task ExecuteAsync(IConsole console)
+        {
+            // Get channels
+            var channels = await DataService.GetDirectMessageChannelsAsync(GetToken());
+
+            // Order channels
+            channels = channels.OrderBy(c => c.Name).ToArray();
+
+            // Loop through channels
+            foreach (var channel in channels)
+            {
+                try
+                {
+                    await ExportAsync(console, channel);
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.Forbidden)
+                {
+                    console.Error.WriteLine("You don't have access to this channel.");
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+                {
+                    console.Error.WriteLine("This channel doesn't exist.");
+                }
+            }
+        }
+    }
+}

DiscordChatExporter.Cli/Commands/ExportGuildCommand.cs

@@ -0,0 +1,49 @@
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Services;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+using DiscordChatExporter.Core.Services.Exceptions;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    [Command("exportguild", Description = "Export all channels within specified guild.")]
+    public class ExportGuildCommand : ExportCommandBase
+    {
+        [CommandOption("guild", 'g', IsRequired = true, Description = "Guild ID.")]
+        public string GuildId { get; set; }
+
+        public ExportGuildCommand(SettingsService settingsService, DataService dataService, ExportService exportService)
+            : base(settingsService, dataService, exportService)
+        {
+        }
+
+        public override async Task ExecuteAsync(IConsole console)
+        {
+            // Get channels
+            var channels = await DataService.GetGuildChannelsAsync(GetToken(), GuildId);
+
+            // Filter and order channels
+            channels = channels.Where(c => c.Type.IsExportable()).OrderBy(c => c.Name).ToArray();
+
+            // Loop through channels
+            foreach (var channel in channels)
+            {
+                try
+                {
+                    await ExportAsync(console, channel);
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.Forbidden)
+                {
+                    console.Error.WriteLine("You don't have access to this channel.");
+                }
+                catch (HttpErrorStatusCodeException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+                {
+                    console.Error.WriteLine("This channel doesn't exist.");
+                }
+            }
+        }
+    }
+}

DiscordChatExporter.Cli/Commands/GetChannelsCommand.cs

@@ -0,0 +1,34 @@
+using System.Linq;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Services;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    [Command("channels", Description = "Get the list of channels in specified guild.")]
+    public class GetChannelsCommand : TokenCommandBase
+    {
+        [CommandOption("guild", 'g', IsRequired = true, Description = "Guild ID.")]
+        public string GuildId { get; set; }
+
+        public GetChannelsCommand(DataService dataService)
+            : base(dataService)
+        {
+        }
+
+        public override async Task ExecuteAsync(IConsole console)
+        {
+            // Get channels
+            var channels = await DataService.GetGuildChannelsAsync(GetToken(), GuildId);
+
+            // Filter and order channels
+            channels = channels.Where(c => c.Type.IsExportable()).OrderBy(c => c.Name).ToArray();
+
+            // Print result
+            foreach (var channel in channels)
+                console.Output.WriteLine($"{channel.Id} | {channel.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Commands/GetDirectMessageChannelsCommand.cs

@@ -0,0 +1,30 @@
+using System.Linq;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Services;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    [Command("dm", Description = "Get the list of direct message channels.")]
+    public class GetDirectMessageChannelsCommand : TokenCommandBase
+    {
+        public GetDirectMessageChannelsCommand(DataService dataService)
+            : base(dataService)
+        {
+        }
+
+        public override async Task ExecuteAsync(IConsole console)
+        {
+            // Get channels
+            var channels = await DataService.GetDirectMessageChannelsAsync(GetToken());
+
+            // Order channels
+            channels = channels.OrderBy(c => c.Name).ToArray();
+
+            // Print result
+            foreach (var channel in channels)
+                console.Output.WriteLine($"{channel.Id} | {channel.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Commands/GetGuildsCommand.cs

@@ -0,0 +1,30 @@
+using System.Linq;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Services;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    [Command("guilds", Description = "Get the list of accessible guilds.")]
+    public class GetGuildsCommand : TokenCommandBase
+    {
+        public GetGuildsCommand(DataService dataService)
+            : base(dataService)
+        {
+        }
+
+        public override async Task ExecuteAsync(IConsole console)
+        {
+            // Get guilds
+            var guilds = await DataService.GetUserGuildsAsync(GetToken());
+
+            // Order guilds
+            guilds = guilds.OrderBy(g => g.Name).ToArray();
+
+            // Print result
+            foreach (var guild in guilds)
+                console.Output.WriteLine($"{guild.Id} | {guild.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Commands/GuideCommand.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Services;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    [Command("guide", Description = "Explains how to obtain token, guild or channel ID.")]
+    public class GuideCommand : ICommand
+    {
+        public Task ExecuteAsync(IConsole console)
+        {
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine("To get user token:"));
+            console.Output.WriteLine(" 1. Open Discord");
+            console.Output.WriteLine(" 2. Press Ctrl+Shift+I to show developer tools");
+            console.Output.WriteLine(" 3. Navigate to the Application tab");
+            console.Output.WriteLine(" 4. Select \"Local Storage\" > \"https://discordapp.com\" on the left");
+            console.Output.WriteLine(" 5. Press Ctrl+R to reload");
+            console.Output.WriteLine(" 6. Find \"token\" at the bottom and copy the value");
+            console.Output.WriteLine(" *  Automating user accounts is technically against TOS, use at your own risk.");
+            console.Output.WriteLine();
+
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine("To get bot token:"));
+            console.Output.WriteLine(" 1. Go to Discord developer portal");
+            console.Output.WriteLine(" 2. Open your application's settings");
+            console.Output.WriteLine(" 3. Navigate to the Bot section on the left");
+            console.Output.WriteLine(" 4. Under Token click Copy");
+            console.Output.WriteLine();
+
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine("To get guild ID or guild channel ID:"));
+            console.Output.WriteLine(" 1. Open Discord");
+            console.Output.WriteLine(" 2. Open Settings");
+            console.Output.WriteLine(" 3. Go to Appearance section");
+            console.Output.WriteLine(" 4. Enable Developer Mode");
+            console.Output.WriteLine(" 5. Right click on the desired guild or channel and click Copy ID");
+            console.Output.WriteLine();
+
+            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine("To get direct message channel ID:"));
+            console.Output.WriteLine(" 1. Open Discord");
+            console.Output.WriteLine(" 2. Open the desired direct message channel");
+            console.Output.WriteLine(" 3. Press Ctrl+Shift+I to show developer tools");
+            console.Output.WriteLine(" 4. Navigate to the Console tab");
+            console.Output.WriteLine(" 5. Type \"window.location.href\" and press Enter");
+            console.Output.WriteLine(" 6. Copy the first long sequence of numbers inside the URL");
+            console.Output.WriteLine();
+
+            console.Output.WriteLine("If you still have unanswered questions, check out the wiki:");
+            console.Output.WriteLine("https://github.com/Tyrrrz/DiscordChatExporter/wiki");
+
+            return Task.CompletedTask;
+        }
+    }
+}

DiscordChatExporter.Cli/Commands/TokenCommandBase.cs

@@ -0,0 +1,29 @@
+using System.Threading.Tasks;
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Services;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Commands
+{
+    public abstract class TokenCommandBase : ICommand
+    {
+        protected DataService DataService { get; }
+
+        [CommandOption("token", 't', IsRequired = true, Description = "Authorization token.")]
+        public string TokenValue { get; set; }
+
+        [CommandOption("bot", 'b', Description = "Whether this authorization token belongs to a bot.")]
+        public bool IsBotToken { get; set; }
+
+        protected TokenCommandBase(DataService dataService)
+        {
+            DataService = dataService;
+        }
+
+        protected AuthToken GetToken() => new AuthToken(IsBotToken ? AuthTokenType.Bot : AuthTokenType.User, TokenValue);
+
+        public abstract Task ExecuteAsync(IConsole console);
+    }
+}

DiscordChatExporter.Cli/Container.cs

@@ -1,37 +0,0 @@
-using CommonServiceLocator;
-using DiscordChatExporter.Cli.ViewModels;
-using DiscordChatExporter.Core.Services;
-using GalaSoft.MvvmLight.Ioc;
-
-namespace DiscordChatExporter.Cli
-{
-    public class Container
-    {
-        public IMainViewModel MainViewModel => Resolve<IMainViewModel>();
-        public ISettingsService SettingsService => Resolve<ISettingsService>();
-
-        private T Resolve<T>(string key = null)
-        {
-            return ServiceLocator.Current.GetInstance<T>(key);
-        }
-
-        public void Init()
-        {
-            ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
-            SimpleIoc.Default.Reset();
-
-            // Services
-            SimpleIoc.Default.Register<IDataService, DataService>();
-            SimpleIoc.Default.Register<IExportService, ExportService>();
-            SimpleIoc.Default.Register<IMessageGroupService, MessageGroupService>();
-            SimpleIoc.Default.Register<ISettingsService, SettingsService>();
-
-            // View models
-            SimpleIoc.Default.Register<IMainViewModel, MainViewModel>(true);
-        }
-
-        public void Cleanup()
-        {
-        }
-    }
-}

DiscordChatExporter.Cli/DiscordChatExporter.Cli.csproj

@@ -1,23 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../DiscordChatExporter.props" />
 
-    <PropertyGroup>
-        <OutputType>Exe</OutputType>
-        <TargetFramework>net461</TargetFramework>
-        <Version>2.4</Version>
-        <Company>Tyrrrz</Company>
-        <Copyright>Copyright (c) 2017-2018 Alexey Golub</Copyright>
-        <ApplicationIcon>..\favicon.ico</ApplicationIcon>
-    </PropertyGroup>
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <ApplicationIcon>..\favicon.ico</ApplicationIcon>
+  </PropertyGroup>
 
-    <ItemGroup>
-        <PackageReference Include="CommonServiceLocator" Version="2.0.3" />
-        <PackageReference Include="FluentCommandLineParser" Version="1.4.3" />
-        <PackageReference Include="MvvmLightLibs" Version="5.4.1" />
-        <PackageReference Include="Tyrrrz.Extensions" Version="1.5.0" />
-    </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="CliFx" Version="0.0.8" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.0.0" />
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.5" />
+  </ItemGroup>
 
-    <ItemGroup>
-        <ProjectReference Include="..\DiscordChatExporter.Core\DiscordChatExporter.Core.csproj" />
-    </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DiscordChatExporter.Core.Models\DiscordChatExporter.Core.Models.csproj" />
+    <ProjectReference Include="..\DiscordChatExporter.Core.Services\DiscordChatExporter.Core.Services.csproj" />
+  </ItemGroup>
 
 </Project>

DiscordChatExporter.Cli/Program.cs

@@ -1,107 +1,44 @@
 using System;
-using System.Reflection;
-using DiscordChatExporter.Core.Models;
-using Fclp;
+using System.Threading.Tasks;
+using CliFx;
+using DiscordChatExporter.Cli.Commands;
+using DiscordChatExporter.Core.Services;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace DiscordChatExporter.Cli
 {
     public static class Program
     {
-        private static readonly Container Container = new Container();
-
-        private static void ShowHelp()
+        private static IServiceProvider ConfigureServices()
         {
-            var version = Assembly.GetExecutingAssembly().GetName().Version;
+            var services = new ServiceCollection();
 
-            Console.WriteLine($"=== Discord Chat Exporter (Command Line Interface) v{version} ===");
-            Console.WriteLine();
-            Console.WriteLine("[-t] [--token]       Discord authorization token.");
-            Console.WriteLine("[-c] [--channel]     Discord channel ID.");
-            Console.WriteLine("[-f] [--format]      Export format (PlainText/HtmlDark/HtmlLight). Optional.");
-            Console.WriteLine("[-o] [--output]      Output file path. Optional.");
-            Console.WriteLine("     [--datefrom]    Limit to messages after this date. Optional.");
-            Console.WriteLine("     [--dateto]      Limit to messages before this date. Optional.");
-            Console.WriteLine("     [--dateformat]  Date format. Optional.");
-            Console.WriteLine("     [--grouplimit]  Message group limit. Optional.");
-            Console.WriteLine();
-            Console.WriteLine("# To get authorization token:");
-            Console.WriteLine(" - Open Discord app");
-            Console.WriteLine(" - Log in if you haven't");
-            Console.WriteLine(" - Press Ctrl+Shift+I");
-            Console.WriteLine(" - Navigate to Application tab");
-            Console.WriteLine(" - Expand Storage > Local Storage > https://discordapp.com");
-            Console.WriteLine(" - Find \"token\" under key and copy the value");
-            Console.WriteLine();
-            Console.WriteLine("# To get channel ID:");
-            Console.WriteLine(" - Open Discord app");
-            Console.WriteLine(" - Log in if you haven't");
-            Console.WriteLine(" - Go to any channel you want to export");
-            Console.WriteLine(" - Press Ctrl+Shift+I");
-            Console.WriteLine(" - Navigate to Console tab");
-            Console.WriteLine(" - Type \"document.URL\" and press Enter");
-            Console.WriteLine(" - Copy the long sequence of numbers after last slash");
+            // Register services
+            services.AddSingleton<DataService>();
+            services.AddSingleton<ExportService>();
+            services.AddSingleton<SettingsService>();
+
+            // Register commands
+            services.AddTransient<ExportChannelCommand>();
+            services.AddTransient<ExportDirectMessagesCommand>();
+            services.AddTransient<ExportGuildCommand>();
+            services.AddTransient<GetChannelsCommand>();
+            services.AddTransient<GetDirectMessageChannelsCommand>();
+            services.AddTransient<GetGuildsCommand>();
+            services.AddTransient<GuideCommand>();
+
+            return services.BuildServiceProvider();
         }
 
-        private static CliOptions ParseOptions(string[] args)
+        public static Task<int> Main(string[] args)
         {
-            var argsParser = new FluentCommandLineParser<CliOptions>();
+            var serviceProvider = ConfigureServices();
 
-            var settings = Container.SettingsService;
-
-            argsParser.Setup(o => o.Token).As('t', "token").Required();
-            argsParser.Setup(o => o.ChannelId).As('c', "channel").Required();
-            argsParser.Setup(o => o.ExportFormat).As('f', "format").SetDefault(ExportFormat.HtmlDark);
-            argsParser.Setup(o => o.FilePath).As('o', "output").SetDefault(null);
-            argsParser.Setup(o => o.From).As("datefrom").SetDefault(null);
-            argsParser.Setup(o => o.To).As("dateto").SetDefault(null);
-            argsParser.Setup(o => o.DateFormat).As("dateformat").SetDefault(settings.DateFormat);
-            argsParser.Setup(o => o.MessageGroupLimit).As("grouplimit").SetDefault(settings.MessageGroupLimit);
-
-            var parsed = argsParser.Parse(args);
-
-            // Show help if no arguments
-            if (parsed.EmptyArgs)
-            {
-                ShowHelp();
-                Environment.Exit(0);
-            }
-            // Show error if there are any
-            else if (parsed.HasErrors)
-            {
-                Console.Error.Write(parsed.ErrorText);
-                Environment.Exit(-1);
-            }
-
-            return argsParser.Object;
-        }
-
-        public static void Main(string[] args)
-        {
-            // Init container
-            Container.Init();
-
-            // Parse options
-            var options = ParseOptions(args);
-
-            // Inject some settings
-            var settings = Container.SettingsService;
-            settings.DateFormat = options.DateFormat;
-            settings.MessageGroupLimit = options.MessageGroupLimit;
-
-            // Export
-            var vm = Container.MainViewModel;
-            vm.ExportAsync(
-                options.Token,
-                options.ChannelId,
-                options.FilePath,
-                options.ExportFormat,
-                options.From,
-                options.To).GetAwaiter().GetResult();
-
-            // Cleanup container
-            Container.Cleanup();
-
-            Console.WriteLine("Export complete.");
+            return new CliApplicationBuilder()
+                .AddCommandsFromThisAssembly()
+                .UseCommandFactory(schema => (ICommand) serviceProvider.GetService(schema.Type))
+                .Build()
+                .RunAsync(args);
         }
     }
 }

DiscordChatExporter.Cli/ViewModels/IMainViewModel.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-
-namespace DiscordChatExporter.Cli.ViewModels
-{
-    public interface IMainViewModel
-    {
-        Task ExportAsync(string token, string channelId, string filePath, ExportFormat format, DateTime? from,
-            DateTime? to);
-    }
-}

DiscordChatExporter.Cli/ViewModels/MainViewModel.cs

@@ -1,53 +0,0 @@
-using System;
-using System.IO;
-using System.Threading.Tasks;
-using DiscordChatExporter.Core.Models;
-using DiscordChatExporter.Core.Services;
-using Tyrrrz.Extensions;
-
-namespace DiscordChatExporter.Cli.ViewModels
-{
-    public class MainViewModel : IMainViewModel
-    {
-        private readonly IDataService _dataService;
-        private readonly IMessageGroupService _messageGroupService;
-        private readonly IExportService _exportService;
-
-        public MainViewModel(IDataService dataService, IMessageGroupService messageGroupService,
-            IExportService exportService)
-        {
-            _dataService = dataService;
-            _messageGroupService = messageGroupService;
-            _exportService = exportService;
-        }
-
-        public async Task ExportAsync(string token, string channelId, string filePath, ExportFormat format, DateTime? from,
-            DateTime? to)
-        {
-            // Get channel and guild
-            var channel = await _dataService.GetChannelAsync(token, channelId);
-            var guild = channel.GuildId == Guild.DirectMessages.Id
-                ? Guild.DirectMessages
-                : await _dataService.GetGuildAsync(token, channel.GuildId);
-
-            // Generate file path if not set
-            if (filePath.IsBlank())
-            {
-                filePath = $"{guild.Name} - {channel.Name}.{format.GetFileExtension()}"
-                    .Replace(Path.GetInvalidFileNameChars(), '_');
-            }
-
-            // Get messages
-            var messages = await _dataService.GetChannelMessagesAsync(token, channelId, from, to);
-
-            // Group them
-            var messageGroups = _messageGroupService.GroupMessages(messages);
-
-            // Create log
-            var log = new ChannelChatLog(guild, channel, messageGroups, messages.Count);
-
-            // Export
-            await _exportService.ExportAsync(format, filePath, log);
-        }
-    }
-}

DiscordChatExporter.Core.Markdown/DiscordChatExporter.Core.Markdown.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../DiscordChatExporter.props" />
+
+  <ItemGroup>
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.5" />
+  </ItemGroup>
+
+</Project>

DiscordChatExporter.Core.Markdown/Internal/AggregateMatcher.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    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>? Match(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.Match(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;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/Extensions.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    internal static class Extensions
+    {
+        public static IEnumerable<ParsedMatch<T>> MatchAll<T>(this IMatcher<T> matcher, StringPart stringPart,
+            Func<StringPart, T> fallbackTransform)
+        {
+            // Loop through segments divided by individual matches
+            var currentIndex = stringPart.StartIndex;
+            while (currentIndex < stringPart.EndIndex)
+            {
+                // Find a match within this segment
+                var match = matcher.Match(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, fallbackTransform(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, fallbackTransform(fallbackPart));
+            }
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/IMatcher.cs

@@ -0,0 +1,7 @@
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    internal interface IMatcher<T>
+    {
+        ParsedMatch<T>? Match(StringPart stringPart);
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/ParsedMatch.cs

@@ -0,0 +1,15 @@
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    internal class ParsedMatch<T>
+    {
+        public StringPart StringPart { get; }
+
+        public T Value { get; }
+
+        public ParsedMatch(StringPart stringPart, T value)
+        {
+            StringPart = stringPart;
+            Value = value;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/RegexMatcher.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    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>? Match(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));
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/StringMatcher.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    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>? Match(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;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/StringPart.cs

@@ -0,0 +1,36 @@
+using System.Text.RegularExpressions;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    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 StringPart(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);
+    }
+}

DiscordChatExporter.Core.Markdown/MarkdownParser.cs

@@ -0,0 +1,236 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using DiscordChatExporter.Core.Markdown.Internal;
+using DiscordChatExporter.Core.Markdown.Nodes;
+
+namespace DiscordChatExporter.Core.Markdown
+{
+    // The following parsing logic is meant to replicate Discord's markdown grammar as close as possible
+    public static 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<Node> BoldFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> ItalicFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> ItalicBoldFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> ItalicAltFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> UnderlineFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> ItalicUnderlineFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> StrikethroughFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> SpoilerFormattedNodeMatcher = new RegexMatcher<Node>(
+            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<Node> SingleLineQuoteNodeMatcher = new RegexMatcher<Node>(
+            new Regex("^>\\s(.+)\r?\n?", DefaultRegexOptions),
+            (p, m) => new FormattedNode(TextFormatting.Quote, Parse(p.Slice(m.Groups[1]))));
+
+        // Capture any character until the end of the input
+        // Opening 'greater than' characters must be followed by whitespace
+        private static readonly IMatcher<Node> MultiLineQuoteNodeMatcher = new RegexMatcher<Node>(
+            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
+        private static readonly IMatcher<Node> InlineCodeBlockNodeMatcher = new RegexMatcher<Node>(
+            new Regex("`([^`]+)`", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new InlineCodeBlockNode(m.Groups[1].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<Node> MultiLineCodeBlockNodeMatcher = new RegexMatcher<Node>(
+            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<Node> EveryoneMentionNodeMatcher = new StringMatcher<Node>(
+            "@everyone",
+            p => new MentionNode("everyone", MentionType.Meta));
+
+        // Capture @here
+        private static readonly IMatcher<Node> HereMentionNodeMatcher = new StringMatcher<Node>(
+            "@here",
+            p => new MentionNode("here", MentionType.Meta));
+
+        // Capture <@123456> or <@!123456>
+        private static readonly IMatcher<Node> UserMentionNodeMatcher = new RegexMatcher<Node>(
+            new Regex("<@!?(\\d+)>", DefaultRegexOptions),
+            m => new MentionNode(m.Groups[1].Value, MentionType.User));
+
+        // Capture <#123456>
+        private static readonly IMatcher<Node> ChannelMentionNodeMatcher = new RegexMatcher<Node>(
+            new Regex("<#(\\d+)>", DefaultRegexOptions),
+            m => new MentionNode(m.Groups[1].Value, MentionType.Channel));
+
+        // Capture <@&123456>
+        private static readonly IMatcher<Node> RoleMentionNodeMatcher = new RegexMatcher<Node>(
+            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<Node> StandardEmojiNodeMatcher = new RegexMatcher<Node>(
+            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<Node> CustomEmojiNodeMatcher = new RegexMatcher<Node>(
+            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<Node> TitledLinkNodeMatcher = new RegexMatcher<Node>(
+            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<Node> AutoLinkNodeMatcher = new RegexMatcher<Node>(
+            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<Node> HiddenLinkNodeMatcher = new RegexMatcher<Node>(
+            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<Node> ShrugTextNodeMatcher = new StringMatcher<Node>(
+            @"¯\_(ツ)_/¯",
+            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<Node> IgnoredEmojiTextNodeMatcher = new RegexMatcher<Node>(
+            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<Node> EscapedSymbolTextNodeMatcher = new RegexMatcher<Node>(
+            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<Node> EscapedCharacterTextNodeMatcher = new RegexMatcher<Node>(
+            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<Node> AggregateNodeMatcher = new AggregateMatcher<Node>(
+            // Escaped text
+            ShrugTextNodeMatcher,
+            IgnoredEmojiTextNodeMatcher,
+            EscapedSymbolTextNodeMatcher,
+            EscapedCharacterTextNodeMatcher,
+
+            // Formatting
+            ItalicBoldFormattedNodeMatcher,
+            ItalicUnderlineFormattedNodeMatcher,
+            BoldFormattedNodeMatcher,
+            ItalicFormattedNodeMatcher,
+            UnderlineFormattedNodeMatcher,
+            ItalicAltFormattedNodeMatcher,
+            StrikethroughFormattedNodeMatcher,
+            SpoilerFormattedNodeMatcher,
+            MultiLineQuoteNodeMatcher,
+            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<Node> MinimalAggregateNodeMatcher = new AggregateMatcher<Node>(
+            // Mentions
+            EveryoneMentionNodeMatcher,
+            HereMentionNodeMatcher,
+            UserMentionNodeMatcher,
+            ChannelMentionNodeMatcher,
+            RoleMentionNodeMatcher,
+
+            // Emoji
+            CustomEmojiNodeMatcher);
+
+        private static IReadOnlyList<Node> Parse(StringPart stringPart, IMatcher<Node> matcher) =>
+            matcher.MatchAll(stringPart, p => new TextNode(p.ToString())).Select(r => r.Value).ToArray();
+
+        private static IReadOnlyList<Node> Parse(StringPart stringPart) => Parse(stringPart, AggregateNodeMatcher);
+
+        private static IReadOnlyList<Node> ParseMinimal(StringPart stringPart) => Parse(stringPart, MinimalAggregateNodeMatcher);
+
+        public static IReadOnlyList<Node> Parse(string input) => Parse(new StringPart(input));
+
+        public static IReadOnlyList<Node> ParseMinimal(string input) => ParseMinimal(new StringPart(input));
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/EmojiNode.cs

@@ -0,0 +1,27 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class EmojiNode : Node
+    {
+        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}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/FormattedNode.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class FormattedNode : Node
+    {
+        public TextFormatting Formatting { get; }
+
+        public IReadOnlyList<Node> Children { get; }
+
+        public FormattedNode(TextFormatting formatting, IReadOnlyList<Node> children)
+        {
+            Formatting = formatting;
+            Children = children;
+        }
+
+        public override string ToString() => $"<{Formatting}> ({Children.Count} direct children)";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/InlineCodeBlockNode.cs

@@ -0,0 +1,14 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class InlineCodeBlockNode : Node
+    {
+        public string Code { get; }
+
+        public InlineCodeBlockNode(string code)
+        {
+            Code = code;
+        }
+
+        public override string ToString() => $"<Code> {Code}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/LinkNode.cs

@@ -0,0 +1,22 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class LinkNode : Node
+    {
+        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}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/MentionNode.cs

@@ -0,0 +1,17 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class MentionNode : Node
+    {
+        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}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/MentionType.cs

@@ -0,0 +1,10 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public enum MentionType
+    {
+        Meta,
+        User,
+        Channel,
+        Role
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/MultiLineCodeBlockNode.cs

@@ -0,0 +1,17 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class MultiLineCodeBlockNode : Node
+    {
+        public string Language { get; }
+
+        public string Code { get; }
+
+        public MultiLineCodeBlockNode(string language, string code)
+        {
+            Language = language;
+            Code = code;
+        }
+
+        public override string ToString() => $"<Code [{Language}]> {Code}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/Node.cs

@@ -0,0 +1,6 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public abstract class Node
+    {
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/TextFormatting.cs

@@ -0,0 +1,12 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public enum TextFormatting
+    {
+        Bold,
+        Italic,
+        Underline,
+        Strikethrough,
+        Spoiler,
+        Quote
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/TextNode.cs

@@ -0,0 +1,14 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class TextNode : Node
+    {
+        public string Text { get; }
+
+        public TextNode(string text)
+        {
+            Text = text;
+        }
+
+        public override string ToString() => Text;
+    }
+}

DiscordChatExporter.Core.Models/Attachment.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#attachment-object
+
+    public partial class Attachment : IHasId
+    {
+        public string Id { get; }
+
+        public string Url { get; }
+
+        public int? Width { get; }
+
+        public int? Height { get; }
+
+        public string FileName { get; }
+
+        public bool IsImage { get; }
+
+        public FileSize FileSize { get; }
+
+        public Attachment(string id, int? width, int? height, string url, string fileName, FileSize fileSize)
+        {
+            Id = id;
+            Url = url;
+            Width = width;
+            Height = height;
+            FileName = fileName;
+            FileSize = fileSize;
+
+            IsImage = GetIsImage(fileName);
+        }
+
+        public override string ToString() => FileName;
+    }
+
+    public partial class Attachment
+    {
+        private static readonly string[] ImageFileExtensions = { ".jpg", ".jpeg", ".png", ".gif", ".bmp" };
+
+        public static bool GetIsImage(string fileName)
+        {
+            var fileExtension = Path.GetExtension(fileName);
+            return ImageFileExtensions.Contains(fileExtension, StringComparer.OrdinalIgnoreCase);
+        }
+    }
+}

DiscordChatExporter.Core.Models/AuthToken.cs

@@ -0,0 +1,15 @@
+namespace DiscordChatExporter.Core.Models
+{
+    public class AuthToken
+    {
+        public AuthTokenType Type { get; }
+
+        public string Value { get; }
+
+        public AuthToken(AuthTokenType type, string value)
+        {
+            Type = type;
+            Value = value;
+        }
+    }
+}

DiscordChatExporter.Core.Models/AuthTokenType.cs

@@ -1,8 +1,8 @@
 namespace DiscordChatExporter.Core.Models
 {
-    public enum AttachmentType
+    public enum AuthTokenType
     {
-        Other,
-        Image
+        User,
+        Bot
     }
 }

DiscordChatExporter.Core.Models/Channel.cs

@@ -0,0 +1,37 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#channel-object
+
+    public partial class Channel : IHasId
+    {
+        public string Id { get; }
+
+        public string? ParentId { get; }
+
+        public string GuildId { get; }
+
+        public string Name { get; }
+
+        public string? Topic { get; }
+
+        public ChannelType Type { get; }
+
+        public Channel(string id, string? parentId, string guildId, string name, string? topic, ChannelType type)
+        {
+            Id = id;
+            ParentId = parentId;
+            GuildId = guildId;
+            Name = name;
+            Topic = topic;
+            Type = type;
+        }
+
+        public override string ToString() => Name;
+    }
+
+    public partial class Channel
+    {
+        public static Channel CreateDeletedChannel(string id) =>
+            new Channel(id, null, "unknown-guild", "deleted-channel", null, ChannelType.GuildTextChat);
+    }
+}

DiscordChatExporter.Core.Models/ChannelType.cs

@@ -0,0 +1,16 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.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
+    }
+}

DiscordChatExporter.Core.Models/DiscordChatExporter.Core.Models.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../DiscordChatExporter.props" />
+
+  <ItemGroup>
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.5" />
+  </ItemGroup>
+
+</Project>

DiscordChatExporter.Core.Models/Embed.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object
+
+    public 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>";
+    }
+}

DiscordChatExporter.Core.Models/EmbedAuthor.cs

@@ -0,0 +1,22 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-author-structure
+
+    public 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>";
+    }
+}

DiscordChatExporter.Core.Models/EmbedField.cs

@@ -0,0 +1,22 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-field-structure
+
+    public 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}";
+    }
+}

DiscordChatExporter.Core.Models/EmbedFooter.cs

@@ -0,0 +1,19 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-footer-structure
+
+    public 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;
+    }
+}

DiscordChatExporter.Core.Models/EmbedImage.cs

@@ -0,0 +1,20 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#embed-object-embed-image-structure
+
+    public 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;
+        }
+    }
+}

DiscordChatExporter.Core.Models/Emoji.cs

@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using System.Linq;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.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 partial class Emoji
+    {
+        private static IEnumerable<int> GetCodePoints(string emoji)
+        {
+            for (var i = 0; i < emoji.Length; i += char.IsHighSurrogate(emoji[i]) ? 2 : 1)
+                yield return char.ConvertToUtf32(emoji, i);
+        }
+
+        private static string GetTwemojiName(string emoji) =>
+            GetCodePoints(emoji).Select(i => i.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 unicode emoji (via twemoji)
+            var twemojiName = GetTwemojiName(name);
+            return $"https://twemoji.maxcdn.com/2/72x72/{twemojiName}.png";
+        }
+    }
+}

DiscordChatExporter.Core.Models/ExportFormat.cs

@@ -4,6 +4,7 @@
     {
         PlainText,
         HtmlDark,
-        HtmlLight
+        HtmlLight,
+        Csv
     }
 }

DiscordChatExporter.Core.Models/Extensions.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace DiscordChatExporter.Core.Models
+{
+    public static class Extensions
+    {
+        public static bool IsExportable(this ChannelType channelType) =>
+            channelType == ChannelType.GuildTextChat ||
+            channelType == ChannelType.DirectTextChat ||
+            channelType == ChannelType.DirectGroupTextChat ||
+            channelType == ChannelType.GuildNews ||
+            channelType == ChannelType.GuildStore;
+
+        public static string GetFileExtension(this ExportFormat format) =>
+            format switch
+            {
+                ExportFormat.PlainText => "txt",
+                ExportFormat.HtmlDark => "html",
+                ExportFormat.HtmlLight => "html",
+                ExportFormat.Csv => "csv",
+                _ => throw new ArgumentOutOfRangeException(nameof(format))
+            };
+
+        public static string GetDisplayName(this ExportFormat format) =>
+            format switch
+            {
+                ExportFormat.PlainText => "Plain Text",
+                ExportFormat.HtmlDark => "HTML (Dark)",
+                ExportFormat.HtmlLight => "HTML (Light)",
+                ExportFormat.Csv => "Comma Separated Values (CSV)",
+                _ => throw new ArgumentOutOfRangeException(nameof(format))
+            };
+    }
+}

DiscordChatExporter.Core.Models/FileSize.cs

@@ -0,0 +1,82 @@
+using System;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // Loosely based on https://github.com/omar/ByteSize (MIT license)
+
+    public struct FileSize
+    {
+        public const long BytesInKiloByte = 1024;
+        public const long BytesInMegaByte = 1024 * BytesInKiloByte;
+        public const long BytesInGigaByte = 1024 * BytesInMegaByte;
+        public const long BytesInTeraByte = 1024 * BytesInGigaByte;
+        public const long BytesInPetaByte = 1024 * BytesInTeraByte;
+
+        public const string ByteSymbol = "B";
+        public const string KiloByteSymbol = "KB";
+        public const string MegaByteSymbol = "MB";
+        public const string GigaByteSymbol = "GB";
+        public const string TeraByteSymbol = "TB";
+        public const string PetaByteSymbol = "PB";
+
+        public double Bytes { get; }
+        public double KiloBytes => Bytes / BytesInKiloByte;
+        public double MegaBytes => Bytes / BytesInMegaByte;
+        public double GigaBytes => Bytes / BytesInGigaByte;
+        public double TeraBytes => Bytes / BytesInTeraByte;
+        public double PetaBytes => Bytes / BytesInPetaByte;
+
+        public string LargestWholeNumberSymbol
+        {
+            get
+            {
+                if (Math.Abs(PetaBytes) >= 1)
+                    return PetaByteSymbol;
+
+                if (Math.Abs(TeraBytes) >= 1)
+                    return TeraByteSymbol;
+
+                if (Math.Abs(GigaBytes) >= 1)
+                    return GigaByteSymbol;
+
+                if (Math.Abs(MegaBytes) >= 1)
+                    return MegaByteSymbol;
+
+                if (Math.Abs(KiloBytes) >= 1)
+                    return KiloByteSymbol;
+
+                return ByteSymbol;
+            }
+        }
+
+        public double LargestWholeNumberValue
+        {
+            get
+            {
+                if (Math.Abs(PetaBytes) >= 1)
+                    return PetaBytes;
+
+                if (Math.Abs(TeraBytes) >= 1)
+                    return TeraBytes;
+
+                if (Math.Abs(GigaBytes) >= 1)
+                    return GigaBytes;
+
+                if (Math.Abs(MegaBytes) >= 1)
+                    return MegaBytes;
+
+                if (Math.Abs(KiloBytes) >= 1)
+                    return KiloBytes;
+
+                return Bytes;
+            }
+        }
+
+        public FileSize(double bytes)
+        {
+            Bytes = bytes;
+        }
+
+        public override string ToString() => $"{LargestWholeNumberValue:0.##} {LargestWholeNumberSymbol}";
+    }
+}

DiscordChatExporter.Core.Models/Guild.cs

@@ -0,0 +1,38 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.string.IsNullOrWhiteSpace(com/developers/docs/resources/guild#guild-object
+
+    public partial class Guild : IHasId
+    {
+        public string Id { get; }
+
+        public string Name { get; }
+
+        public string? IconHash { get; }
+
+        public string IconUrl { get; }
+
+        public Guild(string id, string name, string? iconHash)
+        {
+            Id = id;
+            Name = name;
+            IconHash = iconHash;
+
+            IconUrl = GetIconUrl(id, iconHash);
+        }
+
+        public override string ToString() => Name;
+    }
+
+    public partial class Guild
+    {
+        public static string GetIconUrl(string id, string? iconHash)
+        {
+            return !string.IsNullOrWhiteSpace(iconHash)
+                ? $"https://cdn.discordapp.com/icons/{id}/{iconHash}.png"
+                : "https://cdn.discordapp.com/embed/avatars/0.png";
+        }
+
+        public static Guild DirectMessages { get; } = new Guild("@me", "Direct Messages", null);
+    }
+}

DiscordChatExporter.Core.Models/IHasId.cs

@@ -0,0 +1,7 @@
+namespace DiscordChatExporter.Core.Models
+{
+    public interface IHasId
+    {
+        string Id { get; }
+    }
+}

DiscordChatExporter.Core.Models/IdBasedEqualityComparer.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Models
+{
+    public partial class IdBasedEqualityComparer : IEqualityComparer<IHasId>
+    {
+        public bool Equals(IHasId? x, IHasId? y) => StringComparer.Ordinal.Equals(x?.Id, y?.Id);
+
+        public int GetHashCode(IHasId obj) => StringComparer.Ordinal.GetHashCode(obj.Id);
+    }
+
+    public partial class IdBasedEqualityComparer
+    {
+        public static IdBasedEqualityComparer Instance { get; } = new IdBasedEqualityComparer();
+    }
+}

DiscordChatExporter.Core.Models/Message.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#message-object
+
+    public class Message : IHasId
+    {
+        public string Id { get; }
+
+        public string ChannelId { get; }
+
+        public MessageType Type { get; }
+
+        public User Author { get; }
+
+        public DateTimeOffset Timestamp { get; }
+
+        public DateTimeOffset? EditedTimestamp { 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 Message(string id, string channelId, MessageType type, User author,
+            DateTimeOffset timestamp, DateTimeOffset? editedTimestamp, bool isPinned,
+            string content,
+            IReadOnlyList<Attachment> attachments,IReadOnlyList<Embed> embeds, IReadOnlyList<Reaction> reactions,
+            IReadOnlyList<User> mentionedUsers)
+        {
+            Id = id;
+            ChannelId = channelId;
+            Type = type;
+            Author = author;
+            Timestamp = timestamp;
+            EditedTimestamp = editedTimestamp;
+            IsPinned = isPinned;
+            Content = content;
+            Attachments = attachments;
+            Embeds = embeds;
+            Reactions = reactions;
+            MentionedUsers = mentionedUsers;
+        }
+
+        public override string ToString() => Content ?? "<message without content>";
+    }
+}

DiscordChatExporter.Core.Models/MessageGroup.cs

@@ -3,18 +3,20 @@ using System.Collections.Generic;
 
 namespace DiscordChatExporter.Core.Models
 {
+    // Used for grouping contiguous messages in HTML export
+
     public class MessageGroup
     {
         public User Author { get; }
 
-        public DateTime TimeStamp { get; }
+        public DateTimeOffset Timestamp { get; }
 
         public IReadOnlyList<Message> Messages { get; }
 
-        public MessageGroup(User author, DateTime timeStamp, IReadOnlyList<Message> messages)
+        public MessageGroup(User author, DateTimeOffset timestamp, IReadOnlyList<Message> messages)
         {
             Author = author;
-            TimeStamp = timeStamp;
+            Timestamp = timestamp;
             Messages = messages;
         }
     }

DiscordChatExporter.Core.Models/MessageType.cs

@@ -1,5 +1,7 @@
 namespace DiscordChatExporter.Core.Models
 {
+    // https://discordapp.com/developers/docs/resources/channel#message-object-message-types
+
     public enum MessageType
     {
         Default,

DiscordChatExporter.Core.Models/Reaction.cs

@@ -0,0 +1,17 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#reaction-object
+
+    public class Reaction
+    {
+        public int Count { get; }
+
+        public Emoji Emoji { get; }
+
+        public Reaction(int count, Emoji emoji)
+        {
+            Count = count;
+            Emoji = emoji;
+        }
+    }
+}

DiscordChatExporter.Core.Models/Role.cs

@@ -1,6 +1,8 @@
 namespace DiscordChatExporter.Core.Models
 {
-    public partial class Role
+    // https://discordapp.com/developers/docs/topics/permissions#role-object
+
+    public partial class Role : IHasId
     {
         public string Id { get; }
 
@@ -12,17 +14,11 @@
             Name = name;
         }
 
-        public override string ToString()
-        {
-            return Name;
-        }
+        public override string ToString() => Name;
     }
 
     public partial class Role
     {
-        public static Role CreateDeletedRole(string id)
-        {
-            return new Role(id, "deleted-role");
-        }
+        public static Role CreateDeletedRole(string id) => new Role(id, "deleted-role");
     }
 }

DiscordChatExporter.Core.Models/User.cs

@@ -0,0 +1,61 @@
+using System;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/topics/permissions#role-object
+
+    public partial class User : IHasId
+    {
+        public string Id { get; }
+
+        public int Discriminator { get; }
+
+        public string Name { get; }
+
+        public string FullName { get; }
+
+        public string? AvatarHash { get; }
+
+        public string AvatarUrl { get; }
+
+        public bool IsBot { get; }
+
+        public User(string id, int discriminator, string name, string? avatarHash, bool isBot)
+        {
+            Id = id;
+            Discriminator = discriminator;
+            Name = name;
+            AvatarHash = avatarHash;
+            IsBot = isBot;
+
+            FullName = GetFullName(name, discriminator);
+            AvatarUrl = GetAvatarUrl(id, discriminator, avatarHash);
+        }
+
+        public override string ToString() => FullName;
+    }
+
+    public partial class User
+    {
+        public static string GetFullName(string name, int discriminator) => $"{name}#{discriminator:0000}";
+
+        public static string GetAvatarUrl(string id, int discriminator, string? avatarHash)
+        {
+            // Custom avatar
+            if (!string.IsNullOrWhiteSpace(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";
+            }
+
+            // Default avatar
+            return $"https://cdn.discordapp.com/embed/avatars/{discriminator % 5}.png";
+        }
+
+        public static User CreateUnknownUser(string id) => new User(id, 0, "Unknown", null, false);
+    }
+}

DiscordChatExporter.Core.Rendering/CsvMessageRenderer.cs

@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Rendering.Logic;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public class CsvMessageRenderer : MessageRendererBase
+    {
+        private bool _isHeaderRendered;
+
+        public CsvMessageRenderer(string filePath, RenderContext context)
+            : base(filePath, context)
+        {
+        }
+
+        public override async Task RenderMessageAsync(Message message)
+        {
+            // Render header if it's the first entry
+            if (!_isHeaderRendered)
+            {
+                await Writer.WriteLineAsync(CsvRenderingLogic.FormatHeader(Context));
+                _isHeaderRendered = true;
+            }
+
+            await Writer.WriteLineAsync(CsvRenderingLogic.FormatMessage(Context, message));
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/DiscordChatExporter.Core.Rendering.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../DiscordChatExporter.props" />
+
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\HtmlCore.css" />
+    <EmbeddedResource Include="Resources\HtmlDark.css" />
+    <EmbeddedResource Include="Resources\HtmlLight.css" />
+    <EmbeddedResource Include="Resources\HtmlLayoutTemplate.html" />
+    <EmbeddedResource Include="Resources\HtmlMessageGroupTemplate.html" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Scriban" Version="2.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DiscordChatExporter.Core.Markdown\DiscordChatExporter.Core.Markdown.csproj" />
+    <ProjectReference Include="..\DiscordChatExporter.Core.Models\DiscordChatExporter.Core.Models.csproj" />
+  </ItemGroup>
+
+</Project>

DiscordChatExporter.Core.Rendering/HtmlMessageRenderer.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Rendering.Logic;
+using Scriban;
+using Scriban.Runtime;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public partial class HtmlMessageRenderer : MessageRendererBase
+    {
+        private readonly string _themeName;
+        private readonly List<Message> _messageGroupBuffer = new List<Message>();
+
+        private readonly Template _leadingBlockTemplate;
+        private readonly Template _messageGroupTemplate;
+        private readonly Template _trailingBlockTemplate;
+
+        private bool _isLeadingBlockRendered;
+
+        public HtmlMessageRenderer(string filePath, RenderContext context, string themeName)
+            : base(filePath, context)
+        {
+            _themeName = themeName;
+
+            _leadingBlockTemplate = Template.Parse(GetLeadingBlockTemplateCode());
+            _messageGroupTemplate = Template.Parse(GetMessageGroupTemplateCode());
+            _trailingBlockTemplate = Template.Parse(GetTrailingBlockTemplateCode());
+        }
+
+        private MessageGroup GetCurrentMessageGroup()
+        {
+            var firstMessage = _messageGroupBuffer.First();
+            return new MessageGroup(firstMessage.Author, firstMessage.Timestamp, _messageGroupBuffer);
+        }
+
+        private TemplateContext CreateTemplateContext(IReadOnlyDictionary<string, object>? constants = null)
+        {
+            // Template context
+            var templateContext = new TemplateContext
+            {
+                MemberRenamer = m => m.Name,
+                MemberFilter = m => true,
+                LoopLimit = int.MaxValue,
+                StrictVariables = true
+            };
+
+            // Model
+            var scriptObject = new ScriptObject();
+
+            // Constants
+            scriptObject.SetValue("Context", Context, true);
+            scriptObject.SetValue("CoreStyleSheet", GetCoreStyleSheetCode(), true);
+            scriptObject.SetValue("ThemeStyleSheet", GetThemeStyleSheetCode(_themeName), true);
+            scriptObject.SetValue("HighlightJsStyleName", $"solarized-{_themeName.ToLowerInvariant()}", true);
+
+            // Additional constants
+            if (constants != null)
+            {
+                foreach (var (member, value) in constants)
+                    scriptObject.SetValue(member, value, true);
+            }
+
+            // Functions
+            scriptObject.Import("FormatDate",
+                new Func<DateTimeOffset, string>(d => SharedRenderingLogic.FormatDate(d, Context.DateFormat)));
+
+            scriptObject.Import("FormatMarkdown",
+                new Func<string, string>(m => HtmlRenderingLogic.FormatMarkdown(Context, m)));
+
+            // Push model
+            templateContext.PushGlobal(scriptObject);
+
+            // Push output
+            templateContext.PushOutput(new TextWriterOutput(Writer));
+
+            return templateContext;
+        }
+
+        private async Task RenderLeadingBlockAsync()
+        {
+            var templateContext = CreateTemplateContext();
+            await templateContext.EvaluateAsync(_leadingBlockTemplate.Page);
+        }
+
+        private async Task RenderCurrentMessageGroupAsync()
+        {
+            var templateContext = CreateTemplateContext(new Dictionary<string, object>
+            {
+                ["MessageGroup"] = GetCurrentMessageGroup()
+            });
+
+            await templateContext.EvaluateAsync(_messageGroupTemplate.Page);
+        }
+
+        private async Task RenderTrailingBlockAsync()
+        {
+            var templateContext = CreateTemplateContext();
+            await templateContext.EvaluateAsync(_trailingBlockTemplate.Page);
+        }
+
+        public override async Task RenderMessageAsync(Message message)
+        {
+            // Render leading block if it's the first entry
+            if (!_isLeadingBlockRendered)
+            {
+                await RenderLeadingBlockAsync();
+                _isLeadingBlockRendered = true;
+            }
+
+            // If message group is empty or the given message can be grouped, buffer the given message
+            if (!_messageGroupBuffer.Any() || HtmlRenderingLogic.CanBeGrouped(_messageGroupBuffer.Last(), message))
+            {
+                _messageGroupBuffer.Add(message);
+            }
+            // Otherwise, flush the group and render messages
+            else
+            {
+                await RenderCurrentMessageGroupAsync();
+
+                _messageGroupBuffer.Clear();
+                _messageGroupBuffer.Add(message);
+            }
+        }
+
+        public override async ValueTask DisposeAsync()
+        {
+            // Leading block (can happen if no message were rendered)
+            if (!_isLeadingBlockRendered)
+                await RenderLeadingBlockAsync();
+
+            // Flush current message group
+            if (_messageGroupBuffer.Any())
+                await RenderCurrentMessageGroupAsync();
+
+            // Trailing block
+            await RenderTrailingBlockAsync();
+
+            // Dispose stream
+            await base.DisposeAsync();
+        }
+    }
+
+    public partial class HtmlMessageRenderer
+    {
+        private static readonly Assembly ResourcesAssembly = typeof(HtmlRenderingLogic).Assembly;
+        private static readonly string ResourcesNamespace = $"{ResourcesAssembly.GetName().Name}.Resources";
+
+        private static string GetCoreStyleSheetCode() =>
+            ResourcesAssembly
+                .GetManifestResourceString($"{ResourcesNamespace}.HtmlCore.css");
+
+        private static string GetThemeStyleSheetCode(string themeName) =>
+            ResourcesAssembly
+                .GetManifestResourceString($"{ResourcesNamespace}.Html{themeName}.css");
+
+        private static string GetLeadingBlockTemplateCode() =>
+            ResourcesAssembly
+                .GetManifestResourceString($"{ResourcesNamespace}.HtmlLayoutTemplate.html")
+                .SubstringUntil("{{~ %SPLIT% ~}}");
+
+        private static string GetTrailingBlockTemplateCode() =>
+            ResourcesAssembly
+                .GetManifestResourceString($"{ResourcesNamespace}.HtmlLayoutTemplate.html")
+                .SubstringAfter("{{~ %SPLIT% ~}}");
+
+        private static string GetMessageGroupTemplateCode() =>
+            ResourcesAssembly
+                .GetManifestResourceString($"{ResourcesNamespace}.HtmlMessageGroupTemplate.html");
+    }
+}

DiscordChatExporter.Core.Rendering/IMessageRenderer.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public interface IMessageRenderer : IAsyncDisposable
+    {
+        Task RenderMessageAsync(Message message);
+    }
+}

DiscordChatExporter.Core.Rendering/Internal/Extensions.cs

@@ -0,0 +1,21 @@
+using System.Text;
+
+namespace DiscordChatExporter.Core.Rendering.Internal
+{
+    internal static class Extensions
+    {
+        public static StringBuilder AppendLineIfNotEmpty(this StringBuilder builder, string value) =>
+            !string.IsNullOrWhiteSpace(value) ? builder.AppendLine(value) : builder;
+
+        public static StringBuilder Trim(this StringBuilder builder)
+        {
+            while (builder.Length > 0 && char.IsWhiteSpace(builder[0]))
+                builder.Remove(0, 1);
+
+            while (builder.Length > 0 && char.IsWhiteSpace(builder[^1]))
+                builder.Remove(builder.Length - 1, 1);
+
+            return builder;
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/Logic/CsvRenderingLogic.cs

@@ -0,0 +1,39 @@
+using System.Linq;
+using System.Text;
+using DiscordChatExporter.Core.Models;
+using Tyrrrz.Extensions;
+
+using static DiscordChatExporter.Core.Rendering.Logic.SharedRenderingLogic;
+
+namespace DiscordChatExporter.Core.Rendering.Logic
+{
+    public static class CsvRenderingLogic
+    {
+        // Header is always the same
+        public static string FormatHeader(RenderContext context) => "AuthorID,Author,Date,Content,Attachments,Reactions";
+
+        private static string EncodeValue(string value)
+        {
+            value = value.Replace("\"", "\"\"");
+            return $"\"{value}\"";
+        }
+
+        public static string FormatMarkdown(RenderContext context, string markdown) =>
+            PlainTextRenderingLogic.FormatMarkdown(context, markdown);
+
+        public static string FormatMessage(RenderContext context, Message message)
+        {
+            var buffer = new StringBuilder();
+
+            buffer
+                .Append(EncodeValue(message.Author.Id)).Append(',')
+                .Append(EncodeValue(message.Author.FullName)).Append(',')
+                .Append(EncodeValue(FormatDate(message.Timestamp, context.DateFormat))).Append(',')
+                .Append(EncodeValue(FormatMarkdown(context, message.Content ?? ""))).Append(',')
+                .Append(EncodeValue(message.Attachments.Select(a => a.Url).JoinToString(","))).Append(',')
+                .Append(EncodeValue(message.Reactions.Select(r => $"{r.Emoji.Name} ({r.Count})").JoinToString(",")));
+
+            return buffer.ToString();
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/Logic/HtmlRenderingLogic.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text.RegularExpressions;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Markdown.Nodes;
+using DiscordChatExporter.Core.Models;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Rendering.Logic
+{
+    internal static class HtmlRenderingLogic
+    {
+        public static bool CanBeGrouped(Message message1, Message message2)
+        {
+            if (message1.Author.Id != message2.Author.Id)
+                return false;
+
+            if ((message2.Timestamp - message1.Timestamp).Duration().TotalMinutes > 7)
+                return false;
+
+            return true;
+        }
+
+        private static string HtmlEncode(string s) => WebUtility.HtmlEncode(s);
+
+        private static string FormatMarkdownNode(RenderContext context, Node node, bool isJumbo)
+        {
+            // Text node
+            if (node is TextNode textNode)
+            {
+                // Return HTML-encoded text
+                return HtmlEncode(textNode.Text);
+            }
+
+            // Formatted node
+            if (node is FormattedNode formattedNode)
+            {
+                // Recursively get inner html
+                var innerHtml = FormatMarkdownNodes(context, formattedNode.Children, false);
+
+                // Bold
+                if (formattedNode.Formatting == TextFormatting.Bold)
+                    return $"<strong>{innerHtml}</strong>";
+
+                // Italic
+                if (formattedNode.Formatting == TextFormatting.Italic)
+                    return $"<em>{innerHtml}</em>";
+
+                // Underline
+                if (formattedNode.Formatting == TextFormatting.Underline)
+                    return $"<u>{innerHtml}</u>";
+
+                // Strikethrough
+                if (formattedNode.Formatting == TextFormatting.Strikethrough)
+                    return $"<s>{innerHtml}</s>";
+
+                // Spoiler
+                if (formattedNode.Formatting == TextFormatting.Spoiler)
+                    return $"<span class=\"spoiler\">{innerHtml}</span>";
+
+                // Quote
+                if (formattedNode.Formatting == TextFormatting.Quote)
+                    return $"<div class=\"quote\">{innerHtml}</div>";
+            }
+
+            // Inline code block node
+            if (node is InlineCodeBlockNode inlineCodeBlockNode)
+            {
+                return $"<span class=\"pre pre--inline\">{HtmlEncode(inlineCodeBlockNode.Code)}</span>";
+            }
+
+            // Multi-line code block node
+            if (node is MultiLineCodeBlockNode multilineCodeBlockNode)
+            {
+                // Set CSS class for syntax highlighting
+                var highlightCssClass = !string.IsNullOrWhiteSpace(multilineCodeBlockNode.Language)
+                    ? $"language-{multilineCodeBlockNode.Language}"
+                    : "nohighlight";
+
+                return $"<div class=\"pre pre--multiline {highlightCssClass}\">{HtmlEncode(multilineCodeBlockNode.Code)}</div>";
+            }
+
+            // Mention node
+            if (node is MentionNode mentionNode)
+            {
+                // Meta mention node
+                if (mentionNode.Type == MentionType.Meta)
+                {
+                    return $"<span class=\"mention\">@{HtmlEncode(mentionNode.Id)}</span>";
+                }
+
+                // User mention node
+                if (mentionNode.Type == MentionType.User)
+                {
+                    var user = context.MentionableUsers.FirstOrDefault(u => u.Id == mentionNode.Id) ??
+                               User.CreateUnknownUser(mentionNode.Id);
+
+                    return $"<span class=\"mention\" title=\"{HtmlEncode(user.FullName)}\">@{HtmlEncode(user.Name)}</span>";
+                }
+
+                // Channel mention node
+                if (mentionNode.Type == MentionType.Channel)
+                {
+                    var channel = context.MentionableChannels.FirstOrDefault(c => c.Id == mentionNode.Id) ??
+                                  Channel.CreateDeletedChannel(mentionNode.Id);
+
+                    return $"<span class=\"mention\">#{HtmlEncode(channel.Name)}</span>";
+                }
+
+                // Role mention node
+                if (mentionNode.Type == MentionType.Role)
+                {
+                    var role = context.MentionableRoles.FirstOrDefault(r => r.Id == mentionNode.Id) ??
+                               Role.CreateDeletedRole(mentionNode.Id);
+
+                    return $"<span class=\"mention\">@{HtmlEncode(role.Name)}</span>";
+                }
+            }
+
+            // Emoji node
+            if (node is EmojiNode emojiNode)
+            {
+                // Get emoji image URL
+                var emojiImageUrl = Emoji.GetImageUrl(emojiNode.Id, emojiNode.Name, emojiNode.IsAnimated);
+
+                // Make emoji large if it's jumbo
+                var jumboableCssClass = isJumbo ? "emoji--large" : null;
+
+                return $"<img class=\"emoji {jumboableCssClass}\" alt=\"{emojiNode.Name}\" title=\"{emojiNode.Name}\" src=\"{emojiImageUrl}\" />";
+            }
+
+            // Link node
+            if (node is LinkNode linkNode)
+            {
+                // Extract message ID if the link points to a Discord message
+                var linkedMessageId = Regex.Match(linkNode.Url, "^https?://discordapp.com/channels/.*?/(\\d+)/?$").Groups[1].Value;
+
+                return string.IsNullOrWhiteSpace(linkedMessageId)
+                    ? $"<a href=\"{Uri.EscapeUriString(linkNode.Url)}\">{HtmlEncode(linkNode.Title)}</a>"
+                    : $"<a href=\"{Uri.EscapeUriString(linkNode.Url)}\" onclick=\"scrollToMessage(event, '{linkedMessageId}')\">{HtmlEncode(linkNode.Title)}</a>";
+            }
+
+            // Throw on unexpected nodes
+            throw new InvalidOperationException($"Unexpected node [{node.GetType()}].");
+        }
+
+        private static string FormatMarkdownNodes(RenderContext context, IReadOnlyList<Node> nodes, bool isTopLevel)
+        {
+            // Emojis are jumbo if all top-level nodes are emoji nodes or whitespace text nodes
+            var isJumbo = isTopLevel && nodes.All(n => n is EmojiNode || n is TextNode textNode && string.IsNullOrWhiteSpace(textNode.Text));
+
+            return nodes.Select(n => FormatMarkdownNode(context, n, isJumbo)).JoinToString("");
+        }
+
+        public static string FormatMarkdown(RenderContext context, string markdown) =>
+            FormatMarkdownNodes(context, MarkdownParser.Parse(markdown), true);
+    }
+}

DiscordChatExporter.Core.Rendering/Logic/PlainTextRenderingLogic.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Markdown.Nodes;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Rendering.Internal;
+using Tyrrrz.Extensions;
+
+using static DiscordChatExporter.Core.Rendering.Logic.SharedRenderingLogic;
+
+namespace DiscordChatExporter.Core.Rendering.Logic
+{
+    public static class PlainTextRenderingLogic
+    {
+        public static string FormatPreamble(RenderContext context)
+        {
+            var buffer = new StringBuilder();
+
+            buffer.AppendLine('='.Repeat(62));
+            buffer.AppendLine($"Guild: {context.Guild.Name}");
+            buffer.AppendLine($"Channel: {context.Channel.Name}");
+
+            if (!string.IsNullOrWhiteSpace(context.Channel.Topic))
+                buffer.AppendLine($"Topic: {context.Channel.Topic}");
+
+            if (context.After != null)
+                buffer.AppendLine($"After: {FormatDate(context.After.Value, context.DateFormat)}");
+
+            if (context.Before != null)
+                buffer.AppendLine($"Before: {FormatDate(context.Before.Value, context.DateFormat)}");
+
+            buffer.AppendLine('='.Repeat(62));
+
+            return buffer.ToString();
+        }
+
+        private static string FormatMarkdownNode(RenderContext context, Node node)
+        {
+            // Text node
+            if (node is TextNode textNode)
+            {
+                return textNode.Text;
+            }
+
+            // Mention node
+            if (node is MentionNode mentionNode)
+            {
+                // Meta mention node
+                if (mentionNode.Type == MentionType.Meta)
+                {
+                    return $"@{mentionNode.Id}";
+                }
+
+                // User mention node
+                if (mentionNode.Type == MentionType.User)
+                {
+                    var user = context.MentionableUsers.FirstOrDefault(u => u.Id == mentionNode.Id) ??
+                               User.CreateUnknownUser(mentionNode.Id);
+
+                    return $"@{user.Name}";
+                }
+
+                // Channel mention node
+                if (mentionNode.Type == MentionType.Channel)
+                {
+                    var channel = context.MentionableChannels.FirstOrDefault(c => c.Id == mentionNode.Id) ??
+                                  Channel.CreateDeletedChannel(mentionNode.Id);
+
+                    return $"#{channel.Name}";
+                }
+
+                // Role mention node
+                if (mentionNode.Type == MentionType.Role)
+                {
+                    var role = context.MentionableRoles.FirstOrDefault(r => r.Id == mentionNode.Id) ??
+                               Role.CreateDeletedRole(mentionNode.Id);
+
+                    return $"@{role.Name}";
+                }
+            }
+
+            // Emoji node
+            if (node is EmojiNode emojiNode)
+            {
+                return emojiNode.IsCustomEmoji ? $":{emojiNode.Name}:" : emojiNode.Name;
+            }
+
+            // Throw on unexpected nodes
+            throw new InvalidOperationException($"Unexpected node [{node.GetType()}].");
+        }
+
+        public static string FormatMarkdown(RenderContext context, string markdown) =>
+            MarkdownParser.ParseMinimal(markdown).Select(n => FormatMarkdownNode(context, n)).JoinToString("");
+
+        public static string FormatMessageHeader(RenderContext context, Message message)
+        {
+            var buffer = new StringBuilder();
+
+            // Timestamp & author
+            buffer
+                .Append($"[{FormatDate(message.Timestamp, context.DateFormat)}]")
+                .Append(' ')
+                .Append($"{message.Author.FullName}");
+
+            // Whether the message is pinned
+            if (message.IsPinned)
+            {
+                buffer.Append(' ').Append("(pinned)");
+            }
+
+            return buffer.ToString();
+        }
+
+        public static string FormatMessageContent(RenderContext context, Message message)
+        {
+            if (string.IsNullOrWhiteSpace(message.Content))
+                return "";
+
+            return FormatMarkdown(context, message.Content);
+        }
+
+        public static string FormatAttachments(RenderContext context, IReadOnlyList<Attachment> attachments)
+        {
+            if (!attachments.Any())
+                return "";
+
+            var buffer = new StringBuilder();
+
+            buffer
+                .AppendLine("{Attachments}")
+                .AppendJoin(Environment.NewLine, attachments.Select(a => a.Url))
+                .AppendLine();
+
+            return buffer.ToString();
+        }
+
+        public static string FormatEmbeds(RenderContext context, IReadOnlyList<Embed> embeds)
+        {
+            if (!embeds.Any())
+                return "";
+
+            var buffer = new StringBuilder();
+
+            foreach (var embed in embeds)
+            {
+                buffer.AppendLine("{Embed}");
+
+                // Author name
+                if (!string.IsNullOrWhiteSpace(embed.Author?.Name))
+                    buffer.AppendLine(embed.Author.Name);
+
+                // URL
+                if (!string.IsNullOrWhiteSpace(embed.Url))
+                    buffer.AppendLine(embed.Url);
+
+                // Title
+                if (!string.IsNullOrWhiteSpace(embed.Title))
+                    buffer.AppendLine(FormatMarkdown(context, embed.Title));
+
+                // Description
+                if (!string.IsNullOrWhiteSpace(embed.Description))
+                    buffer.AppendLine(FormatMarkdown(context, embed.Description));
+
+                // Fields
+                foreach (var field in embed.Fields)
+                {
+                    // Name
+                    if (!string.IsNullOrWhiteSpace(field.Name))
+                        buffer.AppendLine(field.Name);
+
+                    // Value
+                    if (!string.IsNullOrWhiteSpace(field.Value))
+                        buffer.AppendLine(field.Value);
+                }
+
+                // Thumbnail URL
+                if (!string.IsNullOrWhiteSpace(embed.Thumbnail?.Url))
+                    buffer.AppendLine(embed.Thumbnail?.Url);
+
+                // Image URL
+                if (!string.IsNullOrWhiteSpace(embed.Image?.Url))
+                    buffer.AppendLine(embed.Image?.Url);
+
+                // Footer text
+                if (!string.IsNullOrWhiteSpace(embed.Footer?.Text))
+                    buffer.AppendLine(embed.Footer?.Text);
+
+                buffer.AppendLine();
+            }
+
+            return buffer.ToString();
+        }
+
+        public static string FormatReactions(RenderContext context, IReadOnlyList<Reaction> reactions)
+        {
+            if (!reactions.Any())
+                return "";
+
+            var buffer = new StringBuilder();
+
+            buffer.AppendLine("{Reactions}");
+
+            foreach (var reaction in reactions)
+            {
+                buffer.Append(reaction.Emoji.Name);
+
+                if (reaction.Count > 1)
+                    buffer.Append($" ({reaction.Count})");
+
+                buffer.Append(" ");
+            }
+
+            buffer.AppendLine();
+
+            return buffer.ToString();
+        }
+
+        public static string FormatMessage(RenderContext context, Message message)
+        {
+            var buffer = new StringBuilder();
+
+            buffer
+                .AppendLine(FormatMessageHeader(context, message))
+                .AppendLineIfNotEmpty(FormatMessageContent(context, message))
+                .AppendLine()
+                .AppendLineIfNotEmpty(FormatAttachments(context, message.Attachments))
+                .AppendLineIfNotEmpty(FormatEmbeds(context, message.Embeds))
+                .AppendLineIfNotEmpty(FormatReactions(context, message.Reactions));
+
+            return buffer.Trim().ToString();
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/Logic/SharedRenderingLogic.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Globalization;
+
+namespace DiscordChatExporter.Core.Rendering.Logic
+{
+    public static class SharedRenderingLogic
+    {
+        public static string FormatDate(DateTimeOffset date, string dateFormat) =>
+            date.ToLocalTime().ToString(dateFormat, CultureInfo.InvariantCulture);
+    }
+}

DiscordChatExporter.Core.Rendering/MessageRendererBase.cs

@@ -0,0 +1,23 @@
+using System.IO;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public abstract class MessageRendererBase : IMessageRenderer
+    {
+        protected TextWriter Writer { get; }
+
+        protected RenderContext Context { get; }
+
+        protected MessageRendererBase(string filePath, RenderContext context)
+        {
+            Writer = File.CreateText(filePath);
+            Context = context;
+        }
+
+        public abstract Task RenderMessageAsync(Message message);
+
+        public virtual ValueTask DisposeAsync() => Writer.DisposeAsync();
+    }
+}

DiscordChatExporter.Core.Rendering/PlainTextMessageRenderer.cs

@@ -0,0 +1,29 @@
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Rendering.Logic;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public class PlainTextMessageRenderer : MessageRendererBase
+    {
+        private bool _isPreambleRendered;
+
+        public PlainTextMessageRenderer(string filePath, RenderContext context)
+            : base(filePath, context)
+        {
+        }
+
+        public override async Task RenderMessageAsync(Message message)
+        {
+            // Render preamble if it's the first entry
+            if (!_isPreambleRendered)
+            {
+                await Writer.WriteLineAsync(PlainTextRenderingLogic.FormatPreamble(Context));
+                _isPreambleRendered = true;
+            }
+
+            await Writer.WriteLineAsync(PlainTextRenderingLogic.FormatMessage(Context, message));
+            await Writer.WriteLineAsync();
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/RenderContext.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public class RenderContext
+    {
+        public Guild Guild { get; }
+
+        public Channel Channel { get; }
+
+        public DateTimeOffset? After { get; }
+
+        public DateTimeOffset? Before { get; }
+
+        public string DateFormat { get; }
+
+        public IReadOnlyCollection<User> MentionableUsers { get; }
+
+        public IReadOnlyCollection<Channel> MentionableChannels { get; }
+
+        public IReadOnlyCollection<Role> MentionableRoles { get; }
+
+        public RenderContext(Guild guild, Channel channel, DateTimeOffset? after, DateTimeOffset? before, string dateFormat,
+            IReadOnlyCollection<User> mentionableUsers, IReadOnlyCollection<Channel> mentionableChannels, IReadOnlyCollection<Role> mentionableRoles)
+        {
+            Guild = guild;
+            Channel = channel;
+            After = after;
+            Before = before;
+            DateFormat = dateFormat;
+            MentionableUsers = mentionableUsers;
+            MentionableChannels = mentionableChannels;
+            MentionableRoles = mentionableRoles;
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/Resources/HtmlCore.css

@@ -0,0 +1,368 @@
+/* === GENERAL === */
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://discordapp.com/assets/6c6374bad0b0b6d204d8d6dc4a18d820.woff);
+    font-weight: 300;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://discordapp.com/assets/e8acd7d9bf6207f99350ca9f9e23b168.woff);
+    font-weight: 400;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://discordapp.com/assets/3bdef1251a424500c1b3a78dea9b7e57.woff);
+    font-weight: 500;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://discordapp.com/assets/be0060dafb7a0e31d2a1ca17c0708636.woff);
+    font-weight: 600;
+}
+
+@font-face {
+    font-family: Whitney;
+    src: url(https://discordapp.com/assets/8e12fb4f14d9c4592eb8ec9f22337b04.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 {
+    white-space: pre-wrap;
+    line-height: 1.3;
+    overflow-wrap: break-word;
+}
+
+.spoiler {
+    border-radius: 3px;
+}
+
+.quote {
+    border-left: 4px solid;
+    border-radius: 3px;
+    margin: 8px 0;
+    padding-left: 10px;
+}
+
+.pre {
+    font-family: "Consolas", "Courier New", Courier, monospace;
+}
+
+.pre--multiline {
+    margin-top: 4px;
+    padding: 8px;
+    border: 2px solid;
+    border-radius: 5px;
+}
+
+.pre--inline {
+    padding: 2px;
+    border-radius: 3px;
+    font-size: 85%;
+}
+
+.mention {
+    font-weight: 500;
+}
+
+.emoji {
+    width: 1.45em;
+    height: 1.45em;
+    margin: 0 1px;
+    vertical-align: -0.4em;
+}
+
+.emoji--small {
+    width: 1rem;
+    height: 1rem;
+}
+
+.emoji--large {
+    width: 2rem;
+    height: 2rem;
+}
+
+/* === INFO === */
+
+.info {
+    display: flex;
+    max-width: 100%;
+    margin: 0 5px 10px 5px;
+}
+
+.info__guild-icon-container {
+    flex: 0;
+}
+
+.info__guild-icon {
+    max-width: 88px;
+    max-height: 88px;
+}
+
+.info__metadata {
+    flex: 1;
+    margin-left: 10px;
+}
+
+.info__guild-name {
+    font-size: 1.4em;
+}
+
+.info__channel-name {
+    font-size: 1.2em;
+}
+
+.info__channel-topic {
+    margin-top: 2px;
+}
+
+.info__channel-message-count {
+    margin-top: 2px;
+}
+
+.info__channel-date-range {
+    margin-top: 2px;
+}
+
+/* === CHATLOG === */
+
+.chatlog {
+    max-width: 100%;
+    margin-bottom: 24px;
+}
+
+.chatlog__message-group {
+    display: flex;
+    margin: 0 10px;
+    padding: 15px 0;
+    border-top: 1px solid;
+}
+
+.chatlog__author-avatar-container {
+    flex: 0;
+    width: 40px;
+    height: 40px;
+}
+
+.chatlog__author-avatar {
+    border-radius: 50%;
+    height: 40px;
+    width: 40px;
+}
+
+.chatlog__messages {
+    flex: 1;
+    min-width: 50%;
+    margin-left: 20px;
+}
+
+.chatlog__author-name {
+    font-size: 1em;
+    font-weight: 500;
+}
+
+.chatlog__timestamp {
+    margin-left: 5px;
+    font-size: .75em;
+}
+
+.chatlog__message {
+    padding: 2px 5px;
+    margin-right: -5px;
+    margin-left: -5px;
+    background-color: transparent;
+    transition: background-color 1s ease;
+}
+
+.chatlog__content {
+    font-size: .9375em;
+    word-wrap: break-word;
+}
+
+.chatlog__edited-timestamp {
+    margin-left: 3px;
+    font-size: .8em;
+}
+
+.chatlog__attachment-thumbnail {
+    margin-top: 5px;
+    max-width: 50%;
+    max-height: 500px;
+    border-radius: 3px;
+}
+
+.chatlog__embed {
+    margin-top: 5px;
+    display: flex;
+    max-width: 520px;
+}
+
+.chatlog__embed-color-pill {
+    flex-shrink: 0;
+    width: 4px;
+    border-top-left-radius: 3px;
+    border-bottom-left-radius: 3px;
+}
+
+.chatlog__embed-content-container {
+    display: flex;
+    flex-direction: column;
+    padding: 8px 10px;
+    border: 1px solid;
+    border-top-right-radius: 3px;
+    border-bottom-right-radius: 3px;
+}
+
+.chatlog__embed-content {
+    width: 100%;
+    display: flex;
+}
+
+.chatlog__embed-text {
+    flex: 1;
+}
+
+.chatlog__embed-author {
+    display: flex;
+    align-items: center;
+    margin-bottom: 5px;
+}
+
+.chatlog__embed-author-icon {
+    width: 20px;
+    height: 20px;
+    margin-right: 9px;
+    border-radius: 50%;
+}
+
+.chatlog__embed-author-name {
+    font-size: .875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-title {
+    margin-bottom: 4px;
+    font-size: .875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-description {
+    font-weight: 500;
+    font-size: 14px;
+}
+
+.chatlog__embed-fields {
+    display: flex;
+    flex-wrap: wrap;
+}
+
+.chatlog__embed-field {
+    flex: 0;
+    min-width: 100%;
+    max-width: 506px;
+    padding-top: 10px;
+}
+
+.chatlog__embed-field--inline {
+    flex: 1;
+    flex-basis: auto;
+    min-width: 150px;
+}
+
+.chatlog__embed-field-name {
+    margin-bottom: 4px;
+    font-size: .875em;
+    font-weight: 600;
+}
+
+.chatlog__embed-field-value {
+    font-size: .875em;
+    font-weight: 500;
+}
+
+.chatlog__embed-thumbnail {
+    flex: 0;
+    margin-left: 20px;
+    max-width: 80px;
+    max-height: 80px;
+    border-radius: 3px;
+}
+
+.chatlog__embed-image-container {
+    margin-top: 10px;
+}
+
+.chatlog__embed-image {
+    max-width: 500px;
+    max-height: 400px;
+    border-radius: 3px;
+}
+
+.chatlog__embed-footer {
+    margin-top: 10px;
+}
+
+.chatlog__embed-footer-icon {
+    margin-right: 4px;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    vertical-align: middle;
+}
+
+.chatlog__embed-footer-text {
+    font-weight: 500;
+    font-size: .75em;
+}
+
+.chatlog__reactions {
+    display: flex;
+}
+
+.chatlog__reaction {
+    display: flex;
+    align-items: center;
+    margin: 6px 2px 2px 2px;
+    padding: 3px 6px;
+    border-radius: 3px;
+}
+
+.chatlog__reaction-count {
+    min-width: 9px;
+    margin-left: 6px;
+    font-size: .875em;
+}
+
+.chatlog__bot-tag {
+    margin-left: 0.3em;
+    background: #7289da;
+    color: #ffffff;
+    font-size: 0.625em;
+    font-weight: 500;
+    padding: 1px 2px;
+    border-radius: 3px;
+    vertical-align: middle;
+    line-height: 1.3;
+    position: relative;
+    top: -.2em;
+}

DiscordChatExporter.Core.Rendering/Resources/HtmlDark.css

@@ -0,0 +1,116 @@
+/* === GENERAL === */
+
+body {
+    background-color: #36393e;
+    color: #dcddde;
+}
+
+a {
+    color: #0096cf;
+}
+
+.spoiler {
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+.quote {
+    border-color: #4f545c;
+}
+
+.pre {
+    background-color: #2f3136 !important;
+}
+
+.pre--multiline {
+    border-color: #282b30 !important;
+    color: #b9bbbe !important;
+}
+
+.mention {
+    color: #7289da;
+}
+
+/* === INFO === */
+
+.info__guild-name {
+    color: #ffffff;
+}
+
+.info__channel-name {
+    color: #ffffff;
+}
+
+.info__channel-topic {
+    color: #ffffff;
+}
+
+/* === CHATLOG === */
+
+.chatlog__message-group {
+    border-color: rgba(255, 255, 255, 0.1);
+}
+
+.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__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);
+}

DiscordChatExporter.Core.Rendering/Resources/HtmlLayoutTemplate.html

@@ -0,0 +1,84 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    {{~ # Metadata ~}}
+    <title>{{ Context.Guild.Name | html.escape }} - {{ Context.Channel.Name | html.escape }}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+
+    {{~ # Styles ~}}
+    <style>
+        {{ CoreStyleSheet }}
+    </style>
+    <style>
+        {{ ThemeStyleSheet }}
+    </style>
+
+    {{~ # Syntax highlighting ~}}
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.15.6/styles/{{HighlightJsStyleName}}.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>
+
+    {{~ # Local scripts ~}}
+    <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);
+            }
+        }
+    </script>
+</head>
+<body>
+
+{{~ # Info ~}}
+<div class="info">
+    <div class="info__guild-icon-container">
+        <img class="info__guild-icon" src="{{ Context.Guild.IconUrl }}" />
+    </div>
+    <div class="info__metadata">
+        <div class="info__guild-name">{{ Context.Guild.Name | html.escape }}</div>
+        <div class="info__channel-name">{{ Context.Channel.Name | html.escape }}</div>
+
+        {{~ if Context.Channel.Topic ~}}
+            <div class="info__channel-topic">{{ Context.Channel.Topic | html.escape }}</div>
+        {{~ end ~}}
+
+        {{~ if Context.After || Context.Before ~}}
+            <div class="info__channel-date-range">
+                {{~ if Context.After && Context.Before ~}}
+                    Between {{ Context.After | FormatDate | html.escape }} and {{ Context.Before | FormatDate | html.escape }}
+                {{~ else if Context.After ~}}
+                    After {{ Context.After | FormatDate | html.escape }}
+                {{~ else if Context.Before ~}}
+                    Before {{ Context.Before | FormatDate | html.escape }}
+                {{~ end ~}}
+            </div>
+        {{~ end ~}}
+    </div>
+</div>
+
+{{~ # Log ~}}
+<div class="chatlog">
+    {{~ %SPLIT% ~}}
+</div>
+
+</body>
+</html>

DiscordChatExporter.Core.Rendering/Resources/HtmlLight.css

@@ -0,0 +1,119 @@
+/* === GENERAL === */
+
+body {
+    background-color: #ffffff;
+    color: #23262a;
+    font-weight: 500;
+}
+
+a {
+    color: #00b0f4;
+}
+
+.spoiler {
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+.quote {
+    border-color: #c7ccd1;
+}
+
+.pre {
+    background-color: #f9f9f9 !important;
+}
+
+.pre--multiline {
+    border-color: #f3f3f3 !important;
+    color: #657b83 !important;
+}
+
+.mention {
+    background-color: #f1f3fb;
+    color: #7289da;
+}
+
+/* === INFO === */
+
+.info__guild-name {
+    color: #2f3136;
+}
+
+.info__channel-name {
+    color: #2f3136;
+}
+
+.info__channel-topic {
+    color: #2f3136;
+}
+
+/* === CHATLOG === */
+
+.chatlog__message-group {
+    border-color: #eceeef;
+}
+
+.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__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;
+}

DiscordChatExporter.Core.Rendering/Resources/HtmlMessageGroupTemplate.html

@@ -0,0 +1,170 @@
+<div class="chatlog__message-group">
+    {{~ # Avatar ~}}
+    <div class="chatlog__author-avatar-container">
+        <img class="chatlog__author-avatar" src="{{ MessageGroup.Author.AvatarUrl }}" />
+    </div>
+    <div class="chatlog__messages">
+        {{~ # Author name and timestamp ~}}
+        <span class="chatlog__author-name" title="{{ MessageGroup.Author.FullName | html.escape }}" data-user-id="{{ MessageGroup.Author.Id | html.escape }}">{{ MessageGroup.Author.Name | html.escape }}</span>
+
+        {{~ # Bot tag ~}}
+        {{~ if MessageGroup.Author.IsBot ~}}
+            <span class="chatlog__bot-tag">BOT</span>
+        {{~ end ~}}
+
+        <span class="chatlog__timestamp">{{ MessageGroup.Timestamp | FormatDate | html.escape }}</span>
+
+        {{~ # Messages ~}}
+        {{~ for message in MessageGroup.Messages ~}}
+            <div class="chatlog__message {{if message.IsPinned }}chatlog__message--pinned{{ end }}" data-message-id="{{ message.Id }}" id="message-{{ message.Id }}">
+            {{~ # Content ~}}
+            {{~ if message.Content ~}}
+                <div class="chatlog__content">
+                    <span class="markdown">{{ message.Content | FormatMarkdown }}</span>
+
+                    {{~ # Edited timestamp ~}}
+                    {{~ if message.EditedTimestamp ~}}
+                        <span class="chatlog__edited-timestamp" title="{{ message.EditedTimestamp | FormatDate | html.escape }}">(edited)</span>
+                    {{~ end ~}}
+                </div>
+            {{~ end ~}}
+
+            {{~ # Attachments ~}}
+            {{~ for attachment in message.Attachments ~}}
+                <div class="chatlog__attachment">
+                    <a href="{{ attachment.Url }}">
+                        {{ # Image }}
+                        {{~ if attachment.IsImage ~}}
+                            <img class="chatlog__attachment-thumbnail" src="{{ attachment.Url }}" />
+                        {{~ # Non-image ~}}
+                        {{~ else ~}}
+                            Attachment: {{ attachment.FileName }} ({{ attachment.FileSize }})
+                        {{~ end ~}}
+                    </a>
+                </div>
+            {{~ end ~}}
+
+            {{~ # Embeds ~}}
+            {{~ for embed in message.Embeds ~}}
+            <div class="chatlog__embed">
+                {{~ if embed.Color ~}}
+                <div class="chatlog__embed-color-pill" style="background-color: rgba({{ embed.Color.R }},{{ embed.Color.G }},{{ embed.Color.B }},{{ embed.Color.A }})"></div>
+                {{~ else ~}}
+                <div class="chatlog__embed-color-pill chatlog__embed-color-pill--default"></div>
+                {{~ end ~}}
+                <div class="chatlog__embed-content-container">
+                    <div class="chatlog__embed-content">
+                        <div class="chatlog__embed-text">
+                            {{~ # Author ~}}
+                            {{~ if embed.Author ~}}
+                            <div class="chatlog__embed-author">
+                                {{~ if embed.Author.IconUrl ~}}
+                                <img class="chatlog__embed-author-icon" src="{{ embed.Author.IconUrl }}" />
+                                {{~ end ~}}
+
+                                {{~ if embed.Author.Name ~}}
+                                <span class="chatlog__embed-author-name">
+                                    {{~ if embed.Author.Url ~}}
+                                    <a class="chatlog__embed-author-name-link" href="{{ embed.Author.Url }}">{{ embed.Author.Name | html.escape }}</a>
+                                    {{~ else ~}}
+                                    {{ embed.Author.Name | html.escape }}
+                                    {{~ end ~}}
+                                </span>
+                                {{~ end ~}}
+                            </div>
+                            {{~ end ~}}
+
+                            {{~ # Title ~}}
+                            {{~ if embed.Title ~}}
+                            <div class="chatlog__embed-title">
+                                {{~ if embed.Url ~}}
+                                <a class="chatlog__embed-title-link" href="{{ embed.Url }}"><span class="markdown">{{ embed.Title | FormatMarkdown }}</span></a>
+                                {{~ else ~}}
+                                <span class="markdown">{{ embed.Title | FormatMarkdown }}</span>
+                                {{~ end ~}}
+                            </div>
+                            {{~ end ~}}
+
+                            {{~ # Description ~}}
+                            {{~ if embed.Description ~}}
+                            <div class="chatlog__embed-description"><span class="markdown">{{ embed.Description | FormatMarkdown }}</span></div>
+                            {{~ end ~}}
+
+                            {{~ # Fields ~}}
+                            {{~ if embed.Fields | array.size > 0 ~}}
+                            <div class="chatlog__embed-fields">
+                                {{~ for field in embed.Fields ~}}
+                                <div class="chatlog__embed-field {{ if field.IsInline }} chatlog__embed-field--inline {{ end }}">
+                                    {{~ if field.Name ~}}
+                                    <div class="chatlog__embed-field-name"><span class="markdown">{{ field.Name | FormatMarkdown }}</span></div>
+                                    {{~ end ~}}
+                                    {{~ if field.Value ~}}
+                                    <div class="chatlog__embed-field-value"><span class="markdown">{{ field.Value | FormatMarkdown }}</span></div>
+                                    {{~ end ~}}
+                                </div>
+                                {{~ end ~}}
+                            </div>
+                            {{~ end ~}}
+                        </div>
+
+                        {{~ # Thumbnail ~}}
+                        {{~ if embed.Thumbnail ~}}
+                        <div class="chatlog__embed-thumbnail-container">
+                            <a class="chatlog__embed-thumbnail-link" href="{{ embed.Thumbnail.Url }}">
+                                <img class="chatlog__embed-thumbnail" src="{{ embed.Thumbnail.Url }}" />
+                            </a>
+                        </div>
+                        {{~ end ~}}
+                    </div>
+
+                    {{~ # Image ~}}
+                    {{~ if embed.Image ~}}
+                    <div class="chatlog__embed-image-container">
+                        <a class="chatlog__embed-image-link" href="{{ embed.Image.Url }}">
+                            <img class="chatlog__embed-image" src="{{ embed.Image.Url }}" />
+                        </a>
+                    </div>
+                    {{~ end ~}}
+
+                    {{~ # Footer ~}}
+                    {{~ if embed.Footer || embed.Timestamp ~}}
+                    <div class="chatlog__embed-footer">
+                        {{~ if embed.Footer ~}}
+                        {{~ if embed.Footer.Text && embed.Footer.IconUrl ~}}
+                        <img class="chatlog__embed-footer-icon" src="{{ embed.Footer.IconUrl }}" />
+                        {{~ end ~}}
+                        {{~ end ~}}
+
+                        <span class="chatlog__embed-footer-text">
+                            {{~ if embed.Footer ~}}
+                            {{~ if embed.Footer.Text ~}}
+                            {{ embed.Footer.Text | html.escape }}
+                            {{ if embed.Timestamp }} • {{ end }}
+                            {{~ end ~}}
+                            {{~ end ~}}
+
+                            {{~ if embed.Timestamp ~}}
+                            {{ embed.Timestamp | FormatDate | html.escape }}
+                            {{~ end ~}}
+                        </span>
+                    </div>
+                    {{~ end ~}}
+                </div>
+            </div>
+            {{~ end ~}}
+
+            {{~ # Reactions ~}}
+            {{~ if message.Reactions | array.size > 0 ~}}
+                <div class="chatlog__reactions">
+                    {{~ for reaction in message.Reactions ~}}
+                        <div class="chatlog__reaction">
+                            <img class="emoji emoji--small" alt="{{ reaction.Emoji.Name }}" title="{{ reaction.Emoji.Name }}" src="{{ reaction.Emoji.ImageUrl }}" />
+                            <span class="chatlog__reaction-count">{{ reaction.Count }}</span>
+                        </div>
+                    {{~ end ~}}
+                </div>
+            {{~ end ~}}
+            </div>
+        {{~ end ~}}
+    </div>
+</div>

DiscordChatExporter.Core.Services/DataService.Parsers.cs

@@ -0,0 +1,216 @@
+using System;
+using System.Drawing;
+using System.Linq;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services.Internal;
+using Newtonsoft.Json.Linq;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public partial class DataService
+    {
+        private User ParseUser(JToken json)
+        {
+            var id = json["id"]!.Value<string>();
+            var discriminator = json["discriminator"]!.Value<int>();
+            var name = json["username"]!.Value<string>();
+            var avatarHash = json["avatar"]!.Value<string>();
+            var isBot = json["bot"]?.Value<bool>() ?? false;
+
+            return new User(id, discriminator, name, avatarHash, isBot);
+        }
+
+        private Guild ParseGuild(JToken json)
+        {
+            var id = json["id"]!.Value<string>();
+            var name = json["name"]!.Value<string>();
+            var iconHash = json["icon"]!.Value<string>();
+
+            return new Guild(id, name, iconHash);
+        }
+
+        private Channel ParseChannel(JToken json)
+        {
+            // Get basic data
+            var id = json["id"]!.Value<string>();
+            var parentId = json["parent_id"]?.Value<string>();
+            var type = (ChannelType) json["type"]!.Value<int>();
+            var topic = json["topic"]?.Value<string>();
+
+            // Try to extract guild ID
+            var guildId = json["guild_id"]?.Value<string>();
+
+            // If the guild ID is blank, it's direct messages
+            if (string.IsNullOrWhiteSpace(guildId))
+                guildId = Guild.DirectMessages.Id;
+
+            // Try to extract name
+            var name = json["name"]?.Value<string>();
+
+            // If the name is blank, it's direct messages
+            if (string.IsNullOrWhiteSpace(name))
+                name = json["recipients"]?.Select(ParseUser).Select(u => u.Name).JoinToString(", ");
+
+            // If the name is still blank for some reason, fallback to ID
+            // (blind fix to https://github.com/Tyrrrz/DiscordChatExporter/issues/227)
+            if (string.IsNullOrWhiteSpace(name))
+                name = id;
+
+            return new Channel(id, parentId, guildId, name, topic, type);
+        }
+
+        private Role ParseRole(JToken json)
+        {
+            var id = json["id"]!.Value<string>();
+            var name = json["name"]!.Value<string>();
+
+            return new Role(id, name);
+        }
+
+        private Attachment ParseAttachment(JToken json)
+        {
+            var id = json["id"]!.Value<string>();
+            var url = json["url"]!.Value<string>();
+            var width = json["width"]?.Value<int>();
+            var height = json["height"]?.Value<int>();
+            var fileName = json["filename"]!.Value<string>();
+            var fileSizeBytes = json["size"]!.Value<long>();
+
+            var fileSize = new FileSize(fileSizeBytes);
+
+            return new Attachment(id, width, height, url, fileName, fileSize);
+        }
+
+        private EmbedAuthor ParseEmbedAuthor(JToken json)
+        {
+            var name = json["name"]?.Value<string>();
+            var url = json["url"]?.Value<string>();
+            var iconUrl = json["icon_url"]?.Value<string>();
+
+            return new EmbedAuthor(name, url, iconUrl);
+        }
+
+        private EmbedField ParseEmbedField(JToken json)
+        {
+            var name = json["name"]!.Value<string>();
+            var value = json["value"]!.Value<string>();
+            var isInline = json["inline"]?.Value<bool>() ?? false;
+
+            return new EmbedField(name, value, isInline);
+        }
+
+        private EmbedImage ParseEmbedImage(JToken json)
+        {
+            var url = json["url"]?.Value<string>();
+            var width = json["width"]?.Value<int>();
+            var height = json["height"]?.Value<int>();
+
+            return new EmbedImage(url, width, height);
+        }
+
+        private EmbedFooter ParseEmbedFooter(JToken json)
+        {
+            var text = json["text"]!.Value<string>();
+            var iconUrl = json["icon_url"]?.Value<string>();
+
+            return new EmbedFooter(text, iconUrl);
+        }
+
+        private Embed ParseEmbed(JToken json)
+        {
+            // Get basic data
+            var title = json["title"]?.Value<string>();
+            var description = json["description"]?.Value<string>();
+            var url = json["url"]?.Value<string>();
+            var timestamp = json["timestamp"]?.Value<DateTime>().ToDateTimeOffset();
+
+            // Get color
+            var color = json["color"] != null
+                ? Color.FromArgb(json["color"]!.Value<int>()).ResetAlpha()
+                : default(Color?);
+
+            // Get author
+            var author = json["author"] != null ? ParseEmbedAuthor(json["author"]!) : null;
+
+            // Get fields
+            var fields = (json["fields"] ?? Enumerable.Empty<JToken>()).Select(ParseEmbedField).ToArray();
+
+            // Get thumbnail
+            var thumbnail = json["thumbnail"] != null ? ParseEmbedImage(json["thumbnail"]!) : null;
+
+            // Get image
+            var image = json["image"] != null ? ParseEmbedImage(json["image"]!) : null;
+
+            // Get footer
+            var footer = json["footer"] != null ? ParseEmbedFooter(json["footer"]!) : null;
+
+            return new Embed(title, url, timestamp, color, author, description, fields, thumbnail, image, footer);
+        }
+
+        private Emoji ParseEmoji(JToken json)
+        {
+            var id = json["id"]?.Value<string>();
+            var name = json["name"]!.Value<string>();
+            var isAnimated = json["animated"]?.Value<bool>() ?? false;
+
+            return new Emoji(id, name, isAnimated);
+        }
+
+        private Reaction ParseReaction(JToken json)
+        {
+            var count = json["count"]!.Value<int>();
+            var emoji = ParseEmoji(json["emoji"]!);
+
+            return new Reaction(count, emoji);
+        }
+
+        private Message ParseMessage(JToken json)
+        {
+            // Get basic data
+            var id = json["id"]!.Value<string>();
+            var channelId = json["channel_id"]!.Value<string>();
+            var timestamp = json["timestamp"]!.Value<DateTime>().ToDateTimeOffset();
+            var editedTimestamp = json["edited_timestamp"]?.Value<DateTime?>()?.ToDateTimeOffset();
+            var content = json["content"]!.Value<string>();
+            var type = (MessageType) json["type"]!.Value<int>();
+
+            // Workarounds for non-default types
+            if (type == MessageType.RecipientAdd)
+                content = "Added a recipient.";
+            else if (type == MessageType.RecipientRemove)
+                content = "Removed a recipient.";
+            else if (type == MessageType.Call)
+                content = "Started a call.";
+            else if (type == MessageType.ChannelNameChange)
+                content = "Changed the channel name.";
+            else if (type == MessageType.ChannelIconChange)
+                content = "Changed the channel icon.";
+            else if (type == MessageType.ChannelPinnedMessage)
+                content = "Pinned a message.";
+            else if (type == MessageType.GuildMemberJoin)
+                content = "Joined the server.";
+
+            // Get author
+            var author = ParseUser(json["author"]!);
+
+            // Get attachments
+            var attachments = (json["attachments"] ?? Enumerable.Empty<JToken>()).Select(ParseAttachment).ToArray();
+
+            // Get embeds
+            var embeds = (json["embeds"] ?? Enumerable.Empty<JToken>()).Select(ParseEmbed).ToArray();
+
+            // Get reactions
+            var reactions = (json["reactions"] ?? Enumerable.Empty<JToken>()).Select(ParseReaction).ToArray();
+
+            // Get mentions
+            var mentionedUsers = (json["mentions"] ?? Enumerable.Empty<JToken>()).Select(ParseUser).ToArray();
+
+            // Get whether this message is pinned
+            var isPinned = json["pinned"]!.Value<bool>();
+
+            return new Message(id, channelId, type, author, timestamp, editedTimestamp, isPinned, content, attachments, embeds,
+                reactions, mentionedUsers);
+        }
+    }
+}

DiscordChatExporter.Core.Services/DataService.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services.Exceptions;
+using DiscordChatExporter.Core.Services.Internal;
+using Newtonsoft.Json.Linq;
+using Polly;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public partial class DataService : IDisposable
+    {
+        private readonly HttpClient _httpClient = new HttpClient();
+        private readonly IAsyncPolicy<HttpResponseMessage> _httpPolicy;
+
+        public DataService()
+        {
+            _httpClient.BaseAddress = new Uri("https://discordapp.com/api/v6");
+
+            // Discord seems to always respond 429 on our first request with unreasonable wait time (10+ minutes).
+            // For that reason the policy will start respecting their retry-after header only after Nth failed response.
+            _httpPolicy = Policy
+                .HandleResult<HttpResponseMessage>(m => m.StatusCode == HttpStatusCode.TooManyRequests)
+                .OrResult(m => m.StatusCode >= HttpStatusCode.InternalServerError)
+                .WaitAndRetryAsync(6,
+                    (i, result, ctx) =>
+                    {
+                        if (i <= 3)
+                            return TimeSpan.FromSeconds(2 * i);
+
+                        if (i <= 5)
+                            return TimeSpan.FromSeconds(5 * i);
+
+                        return result.Result.Headers.RetryAfter.Delta ?? TimeSpan.FromSeconds(10 * i);
+                    },
+                    (response, timespan, retryCount, context) => Task.CompletedTask);
+        }
+
+        private async Task<JToken> GetApiResponseAsync(AuthToken token, string route)
+        {
+            using var response = await _httpPolicy.ExecuteAsync(async () =>
+            {
+                using var request = new HttpRequestMessage(HttpMethod.Get, route);
+
+                request.Headers.Authorization = token.Type == AuthTokenType.Bot
+                    ? new AuthenticationHeaderValue("Bot", token.Value)
+                    : new AuthenticationHeaderValue(token.Value);
+
+                return await _httpClient.SendAsync(request);
+            });
+
+            // We throw our own exception here because default one doesn't have status code
+            if (!response.IsSuccessStatusCode)
+                throw new HttpErrorStatusCodeException(response.StatusCode, response.ReasonPhrase);
+
+            var jsonRaw = await response.Content.ReadAsStringAsync();
+            return JToken.Parse(jsonRaw);
+        }
+
+        public async Task<Guild> GetGuildAsync(AuthToken token, string guildId)
+        {
+            // Special case for direct messages pseudo-guild
+            if (guildId == Guild.DirectMessages.Id)
+                return Guild.DirectMessages;
+
+            var response = await GetApiResponseAsync(token, $"guilds/{guildId}");
+            var guild = ParseGuild(response);
+
+            return guild;
+        }
+
+        public async Task<Channel> GetChannelAsync(AuthToken token, string channelId)
+        {
+            var response = await GetApiResponseAsync(token, $"channels/{channelId}");
+            var channel = ParseChannel(response);
+
+            return channel;
+        }
+
+        public async IAsyncEnumerable<Guild> GetUserGuildsAsync(AuthToken token)
+        {
+            var afterId = "";
+
+            while (true)
+            {
+                var route = "users/@me/guilds?limit=100";
+                if (!string.IsNullOrWhiteSpace(afterId))
+                    route += $"&after={afterId}";
+
+                var response = await GetApiResponseAsync(token, route);
+
+                if (!response.HasValues)
+                    yield break;
+
+                foreach (var guild in response.Select(ParseGuild))
+                {
+                    yield return guild;
+                    afterId = guild.Id;
+                }
+            }
+        }
+
+        public async Task<IReadOnlyList<Channel>> GetDirectMessageChannelsAsync(AuthToken token)
+        {
+            var response = await GetApiResponseAsync(token, "users/@me/channels");
+            var channels = response.Select(ParseChannel).ToArray();
+
+            return channels;
+        }
+
+        public async Task<IReadOnlyList<Channel>> GetGuildChannelsAsync(AuthToken token, string guildId)
+        {
+            // Special case for direct messages pseudo-guild
+            if (guildId == Guild.DirectMessages.Id)
+                return Array.Empty<Channel>();
+
+            var response = await GetApiResponseAsync(token, $"guilds/{guildId}/channels");
+            var channels = response.Select(ParseChannel).ToArray();
+
+            return channels;
+        }
+
+        public async Task<IReadOnlyList<Role>> GetGuildRolesAsync(AuthToken token, string guildId)
+        {
+            // Special case for direct messages pseudo-guild
+            if (guildId == Guild.DirectMessages.Id)
+                return Array.Empty<Role>();
+
+            var response = await GetApiResponseAsync(token, $"guilds/{guildId}/roles");
+            var roles = response.Select(ParseRole).ToArray();
+
+            return roles;
+        }
+
+        private async Task<Message> GetLastMessageAsync(AuthToken token, string channelId, DateTimeOffset? before = null)
+        {
+            var route = $"channels/{channelId}/messages?limit=1";
+            if (before != null)
+                route += $"&before={before.Value.ToSnowflake()}";
+
+            var response = await GetApiResponseAsync(token, route);
+
+            return response.Select(ParseMessage).FirstOrDefault();
+        }
+
+        public async IAsyncEnumerable<Message> GetMessagesAsync(AuthToken token, string channelId,
+            DateTimeOffset? after = null, DateTimeOffset? before = null, IProgress<double>? progress = null)
+        {
+            // Get the last message
+            var lastMessage = await GetLastMessageAsync(token, channelId, before);
+
+            // If the last message doesn't exist or it's outside of range - return
+            if (lastMessage == null || lastMessage.Timestamp < after)
+            {
+                progress?.Report(1);
+                yield break;
+            }
+
+            // Get other messages
+            var firstMessage = default(Message);
+            var afterId = after?.ToSnowflake() ?? "0";
+            while (true)
+            {
+                // Get message batch
+                var route = $"channels/{channelId}/messages?limit=100&after={afterId}";
+                var response = await GetApiResponseAsync(token, route);
+
+                // Parse
+                var messages = response
+                    .Select(ParseMessage)
+                    .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())
+                    break;
+
+                // Trim messages to range (until last message)
+                var messagesInRange = messages
+                    .TakeWhile(m => m.Id != lastMessage.Id && m.Timestamp < lastMessage.Timestamp)
+                    .ToArray();
+
+                // Yield messages
+                foreach (var message in messagesInRange)
+                {
+                    // Set first message if it's not set
+                    firstMessage ??= message;
+
+                    // Report progress (based on the time range of parsed messages compared to total)
+                    progress?.Report((message.Timestamp - firstMessage.Timestamp).TotalSeconds /
+                                     (lastMessage.Timestamp - firstMessage.Timestamp).TotalSeconds);
+
+                    yield return message;
+                    afterId = message.Id;
+                }
+
+                // Break if messages were trimmed (which means the last message was encountered)
+                if (messagesInRange.Length != messages.Length)
+                    break;
+            }
+
+            // Yield last message
+            yield return lastMessage;
+            progress?.Report(1);
+        }
+
+        public void Dispose() => _httpClient.Dispose();
+    }
+}

DiscordChatExporter.Core.Services/DiscordChatExporter.Core.Services.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../DiscordChatExporter.props" />
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Onova" Version="2.5.1" />
+    <PackageReference Include="Polly" Version="7.2.0" />
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.5" />
+    <PackageReference Include="Tyrrrz.Settings" Version="1.3.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DiscordChatExporter.Core.Models\DiscordChatExporter.Core.Models.csproj" />
+    <ProjectReference Include="..\DiscordChatExporter.Core.Rendering\DiscordChatExporter.Core.Rendering.csproj" />
+  </ItemGroup>
+
+</Project>

DiscordChatExporter.Core.Services/Exceptions/HttpErrorStatusCodeException.cs

@@ -1,15 +1,19 @@
 using System;
 using System.Net;
 
-namespace DiscordChatExporter.Core.Exceptions
+namespace DiscordChatExporter.Core.Services.Exceptions
 {
     public class HttpErrorStatusCodeException : Exception
     {
         public HttpStatusCode StatusCode { get; }
 
-        public HttpErrorStatusCodeException(HttpStatusCode statusCode)
+        public string ReasonPhrase { get; }
+
+        public HttpErrorStatusCodeException(HttpStatusCode statusCode, string reasonPhrase)
+            : base($"Error HTTP status code: {statusCode} - {reasonPhrase}")
         {
             StatusCode = statusCode;
+            ReasonPhrase = reasonPhrase;
         }
     }
 }

DiscordChatExporter.Core.Services/ExportService.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Rendering;
+using DiscordChatExporter.Core.Services.Logic;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public class ExportService
+    {
+        private readonly SettingsService _settingsService;
+        private readonly DataService _dataService;
+
+        public ExportService(SettingsService settingsService, DataService dataService)
+        {
+            _settingsService = settingsService;
+            _dataService = dataService;
+        }
+
+        private string GetFilePathFromOutputPath(string outputPath, ExportFormat format, RenderContext context)
+        {
+            // Output is a directory
+            if (Directory.Exists(outputPath) || string.IsNullOrWhiteSpace(Path.GetExtension(outputPath)))
+            {
+                var fileName = ExportLogic.GetDefaultExportFileName(format, context.Guild, context.Channel, context.After, context.Before);
+                return Path.Combine(outputPath, fileName);
+            }
+
+            // Output is a file
+            return outputPath;
+        }
+
+        private IMessageRenderer CreateRenderer(string outputPath, int partitionIndex, ExportFormat format, RenderContext context)
+        {
+            var filePath = ExportLogic.GetExportPartitionFilePath(
+                GetFilePathFromOutputPath(outputPath, format, context),
+                partitionIndex);
+
+            // Create output directory
+            var dirPath = Path.GetDirectoryName(filePath);
+            if (!string.IsNullOrWhiteSpace(dirPath))
+                Directory.CreateDirectory(dirPath);
+
+            // Create renderer
+
+            if (format == ExportFormat.PlainText)
+                return new PlainTextMessageRenderer(filePath, context);
+
+            if (format == ExportFormat.Csv)
+                return new CsvMessageRenderer(filePath, context);
+
+            if (format == ExportFormat.HtmlDark)
+                return new HtmlMessageRenderer(filePath, context, "Dark");
+
+            if (format == ExportFormat.HtmlLight)
+                return new HtmlMessageRenderer(filePath, context, "Light");
+
+            throw new InvalidOperationException($"Unknown export format [{format}].");
+        }
+
+        public async Task ExportChatLogAsync(AuthToken token, Guild guild, Channel channel,
+            string outputPath, ExportFormat format, int? partitionLimit,
+            DateTimeOffset? after = null, DateTimeOffset? before = null, IProgress<double>? progress = null)
+        {
+            // Create context
+            var mentionableUsers = new HashSet<User>(IdBasedEqualityComparer.Instance);
+            var mentionableChannels = await _dataService.GetGuildChannelsAsync(token, guild.Id);
+            var mentionableRoles = await _dataService.GetGuildRolesAsync(token, guild.Id);
+
+            var context = new RenderContext
+            (
+                guild, channel, after, before, _settingsService.DateFormat,
+                mentionableUsers, mentionableChannels, mentionableRoles
+            );
+
+            // Render messages
+            var partitionIndex = 0;
+            var partitionMessageCount = 0;
+            var renderer = CreateRenderer(outputPath, partitionIndex, format, context);
+
+            await foreach (var message in _dataService.GetMessagesAsync(token, channel.Id, after, before, progress))
+            {
+                // Add encountered users to the list of mentionable users
+                mentionableUsers.Add(message.Author);
+                mentionableUsers.AddRange(message.MentionedUsers);
+
+                // If new partition is required, reset renderer
+                if (partitionLimit != null && partitionLimit > 0 && partitionMessageCount >= partitionLimit)
+                {
+                    partitionIndex++;
+                    partitionMessageCount = 0;
+
+                    // Flush old renderer and create a new one
+                    await renderer.DisposeAsync();
+                    renderer = CreateRenderer(outputPath, partitionIndex, format, context);
+                }
+
+                // Render message
+                await renderer.RenderMessageAsync(message);
+                partitionMessageCount++;
+            }
+
+            // Flush last renderer
+            await renderer.DisposeAsync();
+        }
+    }
+}

DiscordChatExporter.Core.Services/Extensions.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public static class Extensions
+    {
+        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();
+    }
+}

DiscordChatExporter.Core.Services/Internal/Extensions.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Drawing;
+
+namespace DiscordChatExporter.Core.Services.Internal
+{
+    internal static class Extensions
+    {
+        public static DateTimeOffset ToDateTimeOffset(this DateTime dateTime) => new DateTimeOffset(dateTime);
+
+        public static string ToSnowflake(this DateTimeOffset dateTime)
+        {
+            var value = ((ulong) dateTime.ToUnixTimeMilliseconds() - 1420070400000UL) << 22;
+            return value.ToString();
+        }
+
+        public static Color ResetAlpha(this Color color) => Color.FromArgb(1, color);
+    }
+}

DiscordChatExporter.Core.Services/Logic/ExportLogic.cs

@@ -0,0 +1,72 @@
+using System;
+using System.IO;
+using System.Text;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Core.Services.Logic
+{
+    public static class ExportLogic
+    {
+        public static string GetDefaultExportFileName(ExportFormat format,
+            Guild guild, Channel channel,
+            DateTimeOffset? after = null, DateTimeOffset? before = null)
+        {
+            var buffer = new StringBuilder();
+
+            // Append guild and channel names
+            buffer.Append($"{guild.Name} - {channel.Name} [{channel.Id}]");
+
+            // Append date range
+            if (after != null || before != null)
+            {
+                buffer.Append(" (");
+
+                // Both 'after' and 'before' are set
+                if (after != null && before != null)
+                {
+                    buffer.Append($"{after:yyyy-MM-dd} to {before:yyyy-MM-dd}");
+                }
+                // Only 'after' is set
+                else if (after != null)
+                {
+                    buffer.Append($"after {after:yyyy-MM-dd}");
+                }
+                // Only 'before' is set
+                else
+                {
+                    buffer.Append($"before {before:yyyy-MM-dd}");
+                }
+
+                buffer.Append(")");
+            }
+
+            // Append extension
+            buffer.Append($".{format.GetFileExtension()}");
+
+            // Replace invalid chars
+            foreach (var invalidChar in Path.GetInvalidFileNameChars())
+                buffer.Replace(invalidChar, '_');
+
+            return buffer.ToString();
+        }
+
+        public static string GetExportPartitionFilePath(string baseFilePath, int partitionIndex)
+        {
+            // First partition - no changes
+            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}";
+
+            // Generate new path
+            var dirPath = Path.GetDirectoryName(baseFilePath);
+            if (!string.IsNullOrWhiteSpace(dirPath))
+                return Path.Combine(dirPath, fileName);
+
+            return fileName;
+        }
+    }
+}

DiscordChatExporter.Core.Services/SettingsService.cs

@@ -3,16 +3,18 @@ using Tyrrrz.Settings;
 
 namespace DiscordChatExporter.Core.Services
 {
-    public class SettingsService : SettingsManager, ISettingsService
+    public class SettingsService : SettingsManager
     {
         public bool IsAutoUpdateEnabled { get; set; } = true;
 
         public string DateFormat { get; set; } = "dd-MMM-yy hh:mm tt";
-        public int MessageGroupLimit { get; set; } = 20;
 
-        public string LastToken { get; set; }
+        public AuthToken? LastToken { get; set; }
+
         public ExportFormat LastExportFormat { get; set; } = ExportFormat.HtmlDark;
 
+        public int? LastPartitionLimit { get; set; }
+
         public SettingsService()
         {
             Configuration.StorageSpace = StorageSpace.Instance;

DiscordChatExporter.Core/DiscordChatExporter.Core.csproj

@@ -1,24 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net461</TargetFramework>
-        <Version>2.4</Version>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <EmbeddedResource Include="Resources\ExportService\DarkTheme.css" />
-        <EmbeddedResource Include="Resources\ExportService\LightTheme.css" />
-    </ItemGroup>
-
-    <ItemGroup>
-        <Reference Include="System.Net.Http" />
-    </ItemGroup>
-
-    <ItemGroup>
-        <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
-        <PackageReference Include="Onova" Version="2.1.0" />
-        <PackageReference Include="Tyrrrz.Extensions" Version="1.5.0" />
-        <PackageReference Include="Tyrrrz.Settings" Version="1.3.2" />
-    </ItemGroup>
-
-</Project>

DiscordChatExporter.Core/Internal/Extensions.cs

@@ -1,22 +0,0 @@
-using System.IO;
-using System.Reflection;
-using System.Resources;
-
-namespace DiscordChatExporter.Core.Internal
-{
-    internal static class Extensions
-    {
-        public static string GetManifestResourceString(this Assembly assembly, string resourceName)
-        {
-            var stream = assembly.GetManifestResourceStream(resourceName);
-            if (stream == null)
-                throw new MissingManifestResourceException($"Could not find resource [{resourceName}].");
-
-            using (stream)
-            using (var reader = new StreamReader(stream))
-            {
-                return reader.ReadToEnd();
-            }
-        }
-    }
-}

DiscordChatExporter.Core/Models/Attachment.cs

@@ -1,24 +0,0 @@
-namespace DiscordChatExporter.Core.Models
-{
-    public class Attachment
-    {
-        public string Id { get; }
-
-        public AttachmentType Type { get; }
-
-        public string Url { get; }
-
-        public string FileName { get; }
-
-        public long FileSize { get; }
-
-        public Attachment(string id, AttachmentType type, string url, string fileName, long fileSize)
-        {
-            Id = id;
-            Type = type;
-            Url = url;
-            FileName = fileName;
-            FileSize = fileSize;
-        }
-    }
-}

DiscordChatExporter.Core/Models/Channel.cs

@@ -1,37 +0,0 @@
-namespace DiscordChatExporter.Core.Models
-{
-    public partial class Channel
-    {
-        public string Id { get; }
-
-        public string GuildId { get; }
-
-        public string Name { get; }
-
-        public string Topic { get; }
-
-        public ChannelType Type { get; }
-
-        public Channel(string id, string guildId, string name, string topic, ChannelType type)
-        {
-            Id = id;
-            GuildId = guildId;
-            Name = name;
-            Topic = topic;
-            Type = type;
-        }
-
-        public override string ToString()
-        {
-            return Name;
-        }
-    }
-
-    public partial class Channel
-    {
-        public static Channel CreateDeletedChannel(string id)
-        {
-            return new Channel(id, null, "deleted-channel", null, ChannelType.GuildTextChat);
-        }
-    }
-}

DiscordChatExporter.Core/Models/ChannelChatLog.cs

@@ -1,24 +0,0 @@
-using System.Collections.Generic;
-
-namespace DiscordChatExporter.Core.Models
-{
-    public class ChannelChatLog
-    {
-        public Guild Guild { get; }
-
-        public Channel Channel { get; }
-
-        public IReadOnlyList<MessageGroup> MessageGroups { get; }
-
-        public int TotalMessageCount { get; }
-
-        public ChannelChatLog(Guild guild, Channel channel, IReadOnlyList<MessageGroup> messageGroups,
-            int totalMessageCount)
-        {
-            Guild = guild;
-            Channel = channel;
-            MessageGroups = messageGroups;
-            TotalMessageCount = totalMessageCount;
-        }
-    }
-}

DiscordChatExporter.Core/Models/ChannelType.cs

@@ -1,11 +0,0 @@
-namespace DiscordChatExporter.Core.Models
-{
-    public enum ChannelType
-    {
-        GuildTextChat,
-        DirectTextChat,
-        GuildVoiceChat,
-        DirectGroupTextChat,
-        Category
-    }
-}

DiscordChatExporter.Core/Models/Extensions.cs

@@ -1,31 +0,0 @@
-using System;
-
-namespace DiscordChatExporter.Core.Models
-{
-    public static class Extensions
-    {
-        public static string GetFileExtension(this ExportFormat format)
-        {
-            if (format == ExportFormat.PlainText)
-                return "txt";
-            if (format == ExportFormat.HtmlDark)
-                return "html";
-            if (format == ExportFormat.HtmlLight)
-                return "html";
-
-            throw new ArgumentOutOfRangeException(nameof(format));
-        }
-
-        public static string GetDisplayName(this ExportFormat format)
-        {
-            if (format == ExportFormat.PlainText)
-                return "Plain Text";
-            if (format == ExportFormat.HtmlDark)
-                return "HTML (Dark)";
-            if (format == ExportFormat.HtmlLight)
-                return "HTML (Light)";
-
-            throw new ArgumentOutOfRangeException(nameof(format));
-        }
-    }
-}

DiscordChatExporter.Core/Models/Guild.cs

@@ -1,38 +0,0 @@
-using System.Collections.Generic;
-using Tyrrrz.Extensions;
-
-namespace DiscordChatExporter.Core.Models
-{
-    public partial class Guild
-    {
-        public string Id { get; }
-
-        public string Name { get; }
-
-        public string IconHash { get; }
-
-        public string IconUrl => IconHash.IsNotBlank()
-            ? $"https://cdn.discordapp.com/icons/{Id}/{IconHash}.png"
-            : "https://cdn.discordapp.com/embed/avatars/0.png";
-
-        public IReadOnlyList<Role> Roles { get; }
-
-        public Guild(string id, string name, string iconHash, IReadOnlyList<Role> roles)
-        {
-            Id = id;
-            Name = name;
-            IconHash = iconHash;
-            Roles = roles;
-        }
-
-        public override string ToString()
-        {
-            return Name;
-        }
-    }
-
-    public partial class Guild
-    {
-        public static Guild DirectMessages { get; } = new Guild("@me", "Direct Messages", null, new Role[0]);
-    }
-}