diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Boolean.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Boolean.cs
index 83eefeb..a219bf2 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Boolean.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Boolean.cs
@@ -2,86 +2,111 @@
 using Newtonsoft.Json.Linq;
 using Skybrud.Essentials.Strings;
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
-
-    internal static partial class JsonTokenUtils {
-
-        internal static bool GetBoolean(JToken? token) {
-            return token?.Type switch {
-                JTokenType.Boolean => token.Value<bool>(),
-                JTokenType.Integer => token.Value<int>() switch {
-                    0 => false,
-                    1 => true,
-                    _ => false,
-                },
-                JTokenType.String => StringUtils.ParseBoolean(token.Value<string>()),
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
+
+static partial class JsonTokenUtils {
+
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a boolean value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns><see langword="true"/> if <paramref name="token"/> matches a *truthy* value; otherwise, <see langword="false"/>.</returns>
+    public static bool GetBoolean(JToken? token) {
+        return token?.Type switch {
+            JTokenType.Boolean => token.Value<bool>(),
+            JTokenType.Integer => token.Value<int>() switch {
+                0 => false,
+                1 => true,
                 _ => false,
-            };
-        }
+            },
+            JTokenType.String => StringUtils.ParseBoolean(token.Value<string>()),
+            _ => false,
+        };
+    }
 
-        internal static bool GetBoolean(JToken? token, bool fallback) {
-            return token?.Type switch {
-                JTokenType.Boolean => token.Value<bool>(),
-                JTokenType.Integer => token.Value<int>() switch {
-                    0 => false,
-                    1 => true,
-                    _ => fallback,
-                },
-                JTokenType.String => StringUtils.ParseBoolean(token.Value<string>(), fallback),
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a boolean value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">The fallback value to be returned if <paramref name="token"/> matches neither a *truthy* nor *falsy* value.</param>
+    /// <returns><see langword="true"/> if <paramref name="token"/> matches a *truthy* value, <see langword="false"/> if <paramref name="token"/> matches a *falsy* value. If neither, <paramref name="fallback"/> is returned instead.</returns>
+    public static bool GetBoolean(JToken? token, bool fallback) {
+        return token?.Type switch {
+            JTokenType.Boolean => token.Value<bool>(),
+            JTokenType.Integer => token.Value<int>() switch {
+                0 => false,
+                1 => true,
                 _ => fallback,
-            };
-        }
+            },
+            JTokenType.String => StringUtils.ParseBoolean(token.Value<string>(), fallback),
+            _ => fallback,
+        };
+    }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a boolean value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns><see langword="true"/> if <paramref name="token"/> matches a *truthy* value, <see langword="false"/> if <paramref name="token"/> matches a *falsy* value. If neither, <see langword="null"/> is returned instead.</returns>
+    public static bool? GetBooleanOrNull(JToken? token) {
+        return TryGetBoolean(token, out bool? result) ? result : null;
+    }
 
-        internal static bool? GetBooleanOrNull(JToken? token) {
-            return TryGetBoolean(token, out bool? result) ? result : null;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a boolean value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds a boolean value matching either a *truthy* or *falsy* value if successful; otherwise, <see langword="false"/>.</param>
+    /// <returns><see langword="true"/> if <paramref name="token"/> matches either a *truthy* or *falsy* value; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetBoolean(JToken? token, out bool result) {
+
+        if (TryGetBoolean(token, out bool? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetBoolean(JToken? token, out bool result) {
-
-            if (TryGetBoolean(token, out bool? temp)) {
-                result = temp.Value;
-                return true;
-            }
-
-            result = default;
-            return false;
-
-        }
+        result = default;
+        return false;
 
-        internal static bool TryGetBoolean(JToken? token, [NotNullWhen(true)] out bool? result) {
+    }
 
-            switch (token?.Type) {
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a boolean value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds a boolean value matching either a *truthy* or *falsy* value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if <paramref name="token"/> matches either a *truthy* or *falsy* value; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetBoolean(JToken? token, [NotNullWhen(true)] out bool? result) {
 
-                case JTokenType.Boolean:
-                    result = token.Value<bool>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.Integer:
+            case JTokenType.Boolean:
+                result = token.Value<bool>();
+                return true;
 
-                    switch (token.Value<int>()) {
+            case JTokenType.Integer:
 
-                        case 0:
-                            result = false;
-                            return true;
+                switch (token.Value<int>()) {
 
-                        case 1:
-                            result = true;
-                            return true;
+                    case 0:
+                        result = false;
+                        return true;
 
-                        default:
-                            result = false;
-                            return false;
+                    case 1:
+                        result = true;
+                        return true;
 
-                    }
+                    default:
+                        result = false;
+                        return false;
 
-                case JTokenType.String:
-                    return StringUtils.TryParseBoolean(token.Value<string>(), out result);
+                }
 
-                default:
-                    result = false;
-                    return false;
+            case JTokenType.String:
+                return StringUtils.TryParseBoolean(token.Value<string>(), out result);
 
-            }
+            default:
+                result = false;
+                return false;
 
         }
 
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Double.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Double.cs
index 4c9ff90..6cd7a5d 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Double.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Double.cs
@@ -2,92 +2,117 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static double GetDouble(JToken? token) {
-            return GetDouble(token, default);
-        }
-
-        internal static double GetDouble(JToken? token, double fallback) {
-            return TryGetDouble(token, out double? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetDouble<T>(JToken? token, Func<double, T> callback) {
-            return TryGetDouble(token, out double? result) ? callback(result.Value) : default;
-        }
-
-        internal static double? GetDoubleOrNull(JToken? token) {
-            return TryGetDouble(token, out double? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="double"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted <see cref="double"/> value if successful; otherwise, <c>0</c>.</returns>
+    public static double GetDouble(JToken? token) {
+        return GetDouble(token, default);
+    }
 
-        internal static bool TryGetDouble(JToken? token, out double result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="double"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted <see cref="double"/> value if successful; otherwise, <paramref name="fallback"/>.</returns>
+    public static double GetDouble(JToken? token, double fallback) {
+        return TryGetDouble(token, out double? result) ? result.Value : fallback;
+    }
 
-            if (TryGetDouble(token, out double? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    internal static T? GetDouble<T>(JToken? token, Func<double, T> callback) {
+        return TryGetDouble(token, out double? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="double"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted <see cref="double"/> value if successful; otherwise, <see langword="null"/>.</returns>
+    public static double? GetDoubleOrNull(JToken? token) {
+        return TryGetDouble(token, out double? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a <see cref="double"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted <see cref="double"/> value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetDouble(JToken? token, out double result) {
+
+        if (TryGetDouble(token, out double? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetDouble(JToken? token, [NotNullWhen(true)] out double? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.Value<bool>() ? 1 : 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a <see cref="double"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted <see cref="double"/> value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetDouble(JToken? token, [NotNullWhen(true)] out double? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.Value<double>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseDouble(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.Value<bool>() ? 1 : 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.Value<double>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseDouble(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static double[] GetDoubleArray(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToDoubleArray(),
-                JTokenType.Array => ConvertArrayTokenToDoubleArray(token),
-                _ => TryGetDouble(token, out double? result) ? new[] { result.Value } : ArrayUtils.Empty<double>()
-            };
         }
 
-        private static double[] ConvertArrayTokenToDoubleArray(JToken token) {
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<double>();
+    internal static double[] GetDoubleArray(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToDoubleArray(),
+            JTokenType.Array => ConvertArrayTokenToDoubleArray(token),
+            _ => TryGetDouble(token, out double? result) ? [result.Value] : []
+        };
+    }
 
-            List<double> temp = new();
+    private static double[] ConvertArrayTokenToDoubleArray(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetDouble(item, out double? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<double> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetDouble(item, out double? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
+
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Enum.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Enum.cs
index 5c877fa..23dbc37 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Enum.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Enum.cs
@@ -4,37 +4,55 @@
 
 // ReSharper disable SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
-
-    internal static partial class JsonTokenUtils {
-
-        public static T GetEnum<T>(JToken? token) where T : Enum {
-            return token?.Type switch {
-                JTokenType.Integer => EnumUtils.FromInt32Internal<T>(token.Value<int>()),
-                JTokenType.Float => EnumUtils.FromInt32Internal<T>(token.Value<int>()),
-                JTokenType.String => EnumUtils.ParseEnumInternal<T>(token.Value<string>()),
-                _ => throw new EnumParseException(typeof(T), token.Value<string>())
-            };
-        }
-
-        public static T GetEnum<T>(JToken? token, T fallback) where T : Enum {
-            return token?.Type switch {
-                JTokenType.Integer => EnumUtils.FromInt32(token.Value<int>(), fallback),
-                JTokenType.Float => EnumUtils.FromInt32(token.Value<int>(), fallback),
-                JTokenType.String => EnumUtils.ParseEnumInternal(token.Value<string>(), fallback),
-                _ => fallback
-            };
-        }
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
+
+static partial class JsonTokenUtils {
+
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a corresponding enum value of type <typeparamref name="TEnum"/>.
+    /// </summary>
+    /// <typeparam name="TEnum">The type of the enum.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted enum value if successful.</returns>
+    /// <exception cref="EnumParseException">If the type <paramref name="token"/> is not supported, or the doesn't match a valid token value.</exception>
+    public static TEnum GetEnum<TEnum>(JToken? token) where TEnum : Enum {
+        return token?.Type switch {
+            JTokenType.Integer => EnumUtils.FromInt32Internal<TEnum>(token.Value<int>()),
+            JTokenType.Float => EnumUtils.FromInt32Internal<TEnum>(token.Value<int>()),
+            JTokenType.String => EnumUtils.ParseEnumInternal<TEnum>(token.Value<string>()),
+            _ => throw new EnumParseException(typeof(TEnum), token.Value<string>())
+        };
+    }
 
-        public static TEnum? GetEnumOrNull<TEnum>(JToken? token) where TEnum : struct, Enum {
-            return token?.Type switch {
-                JTokenType.Integer => EnumUtils.ToEnumOrNull<TEnum>(token.Value<int>()),
-                JTokenType.Float => EnumUtils.ToEnumOrNull<TEnum>(token.Value<int>()),
-                JTokenType.String => EnumUtils.ParseEnumOrNull<TEnum>(token.Value<string>()),
-                _ => null
-            };
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a corresponding enum value of type <typeparamref name="TEnum"/>.
+    /// </summary>
+    /// <typeparam name="TEnum">The type of the enum.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">The fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted enum value if successful; otherwise, <paramref name="fallback"/>.</returns>
+    public static TEnum GetEnum<TEnum>(JToken? token, TEnum fallback) where TEnum : Enum {
+        return token?.Type switch {
+            JTokenType.Integer => EnumUtils.FromInt32(token.Value<int>(), fallback),
+            JTokenType.Float => EnumUtils.FromInt32(token.Value<int>(), fallback),
+            JTokenType.String => EnumUtils.ParseEnumInternal(token.Value<string>(), fallback),
+            _ => fallback
+        };
+    }
 
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a corresponding enum value of type <typeparamref name="TEnum"/>.
+    /// </summary>
+    /// <typeparam name="TEnum">The type of the enum.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted enum value if successful; otherwise, <see langword="null"/>.</returns>
+    public static TEnum? GetEnumOrNull<TEnum>(JToken? token) where TEnum : struct, Enum {
+        return token?.Type switch {
+            JTokenType.Integer => EnumUtils.ToEnumOrNull<TEnum>(token.Value<int>()),
+            JTokenType.Float => EnumUtils.ToEnumOrNull<TEnum>(token.Value<int>()),
+            JTokenType.String => EnumUtils.ParseEnumOrNull<TEnum>(token.Value<string>()),
+            _ => null
+        };
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Float.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Float.cs
index 233fc6f..592c90b 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Float.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Float.cs
@@ -2,92 +2,129 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static float GetFloat(JToken? token) {
-            return GetFloat(token, default);
-        }
-
-        internal static float GetFloat(JToken? token, float fallback) {
-            return TryGetFloat(token, out float? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetFloat<T>(JToken? token, Func<float, T> callback) {
-            return TryGetFloat(token, out float? result) ? callback(result.Value) : default;
-        }
-
-        internal static float? GetFloatOrNull(JToken? token) {
-            return TryGetFloat(token, out float? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="float"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted <see cref="float"/> value if successful; otherwise, <c>0</c>.</returns>
+    public static float GetFloat(JToken? token) {
+        return GetFloat(token, default);
+    }
 
-        internal static bool TryGetFloat(JToken? token, out float result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="float"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted <see cref="float"/> value if successful; otherwise, <paramref name="fallback"/>.</returns>
+    public static float GetFloat(JToken? token, float fallback) {
+        return TryGetFloat(token, out float? result) ? result.Value : fallback;
+    }
 
-            if (TryGetFloat(token, out float? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetFloat<T>(JToken? token, Func<float, T> callback) {
+        return TryGetFloat(token, out float? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="float"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted <see cref="float"/> value if successful; otherwise, <see langword="null"/>.</returns>
+    public static float? GetFloatOrNull(JToken? token) {
+        return TryGetFloat(token, out float? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a <see cref="float"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted <see cref="float"/> value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetFloat(JToken? token, out float result) {
+
+        if (TryGetFloat(token, out float? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetFloat(JToken? token, [NotNullWhen(true)] out float? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.Value<bool>() ? 1 : 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a <see cref="float"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted <see cref="float"/> value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetFloat(JToken? token, [NotNullWhen(true)] out float? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.Value<float>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseFloat(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.Value<bool>() ? 1 : 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.Value<float>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseFloat(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static float[] GetFloatArray(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToFloatArray(),
-                JTokenType.Array => ConvertArrayTokenToFloatArray(token),
-                _ => TryGetFloat(token, out float? result) ? new[] { result.Value } : ArrayUtils.Empty<float>()
-            };
         }
 
-        private static float[] ConvertArrayTokenToFloatArray(JToken token) {
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<float>();
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of <see cref="float"/> values.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>A <see cref="float"/> array.</returns>
+    public static float[] GetFloatArray(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToFloatArray(),
+            JTokenType.Array => ConvertArrayTokenToFloatArray(token),
+            _ => TryGetFloat(token, out float? result) ? [result.Value] : []
+        };
+    }
 
-            List<float> temp = new();
+    private static float[] ConvertArrayTokenToFloatArray(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetFloat(item, out float? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<float> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetFloat(item, out float? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
+
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Guid.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Guid.cs
index 5d017e7..5d15dc3 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Guid.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Guid.cs
@@ -2,99 +2,136 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
-
-    internal static partial class JsonTokenUtils {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
+
+static partial class JsonTokenUtils {
+
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="Guid"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted <see cref="Guid"/> value if successful; otherwise, <see cref="Guid.Empty"/>.</returns>
+    public static Guid GetGuid(JToken? token) {
+        return token?.Type switch {
+            JTokenType.Guid => token.ToObject<Guid>(),
+            JTokenType.String => token.ToObject<string>().ToGuid(),
+            _ => Guid.Empty
+        };
+    }
 
-        internal static Guid GetGuid(JToken? token) {
-            return token?.Type switch {
-                JTokenType.Guid => token.ToObject<Guid>(),
-                JTokenType.String => token.ToObject<string>().ToGuid(),
-                _ => Guid.Empty
-            };
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="Guid"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted <see cref="Guid"/> value if successful; otherwise, <paramref name="fallback"/>.</returns>
+    public static Guid GetGuid(JToken? token, Guid fallback) {
+        return token?.Type switch {
+            JTokenType.Guid => token.ToObject<Guid>(),
+            JTokenType.String => token.ToObject<string>().ToGuid(fallback),
+            _ => fallback
+        };
+    }
 
-        internal static Guid GetGuid(JToken? token, Guid fallback) {
-            return token?.Type switch {
-                JTokenType.Guid => token.ToObject<Guid>(),
-                JTokenType.String => token.ToObject<string>().ToGuid(fallback),
-                _ => fallback
-            };
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetGuid<T>(JToken? token, Func<Guid, T> callback) {
+        return TryGetGuid(token, out Guid? result) ? callback(result.Value) : default;
+    }
 
-        internal static T? GetGuid<T>(JToken? token, Func<Guid, T> callback) {
-            return TryGetGuid(token, out Guid? result) ? callback(result.Value) : default;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="Guid"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted <see cref="Guid"/> value if successful; otherwise, <see langword="null"/>.</returns>
+    public static Guid? GetGuidOrNull(JToken? token) {
+        return TryGetGuid(token, out Guid? result) ? result : null;
+    }
 
-        internal static Guid? GetGuidOrNull(JToken? token) {
-            return TryGetGuid(token, out Guid? result) ? result : null;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a <see cref="Guid"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted <see cref="Guid"/> value if successful; otherwise, <see cref="Guid.Empty"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetGuid(JToken? token, out Guid result) {
+
+        if (TryGetGuid(token, out Guid? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetGuid(JToken? token, out Guid result) {
+        result = default;
+        return false;
 
-            if (TryGetGuid(token, out Guid? temp)) {
-                result = temp.Value;
-                return true;
-            }
-
-            result = default;
-            return false;
-
-        }
-
-        internal static bool TryGetGuid(JToken? token, [NotNullWhen(true)] out Guid? result) {
+    }
 
-            switch (token?.Type) {
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a <see cref="Guid"/> value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted <see cref="Guid"/> value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetGuid(JToken? token, [NotNullWhen(true)] out Guid? result) {
 
-                case JTokenType.Guid:
-                    result = token.ToObject<Guid>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseGuid(token.ToObject<string>(), out result);
+            case JTokenType.Guid:
+                result = token.ToObject<Guid>();
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.String:
+                return StringUtils.TryParseGuid(token.ToObject<string>(), out result);
 
-            }
+            default:
+                result = null;
+                return false;
 
         }
 
-        internal static Guid[] GetGuidArray(JToken? token) {
+    }
 
-            switch (token) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a <see cref="Guid"/> array.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>A <see cref="Guid"/> array.</returns>
+    public static Guid[] GetGuidArray(JToken? token) {
 
-                case null:
-                    return ArrayUtils.Empty<Guid>();
+        switch (token) {
 
-                case JArray array:
+            case null:
+                return [];
 
-                    List<Guid> temp = new();
+            case JArray array:
 
-                    foreach (JToken t in array) {
+                List<Guid> temp = [];
 
-                        // Attempt to parse the individual tokens in the array, ensuring invalid values doesn't trigger an exception
-                        if (t != null && Guid.TryParse(t.ToString(), out Guid guid)) temp.Add(guid);
+                foreach (JToken t in array) {
 
-                    }
+                    // Attempt to parse the individual tokens in the array, ensuring invalid values doesn't trigger an exception
+                    if (t != null && Guid.TryParse(t.ToString(), out Guid guid)) temp.Add(guid);
 
-                    return temp.ToArray();
+                }
 
-                default:
+                return [..temp];
 
-                    // Be friendly to other formats
-                    return token.Type switch {
-                        JTokenType.String => StringUtils.ParseGuidArray(token.Value<string>()),
-                        JTokenType.Guid => new[] { token.Value<Guid>() },
-                        _ => ArrayUtils.Empty<Guid>()
-                    };
+            default:
 
-            }
+                // Be friendly to other formats
+                return token.Type switch {
+                    JTokenType.String => StringUtils.ParseGuidArray(token.Value<string>()),
+                    JTokenType.Guid => [token.Value<Guid>()],
+                    _ => []
+                };
 
         }
 
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int16.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int16.cs
index ff20534..7ea0642 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int16.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int16.cs
@@ -2,92 +2,129 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static short GetInt16(JToken? token) {
-            return GetInt16(token, default);
-        }
-
-        internal static short GetInt16(JToken? token, short fallback) {
-            return TryGetInt16(token, out short? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetInt16<T>(JToken? token, Func<short, T> callback) {
-            return TryGetInt16(token, out short? result) ? callback(result.Value) : default;
-        }
-
-        internal static short? GetInt16OrNull(JToken? token) {
-            return TryGetInt16(token, out short? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted 16-bit integer value if successful; otherwise, <c>0</c>.</returns>
+    public static short GetInt16(JToken? token) {
+        return GetInt16(token, default);
+    }
 
-        internal static bool TryGetInt16(JToken? token, out short result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted 16-bit integer value if successful; otherwise, <paramref name="fallback"/>>.</returns>
+    public static short GetInt16(JToken? token, short fallback) {
+        return TryGetInt16(token, out short? result) ? result.Value : fallback;
+    }
 
-            if (TryGetInt16(token, out short? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetInt16<T>(JToken? token, Func<short, T> callback) {
+        return TryGetInt16(token, out short? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted 16-bit integer value if successful; otherwise, <see langword="null"/>.</returns>
+    public static short? GetInt16OrNull(JToken? token) {
+        return TryGetInt16(token, out short? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted 16-bit integer value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetInt16(JToken? token, out short result) {
+
+        if (TryGetInt16(token, out short? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetInt16(JToken? token, [NotNullWhen(true)] out short? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.Value<bool>() ? (short) 1 : (short) 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted 16-bit integer value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetInt16(JToken? token, [NotNullWhen(true)] out short? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.Value<short>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseInt16(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.Value<bool>() ? (short) 1 : (short) 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.Value<short>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseInt16(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static short[] GetInt16Array(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToInt16Array(),
-                JTokenType.Array => ConvertArrayTokenToInt16Array(token),
-                _ => TryGetInt16(token, out short? result) ? new[] { result.Value } : ArrayUtils.Empty<short>()
-            };
         }
 
-        private static short[] ConvertArrayTokenToInt16Array(JToken token) {
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<short>();
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of 16-bit integer values.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>A 16-bit integer array.</returns>
+    public static short[] GetInt16Array(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToInt16Array(),
+            JTokenType.Array => ConvertArrayTokenToInt16Array(token),
+            _ => TryGetInt16(token, out short? result) ? [result.Value] : []
+        };
+    }
 
-            List<short> temp = new();
+    private static short[] ConvertArrayTokenToInt16Array(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetInt16(item, out short? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<short> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetInt16(item, out short? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
+
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int32.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int32.cs
index 1128206..acb0db5 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int32.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int32.cs
@@ -2,93 +2,130 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static int GetInt32(JToken? token) {
-            return GetInt32(token, default);
-        }
-
-        internal static int GetInt32(JToken? token, int fallback) {
-            return TryGetInt32(token, out int? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetInt32<T>(JToken? token, Func<int, T> callback) {
-            return TryGetInt32(token, out int? result) ? callback(result.Value) : default;
-        }
-
-        internal static int? GetInt32OrNull(JToken? token) {
-            return TryGetInt32(token, out int? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted 32-bit integer value if successful; otherwise, <c>0</c>.</returns>
+    public static int GetInt32(JToken? token) {
+        return GetInt32(token, default);
+    }
 
-        internal static bool TryGetInt32(JToken? token, out int result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted 32-bit integer value if successful; otherwise, <paramref name="fallback"/>>.</returns>
+    public static int GetInt32(JToken? token, int fallback) {
+        return TryGetInt32(token, out int? result) ? result.Value : fallback;
+    }
 
-            if (TryGetInt32(token, out int? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetInt32<T>(JToken? token, Func<int, T> callback) {
+        return TryGetInt32(token, out int? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted 32-bit integer value if successful; otherwise, <see langword="null"/>.</returns>
+    public static int? GetInt32OrNull(JToken? token) {
+        return TryGetInt32(token, out int? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted 32-bit integer value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetInt32(JToken? token, out int result) {
+
+        if (TryGetInt32(token, out int? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetInt32(JToken? token, [NotNullWhen(true)] out int? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.ToObject<bool>() ? 1 : 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted 32-bit integer value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetInt32(JToken? token, [NotNullWhen(true)] out int? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.ToObject<int>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseInt32(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.ToObject<bool>() ? 1 : 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.ToObject<int>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseInt32(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static int[] GetInt32Array(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToInt32Array(),
-                JTokenType.Array => ConvertArrayTokenToInt32Array(token),
-                _ => TryGetInt32(token, out int? result) ? new[] { result.Value } : ArrayUtils.Empty<int>()
-            };
         }
 
+    }
 
-        internal static int[] ConvertArrayTokenToInt32Array(JToken token) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of 32-bit integer values.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>A 32-bit integer array.</returns>
+    public static int[] GetInt32Array(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToInt32Array(),
+            JTokenType.Array => ConvertArrayTokenToInt32Array(token),
+            _ => TryGetInt32(token, out int? result) ? [result.Value] : []
+        };
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<int>();
 
-            List<int> temp = new();
+    internal static int[] ConvertArrayTokenToInt32Array(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetInt32(item, out int? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<int> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetInt32(item, out int? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
+
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int64.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int64.cs
index c9cc352..738479a 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int64.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.Int64.cs
@@ -2,93 +2,130 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static long GetInt64(JToken? token) {
-            return GetInt64(token, default);
-        }
-
-        internal static long GetInt64(JToken? token, long fallback) {
-            return TryGetInt64(token, out long? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetInt64<T>(JToken? token, Func<long, T> callback) {
-            return TryGetInt64(token, out long? result) ? callback(result.Value) : default;
-        }
-
-        internal static long? GetInt64OrNull(JToken? token) {
-            return TryGetInt64(token, out long? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted 64-bit integer value if successful; otherwise, <c>0</c>.</returns>
+    public static long GetInt64(JToken? token) {
+        return GetInt64(token, default);
+    }
 
-        internal static bool TryGetInt64(JToken? token, out long result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted 64-bit integer value if successful; otherwise, <paramref name="fallback"/>>.</returns>
+    public static long GetInt64(JToken? token, long fallback) {
+        return TryGetInt64(token, out long? result) ? result.Value : fallback;
+    }
 
-            if (TryGetInt64(token, out long? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetInt64<T>(JToken? token, Func<long, T> callback) {
+        return TryGetInt64(token, out long? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted 64-bit integer value if successful; otherwise, <see langword="null"/>.</returns>
+    public static long? GetInt64OrNull(JToken? token) {
+        return TryGetInt64(token, out long? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted 64-bit integer value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetInt64(JToken? token, out long result) {
+
+        if (TryGetInt64(token, out long? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetInt64(JToken? token, [NotNullWhen(true)] out long? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.ToObject<bool>() ? 1 : 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted 64-bit integer value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetInt64(JToken? token, [NotNullWhen(true)] out long? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.ToObject<long>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseInt64(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.ToObject<bool>() ? 1 : 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.ToObject<long>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseInt64(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static long[] GetInt64Array(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToInt64Array(),
-                JTokenType.Array => ConvertArrayTokenToInt64Array(token),
-                _ => TryGetInt64(token, out long? result) ? new[] { result.Value } : ArrayUtils.Empty<long>()
-            };
         }
 
-        internal static long[] ConvertArrayTokenToInt64Array(JToken token) {
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<long>();
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of 64-bit integer values.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>A 64-bit integer array.</returns>
+    public static long[] GetInt64Array(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToInt64Array(),
+            JTokenType.Array => ConvertArrayTokenToInt64Array(token),
+            _ => TryGetInt64(token, out long? result) ? [result.Value] : []
+        };
+    }
 
-            List<long> temp = new();
+    private static long[] ConvertArrayTokenToInt64Array(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetInt64(item, out long? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<long> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetInt64(item, out long? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
 
     }
 
+
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.String.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.String.cs
index d815292..e34481c 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.String.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.String.cs
@@ -3,88 +3,108 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings.Extensions;
 using Skybrud.Essentials.Time.Iso8601;
 
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        #region System.String
+    #region System.String
 
-        internal static string? GetString(JToken? token) {
-            return TryGetString(token, out string? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a string value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted string value if successful; otherwise, <see langword="null"/>.</returns>
+    public static string? GetString(JToken? token) {
+        return TryGetString(token, out string? result) ? result : null;
+    }
 
-        internal static T? GetString<T>(JToken? token, Func<string, T> callback) {
-            return TryGetString(token, out string? result) ? callback(result) : default;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a string value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, <see langword="null"/>.</returns>
+    public static T? GetString<T>(JToken? token, Func<string, T> callback) {
+        return TryGetString(token, out string? result) ? callback(result) : default;
+    }
 
-        internal static bool TryGetString(JToken? token, [NotNullWhen(true)] out string? result) {
-
-            switch (token?.Type) {
-
-                case JTokenType.Boolean:
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                case JTokenType.Guid:
-                    result = string.Format(CultureInfo.InvariantCulture, "{0}", token);
-                    return true;
-
-                case JTokenType.Date:
-                    switch (token.ToObject<object>()) {
-                        case DateTime dt:
-                            result = dt.ToString(Iso8601Constants.DateTimeMilliseconds);
-                            return true;
-                        case DateTimeOffset dto:
-                            result = dto.ToString(Iso8601Constants.DateTimeMilliseconds);
-                            return true;
-                        default:
-                            result = null;
-                            return false;
-                    }
-
-                case JTokenType.String:
-                    result = token.Value<string>();
-                    return true;
-
-                default:
-                    result = null;
-                    return false;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into a string value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When the method returns, holds the string value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetString(JToken? token, [NotNullWhen(true)] out string? result) {
+
+        switch (token?.Type) {
+
+            case JTokenType.Boolean:
+            case JTokenType.Integer:
+            case JTokenType.Float:
+            case JTokenType.Guid:
+                result = string.Format(CultureInfo.InvariantCulture, "{0}", token);
+                return true;
+
+            case JTokenType.Date:
+                switch (token.ToObject<object>()) {
+                    case DateTime dt:
+                        result = dt.ToString(Iso8601Constants.DateTimeMilliseconds);
+                        return true;
+                    case DateTimeOffset dto:
+                        result = dto.ToString(Iso8601Constants.DateTimeMilliseconds);
+                        return true;
+                    default:
+                        result = null;
+                        return false;
+                }
 
-            }
+            case JTokenType.String:
+                result = token.Value<string>();
+                return true;
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static string[] GetStringArray(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToStringArray(),
-                JTokenType.Array => ConvertArrayTokenToStringArray(token),
-                _ => TryGetString(token, out string? result) ? new[] { result } : ArrayUtils.Empty<string>()
-            };
         }
 
-        internal static string[] ConvertArrayTokenToStringArray(JToken token) {
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<string>();
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into a string array.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>A string array.</returns>
+    public static string[] GetStringArray(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToStringArray(),
+            JTokenType.Array => ConvertArrayTokenToStringArray(token),
+            _ => TryGetString(token, out string? result) ? [result] : []
+        };
+    }
 
-            List<string> temp = new();
+    internal static string[] ConvertArrayTokenToStringArray(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetString(item, out string? result)) {
-                    temp.Add(result);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<string> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetString(item, out string? result)) {
+                temp.Add(result);
+            }
         }
 
-        #endregion
+        return [..temp];
 
     }
 
+    #endregion
+
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt16.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt16.cs
index 1ce5136..dad59b4 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt16.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt16.cs
@@ -2,94 +2,131 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static ushort GetUInt16(JToken? token) {
-            return GetUInt16(token, default);
-        }
-
-        internal static ushort GetUInt16(JToken? token, ushort fallback) {
-            return TryGetUInt16(token, out ushort? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetUInt16<T>(JToken? token, Func<ushort, T> callback) {
-            return TryGetUInt16(token, out ushort? result) ? callback(result.Value) : default;
-        }
-
-        internal static ushort? GetUInt16OrNull(JToken? token) {
-            return TryGetUInt16(token, out ushort? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted unsigned 16-bit integer value if successful; otherwise, <c>0</c>.</returns>
+    public static ushort GetUInt16(JToken? token) {
+        return GetUInt16(token, default);
+    }
 
-        internal static bool TryGetUInt16(JToken? token, out ushort result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted unsigned 16-bit integer value if successful; otherwise, <paramref name="fallback"/>>.</returns>
+    public static ushort GetUInt16(JToken? token, ushort fallback) {
+        return TryGetUInt16(token, out ushort? result) ? result.Value : fallback;
+    }
 
-            if (TryGetUInt16(token, out ushort? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetUInt16<T>(JToken? token, Func<ushort, T> callback) {
+        return TryGetUInt16(token, out ushort? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted unsigned 16-bit integer value if successful; otherwise, <see langword="null"/>.</returns>
+    public static ushort? GetUInt16OrNull(JToken? token) {
+        return TryGetUInt16(token, out ushort? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into an unsigned 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted unsigned 16-bit integer value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetUInt16(JToken? token, out ushort result) {
+
+        if (TryGetUInt16(token, out ushort? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetUInt16(JToken? token, [NotNullWhen(true)] out ushort? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.Value<bool>() ? (ushort) 1 : (ushort) 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into an unsigned 16-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted unsigned 16-bit integer value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetUInt16(JToken? token, [NotNullWhen(true)] out ushort? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.ToObject<ushort>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseUInt16(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.Value<bool>() ? (ushort) 1 : (ushort) 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.ToObject<ushort>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseUInt16(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static ushort[] GetUInt16Array(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToUInt16Array(),
-                JTokenType.Array => ConvertArrayTokenToUInt16Array(token),
-                _ => TryGetUInt16(token, out ushort? result) ? new[] { result.Value } : ArrayUtils.Empty<ushort>()
-            };
         }
 
+    }
 
-        private static ushort[] ConvertArrayTokenToUInt16Array(JToken token) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of unsigned 16-bit integer values.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>An unsigned 16-bit integer array.</returns>
+    public static ushort[] GetUInt16Array(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToUInt16Array(),
+            JTokenType.Array => ConvertArrayTokenToUInt16Array(token),
+            _ => TryGetUInt16(token, out ushort? result) ? [result.Value] : []
+        };
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<ushort>();
 
-            List<ushort> temp = new();
+    private static ushort[] ConvertArrayTokenToUInt16Array(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetUInt16(item, out ushort? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<ushort> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetUInt16(item, out ushort? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
+
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt32.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt32.cs
index 637fa93..ebd2c75 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt32.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt32.cs
@@ -2,94 +2,131 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static uint GetUInt32(JToken? token) {
-            return GetUInt32(token, default);
-        }
-
-        internal static uint GetUInt32(JToken? token, uint fallback) {
-            return TryGetUInt32(token, out uint? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetUInt32<T>(JToken? token, Func<uint, T> callback) {
-            return TryGetUInt32(token, out uint? result) ? callback(result.Value) : default;
-        }
-
-        internal static uint? GetUInt32OrNull(JToken? token) {
-            return TryGetUInt32(token, out uint? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted unsigned 32-bit integer value if successful; otherwise, <c>0</c>.</returns>
+    public static uint GetUInt32(JToken? token) {
+        return GetUInt32(token, default);
+    }
 
-        internal static bool TryGetUInt32(JToken? token, out uint result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted unsigned 32-bit integer value if successful; otherwise, <paramref name="fallback"/>>.</returns>
+    public static uint GetUInt32(JToken? token, uint fallback) {
+        return TryGetUInt32(token, out uint? result) ? result.Value : fallback;
+    }
 
-            if (TryGetUInt32(token, out uint? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetUInt32<T>(JToken? token, Func<uint, T> callback) {
+        return TryGetUInt32(token, out uint? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted unsigned 32-bit integer value if successful; otherwise, <see langword="null"/>.</returns>
+    public static uint? GetUInt32OrNull(JToken? token) {
+        return TryGetUInt32(token, out uint? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into an unsigned 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted unsigned 32-bit integer value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetUInt32(JToken? token, out uint result) {
+
+        if (TryGetUInt32(token, out uint? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetUInt32(JToken? token, [NotNullWhen(true)] out uint? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.Value<bool>() ? 1 : (uint) 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into an unsigned 32-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted unsigned 32-bit integer value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetUInt32(JToken? token, [NotNullWhen(true)] out uint? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.ToObject<uint>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseUInt32(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.Value<bool>() ? 1 : (uint) 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.ToObject<uint>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseUInt32(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static uint[] GetUInt32Array(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToUInt32Array(),
-                JTokenType.Array => ConvertArrayTokenToUInt32Array(token),
-                _ => TryGetUInt32(token, out uint? result) ? new[] { result.Value } : ArrayUtils.Empty<uint>()
-            };
         }
 
+    }
 
-        private static uint[] ConvertArrayTokenToUInt32Array(JToken token) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of unsigned 32-bit integer values.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>An unsigned 32-bit integer array.</returns>
+    public static uint[] GetUInt32Array(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToUInt32Array(),
+            JTokenType.Array => ConvertArrayTokenToUInt32Array(token),
+            _ => TryGetUInt32(token, out uint? result) ? [result.Value] : []
+        };
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<uint>();
 
-            List<uint> temp = new();
+    private static uint[] ConvertArrayTokenToUInt32Array(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetUInt32(item, out uint? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<uint> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetUInt32(item, out uint? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
+
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt64.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt64.cs
index 83ad00e..e291960 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt64.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.UInt64.cs
@@ -2,94 +2,131 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 using Skybrud.Essentials.Strings;
 using Skybrud.Essentials.Strings.Extensions;
 
 // ReSharper disable SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+static partial class JsonTokenUtils {
 
-        internal static ulong GetUInt64(JToken? token) {
-            return GetUInt64(token, default);
-        }
-
-        internal static ulong GetUInt64(JToken? token, ulong fallback) {
-            return TryGetUInt64(token, out ulong? result) ? result.Value : fallback;
-        }
-
-        internal static T? GetUInt64<T>(JToken? token, Func<ulong, T> callback) {
-            return TryGetUInt64(token, out ulong? result) ? callback(result.Value) : default;
-        }
-
-        internal static ulong? GetUInt64OrNull(JToken? token) {
-            return TryGetUInt64(token, out ulong? result) ? result : null;
-        }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted unsigned 64-bit integer value if successful; otherwise, <c>0</c>.</returns>
+    public static ulong GetUInt64(JToken? token) {
+        return GetUInt64(token, default);
+    }
 
-        internal static bool TryGetUInt64(JToken? token, out ulong result) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="fallback">A fallback value to be returned if the conversion fails.</param>
+    /// <returns>The converted unsigned 64-bit integer value if successful; otherwise, <paramref name="fallback"/>>.</returns>
+    public static ulong GetUInt64(JToken? token, ulong fallback) {
+        return TryGetUInt64(token, out ulong? result) ? result.Value : fallback;
+    }
 
-            if (TryGetUInt64(token, out ulong? temp)) {
-                result = temp.Value;
-                return true;
-            }
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an instance of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the conversion.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting a <see cref="Guid"/> value into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An instance of <typeparamref name="T"/> if successful; otherwise, the default value of <typeparamref name="T"/>.</returns>
+    public static T? GetUInt64<T>(JToken? token, Func<ulong, T> callback) {
+        return TryGetUInt64(token, out ulong? result) ? callback(result.Value) : default;
+    }
 
-            result = default;
-            return false;
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an unsigned 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>The converted unsigned 64-bit integer value if successful; otherwise, <see langword="null"/>.</returns>
+    public static ulong? GetUInt64OrNull(JToken? token) {
+        return TryGetUInt64(token, out ulong? result) ? result : null;
+    }
 
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into an unsigned 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted unsigned 64-bit integer value if successful; otherwise, <c>0</c>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetUInt64(JToken? token, out ulong result) {
+
+        if (TryGetUInt64(token, out ulong? temp)) {
+            result = temp.Value;
+            return true;
         }
 
-        internal static bool TryGetUInt64(JToken? token, [NotNullWhen(true)] out ulong? result) {
+        result = default;
+        return false;
 
-            switch (token?.Type) {
+    }
 
-                case JTokenType.Boolean:
-                    result = token.Value<bool>() ? 1 : (ulong) 0;
-                    return true;
+    /// <summary>
+    /// Attempts to convert the specified <paramref name="token"/> into an unsigned 64-bit integer value.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="result">When this method returns, holds the converted unsigned 64-bit integer value if successful; otherwise, <see langword="null"/>.</param>
+    /// <returns><see langword="true"/> if the conversion was successful; otherwise, <see langword="false"/>.</returns>
+    public static bool TryGetUInt64(JToken? token, [NotNullWhen(true)] out ulong? result) {
 
-                case JTokenType.Integer:
-                case JTokenType.Float:
-                    result = token.ToObject<ulong>();
-                    return true;
+        switch (token?.Type) {
 
-                case JTokenType.String:
-                    return StringUtils.TryParseUInt64(token.Value<string>(), out result);
+            case JTokenType.Boolean:
+                result = token.Value<bool>() ? 1 : (ulong) 0;
+                return true;
 
-                default:
-                    result = null;
-                    return false;
+            case JTokenType.Integer:
+            case JTokenType.Float:
+                result = token.ToObject<ulong>();
+                return true;
 
-            }
+            case JTokenType.String:
+                return StringUtils.TryParseUInt64(token.Value<string>(), out result);
 
-        }
+            default:
+                result = null;
+                return false;
 
-        internal static ulong[] GetUInt64Array(JToken? token) {
-            return token?.Type switch {
-                JTokenType.String => token.Value<string>().ToUInt64Array(),
-                JTokenType.Array => ConvertArrayTokenToUInt64Array(token),
-                _ => TryGetUInt64(token, out ulong? result) ? new[] { result.Value } : ArrayUtils.Empty<ulong>()
-            };
         }
 
+    }
 
-        private static ulong[] ConvertArrayTokenToUInt64Array(JToken token) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of unsigned 64-bit integer values.
+    /// </summary>
+    /// <param name="token">The token to be converted.</param>
+    /// <returns>An unsigned 64-bit integer array.</returns>
+    public static ulong[] GetUInt64Array(JToken? token) {
+        return token?.Type switch {
+            JTokenType.String => token.Value<string>().ToUInt64Array(),
+            JTokenType.Array => ConvertArrayTokenToUInt64Array(token),
+            _ => TryGetUInt64(token, out ulong? result) ? [result.Value] : []
+        };
+    }
 
-            if (token is not JArray) return ArrayUtils.Empty<ulong>();
 
-            List<ulong> temp = new();
+    private static ulong[] ConvertArrayTokenToUInt64Array(JToken token) {
 
-            foreach (JToken item in token) {
-                if (TryGetUInt64(item, out ulong? result)) {
-                    temp.Add(result.Value);
-                }
-            }
+        if (token is not JArray) return [];
 
-            return temp.ToArray();
+        List<ulong> temp = [];
 
+        foreach (JToken item in token) {
+            if (TryGetUInt64(item, out ulong? result)) {
+                temp.Add(result.Value);
+            }
         }
 
+        return [..temp];
+
     }
 
 }
\ No newline at end of file
diff --git a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.cs b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.cs
index b41a8ca..b98d40b 100644
--- a/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.cs
+++ b/src/Skybrud.Essentials/Json/Newtonsoft/Parsing/JsonTokenUtils.cs
@@ -1,60 +1,76 @@
 using System;
 using System.Collections.Generic;
 using Newtonsoft.Json.Linq;
-using Skybrud.Essentials.Collections;
 
 // ReSharper disable LoopCanBeConvertedToQuery
 // ReSharper disable SwitchExpressionHandlesSomeKnownEnumValuesWithExceptionInDefault
 // ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
-namespace Skybrud.Essentials.Json.Newtonsoft.Parsing {
+namespace Skybrud.Essentials.Json.Newtonsoft.Parsing;
 
-    internal static partial class JsonTokenUtils {
+/// <summary>
+/// Static class with various methods for parsing instances of <see cref="JToken"/>.
+/// </summary>
+public static partial class JsonTokenUtils {
 
-        internal static T[]? ConvertTokenToArray<T>(JToken? token, Func<JToken, T> callback) {
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The item type of the array.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting each child token into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An array of <typeparamref name="T"/> if <paramref name="token"/> is an array; otherwise, <see langword="null"/>.</returns>
+    public static T[]? ConvertTokenToArray<T>(JToken? token, Func<JToken, T> callback) {
 
-            if (token is not JArray array) return null;
-            if (array.Count == 0) return ArrayUtils.Empty<T>();
+        if (token is not JArray array) return null;
+        if (array.Count == 0) return [];
 
-            List<T> temp = new();
-
-            foreach (JToken item in array) {
-                temp.Add(callback(item));
-            }
-
-            return temp.ToArray();
+        List<T> temp = [];
 
+        foreach (JToken item in array) {
+            temp.Add(callback(item));
         }
 
-        internal static T[]? ConvertTokenToArray<T>(JToken? token, Func<JObject, T> callback) {
+        return [..temp];
 
-            if (token is not JArray array) return null;
-            if (array.Count == 0) return ArrayUtils.Empty<T>();
+    }
 
-            List<T> temp = new();
+    /// <summary>
+    /// Converts the specified <paramref name="token"/> into an array of <typeparamref name="T"/>.
+    /// </summary>
+    /// <typeparam name="T">The item type of the array.</typeparam>
+    /// <param name="token">The token to be converted.</param>
+    /// <param name="callback">A callback function used for converting each child object into an instance of <typeparamref name="T"/>.</param>
+    /// <returns>An array of <typeparamref name="T"/> if <paramref name="token"/> is an array; otherwise, <see langword="null"/>.</returns>
+    public static T[]? ConvertTokenToArray<T>(JToken? token, Func<JObject, T> callback) {
 
-            foreach (JToken item in array) {
-                if (item is JObject obj) temp.Add(callback(obj));
-            }
+        if (token is not JArray array) return null;
+        if (array.Count == 0) return [];
 
-            return temp.ToArray();
+        List<T> temp = [];
 
+        foreach (JToken item in array) {
+            if (item is JObject obj) temp.Add(callback(obj));
         }
 
-        internal static IReadOnlyList<T> ConvertTokenToReadOnlyList<T>(JToken? token, Func<JObject, T> callback) {
+        return [..temp];
 
-            if (token is not JArray array || array.Count == 0) return ArrayUtils.Empty<T>();
+    }
+
+    internal static IReadOnlyList<T> ConvertTokenToReadOnlyList<T>(JToken? token, Func<JObject, T> callback) {
 
-            List<T> temp = new();
+        // TODO: should this return null if token is not an array?
 
-            foreach (JToken item in array) {
-                if (item is JObject obj) temp.Add(callback(obj));
-            }
+        if (token is not JArray array || array.Count == 0) return [];
 
-            return temp;
+        List<T> temp = [];
 
+        foreach (JToken item in array) {
+            if (item is JObject obj) temp.Add(callback(obj));
         }
 
+        return temp;
+
     }
 
 }
\ No newline at end of file