com.wallstop-studios.unity-helpers 2.0.0-rc81.7 → 2.0.0-rc81.9

package/Runtime/Core/Extension/StringExtensions.cs

@@ -1,239 +1,1635 @@
-namespace WallstopStudios.UnityHelpers.Core.Extension
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Text;
-    using System.Threading;
-    using Serialization;
-    using UnityEngine;
-
-    public static class StringExtensions
-    {
-        private static readonly ThreadLocal<StringBuilder> StringBuilderCache = new(() =>
-            new StringBuilder()
-        );
-
-        private static readonly HashSet<char> PascalCaseSeparators = new()
-        {
-            '_',
-            ' ',
-            '\r',
-            '\n',
-            '\t',
-            '.',
-            '\'',
-            '"',
-        };
-
-        public static string Center(this string input, int length)
-        {
-            if (input == null || length <= input.Length)
-            {
-                return input;
-            }
-
-            return input.PadLeft((length - input.Length) / 2 + input.Length).PadRight(length);
-        }
-
-        public static byte[] GetBytes(this string input)
-        {
-            if (string.IsNullOrEmpty(input))
-            {
-                return Array.Empty<byte>();
-            }
-            return Encoding.Default.GetBytes(input);
-        }
-
-        public static string GetString(this byte[] bytes)
-        {
-            return Encoding.Default.GetString(bytes);
-        }
-
-        public static string ToJson<T>(this T value)
-        {
-            return Serializer.JsonStringify(value);
-        }
-
-        public static int LevenshteinDistance(this string source1, string source2)
-        {
-            source1 ??= string.Empty;
-            source2 ??= string.Empty;
-
-            int source1Length = source1.Length;
-            int source2Length = source2.Length;
-
-            int[][] matrix = new int[source1Length + 1][];
-            for (int index = 0; index < source1Length + 1; index++)
-            {
-                matrix[index] = new int[source2Length + 1];
-            }
-
-            if (source1Length == 0)
-            {
-                return source2Length;
-            }
-
-            if (source2Length == 0)
-            {
-                return source1Length;
-            }
-
-            for (int i = 0; i <= source1Length; matrix[i][0] = ++i)
-            {
-                // Spin to force array population
-            }
-
-            for (int j = 0; j <= source2Length; matrix[0][j] = ++j)
-            {
-                // Spin to force array population
-            }
-
-            for (int i = 1; i <= source1Length; ++i)
-            {
-                for (int j = 1; j <= source2Length; ++j)
-                {
-                    int cost = source2[j - 1] == source1[i - 1] ? 0 : 1;
-                    matrix[i][j] = Mathf.Min(
-                        Mathf.Min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1),
-                        matrix[i - 1][j - 1] + cost
-                    );
-                }
-            }
-            return matrix[source1Length][source2Length];
-        }
-
-        public static string ToPascalCase(this string value, string separator = "")
-        {
-            if (string.IsNullOrEmpty(value))
-            {
-                return string.Empty;
-            }
-
-            int startIndex = 0;
-            StringBuilder stringBuilder = StringBuilderCache.Value;
-            stringBuilder.Clear();
-            bool appendedAnySeparator = false;
-            for (int i = 0; i < value.Length; ++i)
-            {
-                while (
-                    startIndex < value.Length && PascalCaseSeparators.Contains(value[startIndex])
-                )
-                {
-                    ++startIndex;
-                }
-
-                if (
-                    startIndex < i
-                    && char.IsLower(value[i - 1])
-                    && (char.IsUpper(value[i]) || PascalCaseSeparators.Contains(value[i]))
-                )
-                {
-                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
-                    if (1 < i - startIndex)
-                    {
-                        for (int j = startIndex + 1; j < i; ++j)
-                        {
-                            char current = value[j];
-                            if (PascalCaseSeparators.Contains(current))
-                            {
-                                continue;
-                            }
-
-                            _ = stringBuilder.Append(char.ToLower(current));
-                        }
-                    }
-
-                    if (!string.IsNullOrEmpty(separator))
-                    {
-                        appendedAnySeparator = true;
-                        _ = stringBuilder.Append(separator);
-                    }
-
-                    startIndex = i;
-                    continue;
-                }
-
-                if (
-                    startIndex + 1 < i
-                    && char.IsLower(value[i])
-                    && (char.IsUpper(value[i - 1]) || PascalCaseSeparators.Contains(value[i - 1]))
-                )
-                {
-                    _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
-                    if (1 < i - 1 - startIndex)
-                    {
-                        for (int j = startIndex + 1; j < i; ++j)
-                        {
-                            char current = value[j];
-                            if (PascalCaseSeparators.Contains(current))
-                            {
-                                continue;
-                            }
-
-                            _ = stringBuilder.Append(char.ToLower(current));
-                        }
-                    }
-
-                    if (!string.IsNullOrEmpty(separator))
-                    {
-                        appendedAnySeparator = true;
-                        _ = stringBuilder.Append(separator);
-                    }
-
-                    startIndex = i - 1;
-                }
-            }
-
-            if (startIndex < value.Length)
-            {
-                _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
-                if (startIndex + 1 < value.Length)
-                {
-                    for (int j = startIndex + 1; j < value.Length; ++j)
-                    {
-                        char current = value[j];
-                        if (PascalCaseSeparators.Contains(current))
-                        {
-                            continue;
-                        }
-
-                        _ = stringBuilder.Append(char.ToLower(current));
-                    }
-                }
-            }
-            else if (
-                appendedAnySeparator
-                && !string.IsNullOrEmpty(separator)
-                && separator.Length <= stringBuilder.Length
-            )
-            {
-                stringBuilder.Remove(stringBuilder.Length - separator.Length, separator.Length);
-            }
-
-            return stringBuilder.ToString();
-        }
-
-        public static bool NeedsLowerInvariantConversion(this string input)
-        {
-            foreach (char inputCharacter in input)
-            {
-                if (char.ToLowerInvariant(inputCharacter) != inputCharacter)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        public static bool NeedsTrim(this string input)
-        {
-            if (string.IsNullOrEmpty(input))
-            {
-                return false;
-            }
-
-            return char.IsWhiteSpace(input[0]) || char.IsWhiteSpace(input[^1]);
-        }
-    }
-}
+namespace WallstopStudios.UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Text;
+    using Serialization;
+    using WallstopStudios.UnityHelpers.Utils;
+
+    /// <summary>
+    /// Defines string casing formats for text transformation.
+    /// </summary>
+    public enum StringCase
+    {
+        /// <summary>Invalid string case placeholder.</summary>
+        [Obsolete("Please use a valid StringCase enum value.")]
+        None = 0,
+
+        /// <summary>PascalCase - FirstLetterCapitalized for each word, no separators (e.g., "HelloWorld").</summary>
+        PascalCase = 1,
+
+        /// <summary>camelCase - first letter lowercase, subsequent words capitalized, no separators (e.g., "helloWorld").</summary>
+        CamelCase = 2,
+
+        /// <summary>snake_case - all lowercase with underscores between words (e.g., "hello_world").</summary>
+        SnakeCase = 3,
+
+        /// <summary>kebab-case - all lowercase with hyphens between words (e.g., "hello-world").</summary>
+        KebabCase = 4,
+
+        /// <summary>Title Case - Each Word Capitalized With Spaces (e.g., "Hello World").</summary>
+        TitleCase = 5,
+
+        /// <summary>lowercase - all characters converted to lowercase (e.g., "hello world").</summary>
+        LowerCase = 6,
+
+        /// <summary>UPPERCASE - all characters converted to uppercase (e.g., "HELLO WORLD").</summary>
+        UpperCase = 7,
+
+        /// <summary>lowercase invariant - culture-invariant lowercase conversion.</summary>
+        LowerInvariant = 8,
+
+        /// <summary>UPPERCASE INVARIANT - culture-invariant uppercase conversion.</summary>
+        UpperInvariant = 9,
+    }
+
+    /// <summary>
+    /// Extension methods for string manipulation including case conversion, encoding, serialization, and text analysis.
+    /// </summary>
+    /// <remarks>
+    /// Thread Safety: All methods are thread-safe as they operate on immutable strings.
+    /// Performance: Methods use StringBuilder and pooled buffers for efficiency where possible.
+    /// Allocations: Most methods allocate new strings; some use pooled resources to minimize intermediate allocations.
+    /// </remarks>
+    public static class StringExtensions
+    {
+        private static readonly ImmutableHashSet<char> WordSeparators = new HashSet<char>
+        {
+            '_',
+            '-',
+            ' ',
+            '\r',
+            '\n',
+            '\t',
+            '.',
+            '"',
+        }.ToImmutableHashSet();
+
+        private static readonly ImmutableHashSet<char> CharsToStrip = new HashSet<char>
+        {
+            '\'',
+        }.ToImmutableHashSet();
+
+        private const char CombiningDotAbove = '\u0307';
+        private const char CapitalIWithDot = '\u0130';
+        private static readonly string CombiningDotAboveString = CombiningDotAbove.ToString();
+        private static readonly string CapitalIWithDotString = CapitalIWithDot.ToString();
+
+        private enum CharacterCategory
+        {
+            None,
+            Lower,
+            Upper,
+            Digit,
+            Other,
+        }
+
+        private enum CaseTokenKind
+        {
+            Word,
+            Separator,
+        }
+
+        private readonly struct CaseToken
+        {
+            public CaseToken(
+                CaseTokenKind kind,
+                string value,
+                bool hasLetter,
+                bool hasDigit,
+                bool hasUppercase
+            )
+            {
+                Kind = kind;
+                Value = value;
+                HasLetter = hasLetter;
+                HasDigit = hasDigit;
+                HasUppercase = hasUppercase;
+            }
+
+            public CaseTokenKind Kind { get; }
+
+            public string Value { get; }
+
+            public bool HasLetter { get; }
+
+            public bool HasDigit { get; }
+
+            public bool HasUppercase { get; }
+
+            public bool IsNumeric => !HasLetter && HasDigit;
+        }
+
+        /// <summary>
+        /// Centers a string within a field of the specified total length by padding spaces on both sides.
+        /// </summary>
+        /// <param name="input">The string to center.</param>
+        /// <param name="length">The total width of the resulting string.</param>
+        /// <returns>
+        /// The centered string when <paramref name="length"/> exceeds the input length; otherwise the original string.
+        /// </returns>
+        /// <remarks>
+        /// Returns the original string when <paramref name="length"/> is less than or equal to the input length.
+        /// Uses space characters for padding; does not truncate.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// string s = "hi";
+        /// string centered = s.Center(6); // "  hi  "
+        /// </code>
+        /// </example>
+        public static string Center(this string input, int length)
+        {
+            if (input == null || length <= input.Length)
+            {
+                return input;
+            }
+
+            return input.PadLeft((length - input.Length) / 2 + input.Length).PadRight(length);
+        }
+
+        /// <summary>
+        /// Converts a string to its UTF-8 byte array representation.
+        /// </summary>
+        /// <param name="input">The string to convert.</param>
+        /// <returns>A byte array containing the UTF-8 encoded bytes, or an empty array if input is null or empty.</returns>
+        /// <remarks>
+        /// Null handling: Returns Array.Empty&lt;byte&gt;() if input is null or empty.
+        /// Thread-safe: Yes.
+        /// Performance: O(n) where n is the string length.
+        /// Allocations: Allocates a new byte array. Returns cached empty array for null/empty input.
+        /// Edge cases: Empty or null strings return empty array.
+        /// </remarks>
+        public static byte[] GetBytes(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return Array.Empty<byte>();
+            }
+            return Encoding.UTF8.GetBytes(input);
+        }
+
+        /// <summary>
+        /// Converts a UTF-8 byte array to a string.
+        /// </summary>
+        /// <param name="bytes">The byte array to convert.</param>
+        /// <returns>The decoded string, or an empty string if bytes is null or empty.</returns>
+        /// <remarks>
+        /// Null handling: Returns string.Empty if bytes is null or empty.
+        /// Thread-safe: Yes.
+        /// Performance: O(n) where n is the byte array length.
+        /// Allocations: Allocates a new string.
+        /// Edge cases: Empty or null byte arrays return empty string.
+        /// </remarks>
+        public static string GetString(this byte[] bytes)
+        {
+            if (bytes == null || bytes.Length == 0)
+            {
+                return string.Empty;
+            }
+            return Encoding.UTF8.GetString(bytes);
+        }
+
+        /// <summary>
+        /// Serializes an object to a JSON string representation.
+        /// </summary>
+        /// <typeparam name="T">The type of the value to serialize.</typeparam>
+        /// <param name="value">The value to serialize to JSON.</param>
+        /// <returns>A JSON string representation of the value.</returns>
+        /// <remarks>
+        /// Null handling: Behavior depends on Serializer.JsonStringify implementation.
+        /// Thread-safe: Yes.
+        /// Performance: O(n) where n is the complexity of the object graph.
+        /// Allocations: Allocates new string and intermediate serialization structures.
+        /// Edge cases: Complex object graphs may serialize with circular reference handling depending on serializer.
+        /// </remarks>
+        public static string ToJson<T>(this T value)
+        {
+            return Serializer.JsonStringify(value);
+        }
+
+        public static int LevenshteinDistance(this string source1, string source2)
+        {
+            source1 ??= string.Empty;
+            source2 ??= string.Empty;
+
+            int len1 = source1.Length;
+            int len2 = source2.Length;
+
+            if (len1 == 0)
+            {
+                return len2;
+            }
+
+            if (len2 == 0)
+            {
+                return len1;
+            }
+
+            using PooledResource<int[]> prevLease = WallstopFastArrayPool<int>.Get(
+                len2 + 1,
+                out int[] prev
+            );
+            using PooledResource<int[]> currLease = WallstopFastArrayPool<int>.Get(
+                len2 + 1,
+                out int[] curr
+            );
+
+            for (int j = 0; j <= len2; ++j)
+            {
+                prev[j] = j;
+            }
+
+            for (int i = 1; i <= len1; ++i)
+            {
+                curr[0] = i;
+                char c1 = source1[i - 1];
+                for (int j = 1; j <= len2; ++j)
+                {
+                    int cost = source2[j - 1] == c1 ? 0 : 1;
+                    int deletion = prev[j] + 1;
+                    int insertion = curr[j - 1] + 1;
+                    int substitution = prev[j - 1] + cost;
+                    int min = deletion < insertion ? deletion : insertion;
+                    curr[j] = min < substitution ? min : substitution;
+                }
+
+                // swap prev and curr
+                int[] tmp = prev;
+                prev = curr;
+                curr = tmp;
+            }
+
+            return prev[len2];
+        }
+
+        private static List<CaseToken> TokenizeForCase(string value)
+        {
+            List<CaseToken> tokens = new();
+            if (string.IsNullOrEmpty(value))
+            {
+                return tokens;
+            }
+
+            using PooledResource<StringBuilder> bufferResource = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder buffer
+            );
+
+            CaseTokenKind? currentKind = null;
+            CharacterCategory lastCategory = CharacterCategory.None;
+
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char current = value[i];
+                bool isSeparator = WordSeparators.Contains(current) || char.IsWhiteSpace(current);
+
+                if (isSeparator)
+                {
+                    if (currentKind == CaseTokenKind.Word && buffer.Length > 0)
+                    {
+                        tokens.Add(CreateWordToken(buffer.ToString()));
+                        buffer.Clear();
+                    }
+
+                    if (currentKind != CaseTokenKind.Separator)
+                    {
+                        if (currentKind == CaseTokenKind.Separator && buffer.Length > 0)
+                        {
+                            tokens.Add(
+                                new CaseToken(
+                                    CaseTokenKind.Separator,
+                                    buffer.ToString(),
+                                    false,
+                                    false,
+                                    false
+                                )
+                            );
+                            buffer.Clear();
+                        }
+
+                        currentKind = CaseTokenKind.Separator;
+                        buffer.Clear();
+                    }
+
+                    _ = buffer.Append(current);
+                    lastCategory = CharacterCategory.None;
+                    continue;
+                }
+
+                CharacterCategory category = CategorizeChar(current);
+
+                if (currentKind == CaseTokenKind.Separator && buffer.Length > 0)
+                {
+                    tokens.Add(
+                        new CaseToken(
+                            CaseTokenKind.Separator,
+                            buffer.ToString(),
+                            false,
+                            false,
+                            false
+                        )
+                    );
+                    buffer.Clear();
+                }
+
+                if (currentKind != CaseTokenKind.Word)
+                {
+                    currentKind = CaseTokenKind.Word;
+                    lastCategory = CharacterCategory.None;
+                }
+                else if (ShouldStartNewWord(category, lastCategory, value, i) && buffer.Length > 0)
+                {
+                    tokens.Add(CreateWordToken(buffer.ToString()));
+                    buffer.Clear();
+                    lastCategory = CharacterCategory.None;
+                }
+
+                _ = buffer.Append(current);
+                if (category != CharacterCategory.Other)
+                {
+                    lastCategory = category;
+                }
+            }
+
+            if (currentKind == CaseTokenKind.Separator && buffer.Length > 0)
+            {
+                tokens.Add(
+                    new CaseToken(CaseTokenKind.Separator, buffer.ToString(), false, false, false)
+                );
+            }
+            else if (currentKind == CaseTokenKind.Word && buffer.Length > 0)
+            {
+                tokens.Add(CreateWordToken(buffer.ToString()));
+            }
+
+            return tokens;
+        }
+
+        private static CharacterCategory CategorizeChar(char value)
+        {
+            if (char.IsDigit(value))
+            {
+                return CharacterCategory.Digit;
+            }
+
+            if (char.IsLetter(value))
+            {
+                return char.IsUpper(value) ? CharacterCategory.Upper : CharacterCategory.Lower;
+            }
+
+            return CharacterCategory.Other;
+        }
+
+        private static bool ShouldStartNewWord(
+            CharacterCategory currentCategory,
+            CharacterCategory lastCategory,
+            string value,
+            int index
+        )
+        {
+            if (
+                lastCategory == CharacterCategory.None
+                || currentCategory == CharacterCategory.Other
+            )
+            {
+                return false;
+            }
+
+            if (currentCategory == CharacterCategory.Upper)
+            {
+                if (
+                    lastCategory == CharacterCategory.Lower
+                    || lastCategory == CharacterCategory.Digit
+                )
+                {
+                    return true;
+                }
+
+                if (lastCategory == CharacterCategory.Upper)
+                {
+                    int nextIndex = index + 1;
+                    if (nextIndex < value.Length && char.IsLower(value[nextIndex]))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            bool lastWasDigit = lastCategory == CharacterCategory.Digit;
+            bool currentIsDigit = currentCategory == CharacterCategory.Digit;
+            bool lastWasLetter =
+                lastCategory == CharacterCategory.Lower || lastCategory == CharacterCategory.Upper;
+            bool currentIsLetter =
+                currentCategory == CharacterCategory.Lower
+                || currentCategory == CharacterCategory.Upper;
+
+            if (currentIsDigit && lastWasLetter)
+            {
+                return true;
+            }
+
+            if (currentIsLetter && lastWasDigit)
+            {
+                return currentCategory == CharacterCategory.Upper;
+            }
+
+            return false;
+        }
+
+        private static CaseToken CreateWordToken(string value)
+        {
+            bool hasLetter = false;
+            bool hasDigit = false;
+            bool hasUppercase = false;
+
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                if (char.IsDigit(c))
+                {
+                    hasDigit = true;
+                }
+                else if (char.IsLetter(c))
+                {
+                    hasLetter = true;
+                    if (char.IsUpper(c))
+                    {
+                        hasUppercase = true;
+                    }
+                }
+            }
+
+            return new CaseToken(CaseTokenKind.Word, value, hasLetter, hasDigit, hasUppercase);
+        }
+
+        private static string SanitizeWord(string value, bool removeStripChars)
+        {
+            if (string.IsNullOrEmpty(value) || !removeStripChars)
+            {
+                return value;
+            }
+
+            bool needsSanitization = false;
+            for (int i = 0; i < value.Length; ++i)
+            {
+                if (CharsToStrip.Contains(value[i]))
+                {
+                    needsSanitization = true;
+                    break;
+                }
+            }
+
+            if (!needsSanitization)
+            {
+                return value;
+            }
+
+            using PooledResource<StringBuilder> builderResource = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder builder
+            );
+
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                if (!CharsToStrip.Contains(c))
+                {
+                    _ = builder.Append(c);
+                }
+            }
+
+            return builder.ToString();
+        }
+
+        private static void AppendWordWithCasing(
+            StringBuilder builder,
+            string word,
+            bool uppercaseFirstLetter
+        )
+        {
+            if (string.IsNullOrEmpty(word))
+            {
+                return;
+            }
+
+            char firstChar = word[0];
+            _ = builder.Append(
+                uppercaseFirstLetter
+                    ? char.ToUpperInvariant(firstChar)
+                    : char.ToLowerInvariant(firstChar)
+            );
+
+            for (int i = 1; i < word.Length; ++i)
+            {
+                char c = word[i];
+                _ = builder.Append(char.ToLowerInvariant(c));
+            }
+        }
+
+        private static string ToDelimitedCase(string value, char delimiter)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return string.Empty;
+            }
+
+            List<CaseToken> tokens = TokenizeForCase(value);
+            if (tokens.Count == 0)
+            {
+                return string.Empty;
+            }
+
+            using PooledResource<StringBuilder> stringBuilderBuffer = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder stringBuilder
+            );
+
+            bool previousWasWord = false;
+            bool previousWasNumeric = false;
+            bool previousHadUppercase = false;
+            bool forceDelimiter = false;
+
+            for (int i = 0; i < tokens.Count; ++i)
+            {
+                CaseToken token = tokens[i];
+                if (token.Kind == CaseTokenKind.Separator)
+                {
+                    if (previousWasWord)
+                    {
+                        forceDelimiter = true;
+                    }
+
+                    continue;
+                }
+
+                string sanitized = SanitizeWord(token.Value, removeStripChars: true);
+                if (string.IsNullOrEmpty(sanitized))
+                {
+                    continue;
+                }
+
+                bool isNumeric = true;
+                bool hasLetter = false;
+                for (int j = 0; j < sanitized.Length; ++j)
+                {
+                    char c = sanitized[j];
+                    if (!char.IsDigit(c))
+                    {
+                        isNumeric = false;
+                    }
+
+                    if (char.IsLetter(c))
+                    {
+                        hasLetter = true;
+                    }
+                }
+
+                bool startsWithDigit = char.IsDigit(sanitized[0]);
+                bool tokenHasUppercase = token.HasUppercase;
+
+                bool nextWordHasUppercase = false;
+                for (int lookahead = i + 1; lookahead < tokens.Count; ++lookahead)
+                {
+                    CaseToken lookaheadToken = tokens[lookahead];
+                    if (lookaheadToken.Kind == CaseTokenKind.Separator)
+                    {
+                        continue;
+                    }
+
+                    string lookaheadSanitized = SanitizeWord(
+                        lookaheadToken.Value,
+                        removeStripChars: true
+                    );
+                    if (string.IsNullOrEmpty(lookaheadSanitized))
+                    {
+                        continue;
+                    }
+
+                    nextWordHasUppercase = lookaheadToken.HasUppercase;
+                    break;
+                }
+
+                bool allowDigitLetterContinuation =
+                    previousWasWord
+                    && !forceDelimiter
+                    && startsWithDigit
+                    && hasLetter
+                    && !tokenHasUppercase
+                    && !previousHadUppercase
+                    && !nextWordHasUppercase;
+
+                bool allowNumericContinuation =
+                    previousWasWord
+                    && !forceDelimiter
+                    && isNumeric
+                    && !previousWasNumeric
+                    && !previousHadUppercase
+                    && !nextWordHasUppercase;
+
+                if (!allowDigitLetterContinuation && !allowNumericContinuation && previousWasWord)
+                {
+                    if (stringBuilder.Length > 0 && stringBuilder[^1] != delimiter)
+                    {
+                        _ = stringBuilder.Append(delimiter);
+                    }
+                }
+
+                _ = stringBuilder.Append(sanitized.ToLowerInvariant());
+                previousWasWord = true;
+                previousWasNumeric = isNumeric;
+                previousHadUppercase = tokenHasUppercase;
+                forceDelimiter = false;
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        private static bool StartsWithLowercaseWord(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return false;
+            }
+
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                if (CharsToStrip.Contains(c))
+                {
+                    continue;
+                }
+
+                if (WordSeparators.Contains(c) || char.IsWhiteSpace(c))
+                {
+                    continue;
+                }
+
+                if (char.IsLetter(c))
+                {
+                    return char.IsLower(c);
+                }
+
+                if (char.IsDigit(c))
+                {
+                    return false;
+                }
+            }
+
+            return false;
+        }
+
+        private static void AppendTitleCasedWord(StringBuilder builder, string word)
+        {
+            if (string.IsNullOrEmpty(word))
+            {
+                return;
+            }
+
+            bool firstLetterHandled = false;
+            for (int i = 0; i < word.Length; ++i)
+            {
+                char c = word[i];
+                if (!firstLetterHandled && char.IsLetter(c))
+                {
+                    _ = builder.Append(char.ToUpperInvariant(c));
+                    firstLetterHandled = true;
+                }
+                else if (!firstLetterHandled && char.IsDigit(c))
+                {
+                    _ = builder.Append(c);
+                }
+                else if (!firstLetterHandled)
+                {
+                    _ = builder.Append(c);
+                }
+                else if (char.IsLetter(c))
+                {
+                    _ = builder.Append(char.ToLowerInvariant(c));
+                }
+                else
+                {
+                    _ = builder.Append(c);
+                }
+            }
+        }
+
+        private static void AppendLowerInvariant(StringBuilder builder, string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return;
+            }
+
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                _ = builder.Append(char.IsLetter(c) ? char.ToLowerInvariant(c) : c);
+            }
+        }
+
+        private static bool IsAllUppercaseLetters(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return false;
+            }
+
+            bool foundLetter = false;
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                if (!char.IsLetter(c))
+                {
+                    continue;
+                }
+
+                foundLetter = true;
+                if (!char.IsUpper(c))
+                {
+                    return false;
+                }
+            }
+
+            return foundLetter;
+        }
+
+        private static string CollapseSpaces(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return string.Empty;
+            }
+
+            using PooledResource<StringBuilder> builderResource = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder builder
+            );
+
+            bool previousWasSpace = false;
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                if (char.IsWhiteSpace(c))
+                {
+                    if (!previousWasSpace)
+                    {
+                        _ = builder.Append(' ');
+                        previousWasSpace = true;
+                    }
+                }
+                else
+                {
+                    _ = builder.Append(c);
+                    previousWasSpace = false;
+                }
+            }
+
+            return builder.ToString().Trim();
+        }
+
+        private static string ToTitleCaseInternal(string value, bool preserveSeparators)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return string.Empty;
+            }
+
+            List<CaseToken> tokens = TokenizeForCase(value);
+            if (tokens.Count == 0)
+            {
+                return string.Empty;
+            }
+
+            bool startsWithLowerWord = StartsWithLowercaseWord(value);
+
+            using PooledResource<StringBuilder> stringBuilderBuffer = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder stringBuilder
+            );
+
+            CaseTokenKind? previousTokenKind = null;
+            int previousWordLength = 0;
+
+            for (int i = 0; i < tokens.Count; ++i)
+            {
+                CaseToken token = tokens[i];
+                if (token.Kind == CaseTokenKind.Separator)
+                {
+                    if (preserveSeparators)
+                    {
+                        _ = stringBuilder.Append(token.Value);
+                    }
+                    else if (stringBuilder.Length > 0 && stringBuilder[^1] != ' ')
+                    {
+                        _ = stringBuilder.Append(' ');
+                    }
+
+                    previousTokenKind = CaseTokenKind.Separator;
+                    previousWordLength = 0;
+                    continue;
+                }
+
+                string sanitized = SanitizeWord(token.Value, removeStripChars: false);
+                if (string.IsNullOrEmpty(sanitized))
+                {
+                    previousTokenKind = CaseTokenKind.Word;
+                    continue;
+                }
+
+                bool implicitBoundary = previousTokenKind == CaseTokenKind.Word;
+                bool treatAsContinuation =
+                    implicitBoundary
+                    && startsWithLowerWord
+                    && previousWordLength <= 1
+                    && IsAllUppercaseLetters(sanitized);
+
+                if (implicitBoundary && !treatAsContinuation)
+                {
+                    bool shouldInsertSpace = !startsWithLowerWord;
+                    if (preserveSeparators)
+                    {
+                        if (shouldInsertSpace)
+                        {
+                            _ = stringBuilder.Append(' ');
+                        }
+                    }
+                    else if (
+                        shouldInsertSpace
+                        && stringBuilder.Length > 0
+                        && stringBuilder[^1] != ' '
+                    )
+                    {
+                        _ = stringBuilder.Append(' ');
+                    }
+                }
+
+                if (treatAsContinuation)
+                {
+                    AppendLowerInvariant(stringBuilder, sanitized);
+                    previousWordLength += sanitized.Length;
+                }
+                else
+                {
+                    AppendTitleCasedWord(stringBuilder, sanitized);
+                    previousWordLength = sanitized.Length;
+                }
+
+                previousTokenKind = CaseTokenKind.Word;
+            }
+
+            if (!preserveSeparators)
+            {
+                return CollapseSpaces(stringBuilder.ToString());
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public static string ToPascalCase(this string value, string separator = "")
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return string.Empty;
+            }
+
+            List<CaseToken> tokens = TokenizeForCase(value);
+            if (tokens.Count == 0)
+            {
+                return string.Empty;
+            }
+
+            using PooledResource<StringBuilder> stringBuilderBuffer = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder stringBuilder
+            );
+
+            bool isFirstWord = true;
+            foreach (CaseToken token in tokens)
+            {
+                if (token.Kind != CaseTokenKind.Word)
+                {
+                    continue;
+                }
+
+                string sanitized = SanitizeWord(token.Value, removeStripChars: true);
+                if (string.IsNullOrEmpty(sanitized))
+                {
+                    continue;
+                }
+
+                if (!isFirstWord && !string.IsNullOrEmpty(separator))
+                {
+                    _ = stringBuilder.Append(separator);
+                }
+
+                AppendWordWithCasing(stringBuilder, sanitized, uppercaseFirstLetter: true);
+                isFirstWord = false;
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public static bool NeedsLowerInvariantConversion(this string input)
+        {
+            if (string.IsNullOrWhiteSpace(input))
+            {
+                return false;
+            }
+
+            foreach (char inputCharacter in input)
+            {
+                if (char.ToLowerInvariant(inputCharacter) != inputCharacter)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static bool NeedsTrim(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return false;
+            }
+
+            return char.IsWhiteSpace(input[0]) || char.IsWhiteSpace(input[^1]);
+        }
+
+        public static string Truncate(this string input, int maxLength, string ellipsis = "...")
+        {
+            if (string.IsNullOrEmpty(input) || maxLength < 0)
+            {
+                return input;
+            }
+
+            if (input.Length <= maxLength)
+            {
+                return input;
+            }
+
+            if (string.IsNullOrEmpty(ellipsis))
+            {
+                return input.Substring(0, maxLength);
+            }
+
+            int truncateLength = Math.Max(0, maxLength - ellipsis.Length);
+            return input.Substring(0, truncateLength) + ellipsis;
+        }
+
+        private static bool IsAlreadyCamelCase(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return false;
+            }
+
+            bool hasSeenLetter = false;
+
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+
+                if (WordSeparators.Contains(c) || char.IsWhiteSpace(c) || CharsToStrip.Contains(c))
+                {
+                    return false;
+                }
+
+                if (char.IsLetter(c))
+                {
+                    if (!hasSeenLetter)
+                    {
+                        if (!char.IsLower(c))
+                        {
+                            return false;
+                        }
+
+                        hasSeenLetter = true;
+                    }
+
+                    if (char.IsUpper(c))
+                    {
+                        int nextIndex = i + 1;
+                        if (nextIndex < value.Length && char.IsUpper(value[nextIndex]))
+                        {
+                            return false;
+                        }
+                    }
+                }
+                else if (!char.IsDigit(c))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static string ToCamelCase(this string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return string.Empty;
+            }
+
+            if (IsAlreadyCamelCase(value))
+            {
+                return value;
+            }
+
+            string pascalCase = value.ToPascalCase();
+            if (pascalCase.Length == 0)
+            {
+                return string.Empty;
+            }
+
+            if (pascalCase.Length == 1)
+            {
+                return char.ToLowerInvariant(pascalCase[0]).ToString();
+            }
+
+            using PooledResource<StringBuilder> stringBuilderBuffer = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder stringBuilder
+            );
+            _ = stringBuilder.Append(char.ToLowerInvariant(pascalCase[0]));
+
+            for (int i = 1; i < pascalCase.Length; ++i)
+            {
+                _ = stringBuilder.Append(pascalCase[i]);
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public static string ToSnakeCase(this string value)
+        {
+            return ToDelimitedCase(value, '_');
+        }
+
+        public static string ToKebabCase(this string value)
+        {
+            return ToDelimitedCase(value, '-');
+        }
+
+        public static string ToTitleCase(this string value, bool preserveSeparators = true)
+        {
+            return ToTitleCaseInternal(value, preserveSeparators);
+        }
+
+        public static bool ContainsIgnoreCase(this string input, string value)
+        {
+            if (input == null || value == null)
+            {
+                return false;
+            }
+
+            return input.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
+        }
+
+        public static bool EqualsIgnoreCase(this string input, string value)
+        {
+            return string.Equals(input, value, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public static string Reverse(this string input)
+        {
+            if (input == null || input.Length <= 1)
+            {
+                return input;
+            }
+
+            int len = input.Length;
+            return string.Create(
+                len,
+                input,
+                static (span, src) =>
+                {
+                    for (int i = 0; i < span.Length; ++i)
+                    {
+                        span[i] = src[src.Length - 1 - i];
+                    }
+                }
+            );
+        }
+
+        public static string RemoveWhitespace(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return input;
+            }
+
+            using PooledResource<StringBuilder> stringBuilderBuffer = Buffers.GetStringBuilder(
+                input.Length,
+                out StringBuilder stringBuilder
+            );
+
+            foreach (char c in input)
+            {
+                if (!char.IsWhiteSpace(c))
+                {
+                    _ = stringBuilder.Append(c);
+                }
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public static int CountOccurrences(this string input, char character)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return 0;
+            }
+
+            int count = 0;
+            foreach (char c in input)
+            {
+                if (c == character)
+                {
+                    ++count;
+                }
+            }
+
+            return count;
+        }
+
+        public static int CountOccurrences(this string input, string substring)
+        {
+            if (string.IsNullOrEmpty(input) || string.IsNullOrEmpty(substring))
+            {
+                return 0;
+            }
+
+            int count = 0;
+            int index = 0;
+
+            while ((index = input.IndexOf(substring, index, StringComparison.Ordinal)) != -1)
+            {
+                ++count;
+                index += substring.Length;
+            }
+
+            return count;
+        }
+
+        public static bool IsNumeric(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return false;
+            }
+
+            foreach (char c in input)
+            {
+                if (!char.IsDigit(c))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool IsAlphabetic(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return false;
+            }
+
+            foreach (char c in input)
+            {
+                if (!char.IsLetter(c))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool IsAlphanumeric(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return false;
+            }
+
+            foreach (char c in input)
+            {
+                if (!char.IsLetterOrDigit(c))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static string ToBase64(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return string.Empty;
+            }
+
+            byte[] bytes = Encoding.UTF8.GetBytes(input);
+            return Convert.ToBase64String(bytes);
+        }
+
+        public static string FromBase64(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return string.Empty;
+            }
+
+            if (TryDecodeBase64Utf8(input, out string decoded))
+            {
+                return decoded;
+            }
+
+            return string.Empty;
+        }
+
+        private static bool IsLikelyBase64(string s)
+        {
+            int len = s.Length;
+            if (len == 0 || (len & 3) != 0)
+            {
+                return false;
+            }
+
+            // Count '=' padding at end (0..2), and ensure it only appears at the end
+            int padding = 0;
+            if (s[len - 1] == '=')
+            {
+                padding = 1;
+                if (s[len - 2] == '=')
+                {
+                    padding = 2;
+                }
+            }
+
+            int effectiveLen = len - padding;
+            for (int i = 0; i < effectiveLen; ++i)
+            {
+                char c = s[i];
+                bool isAlphaUpper = c is >= 'A' and <= 'Z';
+                bool isAlphaLower = c is >= 'a' and <= 'z';
+                bool isDigit = c is >= '0' and <= '9';
+                bool isPlusSlash = c == '+' || c == '/';
+                if (!(isAlphaUpper || isAlphaLower || isDigit || isPlusSlash))
+                {
+                    return false;
+                }
+            }
+
+            // Ensure no '=' appears before the padding region
+            for (int i = 0; i < effectiveLen; ++i)
+            {
+                if (s[i] == '=')
+                {
+                    return false;
+                }
+            }
+
+            // Basic checks passed
+            return true;
+        }
+
+        private static bool TryDecodeBase64Utf8(string s, out string result)
+        {
+            result = string.Empty;
+            if (!IsLikelyBase64(s))
+            {
+                return false;
+            }
+
+            int len = s.Length;
+            int padding = 0;
+            if (len > 0 && s[len - 1] == '=')
+            {
+                padding = 1;
+                if (len > 1 && s[len - 2] == '=')
+                {
+                    padding = 2;
+                }
+            }
+
+            int outputLen = (len >> 2) * 3 - padding;
+            if (outputLen < 0)
+            {
+                return false;
+            }
+
+            using PooledResource<byte[]> lease = WallstopFastArrayPool<byte>.Get(
+                outputLen,
+                out byte[] buffer
+            );
+
+            int k = 0;
+            for (int i = 0; i < len; i += 4)
+            {
+                int v0 = Base64Map(s[i]);
+                int v1 = Base64Map(s[i + 1]);
+                char c2 = s[i + 2];
+                char c3 = s[i + 3];
+                int v2 = c2 == '=' ? 0 : Base64Map(c2);
+                int v3 = c3 == '=' ? 0 : Base64Map(c3);
+
+                if (v0 < 0 || v1 < 0 || (c2 != '=' && v2 < 0) || (c3 != '=' && v3 < 0))
+                {
+                    return false;
+                }
+
+                if (k < outputLen)
+                {
+                    buffer[k++] = (byte)((v0 << 2) | (v1 >> 4));
+                }
+                if (k < outputLen)
+                {
+                    buffer[k++] = (byte)((v1 << 4) | (v2 >> 2));
+                }
+                if (k < outputLen)
+                {
+                    buffer[k++] = (byte)((v2 << 6) | v3);
+                }
+            }
+
+            result = Encoding.UTF8.GetString(buffer, 0, outputLen);
+            return true;
+        }
+
+        private static int Base64Map(char c)
+        {
+            if (c is >= 'A' and <= 'Z')
+            {
+                return c - 'A';
+            }
+            if (c is >= 'a' and <= 'z')
+            {
+                return c - 'a' + 26;
+            }
+            if (c is >= '0' and <= '9')
+            {
+                return c - '0' + 52;
+            }
+            if (c == '+')
+            {
+                return 62;
+            }
+            if (c == '/')
+            {
+                return 63;
+            }
+            return -1;
+        }
+
+        public static string Repeat(this string input, int count)
+        {
+            if (string.IsNullOrEmpty(input) || count <= 0)
+            {
+                return string.Empty;
+            }
+
+            if (count == 1)
+            {
+                return input;
+            }
+
+            int estimated = 0;
+            if (count > 1 && input.Length > 0)
+            {
+                int maxMultiplier = int.MaxValue / input.Length;
+                if (count <= maxMultiplier)
+                {
+                    estimated = input.Length * count;
+                }
+                // else leave estimated = 0 to let the builder grow dynamically
+            }
+            using PooledResource<StringBuilder> stringBuilderBuffer = Buffers.GetStringBuilder(
+                estimated,
+                out StringBuilder stringBuilder
+            );
+
+            for (int i = 0; i < count; ++i)
+            {
+                _ = stringBuilder.Append(input);
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public static string[] SplitCamelCase(this string input)
+        {
+            if (string.IsNullOrEmpty(input))
+            {
+                return Array.Empty<string>();
+            }
+
+            using PooledResource<List<string>> listBuffer = Buffers<string>.List.Get();
+            List<string> words = listBuffer.resource;
+            using PooledResource<StringBuilder> stringBuilderBuffer = Buffers.GetStringBuilder(
+                input.Length,
+                out StringBuilder currentWord
+            );
+
+            for (int i = 0; i < input.Length; ++i)
+            {
+                char current = input[i];
+
+                if (WordSeparators.Contains(current))
+                {
+                    if (currentWord.Length > 0)
+                    {
+                        words.Add(currentWord.ToString());
+                        currentWord.Clear();
+                    }
+                    continue;
+                }
+
+                if (char.IsUpper(current) && i > 0)
+                {
+                    char previous = input[i - 1];
+                    if (!char.IsUpper(previous) && !WordSeparators.Contains(previous))
+                    {
+                        if (currentWord.Length > 0)
+                        {
+                            words.Add(currentWord.ToString());
+                            currentWord.Clear();
+                        }
+                    }
+                    else if (i + 1 < input.Length && char.IsLower(input[i + 1]))
+                    {
+                        if (currentWord.Length > 0)
+                        {
+                            words.Add(currentWord.ToString());
+                            currentWord.Clear();
+                        }
+                    }
+                }
+
+                _ = currentWord.Append(current);
+            }
+
+            if (currentWord.Length > 0)
+            {
+                words.Add(currentWord.ToString());
+            }
+
+            return words.ToArray();
+        }
+
+        public static string ReplaceFirst(this string input, string oldValue, string newValue)
+        {
+            if (string.IsNullOrEmpty(input) || string.IsNullOrEmpty(oldValue))
+            {
+                return input;
+            }
+
+            int index = input.IndexOf(oldValue, StringComparison.Ordinal);
+            if (index < 0)
+            {
+                return input;
+            }
+
+            int oldLen = oldValue.Length;
+            int newLen = input.Length - oldLen + (newValue?.Length ?? 0);
+            return string.Create(
+                newLen,
+                (input, index, oldLen, newValue),
+                static (dst, state) =>
+                {
+                    state.input.AsSpan(0, state.index).CopyTo(dst);
+                    int pos = state.index;
+                    if (state.newValue != null)
+                    {
+                        state.newValue.AsSpan().CopyTo(dst.Slice(pos));
+                        pos += state.newValue.Length;
+                    }
+                    state.input.AsSpan(state.index + state.oldLen).CopyTo(dst.Slice(pos));
+                }
+            );
+        }
+
+        public static string ReplaceLast(this string input, string oldValue, string newValue)
+        {
+            if (string.IsNullOrEmpty(input) || string.IsNullOrEmpty(oldValue))
+            {
+                return input;
+            }
+
+            int index = input.LastIndexOf(oldValue, StringComparison.Ordinal);
+            if (index < 0)
+            {
+                return input;
+            }
+
+            int oldLen = oldValue.Length;
+            int newLen = input.Length - oldLen + (newValue?.Length ?? 0);
+            return string.Create(
+                newLen,
+                (input, index, oldLen, newValue),
+                static (dst, state) =>
+                {
+                    state.input.AsSpan(0, state.index).CopyTo(dst);
+                    int pos = state.index;
+                    if (state.newValue != null)
+                    {
+                        state.newValue.AsSpan().CopyTo(dst.Slice(pos));
+                        pos += state.newValue.Length;
+                    }
+                    state.input.AsSpan(state.index + state.oldLen).CopyTo(dst.Slice(pos));
+                }
+            );
+        }
+
+        private static string RemoveCombiningDotAboveIfPresent(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                return value;
+            }
+
+            bool containsSpecialCharacter = false;
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                if (c == CombiningDotAbove || c == CapitalIWithDot)
+                {
+                    containsSpecialCharacter = true;
+                    break;
+                }
+            }
+
+            if (!containsSpecialCharacter)
+            {
+                return value;
+            }
+
+            using PooledResource<StringBuilder> builderResource = Buffers.GetStringBuilder(
+                value.Length,
+                out StringBuilder builder
+            );
+
+            for (int i = 0; i < value.Length; ++i)
+            {
+                char c = value[i];
+                if (c == CombiningDotAbove)
+                {
+                    continue;
+                }
+
+                if (c == CapitalIWithDot)
+                {
+                    _ = builder.Append(char.ToLowerInvariant('I'));
+                    continue;
+                }
+
+                _ = builder.Append(c);
+            }
+
+            return builder.ToString();
+        }
+
+        public static string ToCase(this string value, StringCase stringCase)
+        {
+            switch (stringCase)
+            {
+                case StringCase.PascalCase:
+                    return value.ToPascalCase();
+                case StringCase.CamelCase:
+                    return value.ToCamelCase();
+                case StringCase.SnakeCase:
+                    return value.ToSnakeCase();
+                case StringCase.KebabCase:
+                    return value.ToKebabCase();
+                case StringCase.TitleCase:
+                    return value.ToTitleCase(preserveSeparators: false);
+                case StringCase.LowerCase:
+                    return value == null
+                        ? string.Empty
+                        : RemoveCombiningDotAboveIfPresent(value.ToLowerInvariant());
+                case StringCase.UpperCase:
+                    return value?.ToUpperInvariant() ?? string.Empty;
+                case StringCase.LowerInvariant:
+                    return value == null
+                        ? string.Empty
+                        : RemoveCombiningDotAboveIfPresent(value.ToLowerInvariant());
+                case StringCase.UpperInvariant:
+                    return value?.ToUpperInvariant() ?? string.Empty;
+#pragma warning disable CS0618 // Type or member is obsolete
+                case StringCase.None:
+#pragma warning restore CS0618 // Type or member is obsolete
+                default:
+                    return value ?? string.Empty;
+            }
+        }
+    }
+}