diff --git a/src/Rhythm.Core/CollectionExtensionMethods.cs b/src/Rhythm.Core/CollectionExtensionMethods.cs
index 36ad0fc..8e3b7b9 100644
--- a/src/Rhythm.Core/CollectionExtensionMethods.cs
+++ b/src/Rhythm.Core/CollectionExtensionMethods.cs
@@ -1,155 +1,149 @@
-namespace Rhythm.Core
+namespace Rhythm.Core;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+/// <summary>
+/// Extension methods for collections.
+/// </summary>
+public static class CollectionExtensionMethods
 {
 
-    // The namespaces.
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
+    #region Properties
 
     /// <summary>
-    /// Extension methods for collections.
+    /// Used to generate random numbers.
     /// </summary>
-    public static class CollectionExtensionMethods
-    {
+    private static Random Rnd { get; set; }
 
-        #region Properties
+    #endregion
 
-        /// <summary>
-        /// Used to generate random numbers.
-        /// </summary>
-        private static Random Rnd { get; set; }
+    #region Constructors
 
-        #endregion
+    /// <summary>
+    /// Static constructor.
+    /// </summary>
+    static CollectionExtensionMethods()
+    {
+        Rnd = new Random();
+    }
 
-        #region Constructors
+    #endregion
 
-        /// <summary>
-        /// Static constructor.
-        /// </summary>
-        static CollectionExtensionMethods()
-        {
-            Rnd = new Random();
-        }
+    #region Extension Methods
 
-        #endregion
-
-        #region Extension Methods
-
-        /// <summary>
-        /// Converts a null collection into an empty collection.
-        /// </summary>
-        /// <typeparam name="T">
-        /// The type of item stored by the collection.
-        /// </typeparam>
-        /// <param name="items">
-        /// The collection of items.
-        /// </param>
-        /// <returns>
-        /// An empty list, if the supplied collection is null; otherwise, the supplied collection.
-        /// </returns>
-        public static IEnumerable<T> MakeSafe<T>(this IEnumerable<T> items)
-        {
-            return items == null
-                ? Enumerable.Empty<T>()
-                : items;
-        }
+    /// <summary>
+    /// Converts a null collection into an empty collection.
+    /// </summary>
+    /// <typeparam name="T">
+    /// The type of item stored by the collection.
+    /// </typeparam>
+    /// <param name="items">
+    /// The collection of items.
+    /// </param>
+    /// <returns>
+    /// An empty list, if the supplied collection is null; otherwise, the supplied collection.
+    /// </returns>
+    public static IEnumerable<T> MakeSafe<T>(this IEnumerable<T> items)
+    {
+        return items ?? Enumerable.Empty<T>();
+    }
 
-        /// <summary>
-        /// Returns the collection of items without any nulls.
-        /// </summary>
-        /// <typeparam name="T">
-        /// The type of item stored by the collection.
-        /// </typeparam>
-        /// <param name="items">
-        /// The collection of items.
-        /// </param>
-        /// <returns>
-        /// The collection without null items.
-        /// </returns>
-        public static IEnumerable<T> WithoutNulls<T>(this IEnumerable<T> items)
-        {
-            return items.Where(x => x != null);
-        }
+    /// <summary>
+    /// Returns the collection of items without any nulls.
+    /// </summary>
+    /// <typeparam name="T">
+    /// The type of item stored by the collection.
+    /// </typeparam>
+    /// <param name="items">
+    /// The collection of items.
+    /// </param>
+    /// <returns>
+    /// The collection without null items.
+    /// </returns>
+    public static IEnumerable<T> WithoutNulls<T>(this IEnumerable<T> items)
+    {
+        return items.Where(x => x != null);
+    }
 
-        /// <summary>
-        /// Generates a sequence that conains the specified value the specified number of times.
-        /// </summary>
-        /// <typeparam name="T">
-        /// The type of the value to be repeated in the result sequence.
-        /// </typeparam>
-        /// <param name="element">
-        /// The value to be repeated.
-        /// </param>
-        /// <param name="count">
-        /// The number of times to repeat the value in the generated sequence.
-        /// </param>
-        /// <returns>
-        /// A collection containing the specified element the specified number of times.
-        /// </returns>
-        public static IEnumerable<T> Repeat<T>(this T element, int count)
-        {
-            return Enumerable.Repeat(element, count);
-        }
+    /// <summary>
+    /// Generates a sequence that conains the specified value the specified number of times.
+    /// </summary>
+    /// <typeparam name="T">
+    /// The type of the value to be repeated in the result sequence.
+    /// </typeparam>
+    /// <param name="element">
+    /// The value to be repeated.
+    /// </param>
+    /// <param name="count">
+    /// The number of times to repeat the value in the generated sequence.
+    /// </param>
+    /// <returns>
+    /// A collection containing the specified element the specified number of times.
+    /// </returns>
+    public static IEnumerable<T> Repeat<T>(this T element, int count)
+    {
+        return Enumerable.Repeat(element, count);
+    }
 
-        /// <summary>
-        /// Returns the specified collection of items in random order.
-        /// </summary>
-        /// <typeparam name="T">
-        /// The type of item stored by the collection.
-        /// </typeparam>
-        /// <param name="items">
-        /// The collection of items.
-        /// </param>
-        /// <returns>
-        /// The collection, in random order.
-        /// </returns>
-        public static IEnumerable<T> RandomOrder<T>(this IEnumerable<T> items)
+    /// <summary>
+    /// Returns the specified collection of items in random order.
+    /// </summary>
+    /// <typeparam name="T">
+    /// The type of item stored by the collection.
+    /// </typeparam>
+    /// <param name="items">
+    /// The collection of items.
+    /// </param>
+    /// <returns>
+    /// The collection, in random order.
+    /// </returns>
+    public static IEnumerable<T> RandomOrder<T>(this IEnumerable<T> items)
+    {
+        var itemsList = items.MakeSafe().ToList();
+        var randomized = new List<T>();
+        var count = itemsList.Count;
+        for(var i = 0; i < count; i++)
         {
-            var itemsList = items.MakeSafe().ToList();
-            var randomized = new List<T>();
-            var count = itemsList.Count;
-            for(var i = 0; i < count; i++)
-            {
-                var index = Rnd.Next(itemsList.Count);
-                var item = itemsList[index];
-                randomized.Add(item);
-                itemsList[index] = itemsList.Last();
-                itemsList.RemoveAt(itemsList.Count - 1);
-            }
-            return randomized;
+            var index = Rnd.Next(itemsList.Count);
+            var item = itemsList[index];
+            randomized.Add(item);
+            itemsList[index] = itemsList.Last();
+            itemsList.RemoveAt(itemsList.Count - 1);
         }
+        return randomized;
+    }
 
-        /// <summary>
-        /// Returns a list for the specified collection. Attempts to return the
-        /// underlying collection if it is already a list; otherwise, it converts
-        /// the collection to a list.
-        /// </summary>
-        /// <typeparam name="T">
-        /// The type of item stored by the collection.
-        /// </typeparam>
-        /// <param name="items">
-        /// The collection of items.
-        /// </param>
-        /// <returns>
-        /// An empty list, if the supplied collection is null; otherwise, the
-        /// supplied collection as a list.
-        /// </returns>
-        /// <remarks>
-        /// This will never return a null (i.e., it will return an empty list
-        /// rather than a null).
-        /// </remarks>
-        public static List<T> AsList<T>(this IEnumerable<T> items)
+    /// <summary>
+    /// Returns a list for the specified collection. Attempts to return the
+    /// underlying collection if it is already a list; otherwise, it converts
+    /// the collection to a list.
+    /// </summary>
+    /// <typeparam name="T">
+    /// The type of item stored by the collection.
+    /// </typeparam>
+    /// <param name="items">
+    /// The collection of items.
+    /// </param>
+    /// <returns>
+    /// An empty list, if the supplied collection is null; otherwise, the
+    /// supplied collection as a list.
+    /// </returns>
+    /// <remarks>
+    /// This will never return a null (i.e., it will return an empty list
+    /// rather than a null).
+    /// </remarks>
+    public static List<T> AsList<T>(this IEnumerable<T> items)
+    {
+        var list = items as List<T>;
+        if (list == null)
         {
-            var list = items as List<T>;
-            if (list == null)
-            {
-                list = items.MakeSafe().ToList();
-            }
-            return list;
+            list = items.MakeSafe().ToList();
         }
-
-        #endregion
-
+        return list;
     }
 
-}
\ No newline at end of file
+    #endregion
+
+}
diff --git a/src/Rhythm.Core/Enums/StringSplitDelimiters.cs b/src/Rhythm.Core/Enums/StringSplitDelimiters.cs
index 64cef8f..c954ac3 100644
--- a/src/Rhythm.Core/Enums/StringSplitDelimiters.cs
+++ b/src/Rhythm.Core/Enums/StringSplitDelimiters.cs
@@ -1,51 +1,48 @@
-namespace Rhythm.Core.Enums
+namespace Rhythm.Core.Enums;
+
+/// <summary>
+/// The types of delimiters that can be used to split strings.
+/// </summary>
+public enum StringSplitDelimiters
 {
 
     /// <summary>
-    /// The types of delimiters that can be used to split strings.
+    /// Default will split by common delimiters (e.g., commas, line breaks, semicolons).
     /// </summary>
-    public enum StringSplitDelimiters
-    {
-
-        /// <summary>
-        /// Default will split by common delimiters (e.g., commas, line breaks, semicolons).
-        /// </summary>
-        Default,
-
-        /// <summary>
-        /// Split by line breaks.
-        /// </summary>
-        LineBreak,
+    Default,
 
-        /// <summary>
-        /// Split by commas.
-        /// </summary>
-        Comma,
+    /// <summary>
+    /// Split by line breaks.
+    /// </summary>
+    LineBreak,
 
-        /// <summary>
-        /// Split by semicolon.
-        /// </summary>
-        Semicolon,
+    /// <summary>
+    /// Split by commas.
+    /// </summary>
+    Comma,
 
-        /// <summary>
-        /// Split by tabs.
-        /// </summary>
-        Tab,
+    /// <summary>
+    /// Split by semicolon.
+    /// </summary>
+    Semicolon,
 
-        /// <summary>
-        /// Split by equals signs.
-        /// </summary>
-        Equals,
+    /// <summary>
+    /// Split by tabs.
+    /// </summary>
+    Tab,
 
-        /// <summary>
-        /// Split by \.
-        /// </summary>
-        BackSlash,
+    /// <summary>
+    /// Split by equals signs.
+    /// </summary>
+    Equals,
 
-        /// <summary>
-        /// Split by /.
-        /// </summary>
-        ForwardSlash,
-    }
+    /// <summary>
+    /// Split by \.
+    /// </summary>
+    BackSlash,
 
-}
\ No newline at end of file
+    /// <summary>
+    /// Split by /.
+    /// </summary>
+    ForwardSlash,
+}
diff --git a/src/Rhythm.Core/StringExtensionMethods.cs b/src/Rhythm.Core/StringExtensionMethods.cs
index 9aa94a6..c03226c 100644
--- a/src/Rhythm.Core/StringExtensionMethods.cs
+++ b/src/Rhythm.Core/StringExtensionMethods.cs
@@ -1,277 +1,273 @@
-namespace Rhythm.Core
+namespace Rhythm.Core;
+
+using Enums;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+/// <summary>
+/// Extension methods for strings.
+/// </summary>
+public static class StringExtensionMethods
 {
 
-    // Namespaces.
-    using Enums;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Text.RegularExpressions;
+    #region Constants
 
-    /// <summary>
-    /// Extension methods for strings.
-    /// </summary>
-    public static class StringExtensionMethods
-    {
+    private const string SnakeCaseReplace = @"-${EDGE}";
+    private const string CssReplace = @"-";
 
-        #region Constants
+    #endregion
 
-        private const string SnakeCaseReplace = @"-${EDGE}";
-        private const string CssReplace = @"-";
+    #region Properties
 
-        #endregion
+    /// <summary>
+    /// This regular expression matches the substrings that should have a dash inserted.
+    /// before them.
+    /// </summary>
+    private static Regex SlugInsertionPointRegex { get; set; }
 
-        #region Properties
+    /// <summary>
+    /// This regular expression matches the a hyphen followed by any character.
+    /// before them.
+    /// </summary>
+    private static Regex DashAndCharRegex { get; set; }
 
-        /// <summary>
-        /// This regular expression matches the substrings that should have a dash inserted.
-        /// before them.
-        /// </summary>
-        private static Regex SlugInsertionPointRegex { get; set; }
+    /// <summary>
+    /// This regular expression matches a line (i.e., everything except for line breaks).
+    /// </summary>
+    private static Regex LineRegex { get; set; }
 
-        /// <summary>
-        /// This regular expression matches the a hyphen followed by any character.
-        /// before them.
-        /// </summary>
-        private static Regex DashAndCharRegex { get; set; }
+    /// <summary>
+    /// This regular expression matches the invalid CSS characters.
+    /// </summary>
+    private static Regex InvalidCssChars { get; set; }
 
-        /// <summary>
-        /// This regular expression matches a line (i.e., everything except for line breaks).
-        /// </summary>
-        private static Regex LineRegex { get; set; }
+    #endregion
 
-        /// <summary>
-        /// This regular expression matches the invalid CSS characters.
-        /// </summary>
-        private static Regex InvalidCssChars { get; set; }
+    #region Constructors
 
-        #endregion
+    /// <summary>
+    /// Static constructor.
+    /// </summary>
+    static StringExtensionMethods()
+    {
+        var options = RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase;
+        var options2 = RegexOptions.Compiled | RegexOptions.Singleline;
+        LineRegex = new Regex(@"((?!\r|\n).)+", options);
+        SlugInsertionPointRegex = new Regex(@"(?<EDGE>(?<![A-Z]+|-|^)[A-Z]+)", options2);
+        DashAndCharRegex = new Regex("-(?<CHAR>.)", options);
+        InvalidCssChars = new Regex(@"((?![a-z0-9]).)+", options);
+    }
 
-        #region Constructors
+    #endregion
 
-        /// <summary>
-        /// Static constructor.
-        /// </summary>
-        static StringExtensionMethods()
-        {
-            var options = RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase;
-            var options2 = RegexOptions.Compiled | RegexOptions.Singleline;
-            LineRegex = new Regex(@"((?!\r|\n).)+", options);
-            SlugInsertionPointRegex = new Regex(@"(?<EDGE>(?<![A-Z]+|-|^)[A-Z]+)", options2);
-            DashAndCharRegex = new Regex("-(?<CHAR>.)", options);
-            InvalidCssChars = new Regex(@"((?![a-z0-9]).)+", options);
-        }
+    #region Extension Methods
 
-        #endregion
-
-        #region Extension Methods
+    /// <summary>
+    /// Splits a string by the specified delimiter.
+    /// </summary>
+    /// <param name="source">
+    /// The string to split.
+    /// </param>
+    /// <param name="delimiter">
+    /// Optional. The delimiter. If unspecified, default delimiters will be used.
+    /// </param>
+    /// <returns>
+    /// The split strings.
+    /// </returns>
+    public static IEnumerable<string> SplitBy(this string source,
+        StringSplitDelimiters delimiter = StringSplitDelimiters.Default)
+    {
 
-        /// <summary>
-        /// Splits a string by the specified delimiter.
-        /// </summary>
-        /// <param name="source">
-        /// The string to split.
-        /// </param>
-        /// <param name="delimiter">
-        /// Optional. The delimiter. If unspecified, default delimiters will be used.
-        /// </param>
-        /// <returns>
-        /// The split strings.
-        /// </returns>
-        public static IEnumerable<string> SplitBy(this string source,
-            StringSplitDelimiters delimiter = StringSplitDelimiters.Default)
+        // If the source string is null, return an empty collection.
+        if (source == null)
         {
-
-            // If the source string is null, return an empty collection.
-            if (source == null)
-            {
-                return Enumerable.Empty<string>();
-            }
-
-            // Split by delimiter type.
-            switch (delimiter)
-            {
-                case StringSplitDelimiters.Default:
-                    var lines = SplitByChars(source, ',', ';')
-                        .SelectMany(x => SplitByLineBreaks(x));
-                    return CleanItems(lines);
-                case StringSplitDelimiters.Comma:
-                    return CleanItems(SplitByChars(source, ','));
-                case StringSplitDelimiters.LineBreak:
-                    return CleanItems(SplitByLineBreaks(source));
-                case StringSplitDelimiters.Semicolon:
-                    return CleanItems(SplitByChars(source, ';'));
-                case StringSplitDelimiters.Tab:
-                    return CleanItems(SplitByChars(source, '\t'));
-                case StringSplitDelimiters.Equals:
-                    return CleanItems(SplitByChars(source, '='));
-                case StringSplitDelimiters.BackSlash:
-                    return CleanItems(SplitByChars(source, '\\'));
-                case StringSplitDelimiters.ForwardSlash:
-                    return CleanItems(SplitByChars(source, '/'));
-                default:
-                    return new[] { source };
-            }
-
+            return Enumerable.Empty<string>();
         }
 
-        /// <summary>
-        /// Converts a camel case string to snake case (e.g., converts "thisThing" to "this-thing").
-        /// </summary>
-        /// <param name="source">
-        /// The camel case string to convert.
-        /// </param>
-        /// <returns>
-        /// The snake case string.
-        /// </returns>
-        public static string ToSnakeCase(this string source)
+        // Split by delimiter type.
+        switch (delimiter)
         {
-            if (string.IsNullOrWhiteSpace(source))
-            {
-                return null;
-            }
-            return SlugInsertionPointRegex.Replace(source, SnakeCaseReplace).ToLower();
+            case StringSplitDelimiters.Default:
+                var lines = SplitByChars(source, ',', ';')
+                    .SelectMany(x => SplitByLineBreaks(x));
+                return CleanItems(lines);
+            case StringSplitDelimiters.Comma:
+                return CleanItems(SplitByChars(source, ','));
+            case StringSplitDelimiters.LineBreak:
+                return CleanItems(SplitByLineBreaks(source));
+            case StringSplitDelimiters.Semicolon:
+                return CleanItems(SplitByChars(source, ';'));
+            case StringSplitDelimiters.Tab:
+                return CleanItems(SplitByChars(source, '\t'));
+            case StringSplitDelimiters.Equals:
+                return CleanItems(SplitByChars(source, '='));
+            case StringSplitDelimiters.BackSlash:
+                return CleanItems(SplitByChars(source, '\\'));
+            case StringSplitDelimiters.ForwardSlash:
+                return CleanItems(SplitByChars(source, '/'));
+            default:
+                return new[] { source };
         }
 
-        /// <summary>
-        /// Converts a snake case string to camel case (e.g., converts "this-thing" to "thisThing").
-        /// </summary>
-        /// <param name="source">
-        /// The snake case string to convert.
-        /// </param>
-        /// <returns>
-        /// The camel case string.
-        /// </returns>
-        public static string ToCamelCase(this string source)
+    }
+
+    /// <summary>
+    /// Converts a camel case string to snake case (e.g., converts "thisThing" to "this-thing").
+    /// </summary>
+    /// <param name="source">
+    /// The camel case string to convert.
+    /// </param>
+    /// <returns>
+    /// The snake case string.
+    /// </returns>
+    public static string ToSnakeCase(this string source)
+    {
+        if (string.IsNullOrWhiteSpace(source))
         {
-            if (string.IsNullOrWhiteSpace(source))
-            {
-                return null;
-            }
-            return DashAndCharRegex.Replace(source, x =>
-            {
-                return x.Groups["CHAR"].Value.ToUpper();
-            });
+            return null;
         }
+        return SlugInsertionPointRegex.Replace(source, SnakeCaseReplace).ToLower();
+    }
 
-        /// <summary>
-        /// Converts a snake case string to pascal case (e.g., converts "this-thing" to "ThisThing").
-        /// </summary>
-        /// <param name="source">
-        /// The snake case string to convert.
-        /// </param>
-        /// <returns>
-        /// The pascal case string.
-        /// </returns>
-        public static string ToPascalCase(this string source)
+    /// <summary>
+    /// Converts a snake case string to camel case (e.g., converts "this-thing" to "thisThing").
+    /// </summary>
+    /// <param name="source">
+    /// The snake case string to convert.
+    /// </param>
+    /// <returns>
+    /// The camel case string.
+    /// </returns>
+    public static string ToCamelCase(this string source)
+    {
+        if (string.IsNullOrWhiteSpace(source))
         {
-            if (string.IsNullOrWhiteSpace(source))
-            {
-                return null;
-            }
-            var camelCase = ToCamelCase(source);
-            return camelCase.Substring(0, 1).ToUpper() + camelCase.Substring(1);
+            return null;
         }
+        return DashAndCharRegex.Replace(source, x =>
+        {
+            return x.Groups["CHAR"].Value.ToUpper();
+        });
+    }
 
-        /// <summary>
-        /// Sanitizes a string for use as a CSS class (e.g., converts
-        /// "some randomText" to "some-random-text").
-        /// </summary>
-        /// <param name="source">
-        /// The string to sanitize.
-        /// </param>
-        /// <returns>
-        /// The string that can be used as a CSS class.
-        /// </returns>
-        public static string SanitizeForCss(this string source)
+    /// <summary>
+    /// Converts a snake case string to pascal case (e.g., converts "this-thing" to "ThisThing").
+    /// </summary>
+    /// <param name="source">
+    /// The snake case string to convert.
+    /// </param>
+    /// <returns>
+    /// The pascal case string.
+    /// </returns>
+    public static string ToPascalCase(this string source)
+    {
+        if (string.IsNullOrWhiteSpace(source))
         {
-            if (string.IsNullOrWhiteSpace(source))
-            {
-                return null;
-            }
-            return InvalidCssChars
-                .Replace(source, CssReplace)
-                .ToSnakeCase()
-                .Trim(CssReplace.ToCharArray());
+            return null;
         }
+        var camelCase = ToCamelCase(source);
+        return string.Concat(camelCase[..1].ToUpper(), camelCase.AsSpan(1));
+    }
 
-        /// <summary>
-        /// Returns either the supplied string or null (in the case that the string is empty
-        /// or whitespace).
-        /// </summary>
-        /// <param name="source">
-        /// The string to return.
-        /// </param>
-        /// <returns>
-        /// The specified string, or null.
-        /// </returns>
-        /// <remarks>
-        /// Useful when you want to use the null-coalescing operator and you want to treat an
-        /// empty or whitespace string as if it were null.
-        /// </remarks>
-        public static string PreferNull(this string source)
+    /// <summary>
+    /// Sanitizes a string for use as a CSS class (e.g., converts
+    /// "some randomText" to "some-random-text").
+    /// </summary>
+    /// <param name="source">
+    /// The string to sanitize.
+    /// </param>
+    /// <returns>
+    /// The string that can be used as a CSS class.
+    /// </returns>
+    public static string SanitizeForCss(this string source)
+    {
+        if (string.IsNullOrWhiteSpace(source))
         {
-            return string.IsNullOrWhiteSpace(source)
-                ? null
-                : source;
+            return null;
         }
+        return InvalidCssChars
+            .Replace(source, CssReplace)
+            .ToSnakeCase()
+            .Trim(CssReplace.ToCharArray());
+    }
 
-        #endregion
-
-        #region Private Methods
+    /// <summary>
+    /// Returns either the supplied string or null (in the case that the string is empty
+    /// or whitespace).
+    /// </summary>
+    /// <param name="source">
+    /// The string to return.
+    /// </param>
+    /// <returns>
+    /// The specified string, or null.
+    /// </returns>
+    /// <remarks>
+    /// Useful when you want to use the null-coalescing operator and you want to treat an
+    /// empty or whitespace string as if it were null.
+    /// </remarks>
+    public static string PreferNull(this string source)
+    {
+        return string.IsNullOrWhiteSpace(source)
+            ? null
+            : source;
+    }
 
-        /// <summary>
-        /// Split a string by line breaks.
-        /// </summary>
-        /// <param name="source">
-        /// The string to split.
-        /// </param>
-        /// <returns>
-        /// The split strings.
-        /// </returns>
-        private static IEnumerable<string> SplitByLineBreaks(string source)
-        {
-            return LineRegex
-                .Matches(source)
-                .Cast<Match>()
-                .Select(x => x.Value);
-        }
+    #endregion
 
-        /// <summary>
-        /// Split a string by the specified characters.
-        /// </summary>
-        /// <param name="source">
-        /// The string to split.
-        /// </param>
-        /// <param name="characters">
-        /// The characters to split by.
-        /// </param>
-        /// <returns>
-        /// The split strings.
-        /// </returns>
-        private static IEnumerable<string> SplitByChars(string source, params char[] characters)
-        {
-            return source.Split(characters);
-        }
+    #region Private Methods
 
-        /// <summary>
-        /// Cleans the collection of strings, trimming whitespace and removing empties.
-        /// </summary>
-        /// <param name="items">
-        /// The items to clean.
-        /// </param>
-        /// <returns>
-        /// The cleaned strings.
-        /// </returns>
-        private static IEnumerable<string> CleanItems(IEnumerable<string> items)
-        {
-            return items
-                .MakeSafe()
-                .Select(x => x.Trim())
-                .Where(x => !string.IsNullOrWhiteSpace(x));
-        }
+    /// <summary>
+    /// Split a string by line breaks.
+    /// </summary>
+    /// <param name="source">
+    /// The string to split.
+    /// </param>
+    /// <returns>
+    /// The split strings.
+    /// </returns>
+    private static IEnumerable<string> SplitByLineBreaks(string source)
+    {
+        return LineRegex
+            .Matches(source)
+            .Cast<Match>()
+            .Select(x => x.Value);
+    }
 
-        #endregion
+    /// <summary>
+    /// Split a string by the specified characters.
+    /// </summary>
+    /// <param name="source">
+    /// The string to split.
+    /// </param>
+    /// <param name="characters">
+    /// The characters to split by.
+    /// </param>
+    /// <returns>
+    /// The split strings.
+    /// </returns>
+    private static IEnumerable<string> SplitByChars(string source, params char[] characters)
+    {
+        return source.Split(characters);
+    }
 
+    /// <summary>
+    /// Cleans the collection of strings, trimming whitespace and removing empties.
+    /// </summary>
+    /// <param name="items">
+    /// The items to clean.
+    /// </param>
+    /// <returns>
+    /// The cleaned strings.
+    /// </returns>
+    private static IEnumerable<string> CleanItems(IEnumerable<string> items)
+    {
+        return items
+            .MakeSafe()
+            .Select(x => x.Trim())
+            .Where(x => !string.IsNullOrWhiteSpace(x));
     }
 
-}
\ No newline at end of file
+    #endregion
+}
diff --git a/src/Tests/StringTests.cs b/src/Tests/StringTests.cs
index 0ce29f6..c498ccc 100644
--- a/src/Tests/StringTests.cs
+++ b/src/Tests/StringTests.cs
@@ -1,51 +1,46 @@
-namespace Tests
+namespace Tests;
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Rhythm.Core;
+
+/// <summary>
+/// Tests for string extension methods.
+/// </summary>
+[TestClass]
+public sealed class StringTests
 {
 
-    // Namespaces.
-    using Microsoft.VisualStudio.TestTools.UnitTesting;
-    using Rhythm.Core;
+    #region Test Methods
 
     /// <summary>
-    /// Tests for string extension methods.
+    /// Test if camel case works.
     /// </summary>
-    [TestClass]
-    public class StringTests
+    [TestMethod]
+    public void CamelCase()
     {
+        var result = "hello-world-test".ToCamelCase();
+        Assert.AreEqual("helloWorldTest", result);
+    }
 
-        #region Test Methods
-
-        /// <summary>
-        /// Test if camel case works.
-        /// </summary>
-        [TestMethod]
-        public void CamelCase()
-        {
-            var result = "hello-world-test".ToCamelCase();
-            Assert.AreEqual("helloWorldTest", result);
-        }
-
-        /// <summary>
-        /// Test if pascal case works.
-        /// </summary>
-        [TestMethod]
-        public void PascalCase()
-        {
-            var result = "hello-world-test".ToPascalCase();
-            Assert.AreEqual("HelloWorldTest", result);
-        }
-
-        /// <summary>
-        /// Test if pascal case works with a single letter.
-        /// </summary>
-        [TestMethod]
-        public void PascalCaseSingleLetter()
-        {
-            var result = "a".ToPascalCase();
-            Assert.AreEqual("A", result);
-        }
-
-        #endregion
+    /// <summary>
+    /// Test if pascal case works.
+    /// </summary>
+    [TestMethod]
+    public void PascalCase()
+    {
+        var result = "hello-world-test".ToPascalCase();
+        Assert.AreEqual("HelloWorldTest", result);
+    }
 
+    /// <summary>
+    /// Test if pascal case works with a single letter.
+    /// </summary>
+    [TestMethod]
+    public void PascalCaseSingleLetter()
+    {
+        var result = "a".ToPascalCase();
+        Assert.AreEqual("A", result);
     }
 
-}
\ No newline at end of file
+    #endregion
+}