diff --git a/DisCatSharp.CommandsNext/CommandsNextUtilities.cs b/DisCatSharp.CommandsNext/CommandsNextUtilities.cs
index 7873c9b92..4d04b9874 100644
--- a/DisCatSharp.CommandsNext/CommandsNextUtilities.cs
+++ b/DisCatSharp.CommandsNext/CommandsNextUtilities.cs
@@ -1,431 +1,432 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.CommandsNext.Attributes;
 using DisCatSharp.CommandsNext.Converters;
 using DisCatSharp.Entities;
+using DisCatSharp.Common.RegularExpressions;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.CommandsNext
 {
     /// <summary>
     /// Various CommandsNext-related utilities.
     /// </summary>
     public static class CommandsNextUtilities
     {
         /// <summary>
         /// Gets the user regex.
         /// </summary>
-        private static Regex UserRegex { get; } = new Regex(@"<@\!?(\d+?)> ", RegexOptions.ECMAScript);
+        private static Regex UserRegex { get; } = DiscordRegEx.User;
 
         /// <summary>
         /// Checks whether the message has a specified string prefix.
         /// </summary>
         /// <param name="msg">Message to check.</param>
         /// <param name="str">String to check for.</param>
         /// <param name="comparisonType">Method of string comparison for the purposes of finding prefixes.</param>
         /// <returns>Positive number if the prefix is present, -1 otherwise.</returns>
         public static int GetStringPrefixLength(this DiscordMessage msg, string str, StringComparison comparisonType = StringComparison.Ordinal)
         {
             var content = msg.Content;
             return str.Length >= content.Length ? -1 : !content.StartsWith(str, comparisonType) ? -1 : str.Length;
         }
 
         /// <summary>
         /// Checks whether the message contains a specified mention prefix.
         /// </summary>
         /// <param name="msg">Message to check.</param>
         /// <param name="user">User to check for.</param>
         /// <returns>Positive number if the prefix is present, -1 otherwise.</returns>
         public static int GetMentionPrefixLength(this DiscordMessage msg, DiscordUser user)
         {
             var content = msg.Content;
             if (!content.StartsWith("<@"))
                 return -1;
 
             var cni = content.IndexOf('>');
             if (cni == -1 || content.Length <= cni + 2)
                 return -1;
 
             var cnp = content.Substring(0, cni + 2);
             var m = UserRegex.Match(cnp);
             if (!m.Success)
                 return -1;
 
             var userId = ulong.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture);
             return user.Id != userId ? -1 : m.Value.Length;
         }
 
         //internal static string ExtractNextArgument(string str, out string remainder)
         /// <summary>
         /// Extracts the next argument.
         /// </summary>
         /// <param name="str">The string.</param>
         /// <param name="startPos">The start position.</param>
         internal static string ExtractNextArgument(this string str, ref int startPos)
         {
             if (string.IsNullOrWhiteSpace(str))
                 return null;
 
             var inBacktick = false;
             var inTripleBacktick = false;
             var inQuote = false;
             var inEscape = false;
             var removeIndices = new List<int>(str.Length - startPos);
 
             var i = startPos;
             for (; i < str.Length; i++)
                 if (!char.IsWhiteSpace(str[i]))
                     break;
             startPos = i;
 
             var endPosition = -1;
             var startPosition = startPos;
             for (i = startPosition; i < str.Length; i++)
             {
                 if (char.IsWhiteSpace(str[i]) && !inQuote && !inTripleBacktick && !inBacktick && !inEscape)
                     endPosition = i;
 
                 if (str[i] == '\\' && str.Length > i + 1)
                 {
                     if (!inEscape && !inBacktick && !inTripleBacktick)
                     {
                         inEscape = true;
                         if (str.IndexOf("\\`", i) == i || str.IndexOf("\\\"", i) == i || str.IndexOf("\\\\", i) == i || (str.Length >= i && char.IsWhiteSpace(str[i + 1])))
                             removeIndices.Add(i - startPosition);
                         i++;
                     }
                     else if ((inBacktick || inTripleBacktick) && str.IndexOf("\\`", i) == i)
                     {
                         inEscape = true;
                         removeIndices.Add(i - startPosition);
                         i++;
                     }
                 }
 
                 if (str[i] == '`' && !inEscape)
                 {
                     var tripleBacktick = str.IndexOf("```", i) == i;
                     if (inTripleBacktick && tripleBacktick)
                     {
                         inTripleBacktick = false;
                         i += 2;
                     }
                     else if (!inBacktick && tripleBacktick)
                     {
                         inTripleBacktick = true;
                         i += 2;
                     }
 
                     if (inBacktick && !tripleBacktick)
                         inBacktick = false;
                     else if (!inTripleBacktick && tripleBacktick)
                         inBacktick = true;
                 }
 
                 if (str[i] == '"' && !inEscape && !inBacktick && !inTripleBacktick)
                 {
                     removeIndices.Add(i - startPosition);
 
                     inQuote = !inQuote;
                 }
 
                 if (inEscape)
                     inEscape = false;
 
                 if (endPosition != -1)
                 {
                     startPos = endPosition;
                     return startPosition != endPosition ? str.Substring(startPosition, endPosition - startPosition).CleanupString(removeIndices) : null;
                 }
             }
 
             startPos = str.Length;
             return startPos != startPosition ? str.Substring(startPosition).CleanupString(removeIndices) : null;
         }
 
         /// <summary>
         /// Cleanups the string.
         /// </summary>
         /// <param name="s">The string.</param>
         /// <param name="indices">The indices.</param>
         internal static string CleanupString(this string s, IList<int> indices)
         {
             if (!indices.Any())
                 return s;
 
             var li = indices.Last();
             var ll = 1;
             for (var x = indices.Count - 2; x >= 0; x--)
             {
                 if (li - indices[x] == ll)
                 {
                     ll++;
                     continue;
                 }
 
                 s = s.Remove(li - ll + 1, ll);
                 li = indices[x];
                 ll = 1;
             }
 
             return s.Remove(li - ll + 1, ll);
         }
 
 #pragma warning disable IDE1006 // Naming Styles
         /// <summary>
         /// Binds the arguments.
         /// </summary>
         /// <param name="ctx">The command context.</param>
         /// <param name="ignoreSurplus">If true, ignore further text in string.</param>
         internal static async Task<ArgumentBindingResult> BindArguments(CommandContext ctx, bool ignoreSurplus)
 #pragma warning restore IDE1006 // Naming Styles
         {
             var command = ctx.Command;
             var overload = ctx.Overload;
 
             var args = new object[overload.Arguments.Count + 2];
             args[1] = ctx;
             var rawArgumentList = new List<string>(overload.Arguments.Count);
 
             var argString = ctx.RawArgumentString;
             var foundAt = 0;
             var argValue = "";
             for (var i = 0; i < overload.Arguments.Count; i++)
             {
                 var arg = overload.Arguments[i];
                 if (arg.IsCatchAll)
                 {
                     if (arg.IsArray)
                     {
                         while (true)
                         {
                             argValue = ExtractNextArgument(argString, ref foundAt);
                             if (argValue == null)
                                 break;
 
                             rawArgumentList.Add(argValue);
                         }
 
                         break;
                     }
                     else
                     {
                         if (argString == null)
                             break;
 
                         argValue = argString.Substring(foundAt).Trim();
                         argValue = argValue == "" ? null : argValue;
                         foundAt = argString.Length;
 
                         rawArgumentList.Add(argValue);
                         break;
                     }
                 }
                 else
                 {
                     argValue = ExtractNextArgument(argString, ref foundAt);
                     rawArgumentList.Add(argValue);
                 }
 
                 if (argValue == null && !arg.IsOptional && !arg.IsCatchAll)
                     return new ArgumentBindingResult(new ArgumentException("Not enough arguments supplied to the command."));
                 else if (argValue == null)
                     rawArgumentList.Add(null);
             }
 
             if (!ignoreSurplus && foundAt < argString.Length)
                 return new ArgumentBindingResult(new ArgumentException("Too many arguments were supplied to this command."));
 
             for (var i = 0; i < overload.Arguments.Count; i++)
             {
                 var arg = overload.Arguments[i];
                 if (arg.IsCatchAll && arg.IsArray)
                 {
                     var array = Array.CreateInstance(arg.Type, rawArgumentList.Count - i);
                     var start = i;
                     while (i < rawArgumentList.Count)
                     {
                         try
                         {
                             array.SetValue(await ctx.CommandsNext.ConvertArgument(rawArgumentList[i], ctx, arg.Type).ConfigureAwait(false), i - start);
                         }
                         catch (Exception ex)
                         {
                             return new ArgumentBindingResult(ex);
                         }
                         i++;
                     }
 
                     args[start + 2] = array;
                     break;
                 }
                 else
                 {
                     try
                     {
                         args[i + 2] = rawArgumentList[i] != null ? await ctx.CommandsNext.ConvertArgument(rawArgumentList[i], ctx, arg.Type).ConfigureAwait(false) : arg.DefaultValue;
                     }
                     catch (Exception ex)
                     {
                         return new ArgumentBindingResult(ex);
                     }
                 }
             }
 
             return new ArgumentBindingResult(args, rawArgumentList);
         }
 
         /// <summary>
         /// Whether this module is a candidate type.
         /// </summary>
         /// <param name="type">The type.</param>
         internal static bool IsModuleCandidateType(this Type type)
             => type.GetTypeInfo().IsModuleCandidateType();
 
         /// <summary>
         /// Whether this module is a candidate type.
         /// </summary>
         /// <param name="ti">The type info.</param>
         internal static bool IsModuleCandidateType(this TypeInfo ti)
         {
             // check if compiler-generated
             if (ti.GetCustomAttribute<CompilerGeneratedAttribute>(false) != null)
                 return false;
 
             // check if derives from the required base class
             var tmodule = typeof(BaseCommandModule);
             var timodule = tmodule.GetTypeInfo();
             if (!timodule.IsAssignableFrom(ti))
                 return false;
 
             // check if anonymous
             if (ti.IsGenericType && ti.Name.Contains("AnonymousType") && (ti.Name.StartsWith("<>") || ti.Name.StartsWith("VB$")) && (ti.Attributes & TypeAttributes.NotPublic) == TypeAttributes.NotPublic)
                 return false;
 
             // check if abstract, static, or not a class
             if (!ti.IsClass || ti.IsAbstract)
                 return false;
 
             // check if delegate type
             var tdelegate = typeof(Delegate).GetTypeInfo();
             if (tdelegate.IsAssignableFrom(ti))
                 return false;
 
             // qualifies if any method or type qualifies
             return ti.DeclaredMethods.Any(xmi => xmi.IsCommandCandidate(out _)) || ti.DeclaredNestedTypes.Any(xti => xti.IsModuleCandidateType());
         }
 
         /// <summary>
         /// Whether this is a command candidate.
         /// </summary>
         /// <param name="method">The method.</param>
         /// <param name="parameters">The parameters.</param>
         internal static bool IsCommandCandidate(this MethodInfo method, out ParameterInfo[] parameters)
         {
             parameters = null;
             // check if exists
             if (method == null)
                 return false;
 
             // check if static, non-public, abstract, a constructor, or a special name
             if (method.IsStatic || method.IsAbstract || method.IsConstructor || method.IsSpecialName)
                 return false;
 
             // check if appropriate return and arguments
             parameters = method.GetParameters();
             if (!parameters.Any() || parameters.First().ParameterType != typeof(CommandContext) || method.ReturnType != typeof(Task))
                 return false;
 
             // qualifies
             return true;
         }
 
         /// <summary>
         /// Creates the instance.
         /// </summary>
         /// <param name="t">The type.</param>
         /// <param name="services">The services provider.</param>
         internal static object CreateInstance(this Type t, IServiceProvider services)
         {
             var ti = t.GetTypeInfo();
             var constructors = ti.DeclaredConstructors
                 .Where(xci => xci.IsPublic)
                 .ToArray();
 
             if (constructors.Length != 1)
                 throw new ArgumentException("Specified type does not contain a public constructor or contains more than one public constructor.");
 
             var constructor = constructors[0];
             var constructorArgs = constructor.GetParameters();
             var args = new object[constructorArgs.Length];
 
             if (constructorArgs.Length != 0 && services == null)
                 throw new InvalidOperationException("Dependency collection needs to be specified for parameterized constructors.");
 
             // inject via constructor
             if (constructorArgs.Length != 0)
                 for (var i = 0; i < args.Length; i++)
                     args[i] = services.GetRequiredService(constructorArgs[i].ParameterType);
 
             var moduleInstance = Activator.CreateInstance(t, args);
 
             // inject into properties
             var props = t.GetRuntimeProperties().Where(xp => xp.CanWrite && xp.SetMethod != null && !xp.SetMethod.IsStatic && xp.SetMethod.IsPublic);
             foreach (var prop in props)
             {
                 if (prop.GetCustomAttribute<DontInjectAttribute>() != null)
                     continue;
 
                 var service = services.GetService(prop.PropertyType);
                 if (service == null)
                     continue;
 
                 prop.SetValue(moduleInstance, service);
             }
 
             // inject into fields
             var fields = t.GetRuntimeFields().Where(xf => !xf.IsInitOnly && !xf.IsStatic && xf.IsPublic);
             foreach (var field in fields)
             {
                 if (field.GetCustomAttribute<DontInjectAttribute>() != null)
                     continue;
 
                 var service = services.GetService(field.FieldType);
                 if (service == null)
                     continue;
 
                 field.SetValue(moduleInstance, service);
             }
 
             return moduleInstance;
         }
     }
 }
diff --git a/DisCatSharp.CommandsNext/Converters/EntityConverters.cs b/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
index 9590879ea..7f65ec12c 100644
--- a/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/EntityConverters.cs
@@ -1,641 +1,600 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Common.RegularExpressions;
 using DisCatSharp.Entities;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
     /// <summary>
     /// Represents a discord user converter.
     /// </summary>
     public class DiscordUserConverter : IArgumentConverter<DiscordUser>
     {
         /// <summary>
         /// Gets the user regex.
         /// </summary>
         private static Regex UserRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordUserConverter"/> class.
         /// </summary>
         static DiscordUserConverter()
         {
-#if NETSTANDARD1_3
-            UserRegex = new Regex(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript);
-#else
             UserRegex = DiscordRegEx.User;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordUser>> IArgumentConverter<DiscordUser>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var uid))
             {
                 var result = await ctx.Client.GetUserAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordUser>();
                 return ret;
             }
 
             var m = UserRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out uid))
             {
                 var result = await ctx.Client.GetUserAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordUser>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var di = value.IndexOf('#');
             var un = di != -1 ? value.Substring(0, di) : value;
             var dv = di != -1 ? value.Substring(di + 1) : null;
 
             var us = ctx.Client.Guilds.Values
                 .SelectMany(xkvp => xkvp.Members.Values)
                 .Where(xm => (cs ? xm.Username : xm.Username.ToLowerInvariant()) == un && ((dv != null && xm.Discriminator == dv) || dv == null));
 
             var usr = us.FirstOrDefault();
             return usr != null ? Optional.FromValue<DiscordUser>(usr) : Optional.FromNoValue<DiscordUser>();
         }
     }
 
     /// <summary>
     /// Represents a discord member converter.
     /// </summary>
     public class DiscordMemberConverter : IArgumentConverter<DiscordMember>
     {
         /// <summary>
         /// Gets the user regex.
         /// </summary>
         private static Regex UserRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMemberConverter"/> class.
         /// </summary>
         static DiscordMemberConverter()
         {
-#if NETSTANDARD1_3
-            UserRegex = new Regex(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript);
-#else
             UserRegex = DiscordRegEx.User;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordMember>> IArgumentConverter<DiscordMember>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ctx.Guild == null)
                 return Optional.FromNoValue<DiscordMember>();
 
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var uid))
             {
                 var result = await ctx.Guild.GetMemberAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordMember>();
                 return ret;
             }
 
             var m = UserRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out uid))
             {
                 var result = await ctx.Guild.GetMemberAsync(uid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordMember>();
                 return ret;
             }
 
             var searchResult = await ctx.Guild.SearchMembersAsync(value).ConfigureAwait(false);
             if (searchResult.Any())
                 return Optional.FromValue(searchResult.First());
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var di = value.IndexOf('#');
             var un = di != -1 ? value.Substring(0, di) : value;
             var dv = di != -1 ? value.Substring(di + 1) : null;
 
             var us = ctx.Guild.Members.Values
                 .Where(xm => ((cs ? xm.Username : xm.Username.ToLowerInvariant()) == un && ((dv != null && xm.Discriminator == dv) || dv == null))
                           || (cs ? xm.Nickname : xm.Nickname?.ToLowerInvariant()) == value);
 
             var mbr = us.FirstOrDefault();
             return mbr != null ? Optional.FromValue(mbr) : Optional.FromNoValue<DiscordMember>();
         }
     }
 
     /// <summary>
     /// Represents a discord channel converter.
     /// </summary>
     public class DiscordChannelConverter : IArgumentConverter<DiscordChannel>
     {
         /// <summary>
         /// Gets the channel regex.
         /// </summary>
         private static Regex ChannelRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordChannelConverter"/> class.
         /// </summary>
         static DiscordChannelConverter()
         {
-#if NETSTANDARD1_3
-            ChannelRegex = new Regex(@"^<#(\d+)>$", RegexOptions.ECMAScript);
-#else
             ChannelRegex = DiscordRegEx.Channel;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordChannel>> IArgumentConverter<DiscordChannel>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var cid))
             {
                 var result = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordChannel>();
                 return ret;
             }
 
             var m = ChannelRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out cid))
             {
                 var result = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordChannel>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var chn = ctx.Guild?.Channels.Values.FirstOrDefault(xc => (cs ? xc.Name : xc.Name.ToLowerInvariant()) == value);
             return chn != null ? Optional.FromValue(chn) : Optional.FromNoValue<DiscordChannel>();
         }
     }
 
     /// <summary>
     /// Represents a discord thread channel converter.
     /// </summary>
     public class DiscordThreadChannelConverter : IArgumentConverter<DiscordThreadChannel>
     {
         /// <summary>
         /// Gets the channel regex.
         /// </summary>
         private static Regex ChannelRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordThreadChannelConverter"/> class.
         /// </summary>
         static DiscordThreadChannelConverter()
         {
-#if NETSTANDARD1_3
-            ChannelRegex = new Regex(@"^<#(\d+)>$", RegexOptions.ECMAScript);
-#else
             ChannelRegex = DiscordRegEx.Channel;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordThreadChannel>> IArgumentConverter<DiscordThreadChannel>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var tid))
             {
                 var result = await ctx.Client.GetThreadAsync(tid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordThreadChannel>();
                 return ret;
             }
 
             var m = ChannelRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out tid))
             {
                 var result = await ctx.Client.GetThreadAsync(tid).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordThreadChannel>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var tchn = ctx.Guild?.Threads.Values.FirstOrDefault(xc => (cs ? xc.Name : xc.Name.ToLowerInvariant()) == value);
             return tchn != null ? Optional.FromValue(tchn) : Optional.FromNoValue<DiscordThreadChannel>();
         }
     }
 
     /// <summary>
     /// Represents a discord role converter.
     /// </summary>
     public class DiscordRoleConverter : IArgumentConverter<DiscordRole>
     {
         /// <summary>
         /// Gets the role regex.
         /// </summary>
         private static Regex RoleRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordRoleConverter"/> class.
         /// </summary>
         static DiscordRoleConverter()
         {
-#if NETSTANDARD1_3
-            RoleRegex = new Regex(@"^<@&(\d+?)>$", RegexOptions.ECMAScript);
-#else
             RoleRegex = DiscordRegEx.Role;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordRole>> IArgumentConverter<DiscordRole>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ctx.Guild == null)
                 return Task.FromResult(Optional.FromNoValue<DiscordRole>());
 
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var rid))
             {
                 var result = ctx.Guild.GetRole(rid);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordRole>();
                 return Task.FromResult(ret);
             }
 
             var m = RoleRegex.Match(value);
             if (m.Success && ulong.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out rid))
             {
                 var result = ctx.Guild.GetRole(rid);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordRole>();
                 return Task.FromResult(ret);
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value.ToLowerInvariant();
 
             var rol = ctx.Guild.Roles.Values.FirstOrDefault(xr => (cs ? xr.Name : xr.Name.ToLowerInvariant()) == value);
             return Task.FromResult(rol != null ? Optional.FromValue(rol) : Optional.FromNoValue<DiscordRole>());
         }
     }
 
     /// <summary>
     /// Represents a discord guild converter.
     /// </summary>
     public class DiscordGuildConverter : IArgumentConverter<DiscordGuild>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordGuild>> IArgumentConverter<DiscordGuild>.ConvertAsync(string value, CommandContext ctx)
         {
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var gid))
             {
                 return ctx.Client.Guilds.TryGetValue(gid, out var result)
                     ? Task.FromResult(Optional.FromValue(result))
                     : Task.FromResult(Optional.FromNoValue<DiscordGuild>());
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value?.ToLowerInvariant();
 
             var gld = ctx.Client.Guilds.Values.FirstOrDefault(xg => (cs ? xg.Name : xg.Name.ToLowerInvariant()) == value);
             return Task.FromResult(gld != null ? Optional.FromValue(gld) : Optional.FromNoValue<DiscordGuild>());
         }
     }
 
 
     /// <summary>
     /// Represents a discord invite converter.
     /// </summary>
     public class DiscordInviteConverter : IArgumentConverter<DiscordInvite>
     {
         /// <summary>
         /// Gets the invite regex.
         /// </summary>
         private static Regex InviteRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordInviteConverter"/> class.
         /// </summary>
         static DiscordInviteConverter()
         {
-#if NETSTANDARD1_3
-            InviteRegex = new Regex(@"^(https?:\/\/)?(www\.)?(discord\.(gg|io|me|li)|discordapp\.com\/invite)\/(.+[a-z])$", RegexOptions.ECMAScript);
-#else
             InviteRegex = DiscordRegEx.Invite;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordInvite>> IArgumentConverter<DiscordInvite>.ConvertAsync(string value, CommandContext ctx)
         {
             var m = InviteRegex.Match(value);
             if (m.Success)
             {
                 var result = await ctx.Client.GetInviteByCodeAsync(m.Groups[5].Value).ConfigureAwait(false);
                 var ret = result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordInvite>();
                 return ret;
             }
 
             var cs = ctx.Config.CaseSensitive;
             if (!cs)
                 value = value?.ToLowerInvariant();
 
             var inv  = await ctx.Client.GetInviteByCodeAsync(value);
             return inv != null ? Optional.FromValue(inv) : Optional.FromNoValue<DiscordInvite>();
         }
     }
 
     /// <summary>
     /// Represents a discord message converter.
     /// </summary>
     public class DiscordMessageConverter : IArgumentConverter<DiscordMessage>
     {
         /// <summary>
         /// Gets the message path regex.
         /// </summary>
         private static Regex MessagePathRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordMessageConverter"/> class.
         /// </summary>
         static DiscordMessageConverter()
         {
-#if NETSTANDARD1_3
-            MessagePathRegex = new Regex(@"^\/channels\/(?<guild>(?:\d+|@me))\/(?<channel>\d+)\/(?<message>\d+)\/?$", RegexOptions.ECMAScript);
-#else
             MessagePathRegex = DiscordRegEx.MessageLink;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordMessage>> IArgumentConverter<DiscordMessage>.ConvertAsync(string value, CommandContext ctx)
         {
             if (string.IsNullOrWhiteSpace(value))
                 return Optional.FromNoValue<DiscordMessage>();
 
             var msguri = value.StartsWith("<") && value.EndsWith(">") ? value.Substring(1, value.Length - 2) : value;
             ulong mid;
             if (Uri.TryCreate(msguri, UriKind.Absolute, out var uri))
             {
                 if (uri.Host != "discordapp.com" && uri.Host != "discord.com" && !uri.Host.EndsWith(".discordapp.com") && !uri.Host.EndsWith(".discord.com"))
                     return Optional.FromNoValue<DiscordMessage>();
 
                 var uripath = MessagePathRegex.Match(uri.AbsolutePath);
                 if (!uripath.Success
                     || !ulong.TryParse(uripath.Groups["channel"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var cid)
                     || !ulong.TryParse(uripath.Groups["message"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out mid))
                     return Optional.FromNoValue<DiscordMessage>();
 
                 var chn = await ctx.Client.GetChannelAsync(cid).ConfigureAwait(false);
                 if (chn == null)
                     return Optional.FromNoValue<DiscordMessage>();
 
                 var msg = await chn.GetMessageAsync(mid).ConfigureAwait(false);
                 return msg != null ? Optional.FromValue(msg) : Optional.FromNoValue<DiscordMessage>();
             }
 
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out mid))
             {
                 var result = await ctx.Channel.GetMessageAsync(mid).ConfigureAwait(false);
                 return result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordMessage>();
             }
 
             return Optional.FromNoValue<DiscordMessage>();
         }
     }
 
     /// <summary>
     /// Represents a discord scheduled event converter.
     /// </summary>
     public class DiscordScheduledEventConverter : IArgumentConverter<DiscordScheduledEvent>
     {
         /// <summary>
         /// Gets the event regex.
         /// </summary>
         private static Regex EventRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordScheduledEventConverter"/> class.
         /// </summary>
         static DiscordScheduledEventConverter()
         {
-#if NETSTANDARD1_3
-            EventRegex = new Regex(@"^\/events\/(?<guild>\d+)\/(?<event>\d+)$", RegexOptions.ECMAScript);
-#else
             EventRegex = DiscordRegEx.Event;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         async Task<Optional<DiscordScheduledEvent>> IArgumentConverter<DiscordScheduledEvent>.ConvertAsync(string value, CommandContext ctx)
         {
             if (string.IsNullOrWhiteSpace(value))
                 return Optional.FromNoValue<DiscordScheduledEvent>();
 
             var msguri = value.StartsWith("<") && value.EndsWith(">") ? value.Substring(1, value.Length - 2) : value;
             ulong seid;
             if (Uri.TryCreate(msguri, UriKind.Absolute, out var uri))
             {
                 if (uri.Host != "discordapp.com" && uri.Host != "discord.com" && !uri.Host.EndsWith(".discordapp.com") && !uri.Host.EndsWith(".discord.com"))
                     return Optional.FromNoValue<DiscordScheduledEvent>();
 
                 var uripath = EventRegex.Match(uri.AbsolutePath);
                 if (!uripath.Success
                     || !ulong.TryParse(uripath.Groups["guild"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var gid)
                     || !ulong.TryParse(uripath.Groups["event"].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out seid))
                     return Optional.FromNoValue<DiscordScheduledEvent>();
 
                 var guild = await ctx.Client.GetGuildAsync(gid).ConfigureAwait(false);
                 if (guild == null)
                     return Optional.FromNoValue<DiscordScheduledEvent>();
 
                 var ev = await guild.GetScheduledEventAsync(seid).ConfigureAwait(false);
                 return ev != null ? Optional.FromValue(ev) : Optional.FromNoValue<DiscordScheduledEvent>();
             }
 
             if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out seid))
             {
                 var result = await ctx.Guild.GetScheduledEventAsync(seid).ConfigureAwait(false);
                 return result != null ? Optional.FromValue(result) : Optional.FromNoValue<DiscordScheduledEvent>();
             }
 
             return Optional.FromNoValue<DiscordScheduledEvent>();
         }
     }
 
     /// <summary>
     /// Represents a discord emoji converter.
     /// </summary>
     public class DiscordEmojiConverter : IArgumentConverter<DiscordEmoji>
     {
         /// <summary>
         /// Gets the emote regex.
         /// </summary>
         private static Regex EmoteRegex { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordEmojiConverter"/> class.
         /// </summary>
         static DiscordEmojiConverter()
         {
-#if NETSTANDARD1_3
-            EmoteRegex = new Regex(@"^<a?:([a-zA-Z0-9_]+?):(\d+?)>$", RegexOptions.ECMAScript);
-#else
             EmoteRegex = DiscordRegEx.Emoji;
-#endif
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordEmoji>> IArgumentConverter<DiscordEmoji>.ConvertAsync(string value, CommandContext ctx)
         {
             if (DiscordEmoji.TryFromUnicode(ctx.Client, value, out var emoji))
             {
                 var result = emoji;
                 var ret = Optional.FromValue(result);
                 return Task.FromResult(ret);
             }
 
             var m = EmoteRegex.Match(value);
             if (m.Success)
             {
                 var sid = m.Groups["id"].Value;
                 var name = m.Groups["name"].Value;
                 var anim = m.Groups["animated"].Success;
 
                 return !ulong.TryParse(sid, NumberStyles.Integer, CultureInfo.InvariantCulture, out var id)
                     ? Task.FromResult(Optional.FromNoValue<DiscordEmoji>())
                     : DiscordEmoji.TryFromGuildEmote(ctx.Client, id, out emoji)
                     ? Task.FromResult(Optional.FromValue(emoji))
                     : Task.FromResult(Optional.FromValue(new DiscordEmoji
                     {
                         Discord = ctx.Client,
                         Id = id,
                         Name = name,
                         IsAnimated = anim,
                         RequiresColons = true,
                         IsManaged = false
                     }));
             }
 
             return Task.FromResult(Optional.FromNoValue<DiscordEmoji>());
         }
     }
 
     /// <summary>
     /// Represents a discord color converter.
     /// </summary>
     public class DiscordColorConverter : IArgumentConverter<DiscordColor>
     {
         /// <summary>
         /// Gets the color regex hex.
         /// </summary>
         private static Regex ColorRegexHex { get; }
         /// <summary>
         /// Gets the color regex rgb.
         /// </summary>
         private static Regex ColorRegexRgb { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DiscordColorConverter"/> class.
         /// </summary>
         static DiscordColorConverter()
         {
-#if NETSTANDARD1_3
-            ColorRegexHex = new Regex(@"^#?([a-fA-F0-9]{6})$", RegexOptions.ECMAScript);
-            ColorRegexRgb = new Regex(@"^(\d{1,3})\s*?,\s*?(\d{1,3}),\s*?(\d{1,3})$", RegexOptions.ECMAScript);
-#else
-            ColorRegexHex = DiscordRegEx.HexColorString;
-            ColorRegexRgb = DiscordRegEx.RgbColorString;
-#endif
+            ColorRegexHex = CommonRegEx.HexColorString;
+            ColorRegexRgb = CommonRegEx.RgbColorString;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DiscordColor>> IArgumentConverter<DiscordColor>.ConvertAsync(string value, CommandContext ctx)
         {
             var m = ColorRegexHex.Match(value);
             if (m.Success && int.TryParse(m.Groups[1].Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var clr))
                 return Task.FromResult(Optional.FromValue<DiscordColor>(clr));
 
             m = ColorRegexRgb.Match(value);
             if (m.Success)
             {
                 var p1 = byte.TryParse(m.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var r);
                 var p2 = byte.TryParse(m.Groups[2].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var g);
                 var p3 = byte.TryParse(m.Groups[3].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var b);
 
                 return !(p1 && p2 && p3)
                     ? Task.FromResult(Optional.FromNoValue<DiscordColor>())
                     : Task.FromResult(Optional.FromValue(new DiscordColor(r, g, b)));
             }
 
             return Task.FromResult(Optional.FromNoValue<DiscordColor>());
         }
     }
 }
diff --git a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
index c4675b2c1..f9832adee 100644
--- a/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
+++ b/DisCatSharp.CommandsNext/Converters/TimeConverters.cs
@@ -1,148 +1,145 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Globalization;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
+using DisCatSharp.Common.RegularExpressions;
 
 namespace DisCatSharp.CommandsNext.Converters
 {
     /// <summary>
     /// Represents a date time converter.
     /// </summary>
     public class DateTimeConverter : IArgumentConverter<DateTime>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DateTime>> IArgumentConverter<DateTime>.ConvertAsync(string value, CommandContext ctx)
         {
             return DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
                 ? Task.FromResult(new Optional<DateTime>(result))
                 : Task.FromResult(Optional.FromNoValue<DateTime>());
         }
     }
 
     /// <summary>
     /// Represents a date time offset converter.
     /// </summary>
     public class DateTimeOffsetConverter : IArgumentConverter<DateTimeOffset>
     {
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<DateTimeOffset>> IArgumentConverter<DateTimeOffset>.ConvertAsync(string value, CommandContext ctx)
         {
             return DateTimeOffset.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result)
                 ? Task.FromResult(Optional.FromValue(result))
                 : Task.FromResult(Optional.FromNoValue<DateTimeOffset>());
         }
     }
 
     /// <summary>
     /// Represents a time span converter.
     /// </summary>
     public class TimeSpanConverter : IArgumentConverter<TimeSpan>
     {
         /// <summary>
         /// Gets or sets the time span regex.
         /// </summary>
         private static Regex TimeSpanRegex { get; set; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="TimeSpanConverter"/> class.
         /// </summary>
         static TimeSpanConverter()
         {
-#if NETSTANDARD1_3
-            TimeSpanRegex = new Regex(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript);
-#else
-            TimeSpanRegex = new Regex(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-#endif
+            TimeSpanRegex = CommonRegEx.TimeSpan;
         }
 
         /// <summary>
         /// Converts a string.
         /// </summary>
         /// <param name="value">The string to convert.</param>
         /// <param name="ctx">The command context.</param>
         Task<Optional<TimeSpan>> IArgumentConverter<TimeSpan>.ConvertAsync(string value, CommandContext ctx)
         {
             if (value == "0")
                 return Task.FromResult(Optional.FromValue(TimeSpan.Zero));
 
             if (int.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _))
                 return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
             if (!ctx.Config.CaseSensitive)
                 value = value.ToLowerInvariant();
 
             if (TimeSpan.TryParse(value, CultureInfo.InvariantCulture, out var result))
                 return Task.FromResult(Optional.FromValue(result));
 
             var gps = new string[] { "days", "hours", "minutes", "seconds" };
             var mtc = TimeSpanRegex.Match(value);
             if (!mtc.Success)
                 return Task.FromResult(Optional.FromNoValue<TimeSpan>());
 
             var d = 0;
             var h = 0;
             var m = 0;
             var s = 0;
             foreach (var gp in gps)
             {
                 var gpc = mtc.Groups[gp].Value;
                 if (string.IsNullOrWhiteSpace(gpc))
                     continue;
 
                 var gpt = gpc[gpc.Length - 1];
                 int.TryParse(gpc.Substring(0, gpc.Length - 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out var val);
                 switch (gpt)
                 {
                     case 'd':
                         d = val;
                         break;
 
                     case 'h':
                         h = val;
                         break;
 
                     case 'm':
                         m = val;
                         break;
 
                     case 's':
                         s = val;
                         break;
                 }
             }
             result = new TimeSpan(d, h, m, s);
             return Task.FromResult(Optional.FromValue(result));
         }
     }
 }
diff --git a/DisCatSharp.Common/RegularExpressions/CommonRegEx.cs b/DisCatSharp.Common/RegularExpressions/CommonRegEx.cs
new file mode 100644
index 000000000..95744fcaf
--- /dev/null
+++ b/DisCatSharp.Common/RegularExpressions/CommonRegEx.cs
@@ -0,0 +1,53 @@
+// This file is part of the DisCatSharp project, a fork of DSharpPlus.
+//
+// Copyright (c) 2021 AITSYS
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace DisCatSharp.Common.RegularExpressions
+{
+    /// <summary>
+    /// Provides common regex.
+    /// </summary>
+    public static class CommonRegEx
+    {
+        /// <summary>
+        /// Represents a hex color string.
+        /// </summary>
+        public static Regex HexColorString
+            => new(@"^#?([a-fA-F0-9]{6})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a rgp color string.
+        /// </summary>
+        public static Regex RgbColorString
+            => new(@"^(\d{1,3})\s*?,\s*?(\d{1,3}),\s*?(\d{1,3})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+
+        /// <summary>
+        /// Represents a timespan.
+        /// </summary>
+        public static Regex TimeSpan
+            => new(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
+    }
+}
diff --git a/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs b/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
index 85755045b..8350a3964 100644
--- a/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
+++ b/DisCatSharp.Common/RegularExpressions/DiscordRegEx.cs
@@ -1,137 +1,125 @@
 // This file is part of the DisCatSharp project, a fork of DSharpPlus.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
 
 namespace DisCatSharp.Common.RegularExpressions
 {
     /// <summary>
     /// Provides common regex for discord related things.
     /// </summary>
     public static class DiscordRegEx
     {
         /// <summary>
         /// Represents a invite.
         /// </summary>
         public static Regex Invite
             => new(@"^(https?:\/\/)?(www\.)?(discord\.(gg|io|me|li)|discordapp\.(com|net)\/invite)\/(.+[a-z])$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a message link.
         /// </summary>
         public static Regex MessageLink
             => new(@"^\/channels\/(?<guild>(?:\d+|@me))\/(?<channel>\d+)\/(?<message>\d+)\/?$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a emoji.
         /// </summary>
         public static Regex Emoji
             => new(@"^<(?<animated>a)?:(?<name>[a-zA-Z0-9_]+?):(?<id>\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a animated emoji.
         /// </summary>
         public static Regex AnimatedEmoji
             => new(@"^<(?<animated>a):(?<name>\w{2,32}):(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a non-animated emoji.
         /// </summary>
         public static Regex StaticEmoji
             => new(@"^<:(?<name>\w{2,32}):(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a timestamp.
         /// </summary>
         public static Regex Timestamp
             => new(@"^<t:(?<timestamp>-?\d{1,13})(:(?<style>[tTdDfFR]))?>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a default styled timestamp.
         /// </summary>
         public static Regex DefaultStyledTimestamp
             => new(@"^<t:(?<timestamp>-?\d{1,13})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a styled timestamp.
         /// </summary>
         public static Regex StyledTimestamp
             => new(@"^<t:(?<timestamp>-?\d{1,13}):(?<style>[tTdDfFR])>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
-        /// <summary>
-        /// Represents a hex color string.
-        /// </summary>
-        public static Regex HexColorString
-            => new(@"^#?([a-fA-F0-9]{6})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-
-        /// <summary>
-        /// Represents a rgp color string.
-        /// </summary>
-        public static Regex RgbColorString
-            => new(@"^(\d{1,3})\s*?,\s*?(\d{1,3}),\s*?(\d{1,3})$", RegexOptions.ECMAScript | RegexOptions.Compiled);
-
         /// <summary>
         /// Represents a role.
         /// </summary>
         public static Regex Role
             => new(@"^<@&(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a channel.
         /// </summary>
         public static Regex Channel
             => new(@"^<#(\d+)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a user.
         /// </summary>
         public static Regex User
             => new(@"^<@\!?(\d+?)>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a user with nickname.
         /// </summary>
         public static Regex UserWithNickname
             => new(@"^<@\!(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a user with optional nickname.
         /// </summary>
         public static Regex UserWithOptionalNickname
             => new(@"^<@\!?(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a user without nickname.
         /// </summary>
         public static Regex UserWithoutNickname
             => new(@"^<@(?<id>\d{17,20})>$", RegexOptions.ECMAScript | RegexOptions.Compiled);
 
         /// <summary>
         /// Represents a event.
         /// </summary>
         public static Regex Event
             => new(@"^\/events\/(?<guild>\d+)\/(?<event>\d+)$", RegexOptions.ECMAScript | RegexOptions.Compiled);
     }
 }