diff --git a/TJC.StringExtensions.Tests/Cases/CamelCaseExtensionsTests.cs b/TJC.StringExtensions.Tests/Cases/CamelCaseExtensionsTests.cs
index 0ec33f4..30f38cd 100644
--- a/TJC.StringExtensions.Tests/Cases/CamelCaseExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Cases/CamelCaseExtensionsTests.cs
@@ -60,4 +60,4 @@ public void ToCamelCaseTest()
         // Assert
         Assert.AreEqual(expected, result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Cases/KebabCaseExtensionsTests.cs b/TJC.StringExtensions.Tests/Cases/KebabCaseExtensionsTests.cs
index f246ba2..a1f09bd 100644
--- a/TJC.StringExtensions.Tests/Cases/KebabCaseExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Cases/KebabCaseExtensionsTests.cs
@@ -88,4 +88,4 @@ public void FromKebabCase_ToKebabCase()
         // Assert
         Assert.AreEqual(expected, result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Cases/PascalCaseExtensionsTests.cs b/TJC.StringExtensions.Tests/Cases/PascalCaseExtensionsTests.cs
index 51f8e1d..7d1df3e 100644
--- a/TJC.StringExtensions.Tests/Cases/PascalCaseExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Cases/PascalCaseExtensionsTests.cs
@@ -18,4 +18,4 @@ public void ToPascalCaseTest()
         // Assert
         Assert.AreEqual(expected, result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Cases/SnakeCaseExtensionsTests.cs b/TJC.StringExtensions.Tests/Cases/SnakeCaseExtensionsTests.cs
index 3d2da30..5fdc485 100644
--- a/TJC.StringExtensions.Tests/Cases/SnakeCaseExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Cases/SnakeCaseExtensionsTests.cs
@@ -18,4 +18,4 @@ public void ToSnakeCaseTest()
         // Assert
         Assert.AreEqual(expected, result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Cases/TrainCaseExtensionsTests.cs b/TJC.StringExtensions.Tests/Cases/TrainCaseExtensionsTests.cs
index 56efb80..b5c808d 100644
--- a/TJC.StringExtensions.Tests/Cases/TrainCaseExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Cases/TrainCaseExtensionsTests.cs
@@ -18,4 +18,4 @@ public void ToTrainCaseTest()
         // Assert
         Assert.AreEqual(expected, result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Header/HeaderExtensionsTests.cs b/TJC.StringExtensions.Tests/Header/HeaderExtensionsTests.cs
index 636ee1d..e575af9 100644
--- a/TJC.StringExtensions.Tests/Header/HeaderExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Header/HeaderExtensionsTests.cs
@@ -9,7 +9,12 @@ public class HeaderExtensionsTests
     public void GetHeader()
     {
         // Arrange
-        var headerLines = new List<string> { "Title", "This is a description", "and this is another line" };
+        var headerLines = new List<string>
+        {
+            "Title",
+            "This is a description",
+            "and this is another line",
+        };
 
         // Act
         var result = headerLines.GenerateHeader().ToList();
@@ -22,4 +27,4 @@ public void GetHeader()
         Assert.AreEqual("###   and this is another line   ###", result[3]);
         Assert.AreEqual("####################################", result[4]);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Lines/LineExtensionsTests.cs b/TJC.StringExtensions.Tests/Lines/LineExtensionsTests.cs
index 4d0c632..7765938 100644
--- a/TJC.StringExtensions.Tests/Lines/LineExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Lines/LineExtensionsTests.cs
@@ -24,7 +24,7 @@ public void SplitNewLine()
     public void SplitLines()
     {
         // Arrange
-        var text = "1234 5678 90AB CDEF FEDC BA09 8765 4321 TEST";
+        var text = "1234 5678 90AB TEST WORD BA09 8765 4321 TEST";
 
         // Act
         var result = text.SplitLines(16);
@@ -32,7 +32,7 @@ public void SplitLines()
         // Assert
         Assert.AreEqual(3, result.Count);
         Assert.AreEqual("1234 5678 90AB", result[0]);
-        Assert.AreEqual("CDEF FEDC BA09", result[1]);
+        Assert.AreEqual("TEST WORD BA09", result[1]);
         Assert.AreEqual("8765 4321 TEST", result[2]);
     }
 
@@ -40,15 +40,15 @@ public void SplitLines()
     public void SplitLinesWithoutSpaces()
     {
         // Arrange
-        var text = "1234567890ABCDEFFEDCBA0987654321TEST";
+        var text = "1234567890TEST1001WORD0987654321TEST";
 
         // Act
         var result = text.SplitLines(16);
 
         // Assert
         Assert.AreEqual(3, result.Count);
-        Assert.AreEqual("1234567890ABCDEF", result[0]);
-        Assert.AreEqual("FEDCBA0987654321", result[1]);
+        Assert.AreEqual("1234567890TEST10", result[0]);
+        Assert.AreEqual("01WORD0987654321", result[1]);
         Assert.AreEqual("TEST", result[2]);
     }
 
@@ -70,4 +70,4 @@ public void RemoveMultipleBlankLines()
         Assert.AreEqual("6", result[4]);
         Assert.AreEqual("", result[5]);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Padding/PaddingExtensionsTests.cs b/TJC.StringExtensions.Tests/Padding/PaddingExtensionsTests.cs
index 8347b76..5c54775 100644
--- a/TJC.StringExtensions.Tests/Padding/PaddingExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Padding/PaddingExtensionsTests.cs
@@ -69,4 +69,4 @@ public void PadBoth_Unbalanced3()
         // Assert
         Assert.AreEqual("  abc   ", result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Parsing/StringParserExtensionsTests.cs b/TJC.StringExtensions.Tests/Parsing/StringParserExtensionsTests.cs
index b99116d..6d132cd 100644
--- a/TJC.StringExtensions.Tests/Parsing/StringParserExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Parsing/StringParserExtensionsTests.cs
@@ -108,4 +108,4 @@ public void StringParser_RemoveSymbols_WithExceptions()
         // Assert
         Assert.AreEqual("a1!b2c3.d4 e5", result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Pluralize/PluralizeExtensionsTests.cs b/TJC.StringExtensions.Tests/Pluralize/PluralizeExtensionsTests.cs
index 0997203..9915c9d 100644
--- a/TJC.StringExtensions.Tests/Pluralize/PluralizeExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Pluralize/PluralizeExtensionsTests.cs
@@ -121,4 +121,4 @@ public void IsOne_DoubleIsNotOne_ReturnsFalse()
         // Assert
         Assert.IsFalse(result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Separator/DictionarySeparatorExtensionsTests.cs b/TJC.StringExtensions.Tests/Separator/DictionarySeparatorExtensionsTests.cs
index b212b0f..b527180 100644
--- a/TJC.StringExtensions.Tests/Separator/DictionarySeparatorExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Separator/DictionarySeparatorExtensionsTests.cs
@@ -5,7 +5,13 @@ namespace TJC.StringExtensions.Tests.Separator;
 [TestClass]
 public class DictionarySeparatorExtensionsTests
 {
-    private readonly Dictionary<int, string> _samples = new() { { 1, "one" }, { 2, "two" }, { 3, "three" } };
+    private readonly Dictionary<int, string> _samples =
+        new()
+        {
+            { 1, "one" },
+            { 2, "two" },
+            { 3, "three" },
+        };
 
     [TestMethod]
     public void JoinBothTest()
@@ -46,4 +52,4 @@ public void JoinValueTest()
         // Assert
         Assert.AreEqual("one, two, three", result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions.Tests/Separator/ListSeparatorExtensionsTests.cs b/TJC.StringExtensions.Tests/Separator/ListSeparatorExtensionsTests.cs
index 250d027..776d6e6 100644
--- a/TJC.StringExtensions.Tests/Separator/ListSeparatorExtensionsTests.cs
+++ b/TJC.StringExtensions.Tests/Separator/ListSeparatorExtensionsTests.cs
@@ -116,4 +116,4 @@ public void JoinNewLineWithSpacesTest()
         // Assert
         Assert.AreEqual("    one\n    two\n    three", result);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Cases/CamelCaseExtensions.cs b/TJC.StringExtensions/Cases/CamelCaseExtensions.cs
index 3373f72..6d77789 100644
--- a/TJC.StringExtensions/Cases/CamelCaseExtensions.cs
+++ b/TJC.StringExtensions/Cases/CamelCaseExtensions.cs
@@ -17,7 +17,9 @@ public static string SplitCamelCase(this string? input, string separator = " ")
     {
         if (string.IsNullOrEmpty(input))
             return string.Empty;
-        return string.Concat(input.Select((x, i) => i > 0 && char.IsUpper(x) ? $"{separator}{x}" : x.ToString()));
+        return string.Concat(
+            input.Select((x, i) => i > 0 && char.IsUpper(x) ? $"{separator}{x}" : x.ToString())
+        );
     }
 
     /// <summary>
@@ -33,4 +35,4 @@ public static string ToCamelCase(this string input)
             result.Append(char.ToUpper(words[i][0]) + words[i][1..].ToLower());
         return result.ToString();
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Cases/CodeCaseExtensions.cs b/TJC.StringExtensions/Cases/CodeCaseExtensions.cs
index 87746bd..fc1b4e9 100644
--- a/TJC.StringExtensions/Cases/CodeCaseExtensions.cs
+++ b/TJC.StringExtensions/Cases/CodeCaseExtensions.cs
@@ -29,7 +29,7 @@ public static string[] CodeCaseToWords(this string input)
     {
         if (string.IsNullOrWhiteSpace(input))
             return [];
-        // Add spaces around transitions (camelCase, PascalCase) and split by space, hyphen, or underscore        
+        // Add spaces around transitions (camelCase, PascalCase) and split by space, hyphen, or underscore
         var spaced = CaseWordSplitter.Replace(input, " ");
         return spaced.Split(_separator, StringSplitOptions.RemoveEmptyEntries);
     }
@@ -38,4 +38,4 @@ public static string[] CodeCaseToWords(this string input)
 
     [GeneratedRegex(@"(?<!^)(?=[A-Z])|[_\- ]", RegexOptions.Compiled)]
     private static partial Regex CaseWordSplitterRegex();
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Cases/KebabCaseExtensions.cs b/TJC.StringExtensions/Cases/KebabCaseExtensions.cs
index 5b087a1..2dd03ab 100644
--- a/TJC.StringExtensions/Cases/KebabCaseExtensions.cs
+++ b/TJC.StringExtensions/Cases/KebabCaseExtensions.cs
@@ -14,4 +14,4 @@ public static class KebabCaseExtensions
     /// <returns>kebab-case</returns>
     public static string ToKebabCase(this string input) =>
         string.Join("-", input.CodeCaseToWords()).ToLower();
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Cases/PascalCaseExtensions.cs b/TJC.StringExtensions/Cases/PascalCaseExtensions.cs
index 462a3fd..e458c92 100644
--- a/TJC.StringExtensions/Cases/PascalCaseExtensions.cs
+++ b/TJC.StringExtensions/Cases/PascalCaseExtensions.cs
@@ -20,4 +20,4 @@ public static string ToPascalCase(this string input)
             result.Append(char.ToUpper(word[0]) + word[1..].ToLower());
         return result.ToString();
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Cases/SnakeCaseExtensions.cs b/TJC.StringExtensions/Cases/SnakeCaseExtensions.cs
index 0765f85..1560771 100644
--- a/TJC.StringExtensions/Cases/SnakeCaseExtensions.cs
+++ b/TJC.StringExtensions/Cases/SnakeCaseExtensions.cs
@@ -14,4 +14,4 @@ public static class SnakeCaseExtensions
     /// <returns>snake_case</returns>
     public static string ToSnakeCase(this string input) =>
         string.Join("_", input.CodeCaseToWords()).ToLower();
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Cases/TrainCaseExtensions.cs b/TJC.StringExtensions/Cases/TrainCaseExtensions.cs
index c2f8b4c..80064a7 100644
--- a/TJC.StringExtensions/Cases/TrainCaseExtensions.cs
+++ b/TJC.StringExtensions/Cases/TrainCaseExtensions.cs
@@ -13,6 +13,8 @@ public static class TrainCaseExtensions
     /// <param name="input"></param>
     /// <returns>Train-Case</returns>
     public static string ToTrainCase(this string input) =>
-        string.Join("-", input.CodeCaseToWords()
-            .Select(word => char.ToUpper(word[0]) + word[1..].ToLower()));
-}
\ No newline at end of file
+        string.Join(
+            "-",
+            input.CodeCaseToWords().Select(word => char.ToUpper(word[0]) + word[1..].ToLower())
+        );
+}
diff --git a/TJC.StringExtensions/GlobalUsings.cs b/TJC.StringExtensions/GlobalUsings.cs
index 2882fc1..05887dd 100644
--- a/TJC.StringExtensions/GlobalUsings.cs
+++ b/TJC.StringExtensions/GlobalUsings.cs
@@ -1,3 +1,3 @@
 global using System.Text;
 global using System.Text.RegularExpressions;
-global using TJC.StringExtensions.Separator;
\ No newline at end of file
+global using TJC.StringExtensions.Separator;
diff --git a/TJC.StringExtensions/Header/HeaderExtensions.cs b/TJC.StringExtensions/Header/HeaderExtensions.cs
index 6fa5870..151102f 100644
--- a/TJC.StringExtensions/Header/HeaderExtensions.cs
+++ b/TJC.StringExtensions/Header/HeaderExtensions.cs
@@ -19,18 +19,27 @@ public static class HeaderExtensions
     /// <param name="linePrefix"></param>
     /// <param name="lineSuffix"></param>
     /// <returns></returns>
-    public static IEnumerable<string> GenerateHeader(this IEnumerable<string> lines, int internalLineLimit = 70, char character = '#', string linePrefix = "###   ", string lineSuffix = "   ###")
+    public static IEnumerable<string> GenerateHeader(
+        this IEnumerable<string> lines,
+        int internalLineLimit = 70,
+        char character = '#',
+        string linePrefix = "###   ",
+        string lineSuffix = "   ###"
+    )
     {
         var tempLines = new List<string>();
         // Get lines
         foreach (var newLine in lines)
-            foreach (var splitLine in newLine.SplitNewLine())
-                foreach (var line in splitLine.SplitLines(internalLineLimit))
-                    tempLines.Add(line);
+        foreach (var splitLine in newLine.SplitNewLine())
+        foreach (var line in splitLine.SplitLines(internalLineLimit))
+            tempLines.Add(line);
 
         // Get border
         var longestLine = tempLines.Max(x => x.Length);
-        var headerBorder = new string(character, longestLine + linePrefix.Length + lineSuffix.Length);
+        var headerBorder = new string(
+            character,
+            longestLine + linePrefix.Length + lineSuffix.Length
+        );
 
         // Get lines with prefix and suffix
         var headerLines = new List<string> { headerBorder };
@@ -39,4 +48,4 @@ public static IEnumerable<string> GenerateHeader(this IEnumerable<string> lines,
         headerLines.Add(headerBorder);
         return headerLines;
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Lines/LineExtensions.cs b/TJC.StringExtensions/Lines/LineExtensions.cs
index e5e63d6..a3df975 100644
--- a/TJC.StringExtensions/Lines/LineExtensions.cs
+++ b/TJC.StringExtensions/Lines/LineExtensions.cs
@@ -23,7 +23,11 @@ public static IEnumerable<string> SplitNewLine(this string inputString) =>
     /// <param name="width"></param>
     /// <param name="separator"></param>
     /// <returns></returns>
-    public static List<string> SplitLines(this string? text, int width = MaxLineWidth, char separator = ' ')
+    public static List<string> SplitLines(
+        this string? text,
+        int width = MaxLineWidth,
+        char separator = ' '
+    )
     {
         var list = new List<string>();
         if (text == null)
@@ -31,8 +35,8 @@ public static List<string> SplitLines(this string? text, int width = MaxLineWidt
 
         var array = text.Split(separator);
         foreach (var word in array)
-            foreach (var subword in word.SplitChunks(width))
-                list.AddWord(subword, width, separator);
+        foreach (var chunk in word.SplitChunks(width))
+            list.AddWord(chunk, width, separator);
 
         return list;
     }
@@ -58,7 +62,12 @@ public static IEnumerable<string> SplitChunks(this string str, int chunkSize)
     /// <param name="word"></param>
     /// <param name="width"></param>
     /// <param name="separator"></param>
-    private static void AddWord(this List<string> lines, string word, int width, char separator = ' ')
+    private static void AddWord(
+        this List<string> lines,
+        string word,
+        int width,
+        char separator = ' '
+    )
     {
         word = word.ReplaceLineEndings();
         if (!word.Contains(Environment.NewLine))
@@ -96,7 +105,11 @@ public static List<string> RemoveMultipleBlankLines(this IEnumerable<string> lin
     {
         var lastLineWasBlank = false;
         var list = new List<string>();
-        foreach (string item in lines.Where((string line) => !string.IsNullOrWhiteSpace(line) || !lastLineWasBlank))
+        foreach (
+            string item in lines.Where(
+                (string line) => !string.IsNullOrWhiteSpace(line) || !lastLineWasBlank
+            )
+        )
         {
             list.Add(item);
             lastLineWasBlank = string.IsNullOrWhiteSpace(item);
@@ -104,4 +117,4 @@ public static List<string> RemoveMultipleBlankLines(this IEnumerable<string> lin
 
         return list;
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Padding/PaddingExtensions.cs b/TJC.StringExtensions/Padding/PaddingExtensions.cs
index 3d61ad6..4b2298e 100644
--- a/TJC.StringExtensions/Padding/PaddingExtensions.cs
+++ b/TJC.StringExtensions/Padding/PaddingExtensions.cs
@@ -1,15 +1,15 @@
 namespace TJC.StringExtensions.Padding;
 
-/// <summary>
-/// Padding extensions for strings.
+/// <summary>
+/// Padding extensions for strings.
 /// </summary>
 public static class PaddingExtension
 {
-    /// <summary>
-    /// Pad a string with spaces on both sides to make it the specified length.
-    /// </summary>
-    /// <param name="source"></param>
-    /// <param name="length"></param>
+    /// <summary>
+    /// Pad a string with spaces on both sides to make it the specified length.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <param name="length"></param>
     /// <returns></returns>
     public static string PadBoth(this string source, int length)
     {
@@ -17,4 +17,4 @@ public static string PadBoth(this string source, int length)
         var padLeft = spaces / 2 + source.Length;
         return source.PadLeft(padLeft).PadRight(length);
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Parsing/StringParserExtensions.cs b/TJC.StringExtensions/Parsing/StringParserExtensions.cs
index 8495118..c098105 100644
--- a/TJC.StringExtensions/Parsing/StringParserExtensions.cs
+++ b/TJC.StringExtensions/Parsing/StringParserExtensions.cs
@@ -13,7 +13,9 @@ public static partial class StringParserExtensions
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepAlpha(this string str) => AlphaRegex().Replace(str, string.Empty);
-    [GeneratedRegex("[^a-zA-Z]")] public static partial Regex AlphaRegex();
+
+    [GeneratedRegex("[^a-zA-Z]")]
+    public static partial Regex AlphaRegex();
 
     /// <summary>
     /// Keep Numeric Only.
@@ -21,39 +23,53 @@ public static partial class StringParserExtensions
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepNumeric(this string str) => NumericRegex().Replace(str, string.Empty);
-    [GeneratedRegex("[^0-9]")] public static partial Regex NumericRegex();
+
+    [GeneratedRegex("[^0-9]")]
+    public static partial Regex NumericRegex();
 
     /// <summary>
     /// Keep Numeric &amp; Period.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
-    public static string KeepNumericAndPeriod(this string str) => NumericAndPeriodRegex().Replace(str, string.Empty);
-    [GeneratedRegex("[^0-9.]")] public static partial Regex NumericAndPeriodRegex();
+    public static string KeepNumericAndPeriod(this string str) =>
+        NumericAndPeriodRegex().Replace(str, string.Empty);
+
+    [GeneratedRegex("[^0-9.]")]
+    public static partial Regex NumericAndPeriodRegex();
 
     /// <summary>
     /// Keep Alpha &amp; Numeric.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
-    public static string KeepAlphaNumeric(this string str) => AlphaNumericRegex().Replace(str, string.Empty);
-    [GeneratedRegex("[^a-zA-Z0-9]")] public static partial Regex AlphaNumericRegex();
+    public static string KeepAlphaNumeric(this string str) =>
+        AlphaNumericRegex().Replace(str, string.Empty);
+
+    [GeneratedRegex("[^a-zA-Z0-9]")]
+    public static partial Regex AlphaNumericRegex();
 
     /// <summary>
     /// Keep Alpha, Numeric &amp; Space.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
-    public static string KeepAlphaNumericAndSpace(this string str) => AlphaNumericAndSpaceRegex().Replace(str, string.Empty);
-    [GeneratedRegex("[^a-zA-Z0-9 ]")] public static partial Regex AlphaNumericAndSpaceRegex();
+    public static string KeepAlphaNumericAndSpace(this string str) =>
+        AlphaNumericAndSpaceRegex().Replace(str, string.Empty);
+
+    [GeneratedRegex("[^a-zA-Z0-9 ]")]
+    public static partial Regex AlphaNumericAndSpaceRegex();
 
     /// <summary>
     /// Keep Alpha, Numeric, Space &amp; Period.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
-    public static string KeepAlphaNumericSpaceAndPeriod(this string str) => AlphaNumericSpaceAndPeriodRegex().Replace(str, string.Empty);
-    [GeneratedRegex("[^a-zA-Z0-9. ]")] public static partial Regex AlphaNumericSpaceAndPeriodRegex();
+    public static string KeepAlphaNumericSpaceAndPeriod(this string str) =>
+        AlphaNumericSpaceAndPeriodRegex().Replace(str, string.Empty);
+
+    [GeneratedRegex("[^a-zA-Z0-9. ]")]
+    public static partial Regex AlphaNumericSpaceAndPeriodRegex();
 
     /// <summary>
     /// Keep Only Alpha, Numeric, Spaces, &amp; Excluded Symbols.
@@ -67,4 +83,4 @@ public static string RemoveSymbols(this string str, char[]? exceptions = null)
         str = rgx.Replace(str, "");
         return str;
     }
-}
\ No newline at end of file
+}
diff --git a/TJC.StringExtensions/Pluralize/PluralizeExtensions.cs b/TJC.StringExtensions/Pluralize/PluralizeExtensions.cs
index f6484fb..9ce5307 100644
--- a/TJC.StringExtensions/Pluralize/PluralizeExtensions.cs
+++ b/TJC.StringExtensions/Pluralize/PluralizeExtensions.cs
@@ -12,10 +12,11 @@ public static class PluralizeExtensions
     /// <param name="nonPluralized">Non-Pluralized form of the string</param>
     /// <param name="pluralized">(Optional) Pluralized form of the string. If omitted, will return the Non-Pluralized form of the string with an 's' on the end</param>
     /// <returns></returns>
-    public static string Pluralize(this IEnumerable<object> objects,
-                                   string nonPluralized,
-                                   string? pluralized = null) =>
-        nonPluralized.Pluralize(objects.Count(), pluralized);
+    public static string Pluralize(
+        this IEnumerable<object> objects,
+        string nonPluralized,
+        string? pluralized = null
+    ) => nonPluralized.Pluralize(objects.Count(), pluralized);
 
     /// <summary>
     /// Pluralize a string based upon the number of objects within a collection.
@@ -24,10 +25,11 @@ public static string Pluralize(this IEnumerable<object> objects,
     /// <param name="nonPluralized">Non-Pluralized form of the string</param>
     /// <param name="pluralized">(Optional) Pluralized form of the string. If omitted, will return the Non-Pluralized form of the string with an 's' on the end</param>
     /// <returns></returns>
-    public static string Pluralize(this string nonPluralized,
-                                   IEnumerable<object> objects,
-                                   string? pluralized = null) =>
-        nonPluralized.Pluralize(objects.Count(), pluralized);
+    public static string Pluralize(
+        this string nonPluralized,
+        IEnumerable<object> objects,
+        string? pluralized = null
+    ) => nonPluralized.Pluralize(objects.Count(), pluralized);
 
     /// <summary>
     /// Pluralize a string based upon the value of number.
@@ -36,10 +38,11 @@ public static string Pluralize(this string nonPluralized,
     /// <param name="number">Number (Pluralize unless equal to 1)</param>
     /// <param name="pluralized">(Optional) Pluralized form of the string. If omitted, will return the Non-Pluralized form of the string with an 's' on the end</param>
     /// <returns></returns>
-    public static string Pluralize(this string nonPluralized,
-                                   double number,
-                                   string? pluralized = null) =>
-        nonPluralized.Pluralize(!number.IsOne(), pluralized);
+    public static string Pluralize(
+        this string nonPluralized,
+        double number,
+        string? pluralized = null
+    ) => nonPluralized.Pluralize(!number.IsOne(), pluralized);
 
     /// <summary>
     /// Pluralize a string based upon the value of number.
@@ -48,10 +51,11 @@ public static string Pluralize(this string nonPluralized,
     /// <param name="number">Number (Pluralize unless equal to 1)</param>
     /// <param name="pluralized">(Optional) Pluralized form of the string. If omitted, will return the Non-Pluralized form of the string with an 's' on the end</param>
     /// <returns></returns>
-    public static string Pluralize(this string nonPluralized,
-                                   int number,
-                                   string? pluralized = null) =>
-        nonPluralized.Pluralize(!number.IsOne(), pluralized);
+    public static string Pluralize(
+        this string nonPluralized,
+        int number,
+        string? pluralized = null
+    ) => nonPluralized.Pluralize(!number.IsOne(), pluralized);
 
     /// <summary>
     /// Pluralize a string based upon a boolean.
@@ -60,11 +64,16 @@ public static string Pluralize(this string nonPluralized,
     /// <param name="pluralize">Should we pluralize or not</param>
     /// <param name="pluralized">(Optional) Pluralized form of the string. If omitted, will return the Non-Pluralized form of the string with an 's' on the end</param>
     /// <returns></returns>
-    public static string Pluralize(this string nonPluralized,
-                                   bool pluralize,
-                                   string? pluralized = null) =>
-        pluralize ? !string.IsNullOrEmpty(pluralized) ? pluralized :
-            string.Concat(nonPluralized, 's') : nonPluralized;
+    public static string Pluralize(
+        this string nonPluralized,
+        bool pluralize,
+        string? pluralized = null
+    ) =>
+        pluralize
+            ? !string.IsNullOrEmpty(pluralized)
+                ? pluralized
+                : string.Concat(nonPluralized, 's')
+            : nonPluralized;
 
     internal static bool IsOne(this string number) =>
         double.TryParse(number, out var value) && value.IsOne();
@@ -72,6 +81,5 @@ internal static bool IsOne(this string number) =>
     internal static bool IsOne(this double number, double eps = double.Epsilon) =>
         Math.Abs(number - 1) < eps;
 
-    internal static bool IsOne(this int number) =>
-        number == 1;
-}
\ No newline at end of file
+    internal static bool IsOne(this int number) => number == 1;
+}
diff --git a/TJC.StringExtensions/Separator/SeparatorExtensions.cs b/TJC.StringExtensions/Separator/SeparatorExtensions.cs
index b5e8685..82ebba0 100644
--- a/TJC.StringExtensions/Separator/SeparatorExtensions.cs
+++ b/TJC.StringExtensions/Separator/SeparatorExtensions.cs
@@ -33,8 +33,10 @@ public static string JoinCommaOr(this IEnumerable<string> strings, bool orWithCo
     /// <param name="strings"></param>
     /// <param name="andWithComma"></param>
     /// <returns></returns>
-    public static string JoinCommaAnd(this IEnumerable<string> strings, bool andWithComma = false) =>
-        strings.JoinFinalSeparator(", ", $"{(andWithComma ? "," : string.Empty)} and ");
+    public static string JoinCommaAnd(
+        this IEnumerable<string> strings,
+        bool andWithComma = false
+    ) => strings.JoinFinalSeparator(", ", $"{(andWithComma ? "," : string.Empty)} and ");
 
     /// <summary>
     /// Join string with a comma separator and final separator containing ampersand.
@@ -43,8 +45,10 @@ public static string JoinCommaAnd(this IEnumerable<string> strings, bool andWith
     /// <param name="strings"></param>
     /// <param name="andWithComma"></param>
     /// <returns></returns>
-    public static string JoinCommaAmpersand(this IEnumerable<string> strings, bool andWithComma = false) =>
-        strings.JoinFinalSeparator(", ", $"{(andWithComma ? "," : string.Empty)} & ");
+    public static string JoinCommaAmpersand(
+        this IEnumerable<string> strings,
+        bool andWithComma = false
+    ) => strings.JoinFinalSeparator(", ", $"{(andWithComma ? "," : string.Empty)} & ");
 
     /// <summary>
     /// Join strings with a comma separator and selectable final separator.
@@ -54,10 +58,16 @@ public static string JoinCommaAmpersand(this IEnumerable<string> strings, bool a
     /// <param name="separator"></param>
     /// <param name="finalSeparator"></param>
     /// <returns></returns>
-    public static string JoinFinalSeparator(this IEnumerable<string> strings, string separator, string finalSeparator)
+    public static string JoinFinalSeparator(
+        this IEnumerable<string> strings,
+        string separator,
+        string finalSeparator
+    )
     {
         var list = strings.ToList();
-        return string.Join(separator, list.Take(list.Count - 1)) + (list.Count <= 1 ? string.Empty : finalSeparator) + list.LastOrDefault();
+        return string.Join(separator, list.Take(list.Count - 1))
+            + (list.Count <= 1 ? string.Empty : finalSeparator)
+            + list.LastOrDefault();
     }
 
     #endregion
@@ -103,7 +113,11 @@ public static string JoinNewLineWithSpaces(this IEnumerable<string> strings, int
     /// <param name="separator"></param>
     /// <param name="keyValueSeparator"></param>
     /// <returns></returns>
-    public static string JoinBoth<T1, T2>(this IDictionary<T1, T2> dictionary, string separator = ", ", string keyValueSeparator = ": ")
+    public static string JoinBoth<T1, T2>(
+        this IDictionary<T1, T2> dictionary,
+        string separator = ", ",
+        string keyValueSeparator = ": "
+    )
         where T1 : notnull
         where T2 : notnull =>
         string.Join(separator, dictionary.Select(x => $"{x.Key}{keyValueSeparator}{x.Value}"));
@@ -117,7 +131,11 @@ public static string JoinBoth<T1, T2>(this IDictionary<T1, T2> dictionary, strin
     /// <param name="separator"></param>
     /// <param name="valueKeySeparator"></param>
     /// <returns></returns>
-    public static string JoinBothReverse<T1, T2>(this IDictionary<T1, T2> dictionary, string separator = ", ", string valueKeySeparator = ": ")
+    public static string JoinBothReverse<T1, T2>(
+        this IDictionary<T1, T2> dictionary,
+        string separator = ", ",
+        string valueKeySeparator = ": "
+    )
         where T1 : notnull
         where T2 : notnull =>
         string.Join(separator, dictionary.Select(x => $"{x.Value}{valueKeySeparator}{x.Key}"));
@@ -130,10 +148,12 @@ public static string JoinBothReverse<T1, T2>(this IDictionary<T1, T2> dictionary
     /// <param name="dictionary"></param>
     /// <param name="separator"></param>
     /// <returns></returns>
-    public static string JoinKey<T1, T2>(this IDictionary<T1, T2> dictionary, string separator = ", ")
+    public static string JoinKey<T1, T2>(
+        this IDictionary<T1, T2> dictionary,
+        string separator = ", "
+    )
         where T1 : notnull
-        where T2 : notnull =>
-        string.Join(separator, dictionary.Select(x => x.Key).ToList());
+        where T2 : notnull => string.Join(separator, dictionary.Select(x => x.Key).ToList());
 
     /// <summary>
     /// Join dictionary values with a separator.
@@ -143,10 +163,12 @@ public static string JoinKey<T1, T2>(this IDictionary<T1, T2> dictionary, string
     /// <param name="dictionary"></param>
     /// <param name="separator"></param>
     /// <returns></returns>
-    public static string JoinValue<T1, T2>(this IDictionary<T1, T2> dictionary, string separator = ", ")
+    public static string JoinValue<T1, T2>(
+        this IDictionary<T1, T2> dictionary,
+        string separator = ", "
+    )
         where T1 : notnull
-        where T2 : notnull =>
-        string.Join(separator, dictionary.Select(x => x.Value).ToList());
+        where T2 : notnull => string.Join(separator, dictionary.Select(x => x.Value).ToList());
 
     #endregion
-}
\ No newline at end of file
+}