Update version

Closes #154

.gitignore

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

Changelog.md

@@ -0,0 +1,117 @@
+### 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.
+- Added a command line interface alternative to the current graphical user interface.
+- Implemented application auto-update (can be disabled in settings).
+- Improved some GUI elements and replaced some dialogs with notifications.
+- Fixed a lot of issues with the markdown processor.
+- Fixed DM group chats that have a custom name being shown as blank in the list.
+
+### v2.3 (27-Oct-2017)
+
+- Improved message date filtering, it's now marginally faster.
+- Fixed underscores not recognized as italics in markdown.
+- Added support for custom emojis.
+- Added support for user and role mentions.
+- Added support for channel mentions.
+- Fixed text in pre blocks not being wrapped correctly.
+- Added workaround for non-default message types.

Deploy/Choco/discordchatexporter.nuspec

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2015/06/nuspec.xsd">
+  <metadata>
+    <id>discordchatexporter</id>
+    <title>DiscordChatExporter</title>
+    <version>2.12</version>
+    <owners>Tyrrrz</owners>
+    <authors>Tyrrrz</authors>
+    <copyright>Copyright (C) Alexey Golub</copyright>
+    <summary>Exports Discord chat logs to a file</summary>
+    <description>DiscordChatExporter can be used to export message history from a Discord channel to a file. It works for both direct message chats and guild chats, supports markdown, message grouping, and attachments. The tool also lets you select from/to dates to limit the exported messages. There are options to configure the output, such as date format, color theme, message grouping limit, etc.</description>
+    <tags>discordchatexporter discord export chat logs archive gui</tags>
+    <projectSourceUrl>https://github.com/Tyrrrz/DiscordChatExporter</projectSourceUrl>
+    <packageSourceUrl>https://github.com/Tyrrrz/DiscordChatExporter</packageSourceUrl>
+    <projectUrl>http://tyrrrz.me/Projects/DiscordChatExporter</projectUrl>
+    <releaseNotes>https://github.com/Tyrrrz/DiscordChatExporter/blob/master/Changelog.md</releaseNotes>
+    <iconUrl>https://raw.githubusercontent.com/Tyrrrz/DiscordChatExporter/master/favicon.png</iconUrl>
+    <licenseUrl>https://raw.githubusercontent.com/Tyrrrz/DiscordChatExporter/master/License.txt</licenseUrl>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <bugTrackerUrl>https://github.com/Tyrrrz/DiscordChatExporter/issues</bugTrackerUrl>
+  </metadata>
+  <files>
+    <file src="tools\**" target="tools" />
+  </files>
+</package>

Deploy/Choco/tools/chocolateyinstall.ps1

@@ -0,0 +1,24 @@
+$ErrorActionPreference = 'Stop'
+$packageName = $env:ChocolateyPackageName
+$installDirPath = "$(Split-Path -parent $MyInvocation.MyCommand.Definition)"
+
+# Install package (GUI)
+
+$packageArgs = @{
+    packageName   = $packageName
+    unzipLocation = $installDirPath
+    url           = 'https://github.com/Tyrrrz/DiscordChatExporter/releases/download/2.12/DiscordChatExporter.zip'
+}
+Install-ChocolateyZipPackage @packageArgs
+
+# Mark the executable as GUI
+New-Item (Join-Path $installDirPath "DiscordChatExporter.exe.gui") -ItemType File -Force
+
+# Install package (CLI)
+
+$packageArgs = @{
+    packageName   = $packageName
+    unzipLocation = $installDirPath
+    url           = 'https://github.com/Tyrrrz/DiscordChatExporter/releases/download/2.12/DiscordChatExporter.CLI.zip'
+}
+Install-ChocolateyZipPackage @packageArgs

Deploy/Prepare.ps1

@@ -0,0 +1,27 @@
+# --- PORTABLE / GUI ---
+
+# Get files
+$files = @()
+$files += Get-Item -Path "$PSScriptRoot\..\License.txt"
+$files += Get-ChildItem -Path "$PSScriptRoot\..\DiscordChatExporter.Gui\bin\Release\*" -Include "*.exe", "*.dll", "*.config"
+
+# Pack into archive
+New-Item "$PSScriptRoot\Portable\GUI\bin" -ItemType Directory -Force
+$files | Compress-Archive -DestinationPath "$PSScriptRoot\Portable\GUI\bin\DiscordChatExporter.zip" -Force
+
+# --- PORTABLE / CLI ---
+
+# Get files
+$files = @()
+$files += Get-Item -Path "$PSScriptRoot\..\License.txt"
+$files += Get-ChildItem -Path "$PSScriptRoot\..\DiscordChatExporter.Cli\bin\Release\net46\*" -Include "*.exe", "*.dll", "*.config"
+
+# Pack into archive
+New-Item "$PSScriptRoot\Portable\CLI\bin" -ItemType Directory -Force
+$files | Compress-Archive -DestinationPath "$PSScriptRoot\Portable\CLI\bin\DiscordChatExporter.CLI.zip" -Force
+
+# --- CHOCOLATEY ---
+
+# Create package
+New-Item "$PSScriptRoot\Choco\bin\" -ItemType Directory -Force
+choco pack $PSScriptRoot\Choco\discordchatexporter.nuspec --out $PSScriptRoot\Choco\bin\

DiscordChatExporter.Cli/Container.cs

@@ -0,0 +1,24 @@
+using DiscordChatExporter.Core.Services;
+using StyletIoC;
+
+namespace DiscordChatExporter.Cli
+{
+    public static class Container
+    {
+        public static IContainer Instance { get; }
+
+        static Container()
+        {
+            var builder = new StyletIoCBuilder();
+
+            // Autobind the .Services assembly
+            builder.Autobind(typeof(DataService).Assembly);
+
+            // Bind settings as singleton
+            builder.Bind<SettingsService>().ToSelf().InSingletonScope();
+
+            // Set instance
+            Instance = builder.BuildContainer();
+        }
+    }
+}

DiscordChatExporter.Cli/DiscordChatExporter.Cli.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net46;netcoreapp2.1</TargetFrameworks>
+    <Version>2.12</Version>
+    <Company>Tyrrrz</Company>
+    <Copyright>Copyright (c) Alexey Golub</Copyright>
+    <ApplicationIcon>..\favicon.ico</ApplicationIcon>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommandLineParser" Version="2.3.0" />
+    <PackageReference Include="Stylet" Version="1.1.22" />
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DiscordChatExporter.Core.Models\DiscordChatExporter.Core.Models.csproj" />
+    <ProjectReference Include="..\DiscordChatExporter.Core.Services\DiscordChatExporter.Core.Services.csproj" />
+  </ItemGroup>
+
+</Project>

DiscordChatExporter.Cli/Internal/InlineProgress.cs

@@ -0,0 +1,47 @@
+using System;
+
+namespace DiscordChatExporter.Cli.Internal
+{
+    internal class InlineProgress : IProgress<double>, IDisposable
+    {
+        private readonly int _posX;
+        private readonly int _posY;
+
+        private bool _isCompleted;
+
+        public InlineProgress()
+        {
+            // If output is not redirected - save initial cursor position
+            if (!Console.IsOutputRedirected)
+            {
+                _posX = Console.CursorLeft;
+                _posY = Console.CursorTop;
+            }
+        }
+
+        public void Report(double progress)
+        {
+            // If output is not redirected - reset cursor position and write progress
+            if (!Console.IsOutputRedirected)
+            {
+                Console.SetCursorPosition(_posX, _posY);
+                Console.WriteLine($"{progress:P1}");
+            }
+        }
+
+        public void ReportCompletion() => _isCompleted = true;
+
+        public void Dispose()
+        {
+            // If output is not redirected - reset cursor position
+            if (!Console.IsOutputRedirected)
+                Console.SetCursorPosition(_posX, _posY);
+
+            // Inform about completion
+            if (_isCompleted)
+                Console.WriteLine("Completed ✓");
+            else
+                Console.WriteLine("Failed X");
+        }
+    }
+}

DiscordChatExporter.Cli/Program.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Linq;
+using CommandLine;
+using DiscordChatExporter.Cli.Verbs;
+using DiscordChatExporter.Cli.Verbs.Options;
+
+namespace DiscordChatExporter.Cli
+{
+    public static class Program
+    {
+        private static void PrintTokenHelp()
+        {
+            Console.WriteLine("# To get user token:");
+            Console.WriteLine(" 1. Open Discord");
+            Console.WriteLine(" 2. Press Ctrl+Shift+I to show developer tools");
+            Console.WriteLine(" 3. Press Ctrl+R to reload");
+            Console.WriteLine(" 4. Navigate to the Application tab");
+            Console.WriteLine(" 5. Select \"Local Storage\" > \"https://discordapp.com\" on the left");
+            Console.WriteLine(" 6. Find \"token\" under key and copy the value");
+            Console.WriteLine();
+            Console.WriteLine("# To get bot token:");
+            Console.WriteLine(" 1. Go to Discord developer portal");
+            Console.WriteLine(" 2. Open your application's settings");
+            Console.WriteLine(" 3. Navigate to the Bot section on the left");
+            Console.WriteLine(" 4. Under Token click Copy");
+            Console.WriteLine();
+            Console.WriteLine("# To get guild or channel ID:");
+            Console.WriteLine(" 1. Open Discord");
+            Console.WriteLine(" 2. Open Settings");
+            Console.WriteLine(" 3. Go to Appearance section");
+            Console.WriteLine(" 4. Enable Developer Mode");
+            Console.WriteLine(" 5. Right click on the desired guild or channel and click Copy ID");
+        }
+
+        public static void Main(string[] args)
+        {
+            // Get all verb types
+            var verbTypes = new[]
+            {
+                typeof(ExportChannelOptions),
+                typeof(ExportDirectMessagesOptions),
+                typeof(ExportGuildOptions),
+                typeof(GetChannelsOptions),
+                typeof(GetDirectMessageChannelsOptions),
+                typeof(GetGuildsOptions)
+            };
+
+            // Parse command line arguments
+            var parsedArgs = Parser.Default.ParseArguments(args, verbTypes);
+
+            // Execute commands
+            parsedArgs.WithParsed<ExportChannelOptions>(o => new ExportChannelVerb(o).Execute());
+            parsedArgs.WithParsed<ExportDirectMessagesOptions>(o => new ExportDirectMessagesVerb(o).Execute());
+            parsedArgs.WithParsed<ExportGuildOptions>(o => new ExportGuildVerb(o).Execute());
+            parsedArgs.WithParsed<GetChannelsOptions>(o => new GetChannelsVerb(o).Execute());
+            parsedArgs.WithParsed<GetDirectMessageChannelsOptions>(o => new GetDirectMessageChannelsVerb(o).Execute());
+            parsedArgs.WithParsed<GetGuildsOptions>(o => new GetGuildsVerb(o).Execute());
+
+            // Show token help if help requested or no verb specified
+            parsedArgs.WithNotParsed(errs =>
+            {
+                var err = errs.First();
+
+                if (err.Tag == ErrorType.NoVerbSelectedError)
+                    PrintTokenHelp();
+
+                if (err.Tag == ErrorType.HelpVerbRequestedError && args.Length == 1)
+                    PrintTokenHelp();
+            });
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/ExportChannelVerb.cs

@@ -0,0 +1,58 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Internal;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Services;
+using DiscordChatExporter.Core.Services.Helpers;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class ExportChannelVerb : Verb<ExportChannelOptions>
+    {
+        public ExportChannelVerb(ExportChannelOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get services
+            var settingsService = Container.Instance.Get<SettingsService>();
+            var dataService = Container.Instance.Get<DataService>();
+            var exportService = Container.Instance.Get<ExportService>();
+
+            // Configure settings
+            if (!Options.DateFormat.EmptyIfNull().IsWhiteSpace())
+                settingsService.DateFormat = Options.DateFormat;
+
+            // Track progress
+            Console.Write($"Exporting channel [{Options.ChannelId}]... ");
+            using (var progress = new InlineProgress())
+            {
+                // Get chat log
+                var chatLog = await dataService.GetChatLogAsync(Options.GetToken(), Options.ChannelId,
+                    Options.After, Options.Before, progress);
+
+                // Generate file path if not set or is a directory
+                var filePath = Options.OutputPath;
+                if (filePath.EmptyIfNull().IsWhiteSpace() || ExportHelper.IsDirectoryPath(filePath))
+                {
+                    // Generate default file name
+                    var fileName = ExportHelper.GetDefaultExportFileName(Options.ExportFormat, chatLog.Guild,
+                        chatLog.Channel, Options.After, Options.Before);
+
+                    // Combine paths
+                    filePath = Path.Combine(filePath ?? "", fileName);
+                }
+
+                // Export
+                await exportService.ExportChatLogAsync(chatLog, filePath, Options.ExportFormat, Options.PartitionLimit);
+
+                // Report successful completion
+                progress.ReportCompletion();
+            }
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/ExportDirectMessagesVerb.cs

@@ -0,0 +1,78 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Internal;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Services;
+using DiscordChatExporter.Core.Services.Exceptions;
+using DiscordChatExporter.Core.Services.Helpers;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class ExportDirectMessagesVerb : Verb<ExportDirectMessagesOptions>
+    {
+        public ExportDirectMessagesVerb(ExportDirectMessagesOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get services
+            var settingsService = Container.Instance.Get<SettingsService>();
+            var dataService = Container.Instance.Get<DataService>();
+            var exportService = Container.Instance.Get<ExportService>();
+
+            // Configure settings
+            if (!Options.DateFormat.EmptyIfNull().IsWhiteSpace())
+                settingsService.DateFormat = Options.DateFormat;
+
+            // Get channels
+            var channels = await dataService.GetDirectMessageChannelsAsync(Options.GetToken());
+
+            // Order channels
+            channels = channels.OrderBy(c => c.Name).ToArray();
+
+            // Loop through channels
+            foreach (var channel in channels)
+            {
+                try
+                {
+                    // Track progress
+                    Console.Write($"Exporting channel [{channel.Name}]... ");
+                    using (var progress = new InlineProgress())
+                    {
+                        // Get chat log
+                        var chatLog = await dataService.GetChatLogAsync(Options.GetToken(), channel,
+                            Options.After, Options.Before, progress);
+
+                        // Generate default file name
+                        var fileName = ExportHelper.GetDefaultExportFileName(Options.ExportFormat, chatLog.Guild,
+                            chatLog.Channel, Options.After, Options.Before);
+
+                        // Generate file path
+                        var filePath = Path.Combine(Options.OutputPath ?? "", fileName);
+
+                        // Export
+                        await exportService.ExportChatLogAsync(chatLog, filePath, Options.ExportFormat,
+                            Options.PartitionLimit);
+
+                        // Report successful completion
+                        progress.ReportCompletion();
+                    }
+                }
+                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/Verbs/ExportGuildVerb.cs

@@ -0,0 +1,79 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Internal;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+using DiscordChatExporter.Core.Services.Exceptions;
+using DiscordChatExporter.Core.Services.Helpers;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class ExportGuildVerb : Verb<ExportGuildOptions>
+    {
+        public ExportGuildVerb(ExportGuildOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get services
+            var settingsService = Container.Instance.Get<SettingsService>();
+            var dataService = Container.Instance.Get<DataService>();
+            var exportService = Container.Instance.Get<ExportService>();
+
+            // Configure settings
+            if (!Options.DateFormat.EmptyIfNull().IsWhiteSpace())
+                settingsService.DateFormat = Options.DateFormat;
+
+            // Get channels
+            var channels = await dataService.GetGuildChannelsAsync(Options.GetToken(), Options.GuildId);
+
+            // Filter and order channels
+            channels = channels.Where(c => c.Type == ChannelType.GuildTextChat).OrderBy(c => c.Name).ToArray();
+
+            // Loop through channels
+            foreach (var channel in channels)
+            {
+                try
+                {
+                    // Track progress
+                    Console.Write($"Exporting channel [{channel.Name}]... ");
+                    using (var progress = new InlineProgress())
+                    {
+                        // Get chat log
+                        var chatLog = await dataService.GetChatLogAsync(Options.GetToken(), channel,
+                            Options.After, Options.Before, progress);
+
+                        // Generate default file name
+                        var fileName = ExportHelper.GetDefaultExportFileName(Options.ExportFormat, chatLog.Guild,
+                            chatLog.Channel, Options.After, Options.Before);
+
+                        // Generate file path
+                        var filePath = Path.Combine(Options.OutputPath ?? "", fileName);
+
+                        // Export
+                        await exportService.ExportChatLogAsync(chatLog, filePath, Options.ExportFormat,
+                            Options.PartitionLimit);
+
+                        // Report successful completion
+                        progress.ReportCompletion();
+                    }
+                }
+                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/Verbs/GetChannelsVerb.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class GetChannelsVerb : Verb<GetChannelsOptions>
+    {
+        public GetChannelsVerb(GetChannelsOptions options)
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get data service
+            var dataService = Container.Instance.Get<DataService>();
+
+            // Get channels
+            var channels = await dataService.GetGuildChannelsAsync(Options.GetToken(), Options.GuildId);
+
+            // Filter and order channels
+            channels = channels.Where(c => c.Type == ChannelType.GuildTextChat).OrderBy(c => c.Name).ToArray();
+
+            // Print result
+            foreach (var channel in channels)
+                Console.WriteLine($"{channel.Id} | {channel.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/GetDirectMessageChannelsVerb.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class GetDirectMessageChannelsVerb : Verb<GetDirectMessageChannelsOptions>
+    {
+        public GetDirectMessageChannelsVerb(GetDirectMessageChannelsOptions options) 
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get data service
+            var dataService = Container.Instance.Get<DataService>();
+
+            // Get channels
+            var channels = await dataService.GetDirectMessageChannelsAsync(Options.GetToken());
+
+            // Order channels
+            channels = channels.OrderBy(c => c.Name).ToArray();
+
+            // Print result
+            foreach (var channel in channels)
+                Console.WriteLine($"{channel.Id} | {channel.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/GetGuildsVerb.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Cli.Verbs.Options;
+using DiscordChatExporter.Core.Services;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public class GetGuildsVerb : Verb<GetGuildsOptions>
+    {
+        public GetGuildsVerb(GetGuildsOptions options) 
+            : base(options)
+        {
+        }
+
+        public override async Task ExecuteAsync()
+        {
+            // Get data service
+            var dataService = Container.Instance.Get<DataService>();
+
+            // Get guilds
+            var guilds = await dataService.GetUserGuildsAsync(Options.GetToken());
+
+            // Order guilds
+            guilds = guilds.OrderBy(g => g.Name).ToArray();
+
+            // Print result
+            foreach (var guild in guilds)
+                Console.WriteLine($"{guild.Id} | {guild.Name}");
+        }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportChannelOptions.cs

@@ -0,0 +1,11 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("export", HelpText = "Export channel.")]
+    public class ExportChannelOptions : ExportOptions
+    {
+        [Option('c', "channel", Required = true, HelpText = "Channel ID.")]
+        public string ChannelId { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportDirectMessagesOptions.cs

@@ -0,0 +1,9 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("exportdm", HelpText = "Export all direct message channels.")]
+    public class ExportDirectMessagesOptions : ExportOptions
+    {
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportGuildOptions.cs

@@ -0,0 +1,11 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("exportguild", HelpText = "Export all channels within a given guild.")]
+    public class ExportGuildOptions : ExportOptions
+    {
+        [Option('g', "guild", Required = true, HelpText = "Guild ID.")]
+        public string GuildId { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/ExportOptions.cs

@@ -0,0 +1,29 @@
+using System;
+using CommandLine;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    public abstract class ExportOptions : TokenOptions
+    {
+        [Option('f', "format", Default = ExportFormat.HtmlDark, HelpText = "Output file format.")]
+        public ExportFormat ExportFormat { get; set; }
+
+        [Option('o', "output", Default = null, HelpText = "Output file or directory path.")]
+        public string OutputPath { get; set; }
+
+        // HACK: CommandLineParser doesn't support DateTimeOffset
+        [Option("after", Default = null, HelpText = "Limit to messages sent after this date.")]
+        public DateTime? After { get; set; }
+
+        // HACK: CommandLineParser doesn't support DateTimeOffset
+        [Option("before", Default = null, HelpText = "Limit to messages sent before this date.")]
+        public DateTime? Before { get; set; }
+
+        [Option('p', "partition", Default = null, HelpText = "Split output into partitions limited to this number of messages.")]
+        public int? PartitionLimit { get; set; }
+
+        [Option("dateformat", Default = null, HelpText = "Date format used in output.")]
+        public string DateFormat { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/GetChannelsOptions.cs

@@ -0,0 +1,11 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("channels", HelpText = "Get the list of channels in the given guild.")]
+    public class GetChannelsOptions : TokenOptions
+    {
+        [Option('g', "guild", Required = true, HelpText = "Guild ID.")]
+        public string GuildId { get; set; }
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/GetDirectMessageChannelsOptions.cs

@@ -0,0 +1,9 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("dm", HelpText = "Get the list of direct message channels.")]
+    public class GetDirectMessageChannelsOptions : TokenOptions
+    {
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/GetGuildsOptions.cs

@@ -0,0 +1,9 @@
+using CommandLine;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    [Verb("guilds", HelpText = "Get the list of accessible guilds.")]
+    public class GetGuildsOptions : TokenOptions
+    {
+    }
+}

DiscordChatExporter.Cli/Verbs/Options/TokenOptions.cs

@@ -0,0 +1,16 @@
+using CommandLine;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Cli.Verbs.Options
+{
+    public abstract class TokenOptions
+    {
+        [Option('t', "token", Required = true, HelpText = "Authorization token.")]
+        public string TokenValue { get; set; }
+
+        [Option('b', "bot", Default = false, HelpText = "Whether this authorization token belongs to a bot.")]
+        public bool IsBotToken { get; set; }
+
+        public AuthToken GetToken() => new AuthToken(IsBotToken ? AuthTokenType.Bot : AuthTokenType.User, TokenValue);
+    }
+}

DiscordChatExporter.Cli/Verbs/Verb.cs

@@ -0,0 +1,18 @@
+using System.Threading.Tasks;
+
+namespace DiscordChatExporter.Cli.Verbs
+{
+    public abstract class Verb<TOptions>
+    {
+        protected TOptions Options { get; }
+
+        protected Verb(TOptions options)
+        {
+            Options = options;
+        }
+
+        public abstract Task ExecuteAsync();
+
+        public virtual void Execute() => ExecuteAsync().GetAwaiter().GetResult();
+    }
+}

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

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net46;netstandard2.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.0" />
+  </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(string input, int startIndex, int length)
+        {
+            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(input, startIndex, length);
+
+                // If there's no match - continue
+                if (match == null)
+                    continue;
+
+                // If this match is earlier than previous earliest - replace
+                if (earliestMatch == null || match.StartIndex < earliestMatch.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.StartIndex == startIndex)
+                    break;
+            }
+
+            return earliestMatch;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/Extensions.cs

@@ -0,0 +1,50 @@
+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, string input,
+            int startIndex, int length, Func<string, T> fallbackTransform)
+        {
+            // Get end index for simplicity
+            var endIndex = startIndex + length;
+
+            // Loop through segments divided by individual matches
+            var currentIndex = startIndex;
+            while (currentIndex < endIndex)
+            {
+                // Find a match within this segment
+                var match = matcher.Match(input, currentIndex, 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.StartIndex > currentIndex)
+                {
+                    var fallback = input.Substring(currentIndex, match.StartIndex - currentIndex);
+                    yield return new ParsedMatch<T>(currentIndex, fallback.Length, fallbackTransform(fallback));
+                }
+
+                // Yield match
+                yield return match;
+
+                // Shift current index to the end of the match
+                currentIndex = match.StartIndex + match.Length;
+            }
+
+            // If EOL wasn't reached - transform and yield remaining part as fallback
+            if (currentIndex < endIndex)
+            {
+                var fallback = input.Substring(currentIndex);
+                yield return new ParsedMatch<T>(currentIndex, fallback.Length, fallbackTransform(fallback));
+            }
+        }
+
+        public static IEnumerable<ParsedMatch<T>> MatchAll<T>(this IMatcher<T> matcher, string input,
+            Func<string, T> fallbackTransform) => matcher.MatchAll(input, 0, input.Length, fallbackTransform);
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/IMatcher.cs

@@ -0,0 +1,7 @@
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    internal interface IMatcher<T>
+    {
+        ParsedMatch<T> Match(string input, int startIndex, int length);
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/ParsedMatch.cs

@@ -0,0 +1,18 @@
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    internal partial class ParsedMatch<T>
+    {
+        public int StartIndex { get; }
+
+        public int Length { get; }
+
+        public T Value { get; }
+
+        public ParsedMatch(int startIndex, int length, T value)
+        {
+            StartIndex = startIndex;
+            Length = length;
+            Value = value;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/RegexMatcher.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    internal class RegexMatcher<T> : IMatcher<T>
+    {
+        private readonly Regex _regex;
+        private readonly Func<Match, T> _transform;
+
+        public RegexMatcher(Regex regex, Func<Match, T> transform)
+        {
+            _regex = regex;
+            _transform = transform;
+        }
+
+        public ParsedMatch<T> Match(string input, int startIndex, int length)
+        {
+            var match = _regex.Match(input, startIndex, length);
+            return match.Success ? new ParsedMatch<T>(match.Index, match.Length, _transform(match)) : null;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Internal/StringMatcher.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace DiscordChatExporter.Core.Markdown.Internal
+{
+    internal class StringMatcher<T> : IMatcher<T>
+    {
+        private readonly string _needle;
+        private readonly StringComparison _comparison;
+        private readonly Func<string, T> _transform;
+
+        public StringMatcher(string needle, StringComparison comparison, Func<string, T> transform)
+        {
+            _needle = needle;
+            _comparison = comparison;
+            _transform = transform;
+        }
+
+        public StringMatcher(string needle, Func<string, T> transform)
+            : this(needle, StringComparison.Ordinal, transform)
+        {
+        }
+
+        public ParsedMatch<T> Match(string input, int startIndex, int length)
+        {
+            var index = input.IndexOf(_needle, startIndex, length, _comparison);
+            return index >= 0 ? new ParsedMatch<T>(index, _needle.Length, _transform(_needle)) : null;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/MarkdownParser.cs

@@ -0,0 +1,187 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using DiscordChatExporter.Core.Markdown.Internal;
+using DiscordChatExporter.Core.Markdown.Nodes;
+using Tyrrrz.Extensions;
+
+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;
+
+        /* 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),
+            m => new FormattedNode(m.Value, "**", TextFormatting.Bold, Parse(m.Groups[1].Value)));
+
+        // 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 preceeded by whitespace
+        private static readonly IMatcher<Node> ItalicFormattedNodeMatcher = new RegexMatcher<Node>(
+            new Regex("\\*(?!\\s)(.+?)(?<!\\s|\\*)\\*(?!\\*)", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new FormattedNode(m.Value, "*", TextFormatting.Italic, Parse(m.Groups[1].Value)));
+
+        // 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),
+            m => new FormattedNode(m.Value, "*", TextFormatting.Italic, Parse(m.Groups[1].Value, 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),
+            m => new FormattedNode(m.Value, "_", TextFormatting.Italic, Parse(m.Groups[1].Value)));
+
+        // 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),
+            m => new FormattedNode(m.Value, "__", TextFormatting.Underline, Parse(m.Groups[1].Value)));
+
+        // 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),
+            m => new FormattedNode(m.Value, "_", TextFormatting.Italic, Parse(m.Groups[1].Value, UnderlineFormattedNodeMatcher)));
+
+        // Capture any character until the earliest double tilde
+        private static readonly IMatcher<Node> StrikethroughFormattedNodeMatcher = new RegexMatcher<Node>(
+            new Regex("~~(.+?)~~", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new FormattedNode(m.Value, "~~", TextFormatting.Strikethrough, Parse(m.Groups[1].Value)));
+
+        // Capture any character until the earliest double pipe
+        private static readonly IMatcher<Node> SpoilerFormattedNodeMatcher = new RegexMatcher<Node>(
+            new Regex("\\|\\|(.+?)\\|\\|", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new FormattedNode(m.Value, "||", TextFormatting.Spoiler, Parse(m.Groups[1].Value)));
+
+        /* Code blocks */
+
+        // Capture any character except backtick until a backtick
+        // Whitespace surrounding content inside backticks is trimmed
+        private static readonly IMatcher<Node> InlineCodeBlockNodeMatcher = new RegexMatcher<Node>(
+            new Regex("`([^`]+)`", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new InlineCodeBlockNode(m.Value, m.Groups[1].Value.Trim()));
+
+        // Capture language identifier and then any character until the earliest triple backtick
+        // Languge identifier is one word immediately after opening backticks, followed immediately by newline
+        // Whitespace surrounding content inside backticks is trimmed
+        private static readonly IMatcher<Node> MultilineCodeBlockNodeMatcher = new RegexMatcher<Node>(
+            new Regex("```(?:(\\w*)\\n)?(.+?)```", DefaultRegexOptions | RegexOptions.Singleline),
+            m => new MultilineCodeBlockNode(m.Value, m.Groups[1].Value, m.Groups[2].Value.Trim()));
+
+        /* Mentions */
+
+        // Capture @everyone
+        private static readonly IMatcher<Node> EveryoneMentionNodeMatcher = new StringMatcher<Node>(
+            "@everyone",
+            s => new MentionNode(s, "everyone", MentionType.Meta));
+
+        // Capture @here
+        private static readonly IMatcher<Node> HereMentionNodeMatcher = new StringMatcher<Node>(
+            "@here",
+            s => new MentionNode(s, "here", MentionType.Meta));
+
+        // Capture <@123456> or <@!123456>
+        private static readonly IMatcher<Node> UserMentionNodeMatcher = new RegexMatcher<Node>(
+            new Regex("<@!?(\\d+)>", DefaultRegexOptions),
+            m => new MentionNode(m.Value, 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.Value, 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.Value, m.Groups[1].Value, MentionType.Role));
+
+        /* Emojis */
+
+        // Capture any country flag emoji (two regional indicator surrogate pairs)
+        // ... or "symbol/other" 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}|\\p{So}|\\p{Cs}{2}|\\d\\p{Me})", DefaultRegexOptions),
+            m => new EmojiNode(m.Value, 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.Value, m.Groups[3].Value, m.Groups[2].Value, !m.Groups[1].Value.IsEmpty()));
+
+        /* Links */
+
+        // Capture [title](link)
+        private static readonly IMatcher<Node> TitledLinkNodeMatcher = new RegexMatcher<Node>(
+            new Regex("\\[(.+?)\\]\\((.+?)\\)", DefaultRegexOptions),
+            m => new LinkNode(m.Value, 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.Value, 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.Value, 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>(
+            @"¯\_(ツ)_/¯",
+            s => new TextNode(s));
+
+        // Capture any "symbol/other" character or surrogate pair preceeded 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.Value, m.Groups[1].Value));
+
+        // Capture any non-whitespace, non latin alphanumeric character preceeded 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.Value, 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>(
+            ItalicBoldFormattedNodeMatcher,
+            ItalicUnderlineFormattedNodeMatcher,
+            BoldFormattedNodeMatcher,
+            ItalicFormattedNodeMatcher,
+            UnderlineFormattedNodeMatcher,
+            ItalicAltFormattedNodeMatcher,
+            StrikethroughFormattedNodeMatcher,
+            SpoilerFormattedNodeMatcher,
+            MultilineCodeBlockNodeMatcher,
+            InlineCodeBlockNodeMatcher,
+            EveryoneMentionNodeMatcher,
+            HereMentionNodeMatcher,
+            UserMentionNodeMatcher,
+            ChannelMentionNodeMatcher,
+            RoleMentionNodeMatcher,
+            StandardEmojiNodeMatcher,
+            CustomEmojiNodeMatcher,
+            TitledLinkNodeMatcher,
+            AutoLinkNodeMatcher,
+            HiddenLinkNodeMatcher,
+            ShrugTextNodeMatcher,
+            EscapedSymbolTextNodeMatcher,
+            EscapedCharacterTextNodeMatcher);
+
+        private static IReadOnlyList<Node> Parse(string input, IMatcher<Node> matcher) =>
+            matcher.MatchAll(input, s => new TextNode(s)).Select(r => r.Value).ToArray();
+
+        public static IReadOnlyList<Node> Parse(string input) => Parse(input, AggregateNodeMatcher);
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/EmojiNode.cs

@@ -0,0 +1,28 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class EmojiNode : Node
+    {
+        public string Id { get; }
+
+        public string Name { get; }
+
+        public bool IsAnimated { get; }
+
+        public bool IsCustomEmoji => Id != null;
+
+        public EmojiNode(string source, string id, string name, bool isAnimated)
+            : base(source)
+        {
+            Id = id;
+            Name = name;
+            IsAnimated = isAnimated;
+        }
+
+        public EmojiNode(string source, string name)
+            : this(source, null, name, false)
+        {
+        }
+
+        public override string ToString() => $"<Emoji> {Name}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/FormattedNode.cs

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

DiscordChatExporter.Core.Markdown/Nodes/InlineCodeBlockNode.cs

@@ -0,0 +1,15 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class InlineCodeBlockNode : Node
+    {
+        public string Code { get; }
+
+        public InlineCodeBlockNode(string source, string code)
+            : base(source)
+        {
+            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 source, string url, string title)
+            : base(source)
+        {
+            Url = url;
+            Title = title;
+        }
+
+        public LinkNode(string source, string url) : this(source, url, url)
+        {
+        }
+
+        public override string ToString() => $"<Link> {Title}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/MentionNode.cs

@@ -0,0 +1,18 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class MentionNode : Node
+    {
+        public string Id { get; }
+
+        public MentionType Type { get; }
+
+        public MentionNode(string source, string id, MentionType type)
+            : base(source)
+        {
+            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,18 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class MultilineCodeBlockNode : Node
+    {
+        public string Language { get; }
+
+        public string Code { get; }
+
+        public MultilineCodeBlockNode(string source, string language, string code)
+            : base(source)
+        {
+            Language = language;
+            Code = code;
+        }
+
+        public override string ToString() => $"<Code [{Language}]> {Code}";
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/Node.cs

@@ -0,0 +1,12 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public abstract class Node
+    {
+        public string Source { get; }
+
+        protected Node(string source)
+        {
+            Source = source;
+        }
+    }
+}

DiscordChatExporter.Core.Markdown/Nodes/TextFormatting.cs

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

DiscordChatExporter.Core.Markdown/Nodes/TextNode.cs

@@ -0,0 +1,19 @@
+namespace DiscordChatExporter.Core.Markdown.Nodes
+{
+    public class TextNode : Node
+    {
+        public string Text { get; }
+
+        public TextNode(string source, string text)
+            : base(source)
+        {
+            Text = text;
+        }
+
+        public TextNode(string text) : this(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
+    {
+        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

@@ -0,0 +1,8 @@
+namespace DiscordChatExporter.Core.Models
+{
+    public enum AuthTokenType
+    {
+        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
+    {
+        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, null, "deleted-channel", null, ChannelType.GuildTextChat);
+    }
+}

DiscordChatExporter.Core.Models/ChannelType.cs

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

DiscordChatExporter.Core.Models/ChatLog.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Models
+{
+    public class ChatLog
+    {
+        public Guild Guild { get; }
+
+        public Channel Channel { get; }
+
+        public DateTimeOffset? After { get; }
+
+        public DateTimeOffset? Before { get; }
+
+        public IReadOnlyList<Message> Messages { get; }
+
+        public Mentionables Mentionables { get; }
+
+        public ChatLog(Guild guild, Channel channel, DateTimeOffset? after, DateTimeOffset? before,
+            IReadOnlyList<Message> messages, Mentionables mentionables)
+        {
+            Guild = guild;
+            Channel = channel;
+            After = after;
+            Before = before;
+            Messages = messages;
+            Mentionables = mentionables;
+        }
+
+        public override string ToString() => $"{Guild.Name} | {Channel.Name}";
+    }
+}

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

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net46;netstandard2.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.0" />
+  </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;
+    }
+}

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;
+    }
+}

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 (id != null)
+            {
+                // 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

@@ -1,9 +1,10 @@
-namespace DiscordChatExporter.Models
+namespace DiscordChatExporter.Core.Models
 {
     public enum ExportFormat
     {
         PlainText,
         HtmlDark,
-        HtmlLight
+        HtmlLight,
+        Csv
     }
 }

DiscordChatExporter.Core.Models/Extensions.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace DiscordChatExporter.Models
+namespace DiscordChatExporter.Core.Models
 {
     public static class Extensions
     {
@@ -12,8 +12,10 @@ namespace DiscordChatExporter.Models
                 return "html";
             if (format == ExportFormat.HtmlLight)
                 return "html";
+            if (format == ExportFormat.Csv)
+                return "csv";
 
-            throw new NotImplementedException();
+            throw new ArgumentOutOfRangeException(nameof(format));
         }
 
         public static string GetDisplayName(this ExportFormat format)
@@ -24,8 +26,10 @@ namespace DiscordChatExporter.Models
                 return "HTML (Dark)";
             if (format == ExportFormat.HtmlLight)
                 return "HTML (Light)";
+            if (format == ExportFormat.Csv)
+                return "Comma Seperated Values (CSV)";
 
-            throw new NotImplementedException();
+            throw new ArgumentOutOfRangeException(nameof(format));
         }
     }
 }

DiscordChatExporter.Core.Models/FileSize.cs

@@ -0,0 +1,84 @@
+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
+            {
+                // Absolute value is used to deal with negative values
+                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
+            {
+                // Absolute value is used to deal with negative values
+                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.com/developers/docs/resources/guild#guild-object
+
+    public partial class Guild
+    {
+        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 iconHash != null
+                ? $"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/Mentionables.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DiscordChatExporter.Core.Models
+{
+    public class Mentionables
+    {
+        public IReadOnlyList<User> Users { get; }
+
+        public IReadOnlyList<Channel> Channels { get; }
+
+        public IReadOnlyList<Role> Roles { get; }
+
+        public Mentionables(IReadOnlyList<User> users, IReadOnlyList<Channel> channels, IReadOnlyList<Role> roles)
+        {
+            Users = users;
+            Channels = channels;
+            Roles = roles;
+        }
+
+        public User GetUser(string id) =>
+            Users.FirstOrDefault(u => u.Id == id) ?? User.CreateUnknownUser(id);
+
+        public Channel GetChannel(string id) =>
+            Channels.FirstOrDefault(c => c.Id == id) ?? Channel.CreateDeletedChannel(id);
+
+        public Role GetRole(string id) =>
+            Roles.FirstOrDefault(r => r.Id == id) ?? Role.CreateDeletedRole(id);
+    }
+}

DiscordChatExporter.Core.Models/Message.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#message-object
+
+    public class Message
+    {
+        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 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, 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;
+            Content = content;
+            Attachments = attachments;
+            Embeds = embeds;
+            Reactions = reactions;
+            MentionedUsers = mentionedUsers;
+        }
+
+        public override string ToString() => Content;
+    }
+}

DiscordChatExporter.Core.Models/MessageType.cs

@@ -0,0 +1,16 @@
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/resources/channel#message-object-message-types
+
+    public enum MessageType
+    {
+        Default,
+        RecipientAdd,
+        RecipientRemove,
+        Call,
+        ChannelNameChange,
+        ChannelIconChange,
+        ChannelPinnedMessage,
+        GuildMemberJoin
+    }
+}

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

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

DiscordChatExporter.Core.Models/User.cs

@@ -0,0 +1,58 @@
+using System;
+
+namespace DiscordChatExporter.Core.Models
+{
+    // https://discordapp.com/developers/docs/topics/permissions#role-object
+
+    public partial class User
+    {
+        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 User(string id, int discriminator, string name, string avatarHash)
+        {
+            Id = id;
+            Discriminator = discriminator;
+            Name = name;
+            AvatarHash = avatarHash;
+
+            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 (avatarHash != null)
+            {
+                // 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);
+    }
+}

DiscordChatExporter.Core.Rendering/CsvChatLogRenderer.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Markdown.Nodes;
+using DiscordChatExporter.Core.Models;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public class CsvChatLogRenderer : IChatLogRenderer
+    {
+        private readonly ChatLog _chatLog;
+        private readonly string _dateFormat;
+
+        public CsvChatLogRenderer(ChatLog chatLog, string dateFormat)
+        {
+            _chatLog = chatLog;
+            _dateFormat = dateFormat;
+        }
+
+        private string FormatDate(DateTimeOffset date) =>
+            date.ToLocalTime().ToString(_dateFormat, CultureInfo.InvariantCulture);
+
+        private string FormatMarkdown(Node node)
+        {
+            // Formatted node
+            if (node is FormattedNode formattedNode)
+            {
+                // Recursively get inner text
+                var innerText = FormatMarkdown(formattedNode.Children);
+
+                return $"{formattedNode.Token}{innerText}{formattedNode.Token}";
+            }
+
+            // Non-meta mention node
+            if (node is MentionNode mentionNode && mentionNode.Type != MentionType.Meta)
+            {
+                // User mention node
+                if (mentionNode.Type == MentionType.User)
+                {
+                    var user = _chatLog.Mentionables.GetUser(mentionNode.Id);
+                    return $"@{user.Name}";
+                }
+
+                // Channel mention node
+                if (mentionNode.Type == MentionType.Channel)
+                {
+                    var channel = _chatLog.Mentionables.GetChannel(mentionNode.Id);
+                    return $"#{channel.Name}";
+                }
+
+                // Role mention node
+                if (mentionNode.Type == MentionType.Role)
+                {
+                    var role = _chatLog.Mentionables.GetRole(mentionNode.Id);
+                    return $"@{role.Name}";
+                }
+            }
+
+            // Custom emoji node
+            if (node is EmojiNode emojiNode && emojiNode.IsCustomEmoji)
+            {
+                return $":{emojiNode.Name}:";
+            }
+
+            // All other nodes - simply return source
+            return node.Source;
+        }
+
+        private string FormatMarkdown(IEnumerable<Node> nodes) => nodes.Select(FormatMarkdown).JoinToString("");
+
+        private string FormatMarkdown(string markdown) => FormatMarkdown(MarkdownParser.Parse(markdown));
+
+        private async Task RenderFieldAsync(TextWriter writer, string value)
+        {
+            var encodedValue = value.Replace("\"", "\"\"");
+            await writer.WriteAsync($"\"{encodedValue}\";");
+        }
+
+        private async Task RenderMessageAsync(TextWriter writer, Message message)
+        {
+            // Author
+            await RenderFieldAsync(writer, message.Author.FullName);
+
+            // Timestamp
+            await RenderFieldAsync(writer, FormatDate(message.Timestamp));
+
+            // Content
+            await RenderFieldAsync(writer, FormatMarkdown(message.Content));
+
+            // Attachments
+            var formattedAttachments = message.Attachments.Select(a => a.Url).JoinToString(",");
+            await RenderFieldAsync(writer, formattedAttachments);
+
+            // Line break
+            await writer.WriteLineAsync();
+        }
+
+        public async Task RenderAsync(TextWriter writer)
+        {
+            // Headers
+            await writer.WriteLineAsync("Author;Date;Content;Attachments;");
+
+            // Log
+            foreach (var message in _chatLog.Messages)
+                await RenderMessageAsync(writer, message);
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net46;netstandard2.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="Resources\HtmlDark.css" />
+    <EmbeddedResource Include="Resources\HtmlDark.html" />
+    <EmbeddedResource Include="Resources\HtmlLight.css" />
+    <EmbeddedResource Include="Resources\HtmlLight.html" />
+    <EmbeddedResource Include="Resources\HtmlShared.css" />
+    <EmbeddedResource Include="Resources\HtmlShared.html" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Scriban" Version="2.0.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/HtmlChatLogRenderer.MessageGroup.cs

@@ -0,0 +1,25 @@
+using DiscordChatExporter.Core.Models;
+using System;
+using System.Collections.Generic;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public partial class HtmlChatLogRenderer
+    {
+        private class MessageGroup
+        {
+            public User Author { get; }
+
+            public DateTimeOffset Timestamp { get; }
+
+            public IReadOnlyList<Message> Messages { get; }
+
+            public MessageGroup(User author, DateTimeOffset timestamp, IReadOnlyList<Message> messages)
+            {
+                Author = author;
+                Timestamp = timestamp;
+                Messages = messages;
+            }
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/HtmlChatLogRenderer.TemplateLoader.cs

@@ -0,0 +1,27 @@
+using Scriban.Parsing;
+using Scriban.Runtime;
+using Scriban;
+using System.Reflection;
+using System.Threading.Tasks;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public partial class HtmlChatLogRenderer
+    {
+        private class TemplateLoader : ITemplateLoader
+        {
+            private const string ResourceRootNamespace = "DiscordChatExporter.Core.Rendering.Resources";
+
+            public string Load(string templatePath) =>
+                Assembly.GetExecutingAssembly().GetManifestResourceString($"{ResourceRootNamespace}.{templatePath}");
+
+            public string GetPath(TemplateContext context, SourceSpan callerSpan, string templateName) => templateName;
+
+            public string Load(TemplateContext context, SourceSpan callerSpan, string templatePath) => Load(templatePath);
+
+            public ValueTask<string> LoadAsync(TemplateContext context, SourceSpan callerSpan, string templatePath) =>
+                new ValueTask<string>(Load(templatePath));
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/HtmlChatLogRenderer.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Markdown.Nodes;
+using DiscordChatExporter.Core.Models;
+using Scriban;
+using Scriban.Runtime;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public partial class HtmlChatLogRenderer : IChatLogRenderer
+    {
+        private readonly ChatLog _chatLog;
+        private readonly string _themeName;
+        private readonly string _dateFormat;
+
+        public HtmlChatLogRenderer(ChatLog chatLog, string themeName, string dateFormat)
+        {
+            _chatLog = chatLog;
+            _themeName = themeName;
+            _dateFormat = dateFormat;
+        }
+
+        private string HtmlEncode(string s) => WebUtility.HtmlEncode(s);
+
+        private string FormatDate(DateTimeOffset date) =>
+            date.ToLocalTime().ToString(_dateFormat, CultureInfo.InvariantCulture);
+
+        private IEnumerable<MessageGroup> GroupMessages(IEnumerable<Message> messages) =>
+            messages.GroupContiguous((buffer, message) =>
+            {
+                // Break group if the author changed
+                if (buffer.Last().Author.Id != message.Author.Id)
+                    return false;
+
+                // Break group if last message was more than 7 minutes ago
+                if ((message.Timestamp - buffer.Last().Timestamp).TotalMinutes > 7)
+                    return false;
+
+                return true;
+            }).Select(g => new MessageGroup(g.First().Author, g.First().Timestamp, g));
+
+        private string FormatMarkdown(Node node, bool isTopLevel, bool isSingle)
+        {
+            // 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 = FormatMarkdown(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>";
+            }
+
+            // 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 language class for syntax highlighting
+                var languageCssClass = multilineCodeBlockNode.Language != null
+                    ? "language-" + multilineCodeBlockNode.Language
+                    : null;
+
+                return $"<div class=\"pre pre--multiline {languageCssClass}\">{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 = _chatLog.Mentionables.GetUser(mentionNode.Id);
+                    return $"<span class=\"mention\" title=\"{HtmlEncode(user.FullName)}\">@{HtmlEncode(user.Name)}</span>";
+                }
+
+                // Channel mention node
+                if (mentionNode.Type == MentionType.Channel)
+                {
+                    var channel = _chatLog.Mentionables.GetChannel(mentionNode.Id);
+                    return $"<span class=\"mention\">#{HtmlEncode(channel.Name)}</span>";
+                }
+
+                // Role mention node
+                if (mentionNode.Type == MentionType.Role)
+                {
+                    var role = _chatLog.Mentionables.GetRole(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);
+
+                // Emoji can be jumboable if it's the only top-level node
+                var jumboableCssClass = isTopLevel && isSingle ? "emoji--large" : null;
+
+                return $"<img class=\"emoji {jumboableCssClass}\" alt=\"{emojiNode.Name}\" title=\"{emojiNode.Name}\" src=\"{emojiImageUrl}\" />";
+            }
+
+            // Link node
+            if (node is LinkNode linkNode)
+            {
+                return $"<a href=\"{Uri.EscapeUriString(linkNode.Url)}\">{HtmlEncode(linkNode.Title)}</a>";
+            }
+
+            // All other nodes - simply return source
+            return node.Source;
+        }
+
+        private string FormatMarkdown(IReadOnlyList<Node> nodes, bool isTopLevel)
+        {
+            var isSingle = nodes.Count == 1;
+            return nodes.Select(n => FormatMarkdown(n, isTopLevel, isSingle)).JoinToString("");
+        }
+
+        private string FormatMarkdown(string markdown) => FormatMarkdown(MarkdownParser.Parse(markdown), true);
+
+        public async Task RenderAsync(TextWriter writer)
+        {
+            // Create template loader
+            var loader = new TemplateLoader();
+
+            // Get template
+            var templateCode = loader.Load($"Html{_themeName}.html");
+            var template = Template.Parse(templateCode);
+
+            // Create template context
+            var context = new TemplateContext
+            {
+                TemplateLoader = loader,
+                MemberRenamer = m => m.Name,
+                MemberFilter = m => true,
+                LoopLimit = int.MaxValue,
+                StrictVariables = true
+            };
+
+            // Create template model
+            var model = new ScriptObject();
+            model.SetValue("Model", _chatLog, true);
+            model.Import(nameof(GroupMessages), new Func<IEnumerable<Message>, IEnumerable<MessageGroup>>(GroupMessages));
+            model.Import(nameof(FormatDate), new Func<DateTimeOffset, string>(FormatDate));
+            model.Import(nameof(FormatMarkdown), new Func<string, string>(FormatMarkdown));
+            context.PushGlobal(model);
+
+            // Configure output
+            context.PushOutput(new TextWriterOutput(writer));
+
+            // HACK: Render output in a separate thread
+            // (even though Scriban has async API, it still makes a lot of blocking CPU-bound calls)
+            await Task.Run(async () => await context.EvaluateAsync(template.Page));
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/IChatLogRenderer.cs

@@ -0,0 +1,10 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public interface IChatLogRenderer
+    {
+        Task RenderAsync(TextWriter writer);
+    }
+}

DiscordChatExporter.Core.Rendering/PlainTextChatLogRenderer.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Markdown;
+using DiscordChatExporter.Core.Markdown.Nodes;
+using DiscordChatExporter.Core.Models;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Rendering
+{
+    public class PlainTextChatLogRenderer : IChatLogRenderer
+    {
+        private readonly ChatLog _chatLog;
+        private readonly string _dateFormat;
+
+        public PlainTextChatLogRenderer(ChatLog chatLog, string dateFormat)
+        {
+            _chatLog = chatLog;
+            _dateFormat = dateFormat;
+        }
+
+        private string FormatDate(DateTimeOffset date) =>
+            date.ToLocalTime().ToString(_dateFormat, CultureInfo.InvariantCulture);
+
+        private string FormatDateRange(DateTimeOffset? after, DateTimeOffset? before)
+        {
+            // Both 'after' and 'before'
+            if (after != null && before != null)
+                return $"{FormatDate(after.Value)} to {FormatDate(before.Value)}";
+
+            // Just 'after'
+            if (after != null)
+                return $"after {FormatDate(after.Value)}";
+
+            // Just 'before'
+            if (before != null)
+                return $"before {FormatDate(before.Value)}";
+
+            // Neither
+            return null;
+        }
+
+        private string FormatMarkdown(Node node)
+        {
+            // Formatted node
+            if (node is FormattedNode formattedNode)
+            {
+                // Recursively get inner text
+                var innerText = FormatMarkdown(formattedNode.Children);
+
+                return $"{formattedNode.Token}{innerText}{formattedNode.Token}";
+            }
+
+            // Non-meta mention node
+            if (node is MentionNode mentionNode && mentionNode.Type != MentionType.Meta)
+            {
+                // User mention node
+                if (mentionNode.Type == MentionType.User)
+                {
+                    var user = _chatLog.Mentionables.GetUser(mentionNode.Id);
+                    return $"@{user.Name}";
+                }
+
+                // Channel mention node
+                if (mentionNode.Type == MentionType.Channel)
+                {
+                    var channel = _chatLog.Mentionables.GetChannel(mentionNode.Id);
+                    return $"#{channel.Name}";
+                }
+
+                // Role mention node
+                if (mentionNode.Type == MentionType.Role)
+                {
+                    var role = _chatLog.Mentionables.GetRole(mentionNode.Id);
+                    return $"@{role.Name}";
+                }
+            }
+
+            // Custom emoji node
+            if (node is EmojiNode emojiNode && emojiNode.IsCustomEmoji)
+            {
+                return $":{emojiNode.Name}:";
+            }
+
+            // All other nodes - simply return source
+            return node.Source;
+        }
+
+        private string FormatMarkdown(IEnumerable<Node> nodes) => nodes.Select(FormatMarkdown).JoinToString("");
+
+        private string FormatMarkdown(string markdown) => FormatMarkdown(MarkdownParser.Parse(markdown));
+
+        private async Task RenderMessageAsync(TextWriter writer, Message message)
+        {
+            // Timestamp and author
+            await writer.WriteLineAsync($"[{FormatDate(message.Timestamp)}] {message.Author.FullName}");
+
+            // Content
+            await writer.WriteLineAsync(FormatMarkdown(message.Content));
+
+            // Attachments
+            foreach (var attachment in message.Attachments)
+                await writer.WriteLineAsync(attachment.Url);
+        }
+
+        public async Task RenderAsync(TextWriter writer)
+        {
+            // Metadata
+            await writer.WriteLineAsync('='.Repeat(62));
+            await writer.WriteLineAsync($"Guild: {_chatLog.Guild.Name}");
+            await writer.WriteLineAsync($"Channel: {_chatLog.Channel.Name}");
+            await writer.WriteLineAsync($"Topic: {_chatLog.Channel.Topic}");
+            await writer.WriteLineAsync($"Messages: {_chatLog.Messages.Count:N0}");
+            await writer.WriteLineAsync($"Range: {FormatDateRange(_chatLog.After, _chatLog.Before)}");
+            await writer.WriteLineAsync('='.Repeat(62));
+            await writer.WriteLineAsync();
+
+            // Log
+            foreach (var message in _chatLog.Messages)
+            {
+                await RenderMessageAsync(writer, message);
+                await writer.WriteLineAsync();
+            }
+        }
+    }
+}

DiscordChatExporter.Core.Rendering/Resources/HtmlDark.css

@@ -0,0 +1,100 @@
+/* === GENERAL === */
+
+body {
+    background-color: #36393e;
+    color: #dcddde;
+}
+
+a {
+    color: #0096cf;
+}
+
+.spoiler {
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
+.pre {
+    background-color: #2f3136 !important;
+}
+
+.pre--multiline {
+    border-color: #282b30 !important;
+    color: #839496 !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__edited-timestamp {
+    color: rgba(255, 255, 255, 0.2);
+}
+
+.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/HtmlDark.html

@@ -0,0 +1,3 @@
+{{~ ThemeStyleSheet = include "HtmlDark.css" ~}}
+{{~ HighlightJsStyleName = "solarized-dark" ~}}
+{{~ include "HtmlShared.html" ~}}

DiscordChatExporter.Core.Rendering/Resources/HtmlLight.css

@@ -0,0 +1,101 @@
+/* === GENERAL === */
+
+body {
+    background-color: #ffffff;
+    color: #747f8d;
+}
+
+a {
+    color: #00b0f4;
+}
+
+.spoiler {
+    background-color: rgba(0, 0, 0, 0.1);
+}
+
+.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 {
+    color: #2f3136;
+}
+
+.chatlog__timestamp {
+    color: #99aab5;
+}
+
+.chatlog__edited-timestamp {
+    color: #99aab5;
+}
+
+.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.4);
+}
+
+.chatlog__reaction {
+    background-color: rgba(79, 84, 92, 0.06);
+}
+
+.chatlog__reaction-count {
+    color: #99aab5;
+}

DiscordChatExporter.Core.Rendering/Resources/HtmlLight.html

@@ -0,0 +1,3 @@
+{{~ ThemeStyleSheet = include "HtmlLight.css" ~}}
+{{~ HighlightJsStyleName = "solarized-light" ~}}
+{{~ include "HtmlShared.html" ~}}

DiscordChatExporter.Core.Rendering/Resources/HtmlShared.css

@@ -0,0 +1,312 @@
+/* === GENERAL === */
+
+body {
+    font-family: "Whitney", "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 16px;
+}
+
+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;
+}
+
+.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;
+}
+
+.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__content {
+    padding-top: 5px;
+    font-size: .9375em;
+    word-wrap: break-word;
+}
+
+.chatlog__edited-timestamp {
+    margin-left: 3px;
+    font-size: .8em;
+}
+
+.chatlog__attachment {
+    margin: 5px 0;
+}
+
+.chatlog__attachment-thumbnail {
+    max-width: 50%;
+    max-height: 500px;
+    border-radius: 3px;
+}
+
+.chatlog__embed {
+    display: flex;
+    max-width: 520px;
+    margin-top: 5px;
+}
+
+.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: 600;
+    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;
+}

DiscordChatExporter.Core.Rendering/Resources/HtmlShared.html

@@ -0,0 +1,225 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    {{~ # Metadata ~}}
+    <title>{{ Model.Guild.Name | html.escape }} - {{ Model.Channel.Name | html.escape }}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+
+    {{~ # Styles ~}}
+    <style>
+        {{ include "HtmlShared.css" }}
+    </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>
+</head>
+<body>
+    
+{{~ # Info ~}}
+<div class="info">
+    <div class="info__guild-icon-container">
+        <img class="info__guild-icon" src="{{ Model.Guild.IconUrl }}" />
+    </div>
+    <div class="info__metadata">
+        <div class="info__guild-name">{{ Model.Guild.Name | html.escape }}</div>
+        <div class="info__channel-name">{{ Model.Channel.Name | html.escape }}</div>
+        
+        {{~ if Model.Channel.Topic ~}}
+            <div class="info__channel-topic">{{ Model.Channel.Topic | html.escape }}</div>
+        {{~ end ~}}
+
+        <div class="info__channel-message-count">{{ Model.Messages | array.size | object.format "N0" }} messages</div>
+        
+        {{~ if Model.After || Model.Before ~}}
+            <div class="info__channel-date-range">
+                {{~ if Model.After && Model.Before ~}}
+                    Between {{ Model.After | FormatDate | html.escape }} and {{ Model.Before | FormatDate | html.escape }}
+                {{~ else if Model.After ~}}
+                    After {{ Model.After | FormatDate | html.escape }}
+                {{~ else if Model.Before ~}}
+                    Before {{ Model.Before | FormatDate | html.escape }}
+                {{~ end ~}}
+            </div>
+        {{~ end ~}}
+    </div>
+</div>
+
+{{~ # Log ~}}
+<div class="chatlog">
+    {{~ for group in Model.Messages | GroupMessages ~}}
+        <div class="chatlog__message-group">
+            {{~ # Avatar ~}}
+            <div class="chatlog__author-avatar-container">
+                <img class="chatlog__author-avatar" src="{{ group.Author.AvatarUrl }}" />
+            </div>            
+            <div class="chatlog__messages">
+                {{~ # Author name and timestamp ~}}
+                <span class="chatlog__author-name" title="{{ group.Author.FullName | html.escape }}">{{ group.Author.Name | html.escape }}</span>
+                <span class="chatlog__timestamp">{{ group.Timestamp | FormatDate | html.escape }}</span>
+
+                {{~ # Messages ~}}
+                {{~ for message in group.Messages ~}}
+                    {{~ # 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">
+                            <div class="chatlog__embed-color-pill" style="background-color: rgba({{ embed.Color.R }},{{ embed.Color.G }},{{ embed.Color.B }},{{ embed.Color.A }})"></div>
+                            <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 ~}}
+                {{~ end ~}}
+            </div>
+        </div>
+    {{~ end ~}}
+</div>
+
+</body>
+</html>

DiscordChatExporter.Core.Services/DataService.Parsers.cs

@@ -0,0 +1,207 @@
+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>();
+
+            return new User(id, discriminator, name, avatarHash);
+        }
+
+        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 (guildId == null)
+                guildId = Guild.DirectMessages.Id;
+
+            // Try to extract name
+            var name = json["name"]?.Value<string>();
+
+            // If the name is blank, it's direct messages
+            if (name == null)
+                name = json["recipients"].Select(ParseUser).Select(u => u.Name).JoinToString(", ");
+
+            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<DateTimeOffset>();
+
+            // Get color
+            var color = json["color"] != null
+                ? Color.FromArgb(json["color"].Value<int>()).ResetAlpha()
+                : Color.FromArgb(79, 84, 92); // default color
+
+            // Get author
+            var author = json["author"] != null ? ParseEmbedAuthor(json["author"]) : null;
+
+            // Get fields
+            var fields = json["fields"].EmptyIfNull().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<DateTimeOffset>();
+            var editedTimestamp = json["edited_timestamp"]?.Value<DateTimeOffset?>();
+            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"].EmptyIfNull().Select(ParseAttachment).ToArray();
+
+            // Get embeds
+            var embeds = json["embeds"].EmptyIfNull().Select(ParseEmbed).ToArray();
+
+            // Get reactions
+            var reactions = json["reactions"].EmptyIfNull().Select(ParseReaction).ToArray();
+
+            // Get mentioned users
+            var mentionedUsers = json["mentions"].EmptyIfNull().Select(ParseUser).ToArray();
+
+            return new Message(id, channelId, type, author, timestamp, editedTimestamp, content, attachments, embeds,
+                reactions, mentionedUsers);
+        }
+    }
+}

DiscordChatExporter.Core.Services/DataService.cs

@@ -0,0 +1,263 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+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 Failsafe;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public partial class DataService : IDisposable
+    {
+        private readonly HttpClient _httpClient = new HttpClient();
+
+        private async Task<JToken> GetApiResponseAsync(AuthToken token, string resource, string endpoint,
+            params string[] parameters)
+        {
+            // Create retry policy
+            var retry = Retry.Create()
+                .Catch<HttpErrorStatusCodeException>(false, e => (int) e.StatusCode >= 500)
+                .Catch<HttpErrorStatusCodeException>(false, e => (int) e.StatusCode == 429)
+                .WithMaxTryCount(10)
+                .WithDelay(TimeSpan.FromSeconds(0.4));
+
+            // Send request
+            return await retry.ExecuteAsync(async () =>
+            {
+                // Create request
+                const string apiRoot = "https://discordapp.com/api/v6";
+                using (var request = new HttpRequestMessage(HttpMethod.Get, $"{apiRoot}/{resource}/{endpoint}"))
+                {
+                    // Set authorization header
+                    request.Headers.Authorization = token.Type == AuthTokenType.Bot
+                        ? new AuthenticationHeaderValue("Bot", token.Value)
+                        : new AuthenticationHeaderValue(token.Value);
+
+                    // Add parameters
+                    foreach (var parameter in parameters)
+                    {
+                        var key = parameter.SubstringUntil("=");
+                        var value = parameter.SubstringAfter("=");
+
+                        // Skip empty values
+                        if (value.IsEmpty())
+                            continue;
+
+                        request.RequestUri = request.RequestUri.SetQueryParameter(key, value);
+                    }
+
+                    // Get response
+                    using (var response = await _httpClient.SendAsync(request))
+                    {
+                        // Check status code
+                        // We throw our own exception here because default one doesn't have status code
+                        if (!response.IsSuccessStatusCode)
+                            throw new HttpErrorStatusCodeException(response.StatusCode, response.ReasonPhrase);
+
+                        // Get content
+                        var raw = await response.Content.ReadAsStringAsync();
+
+                        // Parse
+                        using (var reader = new JsonTextReader(new StringReader(raw)))
+                        {
+                            reader.DateParseHandling = DateParseHandling.DateTimeOffset;
+
+                            return JToken.Load(reader);
+                        }
+                    }
+                }
+            });
+        }
+
+        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 Task<IReadOnlyList<Guild>> GetUserGuildsAsync(AuthToken token)
+        {
+            var response = await GetApiResponseAsync(token, "users", "@me/guilds", "limit=100");
+            var guilds = response.Select(ParseGuild).ToArray();
+
+            return guilds;
+        }
+
+        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)
+        {
+            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)
+        {
+            var response = await GetApiResponseAsync(token, "guilds", $"{guildId}/roles");
+            var roles = response.Select(ParseRole).ToArray();
+
+            return roles;
+        }
+
+        public async Task<IReadOnlyList<Message>> GetChannelMessagesAsync(AuthToken token, string channelId,
+            DateTimeOffset? after = null, DateTimeOffset? before = null, IProgress<double> progress = null)
+        {
+            var result = new List<Message>();
+
+            // Get the last message
+            var response = await GetApiResponseAsync(token, "channels", $"{channelId}/messages",
+                "limit=1", $"before={before?.ToSnowflake()}");
+            var lastMessage = response.Select(ParseMessage).FirstOrDefault();
+
+            // If the last message doesn't exist or it's outside of range - return
+            if (lastMessage == null || lastMessage.Timestamp < after)
+            {
+                progress?.Report(1);
+                return result;
+            }
+
+            // Get other messages
+            var offsetId = after?.ToSnowflake() ?? "0";
+            while (true)
+            {
+                // Get message batch
+                response = await GetApiResponseAsync(token, "channels", $"{channelId}/messages",
+                    "limit=100", $"after={offsetId}");
+
+                // 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();
+
+                // Add to result
+                result.AddRange(messagesInRange);
+
+                // Break if messages were trimmed (which means the last message was encountered)
+                if (messagesInRange.Length != messages.Length)
+                    break;
+
+                // Report progress (based on the time range of parsed messages compared to total)
+                progress?.Report((result.Last().Timestamp - result.First().Timestamp).TotalSeconds /
+                                 (lastMessage.Timestamp - result.First().Timestamp).TotalSeconds);
+
+                // Move offset
+                offsetId = result.Last().Id;
+            }
+
+            // Add last message
+            result.Add(lastMessage);
+
+            // Report progress
+            progress?.Report(1);
+
+            return result;
+        }
+
+        public async Task<Mentionables> GetMentionablesAsync(AuthToken token, string guildId,
+            IEnumerable<Message> messages)
+        {
+            // Get channels and roles
+            var channels = guildId != Guild.DirectMessages.Id
+                ? await GetGuildChannelsAsync(token, guildId)
+                : Array.Empty<Channel>();
+            var roles = guildId != Guild.DirectMessages.Id
+                ? await GetGuildRolesAsync(token, guildId)
+                : Array.Empty<Role>();
+
+            // Get users
+            var userMap = new Dictionary<string, User>();
+            foreach (var message in messages)
+            {
+                // Author
+                userMap[message.Author.Id] = message.Author;
+
+                // Mentioned users
+                foreach (var mentionedUser in message.MentionedUsers)
+                    userMap[mentionedUser.Id] = mentionedUser;
+            }
+
+            var users = userMap.Values.ToArray();
+
+            return new Mentionables(users, channels, roles);
+        }
+
+        public async Task<ChatLog> GetChatLogAsync(AuthToken token, Guild guild, Channel channel,
+            DateTimeOffset? after = null, DateTimeOffset? before = null, IProgress<double> progress = null)
+        {
+            // Get messages
+            var messages = await GetChannelMessagesAsync(token, channel.Id, after, before, progress);
+
+            // Get mentionables
+            var mentionables = await GetMentionablesAsync(token, guild.Id, messages);
+
+            return new ChatLog(guild, channel, after, before, messages, mentionables);
+        }
+
+        public async Task<ChatLog> GetChatLogAsync(AuthToken token, Channel channel,
+            DateTimeOffset? after = null, DateTimeOffset? before = null, IProgress<double> progress = null)
+        {
+            // Get guild
+            var guild = channel.GuildId == Guild.DirectMessages.Id
+                ? Guild.DirectMessages
+                : await GetGuildAsync(token, channel.GuildId);
+
+            // Get the chat log
+            return await GetChatLogAsync(token, guild, channel, after, before, progress);
+        }
+
+        public async Task<ChatLog> GetChatLogAsync(AuthToken token, string channelId,
+            DateTimeOffset? after = null, DateTimeOffset? before = null, IProgress<double> progress = null)
+        {
+            // Get channel
+            var channel = await GetChannelAsync(token, channelId);
+
+            // Get the chat log
+            return await GetChatLogAsync(token, channel, after, before, progress);
+        }
+
+        public void Dispose()
+        {
+            _httpClient.Dispose();
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net46;netstandard2.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Failsafe" Version="1.1.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
+    <PackageReference Include="Onova" Version="2.4.2" />
+    <PackageReference Include="Tyrrrz.Extensions" Version="1.6.0" />
+    <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.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,89 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using DiscordChatExporter.Core.Models;
+using DiscordChatExporter.Core.Rendering;
+using Tyrrrz.Extensions;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public class ExportService
+    {
+        private readonly SettingsService _settingsService;
+
+        public ExportService(SettingsService settingsService)
+        {
+            _settingsService = settingsService;
+        }
+
+        private IChatLogRenderer CreateRenderer(ChatLog chatLog, ExportFormat format)
+        {
+            if (format == ExportFormat.PlainText)
+                return new PlainTextChatLogRenderer(chatLog, _settingsService.DateFormat);
+
+            if (format == ExportFormat.HtmlDark)
+                return new HtmlChatLogRenderer(chatLog, "Dark", _settingsService.DateFormat);
+
+            if (format == ExportFormat.HtmlLight)
+                return new HtmlChatLogRenderer(chatLog, "Light", _settingsService.DateFormat);
+
+            if (format == ExportFormat.Csv)
+                return new CsvChatLogRenderer(chatLog, _settingsService.DateFormat);
+
+            throw new ArgumentOutOfRangeException(nameof(format), $"Unknown format [{format}].");
+        }
+
+        private async Task ExportChatLogAsync(ChatLog chatLog, string filePath, ExportFormat format)
+        {
+            // Create output directory
+            var dirPath = Path.GetDirectoryName(filePath);
+            if (!dirPath.EmptyIfNull().IsWhiteSpace())
+                Directory.CreateDirectory(dirPath);
+
+            // Render chat log to output file
+            using (var writer = File.CreateText(filePath))
+                await CreateRenderer(chatLog, format).RenderAsync(writer);
+        }
+
+        public async Task ExportChatLogAsync(ChatLog chatLog, string filePath, ExportFormat format, int? partitionLimit)
+        {
+            // If partitioning is disabled or there are fewer messages in chat log than the limit - process it without partitioning
+            if (partitionLimit == null || partitionLimit <= 0 || chatLog.Messages.Count <= partitionLimit)
+            {
+                await ExportChatLogAsync(chatLog, filePath, format);
+            }
+            // Otherwise split into partitions and export separately
+            else
+            {
+                // Create partitions by grouping up to X contiguous messages into separate chat logs
+                var partitions = chatLog.Messages.GroupContiguous(g => g.Count < partitionLimit.Value)
+                    .Select(g => new ChatLog(chatLog.Guild, chatLog.Channel, chatLog.After, chatLog.Before, g, chatLog.Mentionables))
+                    .ToArray();
+
+                // Split file path into components
+                var dirPath = Path.GetDirectoryName(filePath);
+                var fileNameWithoutExt = Path.GetFileNameWithoutExtension(filePath);
+                var fileExt = Path.GetExtension(filePath);
+
+                // Export each partition separately
+                var partitionNumber = 1;
+                foreach (var partition in partitions)
+                {
+                    // Compose new file name
+                    var partitionFilePath = $"{fileNameWithoutExt} [{partitionNumber} of {partitions.Length}]{fileExt}";
+
+                    // Compose full file path
+                    if (!dirPath.EmptyIfNull().IsWhiteSpace())
+                        partitionFilePath = Path.Combine(dirPath, partitionFilePath);
+
+                    // Export
+                    await ExportChatLogAsync(partition, partitionFilePath, format);
+
+                    // Increment partition number
+                    partitionNumber++;
+                }
+            }
+        }
+    }
+}

DiscordChatExporter.Core.Services/Helpers/ExportHelper.cs

@@ -0,0 +1,58 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Core.Services.Helpers
+{
+    public static class ExportHelper
+    {
+        public static bool IsDirectoryPath(string path) =>
+            path.Last() == Path.DirectorySeparatorChar ||
+            path.Last() == Path.AltDirectorySeparatorChar ||
+            Path.GetExtension(path) == null;
+
+        public static string GetDefaultExportFileName(ExportFormat format, Guild guild, Channel channel,
+            DateTimeOffset? after = null, DateTimeOffset? before = null)
+        {
+            var result = new StringBuilder();
+
+            // Append guild and channel names
+            result.Append($"{guild.Name} - {channel.Name} [{channel.Id}]");
+
+            // Append date range
+            if (after != null || before != null)
+            {
+                result.Append(" (");
+
+                // Both 'after' and 'before' are set
+                if (after != null && before != null)
+                {
+                    result.Append($"{after:yyyy-MM-dd} to {before:yyyy-MM-dd}");
+                }
+                // Only 'after' is set
+                else if (after != null)
+                {
+                    result.Append($"after {after:yyyy-MM-dd}");
+                }
+                // Only 'before' is set
+                else
+                {
+                    result.Append($"before {before:yyyy-MM-dd}");
+                }
+
+                result.Append(")");
+            }
+
+            // Append extension
+            result.Append($".{format.GetFileExtension()}");
+
+            // Replace invalid chars
+            foreach (var invalidChar in Path.GetInvalidFileNameChars())
+                result.Replace(invalidChar, '_');
+
+            return result.ToString();
+        }
+    }
+}

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 string ToSnowflake(this DateTimeOffset date)
+        {
+            const long epoch = 62135596800000;
+            var unixTime = date.ToUniversalTime().Ticks / TimeSpan.TicksPerMillisecond - epoch;
+            var value = ((ulong) unixTime - 1420070400000UL) << 22;
+            return value.ToString();
+        }
+
+        public static Color ResetAlpha(this Color color) => Color.FromArgb(1, color);
+    }
+}

DiscordChatExporter.Core.Services/SettingsService.cs

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

DiscordChatExporter.Core.Services/UpdateService.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Threading.Tasks;
+using Onova;
+using Onova.Exceptions;
+using Onova.Services;
+
+namespace DiscordChatExporter.Core.Services
+{
+    public class UpdateService : IDisposable
+    {
+        private readonly SettingsService _settingsService;
+
+        private readonly IUpdateManager _updateManager = new UpdateManager(
+            new GithubPackageResolver("Tyrrrz", "DiscordChatExporter", "DiscordChatExporter.zip"),
+            new ZipPackageExtractor());
+
+        private Version _updateVersion;
+        private bool _updaterLaunched;
+
+        public UpdateService(SettingsService settingsService)
+        {
+            _settingsService = settingsService;
+        }
+
+        public async Task<Version> CheckPrepareUpdateAsync()
+        {
+            try
+            {
+                // If auto-update is disabled - don't check for updates
+                if (!_settingsService.IsAutoUpdateEnabled)
+                    return null;
+
+                // Check for updates
+                var check = await _updateManager.CheckForUpdatesAsync();
+                if (!check.CanUpdate)
+                    return null;
+
+                // Prepare the update
+                await _updateManager.PrepareUpdateAsync(check.LastVersion);
+
+                return _updateVersion = check.LastVersion;
+            }
+            catch (UpdaterAlreadyLaunchedException)
+            {
+                return null;
+            }
+            catch (LockFileNotAcquiredException)
+            {
+                return null;
+            }
+        }
+
+        public void FinalizeUpdate(bool needRestart)
+        {
+            try
+            {
+                // Check if an update is pending
+                if (_updateVersion == null)
+                    return;
+
+                // Check if the updater has already been launched
+                if (_updaterLaunched)
+                    return;
+
+                // Launch the updater
+                _updateManager.LaunchUpdater(_updateVersion, needRestart);
+                _updaterLaunched = true;
+            }
+            catch (UpdaterAlreadyLaunchedException)
+            {
+            }
+            catch (LockFileNotAcquiredException)
+            {
+            }
+        }
+
+        public void Dispose() => _updateManager.Dispose();
+    }
+}

DiscordChatExporter.Gui/App.xaml

@@ -0,0 +1,139 @@
+<Application
+    x:Class="DiscordChatExporter.Gui.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="clr-namespace:DiscordChatExporter.Gui"
+    xmlns:s="https://github.com/canton7/Stylet">
+    <Application.Resources>
+        <s:ApplicationLoader>
+            <!--  Bootstrapper  -->
+            <s:ApplicationLoader.Bootstrapper>
+                <local:Bootstrapper />
+            </s:ApplicationLoader.Bootstrapper>
+
+            <!--  Merged dictionaries  -->
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Light.xaml" />
+                <ResourceDictionary Source="pack://application:,,,/MaterialDesignThemes.Wpf;component/Themes/MaterialDesignTheme.Defaults.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+
+            <!--  Colors  -->
+            <Color x:Key="PrimaryColor">#343838</Color>
+            <Color x:Key="PrimaryLightColor">#5E6262</Color>
+            <Color x:Key="PrimaryDarkColor">#0D1212</Color>
+            <Color x:Key="AccentColor">#F9A825</Color>
+            <Color x:Key="AccentDarkColor">#C17900</Color>
+            <Color x:Key="TextColor">#000000</Color>
+            <Color x:Key="InverseTextColor">#FFFFFF</Color>
+
+            <SolidColorBrush x:Key="PrimaryHueLightBrush" Color="{DynamicResource PrimaryLightColor}" />
+            <SolidColorBrush x:Key="PrimaryHueLightForegroundBrush" Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush x:Key="PrimaryHueMidBrush" Color="{DynamicResource PrimaryColor}" />
+            <SolidColorBrush x:Key="PrimaryHueMidForegroundBrush" Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush x:Key="PrimaryHueDarkBrush" Color="{DynamicResource PrimaryDarkColor}" />
+            <SolidColorBrush x:Key="PrimaryHueDarkForegroundBrush" Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush x:Key="SecondaryAccentBrush" Color="{DynamicResource AccentColor}" />
+            <SolidColorBrush x:Key="SecondaryAccentForegroundBrush" Color="{DynamicResource TextColor}" />
+
+            <SolidColorBrush
+                x:Key="PrimaryTextBrush"
+                Opacity="0.87"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="SecondaryTextBrush"
+                Opacity="0.64"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="DimTextBrush"
+                Opacity="0.45"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="PrimaryInverseTextBrush"
+                Opacity="1"
+                Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush
+                x:Key="SecondaryInverseTextBrush"
+                Opacity="0.7"
+                Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush
+                x:Key="DimInverseTextBrush"
+                Opacity="0.52"
+                Color="{DynamicResource InverseTextColor}" />
+            <SolidColorBrush
+                x:Key="AccentTextBrush"
+                Opacity="1"
+                Color="{DynamicResource AccentColor}" />
+            <SolidColorBrush
+                x:Key="AccentDarkTextBrush"
+                Opacity="1"
+                Color="{DynamicResource AccentDarkColor}" />
+            <SolidColorBrush
+                x:Key="DividerBrush"
+                Opacity="0.12"
+                Color="{DynamicResource TextColor}" />
+            <SolidColorBrush
+                x:Key="InverseDividerBrush"
+                Opacity="0.12"
+                Color="{DynamicResource InverseTextColor}" />
+
+            <!--  Styles  -->
+            <Style x:Key="MaterialDesignRoot" TargetType="{x:Type Control}">
+                <Setter Property="FontFamily" Value="{DynamicResource MaterialDesignFont}" />
+                <Setter Property="RenderOptions.BitmapScalingMode" Value="HighQuality" />
+                <Setter Property="SnapsToDevicePixels" Value="True" />
+                <Setter Property="TextElement.FontSize" Value="13" />
+                <Setter Property="TextElement.FontWeight" Value="Regular" />
+                <Setter Property="TextElement.Foreground" Value="{DynamicResource SecondaryTextBrush}" />
+                <Setter Property="TextOptions.TextFormattingMode" Value="Ideal" />
+                <Setter Property="TextOptions.TextRenderingMode" Value="Auto" />
+                <Setter Property="UseLayoutRounding" Value="True" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignLinearProgressBar}" TargetType="{x:Type ProgressBar}">
+                <Setter Property="BorderThickness" Value="0" />
+                <Setter Property="Foreground" Value="{DynamicResource SecondaryAccentBrush}" />
+                <Setter Property="Height" Value="2" />
+                <Setter Property="Maximum" Value="1" />
+                <Setter Property="Minimum" Value="0" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignTextBox}" TargetType="{x:Type TextBox}">
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryTextBrush}" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignComboBox}" TargetType="{x:Type ComboBox}">
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryTextBrush}" />
+            </Style>
+
+            <Style BasedOn="{StaticResource MaterialDesignDatePicker}" TargetType="{x:Type DatePicker}">
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryTextBrush}" />
+            </Style>
+
+            <Style
+                x:Key="MaterialDesignFlatDarkButton"
+                BasedOn="{StaticResource MaterialDesignFlatButton}"
+                TargetType="{x:Type Button}">
+                <Style.Resources>
+                    <SolidColorBrush x:Key="MaterialDesignFlatButtonClick" Color="#4C4C4C" />
+                </Style.Resources>
+
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryHueMidForegroundBrush}" />
+            </Style>
+
+            <Style
+                x:Key="MaterialDesignFlatActionToggleButton"
+                BasedOn="{StaticResource MaterialDesignActionToggleButton}"
+                TargetType="{x:Type ToggleButton}">
+                <Setter Property="Background" Value="Transparent" />
+                <Setter Property="Foreground" Value="{DynamicResource PrimaryHueMidBrush}" />
+
+                <Style.Triggers>
+                    <Trigger Property="IsMouseOver" Value="True">
+                        <Setter Property="Background" Value="{DynamicResource MaterialDesignFlatButtonClick}" />
+                        <Setter Property="BorderBrush" Value="{DynamicResource MaterialDesignFlatButtonClick}" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+        </s:ApplicationLoader>
+    </Application.Resources>
+</Application>

DiscordChatExporter.Gui/App.xaml.cs

@@ -0,0 +1,6 @@
+namespace DiscordChatExporter.Gui
+{
+    public partial class App
+    {        
+    }
+}

DiscordChatExporter.Gui/Behaviors/ChannelViewModelMultiSelectionListBoxBehavior.cs

@@ -0,0 +1,8 @@
+using DiscordChatExporter.Gui.ViewModels.Components;
+
+namespace DiscordChatExporter.Gui.Behaviors
+{
+    public class ChannelViewModelMultiSelectionListBoxBehavior : MultiSelectionListBoxBehavior<ChannelViewModel>
+    {
+    }
+}

DiscordChatExporter.Gui/Behaviors/MultiSelectionListBoxBehavior.cs

@@ -0,0 +1,92 @@
+using System.Collections;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Interactivity;
+
+namespace DiscordChatExporter.Gui.Behaviors
+{
+    public class MultiSelectionListBoxBehavior<T> : Behavior<ListBox>
+    {
+        public static readonly DependencyProperty SelectedItemsProperty =
+            DependencyProperty.Register(nameof(SelectedItems), typeof(IList),
+                typeof(MultiSelectionListBoxBehavior<T>),
+                new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault,
+                    OnSelectedItemsChanged));
+
+        private static void OnSelectedItemsChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
+        {
+            var behavior = (MultiSelectionListBoxBehavior<T>) sender;
+            if (behavior._modelHandled) return;
+
+            if (behavior.AssociatedObject == null)
+                return;
+
+            behavior._modelHandled = true;
+            behavior.SelectItems();
+            behavior._modelHandled = false;
+        }
+
+        private bool _viewHandled;
+        private bool _modelHandled;
+
+        public IList SelectedItems
+        {
+            get => (IList) GetValue(SelectedItemsProperty);
+            set => SetValue(SelectedItemsProperty, value);
+        }
+
+        // Propagate selected items from model to view
+        private void SelectItems()
+        {
+            _viewHandled = true;
+
+            AssociatedObject.SelectedItems.Clear();
+            if (SelectedItems != null)
+            {
+                foreach (var item in SelectedItems)
+                    AssociatedObject.SelectedItems.Add(item);
+            }
+
+            _viewHandled = false;
+        }
+
+        // Propagate selected items from view to model
+        private void OnListBoxSelectionChanged(object sender, SelectionChangedEventArgs args)
+        {
+            if (_viewHandled) return;
+            if (AssociatedObject.Items.SourceCollection == null) return;
+
+            SelectedItems = AssociatedObject.SelectedItems.Cast<T>().ToArray();
+        }
+
+        // Re-select items when the set of items changes
+        private void OnListBoxItemsChanged(object sender, NotifyCollectionChangedEventArgs args)
+        {
+            if (_viewHandled) return;
+            if (AssociatedObject.Items.SourceCollection == null) return;
+            SelectItems();
+        }
+
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+
+            AssociatedObject.SelectionChanged += OnListBoxSelectionChanged;
+            ((INotifyCollectionChanged) AssociatedObject.Items).CollectionChanged += OnListBoxItemsChanged;
+        }
+
+        /// <inheritdoc />
+        protected override void OnDetaching()
+        {
+            base.OnDetaching();
+
+            if (AssociatedObject != null)
+            {
+                AssociatedObject.SelectionChanged -= OnListBoxSelectionChanged;
+                ((INotifyCollectionChanged) AssociatedObject.Items).CollectionChanged -= OnListBoxItemsChanged;
+            }
+        }
+    }
+}

DiscordChatExporter.Gui/Bootstrapper.cs

@@ -0,0 +1,34 @@
+using System.Windows;
+using System.Windows.Threading;
+using DiscordChatExporter.Core.Services;
+using DiscordChatExporter.Gui.ViewModels;
+using DiscordChatExporter.Gui.ViewModels.Framework;
+using Stylet;
+using StyletIoC;
+
+namespace DiscordChatExporter.Gui
+{
+    public class Bootstrapper : Bootstrapper<RootViewModel>
+    {
+        protected override void ConfigureIoC(IStyletIoCBuilder builder)
+        {
+            base.ConfigureIoC(builder);
+
+            // Autobind the .Services assembly
+            builder.Autobind(typeof(DataService).Assembly);
+
+            // Bind settings as singleton
+            builder.Bind<SettingsService>().ToSelf().InSingletonScope();
+
+            // Bind view model factory
+            builder.Bind<IViewModelFactory>().ToAbstractFactory();
+        }
+
+        protected override void OnUnhandledException(DispatcherUnhandledExceptionEventArgs e)
+        {
+            base.OnUnhandledException(e);
+
+            MessageBox.Show(e.Exception.ToString(), "Error occured", MessageBoxButton.OK, MessageBoxImage.Error);
+        }
+    }
+}

DiscordChatExporter.Gui/Converters/DateTimeOffsetToDateTimeConverter.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace DiscordChatExporter.Gui.Converters
+{
+    [ValueConversion(typeof(DateTimeOffset), typeof(DateTime))]
+    public class DateTimeOffsetToDateTimeConverter : IValueConverter
+    {
+        public static DateTimeOffsetToDateTimeConverter Instance { get; } = new DateTimeOffsetToDateTimeConverter();
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (value is DateTimeOffset date)
+                return date.DateTime;
+
+            return null;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (value is DateTime date)
+                return new DateTimeOffset(date);
+
+            return null;
+        }
+    }
+}

DiscordChatExporter.Gui/Converters/ExportFormatToStringConverter.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+using DiscordChatExporter.Core.Models;
+
+namespace DiscordChatExporter.Gui.Converters
+{
+    [ValueConversion(typeof(ExportFormat), typeof(string))]
+    public class ExportFormatToStringConverter : IValueConverter
+    {
+        public static ExportFormatToStringConverter Instance { get; } = new ExportFormatToStringConverter();
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (value is ExportFormat format)
+                return format.GetDisplayName();
+
+            return null;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

DiscordChatExporter.Gui/DiscordChatExporter.Gui.csproj

@@ -0,0 +1,155 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{732A67AF-93DE-49DF-B10F-FD74710B7863}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <RootNamespace>DiscordChatExporter.Gui</RootNamespace>
+    <AssemblyName>DiscordChatExporter</AssemblyName>
+    <TargetFrameworkVersion>v4.6</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <WarningLevel>4</WarningLevel>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationIcon>..\favicon.ico</ApplicationIcon>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xaml">
+      <RequiredTargetFramework>4.0</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="WindowsBase" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="App.xaml.cs">
+      <DependentUpon>App.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Behaviors\ChannelViewModelMultiSelectionListBoxBehavior.cs" />
+    <Compile Include="Behaviors\MultiSelectionListBoxBehavior.cs" />
+    <Compile Include="Bootstrapper.cs" />
+    <Compile Include="Converters\DateTimeOffsetToDateTimeConverter.cs" />
+    <Compile Include="Converters\ExportFormatToStringConverter.cs" />
+    <Compile Include="ViewModels\Components\ChannelViewModel.cs" />
+    <Compile Include="ViewModels\Components\GuildViewModel.cs" />
+    <Compile Include="ViewModels\Dialogs\ExportSetupViewModel.cs" />
+    <Compile Include="ViewModels\Framework\DialogManager.cs" />
+    <Compile Include="ViewModels\Framework\DialogScreen.cs" />
+    <Compile Include="ViewModels\Framework\Extensions.cs" />
+    <Compile Include="ViewModels\Framework\IViewModelFactory.cs" />
+    <Compile Include="ViewModels\Dialogs\SettingsViewModel.cs" />
+    <Compile Include="ViewModels\RootViewModel.cs" />
+    <Compile Include="Views\Dialogs\ExportSetupView.xaml.cs">
+      <DependentUpon>ExportSetupView.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Views\RootView.xaml.cs">
+      <DependentUpon>RootView.xaml</DependentUpon>
+    </Compile>
+    <Compile Include="Views\Dialogs\SettingsView.xaml.cs">
+      <DependentUpon>SettingsView.xaml</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <Resource Include="..\favicon.ico" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DiscordChatExporter.Core.Models\DiscordChatExporter.Core.Models.csproj">
+      <Project>{67a9d184-4656-4ce1-9d75-bddcbcafb200}</Project>
+      <Name>DiscordChatExporter.Core.Models</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\DiscordChatExporter.Core.Services\DiscordChatExporter.Core.Services.csproj">
+      <Project>{707c0cd0-a7e0-4cab-8db9-07a45cb87377}</Project>
+      <Name>DiscordChatExporter.Core.Services</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ApplicationDefinition Include="App.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+    <Page Include="Views\Dialogs\ExportSetupView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+    <Page Include="Views\RootView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+    <Page Include="Views\Dialogs\SettingsView.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Gress">
+      <Version>1.0.2</Version>
+    </PackageReference>
+    <PackageReference Include="MaterialDesignColors">
+      <Version>1.1.3</Version>
+    </PackageReference>
+    <PackageReference Include="MaterialDesignThemes">
+      <Version>2.5.0.1205</Version>
+    </PackageReference>
+    <PackageReference Include="Ookii.Dialogs.Wpf">
+      <Version>1.0.0</Version>
+    </PackageReference>
+    <PackageReference Include="PropertyChanged.Fody">
+      <Version>2.6.0</Version>
+    </PackageReference>
+    <PackageReference Include="Stylet">
+      <Version>1.1.22</Version>
+    </PackageReference>
+    <PackageReference Include="System.Windows.Interactivity.WPF">
+      <Version>2.0.20525</Version>
+    </PackageReference>
+    <PackageReference Include="Tyrrrz.Extensions">
+      <Version>1.6.0</Version>
+    </PackageReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

DiscordChatExporter.Gui/FodyWeavers.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Weavers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FodyWeavers.xsd">
+  <PropertyChanged />
+</Weavers>

DiscordChatExporter.Gui/FodyWeavers.xsd

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <!-- This file was generated by Fody. Manual changes to this file will be lost when your project is rebuild.  -->
+  <xs:element name="Weavers">
+    <xs:complexType>
+      <xs:all>
+        <xs:element name="PropertyChanged" minOccurs="0" maxOccurs="1">
+          <xs:complexType>
+            <xs:attribute name="InjectOnPropertyNameChanged" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if the On_PropertyName_Changed feature is enabled.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="EventInvokerNames" type="xs:string">
+              <xs:annotation>
+                <xs:documentation>Used to change the name of the method that fires the notify event. This is a string that accepts multiple values in a comma separated form.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="CheckForEquality" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if equality checks should be inserted. If false, equality checking will be disabled for the project.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="CheckForEqualityUsingBaseEquals" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if equality checks should use the Equals method resolved from the base class.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+            <xs:attribute name="UseStaticEqualsFromBase" type="xs:boolean">
+              <xs:annotation>
+                <xs:documentation>Used to control if equality checks should use the static Equals method resolved from the base class.</xs:documentation>
+              </xs:annotation>
+            </xs:attribute>
+          </xs:complexType>
+        </xs:element>
+      </xs:all>
+      <xs:attribute name="VerifyAssembly" type="xs:boolean">
+        <xs:annotation>
+          <xs:documentation>'true' to run assembly verification on the target assembly after all weavers have been finished.</xs:documentation>
+        </xs:annotation>
+      </xs:attribute>
+      <xs:attribute name="VerifyIgnoreCodes" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>A comma separated list of error codes that can be safely ignored in assembly verification.</xs:documentation>
+        </xs:annotation>
+      </xs:attribute>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>

DiscordChatExporter.Gui/Properties/AssemblyInfo.cs

@@ -0,0 +1,7 @@
+using System.Reflection;
+
+[assembly: AssemblyTitle("DiscordChatExporter")]
+[assembly: AssemblyCompany("Tyrrrz")]
+[assembly: AssemblyCopyright("Copyright (c) Alexey Golub")]
+[assembly: AssemblyVersion("2.12")]
+[assembly: AssemblyFileVersion("2.12")]

DiscordChatExporter.Gui/Properties/Resources.Designer.cs

@@ -8,10 +8,10 @@
 // </auto-generated>
 //------------------------------------------------------------------------------
 
-namespace DiscordChatExporter.Properties
-{
-
-
+namespace DiscordChatExporter.Gui.Properties {
+    using System;
+    
+    
     /// <summary>
     ///   A strongly-typed resource class, for looking up localized strings, etc.
     /// </summary>
@@ -19,51 +19,43 @@ namespace DiscordChatExporter.Properties
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class Resources
-    {
-
+    internal class Resources {
+        
         private static global::System.Resources.ResourceManager resourceMan;
-
+        
         private static global::System.Globalization.CultureInfo resourceCulture;
-
+        
         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        internal Resources()
-        {
+        internal Resources() {
         }
-
+        
         /// <summary>
         ///   Returns the cached ResourceManager instance used by this class.
         /// </summary>
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager
-        {
-            get
-            {
-                if ((resourceMan == null))
-                {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DiscordChatExporter.Properties.Resources", typeof(Resources).Assembly);
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DiscordChatExporter.Gui.Properties.Resources", typeof(Resources).Assembly);
                     resourceMan = temp;
                 }
                 return resourceMan;
             }
         }
-
+        
         /// <summary>
         ///   Overrides the current thread's CurrentUICulture property for all
         ///   resource lookups using this strongly typed resource class.
         /// </summary>
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture
-        {
-            get
-            {
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
                 return resourceCulture;
             }
-            set
-            {
+            set {
                 resourceCulture = value;
             }
         }