repo creation with initial code after cloning public repo

src/Jellyfin.Extensions/CopyToExtensions.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Provides <c>CopyTo</c> extensions methods for <see cref="IReadOnlyList{T}" />.
+    /// </summary>
+    public static class CopyToExtensions
+    {
+        /// <summary>
+        /// Copies all the elements of the current collection to the specified list
+        /// starting at the specified destination array index. The index is specified as a 32-bit integer.
+        /// </summary>
+        /// <param name="source">The current collection that is the source of the elements.</param>
+        /// <param name="destination">The list that is the destination of the elements copied from the current collection.</param>
+        /// <param name="index">A 32-bit integer that represents the index in <c>destination</c> at which copying begins.</param>
+        /// <typeparam name="T">The type of the array.</typeparam>
+        public static void CopyTo<T>(this IReadOnlyList<T> source, IList<T> destination, int index = 0)
+        {
+            for (int i = 0; i < source.Count; i++)
+            {
+                destination[index + i] = source[i];
+            }
+        }
+    }
+}

src/Jellyfin.Extensions/DictionaryExtensions.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Static extensions for the <see cref="IReadOnlyDictionary{TKey,TValue}"/> interface.
+    /// </summary>
+    public static class DictionaryExtensions
+    {
+        /// <summary>
+        /// Gets a string from a string dictionary, checking all keys sequentially,
+        /// stopping at the first key that returns a result that's neither null nor blank.
+        /// </summary>
+        /// <param name="dictionary">The dictionary.</param>
+        /// <param name="key1">The first checked key.</param>
+        /// <param name="key2">The second checked key.</param>
+        /// <param name="key3">The third checked key.</param>
+        /// <param name="key4">The fourth checked key.</param>
+        /// <returns>System.String.</returns>
+        public static string? GetFirstNotNullNorWhiteSpaceValue(this IReadOnlyDictionary<string, string> dictionary, string key1, string? key2 = null, string? key3 = null, string? key4 = null)
+        {
+            if (dictionary.TryGetValue(key1, out var val) && !string.IsNullOrWhiteSpace(val))
+            {
+                return val;
+            }
+
+            if (!string.IsNullOrEmpty(key2) && dictionary.TryGetValue(key2, out val) && !string.IsNullOrWhiteSpace(val))
+            {
+                return val;
+            }
+
+            if (!string.IsNullOrEmpty(key3) && dictionary.TryGetValue(key3, out val) && !string.IsNullOrWhiteSpace(val))
+            {
+                return val;
+            }
+
+            if (!string.IsNullOrEmpty(key4) && dictionary.TryGetValue(key4, out val) && !string.IsNullOrWhiteSpace(val))
+            {
+                return val;
+            }
+
+            return null;
+        }
+    }
+}

src/Jellyfin.Extensions/EnumerableExtensions.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Jellyfin.Extensions;
+
+/// <summary>
+/// Static extensions for the <see cref="IEnumerable{T}"/> interface.
+/// </summary>
+public static class EnumerableExtensions
+{
+    /// <summary>
+    /// Determines whether the value is contained in the source collection.
+    /// </summary>
+    /// <param name="source">An instance of the <see cref="IEnumerable{String}"/> interface.</param>
+    /// <param name="value">The value to look for in the collection.</param>
+    /// <param name="stringComparison">The string comparison.</param>
+    /// <returns>A value indicating whether the value is contained in the collection.</returns>
+    /// <exception cref="ArgumentNullException">The source is null.</exception>
+    public static bool Contains(this IEnumerable<string> source, ReadOnlySpan<char> value, StringComparison stringComparison)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        if (source is IList<string> list)
+        {
+            int len = list.Count;
+            for (int i = 0; i < len; i++)
+            {
+                if (value.Equals(list[i], stringComparison))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        foreach (string element in source)
+        {
+            if (value.Equals(element, stringComparison))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Gets an IEnumerable from a single item.
+    /// </summary>
+    /// <param name="item">The item to return.</param>
+    /// <typeparam name="T">The type of item.</typeparam>
+    /// <returns>The IEnumerable{T}.</returns>
+    public static IEnumerable<T> SingleItemAsEnumerable<T>(this T item)
+    {
+        yield return item;
+    }
+
+    /// <summary>
+    /// Gets an IEnumerable consisting of all flags of an enum.
+    /// </summary>
+    /// <param name="flags">The flags enum.</param>
+    /// <typeparam name="T">The type of item.</typeparam>
+    /// <returns>The IEnumerable{Enum}.</returns>
+    public static IEnumerable<T> GetUniqueFlags<T>(this T flags)
+        where T : struct, Enum
+    {
+        foreach (T value in Enum.GetValues<T>())
+        {
+            if (flags.HasFlag(value))
+            {
+                yield return value;
+            }
+        }
+    }
+}

src/Jellyfin.Extensions/FileHelper.cs

@@ -0,0 +1,20 @@
+using System.IO;
+
+namespace Jellyfin.Extensions;
+
+/// <summary>
+/// Provides helper functions for <see cref="File" />.
+/// </summary>
+public static class FileHelper
+{
+    /// <summary>
+    /// Creates, or truncates a file in the specified path.
+    /// </summary>
+    /// <param name="path">The path and name of the file to create.</param>
+    public static void CreateEmpty(string path)
+    {
+        using (File.OpenHandle(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
+        {
+        }
+    }
+}

src/Jellyfin.Extensions/FormattingStreamWriter.cs

@@ -0,0 +1,38 @@
+using System;
+using System.IO;
+
+namespace Jellyfin.Extensions;
+
+/// <summary>
+/// A custom StreamWriter which supports setting a IFormatProvider.
+/// </summary>
+public class FormattingStreamWriter : StreamWriter
+{
+    private readonly IFormatProvider _formatProvider;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FormattingStreamWriter"/> class.
+    /// </summary>
+    /// <param name="stream">The stream to write to.</param>
+    /// <param name="formatProvider">The format provider to use.</param>
+    public FormattingStreamWriter(Stream stream, IFormatProvider formatProvider)
+        : base(stream)
+    {
+        _formatProvider = formatProvider;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="FormattingStreamWriter"/> class.
+    /// </summary>
+    /// <param name="path">The complete file path to write to.</param>
+    /// <param name="formatProvider">The format provider to use.</param>
+    public FormattingStreamWriter(string path, IFormatProvider formatProvider)
+        : base(path)
+    {
+        _formatProvider = formatProvider;
+    }
+
+    /// <inheritdoc />
+    public override IFormatProvider FormatProvider
+        => _formatProvider;
+}

src/Jellyfin.Extensions/GuidExtensions.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Jellyfin.Extensions;
+
+/// <summary>
+/// Guid specific extensions.
+/// </summary>
+public static class GuidExtensions
+{
+    /// <summary>
+    /// Determine whether the guid is default.
+    /// </summary>
+    /// <param name="guid">The guid.</param>
+    /// <returns>Whether the guid is the default value.</returns>
+    public static bool IsEmpty(this Guid guid)
+        => guid.Equals(default);
+
+    /// <summary>
+    /// Determine whether the guid is null or default.
+    /// </summary>
+    /// <param name="guid">The guid.</param>
+    /// <returns>Whether the guid is null or the default valueF.</returns>
+    public static bool IsNullOrEmpty([NotNullWhen(false)] this Guid? guid)
+        => guid is null || guid.Value.IsEmpty();
+}

src/Jellyfin.Extensions/Jellyfin.Extensions.csproj

@@ -0,0 +1,37 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <IncludeSymbols>true</IncludeSymbols>
+    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <!-- ICU4N.Transliterator only has prerelease versions -->
+    <NoWarn>NU5104</NoWarn>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <Authors>Jellyfin Contributors</Authors>
+    <PackageId>Jellyfin.Extensions</PackageId>
+    <VersionPrefix>10.12.0</VersionPrefix>
+    <RepositoryUrl>https://github.com/jellyfin/jellyfin</RepositoryUrl>
+    <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Stability)'=='Unstable'">
+    <!-- Include all symbols in the main nupkg until Azure Artifact Feed starts supporting ingesting NuGet symbol packages. -->
+    <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="../../SharedVersion.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Diacritics" />
+    <PackageReference Include="ICU4N.Transliterator" />
+  </ItemGroup>
+
+</Project>

src/Jellyfin.Extensions/Json/Converters/JsonBoolNumberConverter.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Converts a number to a boolean.
+    /// This is needed for HDHomerun.
+    /// </summary>
+    public class JsonBoolNumberConverter : JsonConverter<bool>
+    {
+        /// <inheritdoc />
+        public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Number)
+            {
+                return Convert.ToBoolean(reader.GetInt32());
+            }
+
+            return reader.GetBoolean();
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, bool value, JsonSerializerOptions options)
+        {
+            writer.WriteBooleanValue(value);
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonBoolStringConverter.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Buffers;
+using System.Buffers.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters;
+
+/// <summary>
+/// Converts a string to a boolean.
+/// This is needed for FFprobe.
+/// </summary>
+public class JsonBoolStringConverter : JsonConverter<bool>
+{
+    /// <inheritdoc />
+    public override bool Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            ReadOnlySpan<byte> utf8Span = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan;
+            if (Utf8Parser.TryParse(utf8Span, out bool val, out _, 'l'))
+            {
+                return val;
+            }
+        }
+
+        return reader.GetBoolean();
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, bool value, JsonSerializerOptions options)
+        => writer.WriteBooleanValue(value);
+}

src/Jellyfin.Extensions/Json/Converters/JsonCommaDelimitedCollectionConverter.cs

@@ -0,0 +1,19 @@
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Convert comma delimited string to collection of type.
+    /// </summary>
+    /// <typeparam name="T">Type to convert to.</typeparam>
+    public sealed class JsonCommaDelimitedCollectionConverter<T> : JsonDelimitedCollectionConverter<T>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonCommaDelimitedCollectionConverter{T}"/> class.
+        /// </summary>
+        public JsonCommaDelimitedCollectionConverter() : base()
+        {
+        }
+
+        /// <inheritdoc />
+        protected override char Delimiter => ',';
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonCommaDelimitedCollectionConverterFactory.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Json comma delimited collection converter factory.
+    /// </summary>
+    /// <remarks>
+    /// This must be applied as an attribute, adding to the JsonConverter list causes stack overflow.
+    /// </remarks>
+    public class JsonCommaDelimitedCollectionConverterFactory : JsonConverterFactory
+    {
+        /// <inheritdoc />
+        public override bool CanConvert(Type typeToConvert)
+        {
+            return typeToConvert.IsArray
+                || (typeToConvert.IsGenericType
+                    && (typeToConvert.GetGenericTypeDefinition().IsAssignableFrom(typeof(IReadOnlyCollection<>)) || typeToConvert.GetGenericTypeDefinition().IsAssignableFrom(typeof(IReadOnlyList<>))));
+        }
+
+        /// <inheritdoc />
+        public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+        {
+            var structType = typeToConvert.GetElementType() ?? typeToConvert.GenericTypeArguments[0];
+            return (JsonConverter?)Activator.CreateInstance(typeof(JsonCommaDelimitedCollectionConverter<>).MakeGenericType(structType));
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonDateTimeConverter.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Legacy DateTime converter.
+    /// Milliseconds aren't output if zero by default.
+    /// </summary>
+    public class JsonDateTimeConverter : JsonConverter<DateTime>
+    {
+        /// <inheritdoc />
+        public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            return reader.GetDateTime();
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
+        {
+            if (value.Millisecond == 0)
+            {
+                // Remaining ticks value will be 0, manually format.
+                writer.WriteStringValue(value.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffZ", CultureInfo.InvariantCulture));
+            }
+            else
+            {
+                writer.WriteStringValue(value);
+            }
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonDefaultStringEnumConverter.cs

@@ -0,0 +1,49 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters;
+
+/// <summary>
+/// Json unknown enum converter.
+/// </summary>
+/// <typeparam name="T">The type of enum.</typeparam>
+public class JsonDefaultStringEnumConverter<T> : JsonConverter<T>
+    where T : struct, Enum
+{
+    private readonly JsonConverter<T> _baseConverter;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JsonDefaultStringEnumConverter{T}"/> class.
+    /// </summary>
+    /// <param name="baseConverter">The base json converter.</param>
+    public JsonDefaultStringEnumConverter(JsonConverter<T> baseConverter)
+    {
+        _baseConverter = baseConverter;
+    }
+
+    /// <inheritdoc />
+    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.IsNull() || reader.IsEmptyString())
+        {
+            var customValueAttribute = typeToConvert.GetCustomAttribute<DefaultValueAttribute>();
+            if (customValueAttribute?.Value is null)
+            {
+                throw new InvalidOperationException($"Default value not set for '{typeToConvert.Name}'");
+            }
+
+            return (T)customValueAttribute.Value;
+        }
+
+        return _baseConverter.Read(ref reader, typeToConvert, options);
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+    {
+        _baseConverter.Write(writer, value, options);
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonDefaultStringEnumConverterFactory.cs

@@ -0,0 +1,31 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters;
+
+/// <summary>
+/// Utilizes the JsonStringEnumConverter and sets a default value if not provided.
+/// </summary>
+public class JsonDefaultStringEnumConverterFactory : JsonConverterFactory
+{
+    private static readonly JsonStringEnumConverter _baseConverterFactory = new();
+
+    /// <inheritdoc />
+    public override bool CanConvert(Type typeToConvert)
+    {
+        return _baseConverterFactory.CanConvert(typeToConvert)
+               && typeToConvert.IsDefined(typeof(DefaultValueAttribute));
+    }
+
+    /// <inheritdoc />
+    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        var baseConverter = _baseConverterFactory.CreateConverter(typeToConvert, options);
+        var converterType = typeof(JsonDefaultStringEnumConverter<>).MakeGenericType(typeToConvert);
+
+        return (JsonConverter?)Activator.CreateInstance(converterType, baseConverter);
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonDelimitedCollectionConverter.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Convert delimited string to array of type.
+    /// </summary>
+    /// <typeparam name="T">Type to convert to.</typeparam>
+    public abstract class JsonDelimitedCollectionConverter<T> : JsonConverter<IReadOnlyCollection<T>>
+    {
+        private readonly TypeConverter _typeConverter;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonDelimitedCollectionConverter{T}"/> class.
+        /// </summary>
+        protected JsonDelimitedCollectionConverter()
+        {
+            _typeConverter = TypeDescriptor.GetConverter(typeof(T));
+        }
+
+        /// <summary>
+        /// Gets the array delimiter.
+        /// </summary>
+        protected virtual char Delimiter { get; }
+
+        /// <inheritdoc />
+        public override IReadOnlyCollection<T>? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                // null got handled higher up the call stack
+                var stringEntries = reader.GetString()!.Split(Delimiter, StringSplitOptions.RemoveEmptyEntries);
+                if (stringEntries.Length == 0)
+                {
+                    return [];
+                }
+
+                var typedValues = new List<T>();
+                for (var i = 0; i < stringEntries.Length; i++)
+                {
+                    try
+                    {
+                        var parsedValue = _typeConverter.ConvertFromInvariantString(stringEntries[i].Trim());
+                        if (parsedValue is not null)
+                        {
+                            typedValues.Add((T)parsedValue);
+                        }
+                    }
+                    catch (FormatException)
+                    {
+                        // Ignore unconvertible inputs
+                    }
+                }
+
+                if (typeToConvert.IsArray)
+                {
+                    return typedValues.ToArray();
+                }
+
+                return typedValues;
+            }
+
+            return JsonSerializer.Deserialize<T[]>(ref reader, options);
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, IReadOnlyCollection<T>? value, JsonSerializerOptions options)
+        {
+            JsonSerializer.Serialize(writer, value, options);
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonFlagEnumConverter.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters;
+
+/// <summary>
+/// Enum flag to json array converter.
+/// </summary>
+/// <typeparam name="T">The type of enum.</typeparam>
+public class JsonFlagEnumConverter<T> : JsonConverter<T>
+    where T : struct, Enum
+{
+    private static readonly T[] _enumValues = Enum.GetValues<T>();
+
+    /// <inheritdoc />
+    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <inheritdoc />
+    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+    {
+        writer.WriteStartArray();
+        foreach (var enumValue in _enumValues)
+        {
+            if (value.HasFlag(enumValue))
+            {
+                writer.WriteStringValue(enumValue.ToString());
+            }
+        }
+
+        writer.WriteEndArray();
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonFlagEnumConverterFactory.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters;
+
+/// <summary>
+/// Json flag enum converter factory.
+/// </summary>
+public class JsonFlagEnumConverterFactory : JsonConverterFactory
+{
+    /// <inheritdoc />
+    public override bool CanConvert(Type typeToConvert)
+    {
+        return typeToConvert.IsEnum && typeToConvert.IsDefined(typeof(FlagsAttribute));
+    }
+
+    /// <inheritdoc />
+    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        return (JsonConverter?)Activator.CreateInstance(typeof(JsonFlagEnumConverter<>).MakeGenericType(typeToConvert));
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonGuidConverter.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Converts a GUID object or value to/from JSON.
+    /// </summary>
+    public class JsonGuidConverter : JsonConverter<Guid>
+    {
+        /// <inheritdoc />
+        public override Guid Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            => reader.IsNull()
+                ? Guid.Empty
+                : ReadInternal(ref reader);
+
+        // TODO: optimize by parsing the UTF8 bytes instead of converting to string first
+        internal static Guid ReadInternal(ref Utf8JsonReader reader)
+            => Guid.Parse(reader.GetString()!); // null got handled higher up the call stack
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, Guid value, JsonSerializerOptions options)
+            => WriteInternal(writer, value);
+
+        internal static void WriteInternal(Utf8JsonWriter writer, Guid value)
+            => writer.WriteStringValue(value.ToString("N", CultureInfo.InvariantCulture));
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonNullableGuidConverter.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Converts a GUID object or value to/from JSON.
+    /// </summary>
+    public class JsonNullableGuidConverter : JsonConverter<Guid?>
+    {
+        /// <inheritdoc />
+        public override Guid? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            => JsonGuidConverter.ReadInternal(ref reader);
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, Guid? value, JsonSerializerOptions options)
+        {
+            // null got handled higher up the call stack
+            var val = value!.Value;
+            if (val.IsEmpty())
+            {
+                writer.WriteNullValue();
+            }
+            else
+            {
+                JsonGuidConverter.WriteInternal(writer, val);
+            }
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonNullableStructConverter.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Converts a nullable struct or value to/from JSON.
+    /// Required - some clients send an empty string.
+    /// </summary>
+    /// <typeparam name="TStruct">The struct type.</typeparam>
+    public class JsonNullableStructConverter<TStruct> : JsonConverter<TStruct?>
+        where TStruct : struct
+    {
+        /// <inheritdoc />
+        public override TStruct? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.IsEmptyString())
+            {
+                return null;
+            }
+
+            return JsonSerializer.Deserialize<TStruct>(ref reader, options);
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, TStruct? value, JsonSerializerOptions options)
+            => JsonSerializer.Serialize(writer, value!.Value, options); // null got handled higher up the call stack
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonNullableStructConverterFactory.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Json nullable struct converter factory.
+    /// </summary>
+    public class JsonNullableStructConverterFactory : JsonConverterFactory
+    {
+        /// <inheritdoc />
+        public override bool CanConvert(Type typeToConvert)
+        {
+            return typeToConvert.IsGenericType
+                   && typeToConvert.GetGenericTypeDefinition() == typeof(Nullable<>)
+                   && typeToConvert.GenericTypeArguments[0].IsValueType;
+        }
+
+        /// <inheritdoc />
+        public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+        {
+            var structType = typeToConvert.GenericTypeArguments[0];
+            return (JsonConverter?)Activator.CreateInstance(typeof(JsonNullableStructConverter<>).MakeGenericType(structType));
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonPipeDelimitedCollectionConverter.cs

@@ -0,0 +1,19 @@
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Convert Pipe delimited string to array of type.
+    /// </summary>
+    /// <typeparam name="T">Type to convert to.</typeparam>
+    public sealed class JsonPipeDelimitedCollectionConverter<T> : JsonDelimitedCollectionConverter<T>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPipeDelimitedCollectionConverter{T}"/> class.
+        /// </summary>
+        public JsonPipeDelimitedCollectionConverter() : base()
+        {
+        }
+
+        /// <inheritdoc />
+        protected override char Delimiter => '|';
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonPipeDelimitedCollectionConverterFactory.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Json Pipe delimited collection converter factory.
+    /// </summary>
+    /// <remarks>
+    /// This must be applied as an attribute, adding to the JsonConverter list causes stack overflow.
+    /// </remarks>
+    public class JsonPipeDelimitedCollectionConverterFactory : JsonConverterFactory
+    {
+        /// <inheritdoc />
+        public override bool CanConvert(Type typeToConvert)
+        {
+            return typeToConvert.IsArray
+                || (typeToConvert.IsGenericType
+                    && (typeToConvert.GetGenericTypeDefinition().IsAssignableFrom(typeof(IReadOnlyCollection<>)) || typeToConvert.GetGenericTypeDefinition().IsAssignableFrom(typeof(IReadOnlyList<>))));
+        }
+
+        /// <inheritdoc />
+        public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+        {
+            var structType = typeToConvert.GetElementType() ?? typeToConvert.GenericTypeArguments[0];
+            return (JsonConverter?)Activator.CreateInstance(typeof(JsonPipeDelimitedCollectionConverter<>).MakeGenericType(structType));
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonStringConverter.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Buffers;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Converter to allow the serializer to read strings.
+    /// </summary>
+    public class JsonStringConverter : JsonConverter<string?>
+    {
+        /// <inheritdoc />
+        public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            => reader.TokenType == JsonTokenType.String ? reader.GetString() : GetRawValue(reader);
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, string? value, JsonSerializerOptions options)
+            => writer.WriteStringValue(value);
+
+        private static string GetRawValue(Utf8JsonReader reader)
+        {
+            var utf8Bytes = reader.HasValueSequence
+                ? reader.ValueSequence.ToArray()
+                : reader.ValueSpan;
+            return Encoding.UTF8.GetString(utf8Bytes);
+        }
+    }
+}

src/Jellyfin.Extensions/Json/Converters/JsonVersionConverter.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Jellyfin.Extensions.Json.Converters
+{
+    /// <summary>
+    /// Converts a Version object or value to/from JSON.
+    /// </summary>
+    /// <remarks>
+    /// Required to send <see cref="Version"/> as a string instead of an object.
+    /// </remarks>
+    public class JsonVersionConverter : JsonConverter<Version>
+    {
+        /// <inheritdoc />
+        public override Version Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            => new Version(reader.GetString()!); // Will throw ArgumentNullException on null
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, Version value, JsonSerializerOptions options)
+            => writer.WriteStringValue(value.ToString());
+    }
+}

src/Jellyfin.Extensions/Json/JsonDefaults.cs

@@ -0,0 +1,93 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+using Jellyfin.Extensions.Json.Converters;
+
+namespace Jellyfin.Extensions.Json
+{
+    /// <summary>
+    /// Helper class for having compatible JSON throughout the codebase.
+    /// </summary>
+    public static class JsonDefaults
+    {
+        /// <summary>
+        /// Pascal case json profile media type.
+        /// </summary>
+        public const string PascalCaseMediaType = "application/json; profile=\"PascalCase\"";
+
+        /// <summary>
+        /// Camel case json profile media type.
+        /// </summary>
+        public const string CamelCaseMediaType = "application/json; profile=\"CamelCase\"";
+
+        /// <summary>
+        /// When changing these options, update
+        ///  Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
+        ///   -> AddJellyfinApi
+        ///    -> AddJsonOptions.
+        /// </summary>
+        private static readonly JsonSerializerOptions _jsonSerializerOptions = new()
+        {
+            ReadCommentHandling = JsonCommentHandling.Disallow,
+            WriteIndented = false,
+            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+            NumberHandling = JsonNumberHandling.AllowReadingFromString,
+            Converters =
+            {
+                new JsonGuidConverter(),
+                new JsonNullableGuidConverter(),
+                new JsonVersionConverter(),
+                new JsonFlagEnumConverterFactory(),
+                new JsonDefaultStringEnumConverterFactory(),
+                new JsonStringEnumConverter(),
+                new JsonNullableStructConverterFactory(),
+                new JsonDateTimeConverter(),
+                new JsonStringConverter()
+            },
+            TypeInfoResolver = new DefaultJsonTypeInfoResolver()
+        };
+
+        private static readonly JsonSerializerOptions _pascalCaseJsonSerializerOptions = new(_jsonSerializerOptions)
+        {
+            PropertyNamingPolicy = null
+        };
+
+        private static readonly JsonSerializerOptions _camelCaseJsonSerializerOptions = new(_jsonSerializerOptions)
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+        };
+
+        /// <summary>
+        /// Gets the default <see cref="JsonSerializerOptions" /> options.
+        /// </summary>
+        /// <remarks>
+        /// The return value must not be modified.
+        /// If the defaults must be modified the author must use the copy constructor.
+        /// </remarks>
+        /// <returns>The default <see cref="JsonSerializerOptions" /> options.</returns>
+        public static JsonSerializerOptions Options
+            => _jsonSerializerOptions;
+
+        /// <summary>
+        /// Gets camelCase json options.
+        /// </summary>
+        /// <remarks>
+        /// The return value must not be modified.
+        /// If the defaults must be modified the author must use the copy constructor.
+        /// </remarks>
+        /// <returns>The camelCase <see cref="JsonSerializerOptions" /> options.</returns>
+        public static JsonSerializerOptions CamelCaseOptions
+            => _camelCaseJsonSerializerOptions;
+
+        /// <summary>
+        /// Gets PascalCase json options.
+        /// </summary>
+        /// <remarks>
+        /// The return value must not be modified.
+        /// If the defaults must be modified the author must use the copy constructor.
+        /// </remarks>
+        /// <returns>The PascalCase <see cref="JsonSerializerOptions" /> options.</returns>
+        public static JsonSerializerOptions PascalCaseOptions
+            => _pascalCaseJsonSerializerOptions;
+    }
+}

src/Jellyfin.Extensions/Json/Utf8JsonExtensions.cs

@@ -0,0 +1,27 @@
+using System.Text.Json;
+
+namespace Jellyfin.Extensions.Json;
+
+/// <summary>
+/// Extensions for Utf8JsonReader and Utf8JsonWriter.
+/// </summary>
+public static class Utf8JsonExtensions
+{
+    /// <summary>
+    /// Determines if the reader contains an empty string.
+    /// </summary>
+    /// <param name="reader">The reader.</param>
+    /// <returns>Whether the reader contains an empty string.</returns>
+    public static bool IsEmptyString(this Utf8JsonReader reader)
+        => reader.TokenType == JsonTokenType.String
+           && ((reader.HasValueSequence && reader.ValueSequence.IsEmpty)
+               || (!reader.HasValueSequence && reader.ValueSpan.IsEmpty));
+
+    /// <summary>
+    /// Determines if the reader contains a null value.
+    /// </summary>
+    /// <param name="reader">The reader.</param>
+    /// <returns>Whether the reader contains null.</returns>
+    public static bool IsNull(this Utf8JsonReader reader)
+        => reader.TokenType == JsonTokenType.Null;
+}

src/Jellyfin.Extensions/ReadOnlyListExtension.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Static extensions for the <see cref="IReadOnlyList{T}"/> interface.
+    /// </summary>
+    public static class ReadOnlyListExtension
+    {
+        /// <summary>
+        /// Finds the index of the desired item.
+        /// </summary>
+        /// <param name="source">The source list.</param>
+        /// <param name="value">The value to fine.</param>
+        /// <typeparam name="T">The type of item to find.</typeparam>
+        /// <returns>Index if found, else -1.</returns>
+        public static int IndexOf<T>(this IReadOnlyList<T> source, T value)
+        {
+            if (source is IList<T> list)
+            {
+                return list.IndexOf(value);
+            }
+
+            for (int i = 0; i < source.Count; i++)
+            {
+                if (Equals(value, source[i]))
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Finds the index of the predicate.
+        /// </summary>
+        /// <param name="source">The source list.</param>
+        /// <param name="match">The value to find.</param>
+        /// <typeparam name="T">The type of item to find.</typeparam>
+        /// <returns>Index if found, else -1.</returns>
+        public static int FindIndex<T>(this IReadOnlyList<T> source, Predicate<T> match)
+        {
+            if (source is List<T> list)
+            {
+                return list.FindIndex(match);
+            }
+
+            for (int i = 0; i < source.Count; i++)
+            {
+                if (match(source[i]))
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Get the first or default item from a list.
+        /// </summary>
+        /// <param name="source">The source list.</param>
+        /// <typeparam name="T">The type of item.</typeparam>
+        /// <returns>The first item or default if list is empty.</returns>
+        public static T? FirstOrDefault<T>(this IReadOnlyList<T>? source)
+        {
+            if (source is null || source.Count == 0)
+            {
+                return default;
+            }
+
+            return source[0];
+        }
+    }
+}

src/Jellyfin.Extensions/ShuffleExtensions.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Provides <c>Shuffle</c> extensions methods for <see cref="IList{T}" />.
+    /// </summary>
+    public static class ShuffleExtensions
+    {
+        /// <summary>
+        /// Shuffles the items in a list.
+        /// </summary>
+        /// <param name="list">The list that should get shuffled.</param>
+        /// <typeparam name="T">The type.</typeparam>
+        public static void Shuffle<T>(this IList<T> list)
+        {
+            list.Shuffle(Random.Shared);
+        }
+
+        /// <summary>
+        /// Shuffles the items in a list.
+        /// </summary>
+        /// <param name="list">The list that should get shuffled.</param>
+        /// <param name="rng">The random number generator to use.</param>
+        /// <typeparam name="T">The type.</typeparam>
+        public static void Shuffle<T>(this IList<T> list, Random rng)
+        {
+            int n = list.Count;
+            while (n > 1)
+            {
+                int k = rng.Next(n--);
+                T value = list[k];
+                list[k] = list[n];
+                list[n] = value;
+            }
+        }
+    }
+}

src/Jellyfin.Extensions/SplitStringExtensions.cs

@@ -0,0 +1,115 @@
+/*
+MIT License
+
+Copyright (c) 2019 Gérald Barré
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+// TODO: remove when analyzer is fixed: https://github.com/dotnet/roslyn-analyzers/issues/5158
+#pragma warning disable CA1034 // Nested types should not be visible
+
+using System;
+using System.Diagnostics.Contracts;
+using System.Runtime.InteropServices;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Extension class for splitting lines without unnecessary allocations.
+    /// </summary>
+    public static class SplitStringExtensions
+    {
+        /// <summary>
+        /// Creates a new string split enumerator.
+        /// </summary>
+        /// <param name="str">The string to split.</param>
+        /// <param name="separator">The separator to split on.</param>
+        /// <returns>The enumerator struct.</returns>
+        [Pure]
+        public static Enumerator SpanSplit(this string str, char separator) => new(str.AsSpan(), separator);
+
+        /// <summary>
+        /// Creates a new span split enumerator.
+        /// </summary>
+        /// <param name="str">The span to split.</param>
+        /// <param name="separator">The separator to split on.</param>
+        /// <returns>The enumerator struct.</returns>
+        [Pure]
+        public static Enumerator Split(this ReadOnlySpan<char> str, char separator) => new(str, separator);
+
+        /// <summary>
+        /// Provides an enumerator for the substrings separated by the separator.
+        /// </summary>
+        [StructLayout(LayoutKind.Auto)]
+        public ref struct Enumerator
+        {
+            private readonly char _separator;
+            private ReadOnlySpan<char> _str;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="Enumerator"/> struct.
+            /// </summary>
+            /// <param name="str">The span to split.</param>
+            /// <param name="separator">The separator to split on.</param>
+            public Enumerator(ReadOnlySpan<char> str, char separator)
+            {
+                _str = str;
+                _separator = separator;
+                Current = default;
+            }
+
+            /// <summary>
+            /// Gets a reference to the item at the current position of the enumerator.
+            /// </summary>
+            public ReadOnlySpan<char> Current { get; private set; }
+
+            /// <summary>
+            /// Returns <c>this</c>.
+            /// </summary>
+            /// <returns><c>this</c>.</returns>
+            public readonly Enumerator GetEnumerator() => this;
+
+            /// <summary>
+            /// Advances the enumerator to the next item.
+            /// </summary>
+            /// <returns><c>true</c> if there is a next element; otherwise <c>false</c>.</returns>
+            public bool MoveNext()
+            {
+                if (_str.Length == 0)
+                {
+                    return false;
+                }
+
+                var span = _str;
+                var index = span.IndexOf(_separator);
+                if (index == -1)
+                {
+                    _str = ReadOnlySpan<char>.Empty;
+                    Current = span;
+                    return true;
+                }
+
+                Current = span.Slice(0, index);
+                _str = span[(index + 1)..];
+                return true;
+            }
+        }
+    }
+}

src/Jellyfin.Extensions/StreamExtensions.cs

@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Class BaseExtensions.
+    /// </summary>
+    public static class StreamExtensions
+    {
+        /// <summary>
+        /// Reads all lines in the <see cref="Stream" />.
+        /// </summary>
+        /// <param name="stream">The <see cref="Stream" /> to read from.</param>
+        /// <returns>All lines in the stream.</returns>
+        public static string[] ReadAllLines(this Stream stream)
+            => ReadAllLines(stream, Encoding.UTF8);
+
+        /// <summary>
+        /// Reads all lines in the <see cref="Stream" />.
+        /// </summary>
+        /// <param name="stream">The <see cref="Stream" /> to read from.</param>
+        /// <param name="encoding">The character encoding to use.</param>
+        /// <returns>All lines in the stream.</returns>
+        public static string[] ReadAllLines(this Stream stream, Encoding encoding)
+        {
+            using StreamReader reader = new StreamReader(stream, encoding);
+            return ReadAllLines(reader).ToArray();
+        }
+
+        /// <summary>
+        /// Reads all lines in the <see cref="TextReader" />.
+        /// </summary>
+        /// <param name="reader">The <see cref="TextReader" /> to read from.</param>
+        /// <returns>All lines in the stream.</returns>
+        public static IEnumerable<string> ReadAllLines(this TextReader reader)
+        {
+            string? line;
+            while ((line = reader.ReadLine()) is not null)
+            {
+                yield return line;
+            }
+        }
+
+        /// <summary>
+        /// Reads all lines in the <see cref="TextReader" />.
+        /// </summary>
+        /// <param name="reader">The <see cref="TextReader" /> to read from.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
+        /// <returns>All lines in the stream.</returns>
+        public static async IAsyncEnumerable<string> ReadAllLinesAsync(this TextReader reader, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+        {
+            string? line;
+            while ((line = await reader.ReadLineAsync(cancellationToken).ConfigureAwait(false)) is not null)
+            {
+                yield return line;
+            }
+        }
+    }
+}

src/Jellyfin.Extensions/StringBuilderExtensions.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Text;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Extension methods for the <see cref="StringBuilder"/> class.
+    /// </summary>
+    public static class StringBuilderExtensions
+    {
+        /// <summary>
+        /// Concatenates and appends the members of a collection in single quotes using the specified delimiter.
+        /// </summary>
+        /// <param name="builder">The string builder.</param>
+        /// <param name="delimiter">The character delimiter.</param>
+        /// <param name="values">The collection of strings to concatenate.</param>
+        /// <returns>The updated string builder.</returns>
+        public static StringBuilder AppendJoinInSingleQuotes(this StringBuilder builder, char delimiter, IReadOnlyList<string> values)
+        {
+            var len = values.Count;
+            for (var i = 0; i < len; i++)
+            {
+                builder.Append('\'')
+                    .Append(values[i])
+                    .Append('\'')
+                    .Append(delimiter);
+            }
+
+            // remove last ,
+            builder.Length--;
+
+            return builder;
+        }
+    }
+}

src/Jellyfin.Extensions/StringExtensions.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using ICU4N.Text;
+
+namespace Jellyfin.Extensions
+{
+    /// <summary>
+    /// Provides extensions methods for <see cref="string" />.
+    /// </summary>
+    public static partial class StringExtensions
+    {
+        private static readonly Lazy<string> _transliteratorId = new(() =>
+            Environment.GetEnvironmentVariable("JELLYFIN_TRANSLITERATOR_ID")
+            ?? "Any-Latin; Latin-Ascii; Lower; NFD; [:Nonspacing Mark:] Remove; [:Punctuation:] Remove;");
+
+        private static readonly Lazy<Transliterator?> _transliterator = new(() =>
+        {
+            try
+            {
+                return Transliterator.GetInstance(_transliteratorId.Value);
+            }
+            catch (ArgumentException)
+            {
+                return null;
+            }
+        });
+
+        // Matches non-conforming unicode chars
+        // https://mnaoumov.wordpress.com/2014/06/14/stripping-invalid-characters-from-utf-16-strings/
+
+        [GeneratedRegex("([\ud800-\udbff](?![\udc00-\udfff]))|((?<![\ud800-\udbff])[\udc00-\udfff])|(�)")]
+        private static partial Regex NonConformingUnicodeRegex();
+
+        /// <summary>
+        /// Removes the diacritics character from the strings.
+        /// </summary>
+        /// <param name="text">The string to act on.</param>
+        /// <returns>The string without diacritics character.</returns>
+        public static string RemoveDiacritics(this string text)
+            => Diacritics.Extensions.StringExtensions.RemoveDiacritics(
+                NonConformingUnicodeRegex().Replace(text, string.Empty));
+
+        /// <summary>
+        /// Checks whether or not the specified string has diacritics in it.
+        /// </summary>
+        /// <param name="text">The string to check.</param>
+        /// <returns>True if the string has diacritics, false otherwise.</returns>
+        public static bool HasDiacritics(this string text)
+            => Diacritics.Extensions.StringExtensions.HasDiacritics(text)
+                || NonConformingUnicodeRegex().IsMatch(text);
+
+        /// <summary>
+        /// Counts the number of occurrences of [needle] in the string.
+        /// </summary>
+        /// <param name="value">The haystack to search in.</param>
+        /// <param name="needle">The character to search for.</param>
+        /// <returns>The number of occurrences of the [needle] character.</returns>
+        public static int Count(this ReadOnlySpan<char> value, char needle)
+        {
+            var count = 0;
+            var length = value.Length;
+            for (var i = 0; i < length; i++)
+            {
+                if (value[i] == needle)
+                {
+                    count++;
+                }
+            }
+
+            return count;
+        }
+
+        /// <summary>
+        /// Returns the part on the left of the <c>needle</c>.
+        /// </summary>
+        /// <param name="haystack">The string to seek.</param>
+        /// <param name="needle">The needle to find.</param>
+        /// <returns>The part left of the <paramref name="needle" />.</returns>
+        public static ReadOnlySpan<char> LeftPart(this ReadOnlySpan<char> haystack, char needle)
+        {
+            if (haystack.IsEmpty)
+            {
+                return ReadOnlySpan<char>.Empty;
+            }
+
+            var pos = haystack.IndexOf(needle);
+            return pos == -1 ? haystack : haystack[..pos];
+        }
+
+        /// <summary>
+        /// Returns the part on the right of the <c>needle</c>.
+        /// </summary>
+        /// <param name="haystack">The string to seek.</param>
+        /// <param name="needle">The needle to find.</param>
+        /// <returns>The part right of the <paramref name="needle" />.</returns>
+        public static ReadOnlySpan<char> RightPart(this ReadOnlySpan<char> haystack, char needle)
+        {
+            if (haystack.IsEmpty)
+            {
+                return ReadOnlySpan<char>.Empty;
+            }
+
+            var pos = haystack.LastIndexOf(needle);
+            if (pos == -1)
+            {
+                return haystack;
+            }
+
+            if (pos == haystack.Length - 1)
+            {
+                return ReadOnlySpan<char>.Empty;
+            }
+
+            return haystack[(pos + 1)..];
+        }
+
+        /// <summary>
+        /// Returns a transliterated string which only contain ascii characters.
+        /// </summary>
+        /// <param name="text">The string to act on.</param>
+        /// <returns>The transliterated string.</returns>
+        public static string Transliterated(this string text)
+        {
+            return (_transliterator.Value is null) ? text : _transliterator.Value.Transliterate(text);
+        }
+
+        /// <summary>
+        /// Ensures all strings are non-null and trimmed of leading an trailing blanks.
+        /// </summary>
+        /// <param name="values">The enumerable of strings to trim.</param>
+        /// <returns>The enumeration of trimmed strings.</returns>
+        public static IEnumerable<string> Trimmed(this IEnumerable<string> values)
+        {
+            return values.Select(i => (i ?? string.Empty).Trim());
+        }
+
+        /// <summary>
+        /// Truncates a string at the first null character ('\0').
+        /// </summary>
+        /// <param name="text">The input string.</param>
+        /// <returns>
+        /// The substring up to (but not including) the first null character,
+        /// or the original string if no null character is present.
+        /// </returns>
+        public static string TruncateAtNull(this string text)
+        {
+            return string.IsNullOrEmpty(text) ? text : text.AsSpan().LeftPart('\0').ToString();
+        }
+    }
+}

src/Jellyfin.Extensions/obj/Debug/net10.0/.NETCoreApp,Version=v10.0.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v10.0", FrameworkDisplayName = ".NET 10.0")]

src/Jellyfin.Extensions/obj/Debug/net10.0/Jellyfin.Extensions.GeneratedMSBuildEditorConfig.editorconfig

@@ -0,0 +1,27 @@
+is_global = true
+build_property.TargetFramework = net10.0
+build_property.TargetFramework = net10.0
+build_property.TargetFrameworkIdentifier = .NETCoreApp
+build_property.TargetFrameworkIdentifier = .NETCoreApp
+build_property.TargetFrameworkVersion = v10.0
+build_property.TargetFrameworkVersion = v10.0
+build_property.TargetPlatformMinVersion = 
+build_property.TargetPlatformMinVersion = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.UsingMicrosoftNETSdkWeb = 
+build_property.ProjectTypeGuids = 
+build_property.ProjectTypeGuids = 
+build_property.InvariantGlobalization = 
+build_property.InvariantGlobalization = 
+build_property.PlatformNeutralAssembly = 
+build_property.PlatformNeutralAssembly = 
+build_property.EnforceExtendedAnalyzerRules = 
+build_property.EnforceExtendedAnalyzerRules = 
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = Jellyfin.Extensions
+build_property.ProjectDir = /srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/
+build_property.EnableComHosting = 
+build_property.EnableGeneratedComInterfaceComImportInterop = 
+build_property.EffectiveAnalysisLevelStyle = 10.0
+build_property.EnableCodeStyleSeverity = 

src/Jellyfin.Extensions/obj/Jellyfin.Extensions.csproj.nuget.dgspec.json

@@ -0,0 +1,680 @@
+{
+  "format": 1,
+  "restore": {
+    "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj": {}
+  },
+  "projects": {
+    "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj": {
+      "version": "1.0.0",
+      "restore": {
+        "projectUniqueName": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj",
+        "projectName": "Jellyfin.CodeAnalysis",
+        "projectPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj",
+        "packagesPath": "/home/wjones/.nuget/packages/",
+        "outputPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/obj/",
+        "projectStyle": "PackageReference",
+        "centralPackageVersionsManagementEnabled": true,
+        "configFilePaths": [
+          "/srv/common_drive/Projects/pgsql-jellyfin/nuget.config",
+          "/home/wjones/.nuget/NuGet/NuGet.Config"
+        ],
+        "originalTargetFrameworks": [
+          "netstandard2.0"
+        ],
+        "sources": {
+          "/usr/lib/dotnet/library-packs": {},
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "netstandard2.0": {
+            "targetAlias": "netstandard2.0",
+            "projectReferences": {}
+          }
+        },
+        "warningProperties": {
+          "allWarningsAsErrors": true,
+          "warnAsError": [
+            "NU1605"
+          ],
+          "warnNotAsError": [
+            "NU1902",
+            "NU1903"
+          ]
+        },
+        "restoreAuditProperties": {
+          "enableAudit": "true",
+          "auditLevel": "low",
+          "auditMode": "direct"
+        },
+        "SdkAnalysisLevel": "10.0.100"
+      },
+      "frameworks": {
+        "netstandard2.0": {
+          "targetAlias": "netstandard2.0",
+          "dependencies": {
+            "IDisposableAnalyzers": {
+              "include": "Runtime, Build, Native, ContentFiles, Analyzers",
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[4.0.8, )",
+              "versionCentrallyManaged": true
+            },
+            "Microsoft.CodeAnalysis.Analyzers": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[3.11.0, )",
+              "versionCentrallyManaged": true
+            },
+            "Microsoft.CodeAnalysis.BannedApiAnalyzers": {
+              "include": "Runtime, Build, Native, ContentFiles, Analyzers",
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[4.14.0, )",
+              "versionCentrallyManaged": true
+            },
+            "Microsoft.CodeAnalysis.CSharp": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[5.0.0, )",
+              "versionCentrallyManaged": true
+            },
+            "NETStandard.Library": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[2.0.3, )",
+              "autoReferenced": true
+            },
+            "SerilogAnalyzer": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[0.15.0, )",
+              "versionCentrallyManaged": true
+            },
+            "SmartAnalyzers.MultithreadingAnalyzer": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[1.1.31, )",
+              "versionCentrallyManaged": true
+            },
+            "StyleCop.Analyzers": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[1.2.0-beta.556, )",
+              "versionCentrallyManaged": true
+            }
+          },
+          "centralPackageVersions": {
+            "AsyncKeyedLock": "8.0.2",
+            "AutoFixture": "4.18.1",
+            "AutoFixture.AutoMoq": "4.18.1",
+            "AutoFixture.Xunit2": "4.18.1",
+            "BDInfo": "0.8.0",
+            "BitFaster.Caching": "2.5.4",
+            "BlurHashSharp": "1.4.0-pre.1",
+            "BlurHashSharp.SkiaSharp": "1.4.0-pre.1",
+            "CommandLineParser": "2.9.1",
+            "coverlet.collector": "8.0.0",
+            "Diacritics": "4.1.4",
+            "DiscUtils.Udf": "0.16.13",
+            "DotNet.Glob": "3.1.3",
+            "FsCheck.Xunit": "3.3.2",
+            "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.1",
+            "ICU4N.Transliterator": "60.1.0-alpha.356",
+            "IDisposableAnalyzers": "4.0.8",
+            "Ignore": "0.2.1",
+            "Jellyfin.XmlTv": "10.8.0",
+            "libse": "4.0.12",
+            "LrcParser": "2025.623.0",
+            "MetaBrainz.MusicBrainz": "8.0.1",
+            "Microsoft.AspNetCore.Authorization": "10.0.3",
+            "Microsoft.AspNetCore.Mvc.Testing": "10.0.3",
+            "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+            "Microsoft.CodeAnalysis.BannedApiAnalyzers": "4.14.0",
+            "Microsoft.CodeAnalysis.Common": "5.0.0",
+            "Microsoft.CodeAnalysis.CSharp": "5.0.0",
+            "Microsoft.Data.Sqlite": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Design": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Relational": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Sqlite": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Tools": "10.0.3",
+            "Microsoft.Extensions.Caching.Abstractions": "10.0.3",
+            "Microsoft.Extensions.Caching.Memory": "10.0.3",
+            "Microsoft.Extensions.Configuration.Abstractions": "10.0.3",
+            "Microsoft.Extensions.Configuration.Binder": "10.0.3",
+            "Microsoft.Extensions.DependencyInjection": "10.0.3",
+            "Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore": "10.0.3",
+            "Microsoft.Extensions.Hosting.Abstractions": "10.0.3",
+            "Microsoft.Extensions.Http": "10.0.3",
+            "Microsoft.Extensions.Logging": "10.0.3",
+            "Microsoft.Extensions.Options": "10.0.3",
+            "Microsoft.NET.Test.Sdk": "18.0.1",
+            "MimeTypes": "2.5.2",
+            "Moq": "4.18.4",
+            "Morestachio": "5.0.1.631",
+            "NEbml": "1.1.0.5",
+            "Newtonsoft.Json": "13.0.4",
+            "PlaylistsNET": "1.4.1",
+            "Polly": "8.6.5",
+            "prometheus-net": "8.2.1",
+            "prometheus-net.AspNetCore": "8.2.1",
+            "prometheus-net.DotNetRuntime": "4.4.1",
+            "Serilog.AspNetCore": "10.0.0",
+            "Serilog.Enrichers.Thread": "4.0.0",
+            "Serilog.Expressions": "5.0.0",
+            "Serilog.Settings.Configuration": "10.0.0",
+            "Serilog.Sinks.Async": "2.1.0",
+            "Serilog.Sinks.Console": "6.1.1",
+            "Serilog.Sinks.File": "7.0.0",
+            "Serilog.Sinks.Graylog": "3.1.1",
+            "SerilogAnalyzer": "0.15.0",
+            "SharpFuzz": "2.2.0",
+            "SkiaSharp": "[3.116.1]",
+            "SkiaSharp.HarfBuzz": "[3.116.1]",
+            "SkiaSharp.NativeAssets.Linux": "[3.116.1]",
+            "SmartAnalyzers.MultithreadingAnalyzer": "1.1.31",
+            "StyleCop.Analyzers": "1.2.0-beta.556",
+            "Svg.Skia": "3.4.1",
+            "Swashbuckle.AspNetCore": "7.3.2",
+            "Swashbuckle.AspNetCore.ReDoc": "6.9.0",
+            "System.Text.Json": "10.0.3",
+            "TagLibSharp": "2.3.0",
+            "TMDbLib": "2.3.0",
+            "UTF.Unknown": "2.6.0",
+            "xunit": "2.9.3",
+            "Xunit.Priority": "1.1.6",
+            "xunit.runner.visualstudio": "2.8.2",
+            "Xunit.SkippableFact": "1.5.61",
+            "z440.atl.core": "7.11.0"
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48",
+            "net481"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "runtimeIdentifierGraphPath": "/usr/lib/dotnet/sdk/10.0.103/RuntimeIdentifierGraph.json"
+        }
+      }
+    },
+    "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj": {
+      "version": "10.12.0",
+      "restore": {
+        "projectUniqueName": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj",
+        "projectName": "Jellyfin.Extensions",
+        "projectPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj",
+        "packagesPath": "/home/wjones/.nuget/packages/",
+        "outputPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/obj/",
+        "projectStyle": "PackageReference",
+        "centralPackageVersionsManagementEnabled": true,
+        "configFilePaths": [
+          "/srv/common_drive/Projects/pgsql-jellyfin/nuget.config",
+          "/home/wjones/.nuget/NuGet/NuGet.Config"
+        ],
+        "originalTargetFrameworks": [
+          "net10.0"
+        ],
+        "sources": {
+          "/usr/lib/dotnet/library-packs": {},
+          "https://api.nuget.org/v3/index.json": {}
+        },
+        "frameworks": {
+          "net10.0": {
+            "targetAlias": "net10.0",
+            "projectReferences": {
+              "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj": {
+                "projectPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj"
+              }
+            }
+          }
+        },
+        "warningProperties": {
+          "allWarningsAsErrors": true,
+          "noWarn": [
+            "NU5104"
+          ],
+          "warnAsError": [
+            "NU1605"
+          ],
+          "warnNotAsError": [
+            "NU1902",
+            "NU1903"
+          ]
+        },
+        "restoreAuditProperties": {
+          "enableAudit": "true",
+          "auditLevel": "low",
+          "auditMode": "all"
+        },
+        "SdkAnalysisLevel": "10.0.100"
+      },
+      "frameworks": {
+        "net10.0": {
+          "targetAlias": "net10.0",
+          "dependencies": {
+            "Diacritics": {
+              "target": "Package",
+              "version": "[4.1.4, )",
+              "versionCentrallyManaged": true
+            },
+            "ICU4N.Transliterator": {
+              "target": "Package",
+              "version": "[60.1.0-alpha.356, )",
+              "versionCentrallyManaged": true
+            },
+            "IDisposableAnalyzers": {
+              "include": "Runtime, Build, Native, ContentFiles, Analyzers",
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[4.0.8, )",
+              "versionCentrallyManaged": true
+            },
+            "Microsoft.CodeAnalysis.BannedApiAnalyzers": {
+              "include": "Runtime, Build, Native, ContentFiles, Analyzers",
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[4.14.0, )",
+              "versionCentrallyManaged": true
+            },
+            "SerilogAnalyzer": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[0.15.0, )",
+              "versionCentrallyManaged": true
+            },
+            "SmartAnalyzers.MultithreadingAnalyzer": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[1.1.31, )",
+              "versionCentrallyManaged": true
+            },
+            "StyleCop.Analyzers": {
+              "suppressParent": "All",
+              "target": "Package",
+              "version": "[1.2.0-beta.556, )",
+              "versionCentrallyManaged": true
+            }
+          },
+          "centralPackageVersions": {
+            "AsyncKeyedLock": "8.0.2",
+            "AutoFixture": "4.18.1",
+            "AutoFixture.AutoMoq": "4.18.1",
+            "AutoFixture.Xunit2": "4.18.1",
+            "BDInfo": "0.8.0",
+            "BitFaster.Caching": "2.5.4",
+            "BlurHashSharp": "1.4.0-pre.1",
+            "BlurHashSharp.SkiaSharp": "1.4.0-pre.1",
+            "CommandLineParser": "2.9.1",
+            "coverlet.collector": "8.0.0",
+            "Diacritics": "4.1.4",
+            "DiscUtils.Udf": "0.16.13",
+            "DotNet.Glob": "3.1.3",
+            "FsCheck.Xunit": "3.3.2",
+            "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.1",
+            "ICU4N.Transliterator": "60.1.0-alpha.356",
+            "IDisposableAnalyzers": "4.0.8",
+            "Ignore": "0.2.1",
+            "Jellyfin.XmlTv": "10.8.0",
+            "libse": "4.0.12",
+            "LrcParser": "2025.623.0",
+            "MetaBrainz.MusicBrainz": "8.0.1",
+            "Microsoft.AspNetCore.Authorization": "10.0.3",
+            "Microsoft.AspNetCore.Mvc.Testing": "10.0.3",
+            "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+            "Microsoft.CodeAnalysis.BannedApiAnalyzers": "4.14.0",
+            "Microsoft.CodeAnalysis.Common": "5.0.0",
+            "Microsoft.CodeAnalysis.CSharp": "5.0.0",
+            "Microsoft.Data.Sqlite": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Design": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Relational": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Sqlite": "10.0.3",
+            "Microsoft.EntityFrameworkCore.Tools": "10.0.3",
+            "Microsoft.Extensions.Caching.Abstractions": "10.0.3",
+            "Microsoft.Extensions.Caching.Memory": "10.0.3",
+            "Microsoft.Extensions.Configuration.Abstractions": "10.0.3",
+            "Microsoft.Extensions.Configuration.Binder": "10.0.3",
+            "Microsoft.Extensions.DependencyInjection": "10.0.3",
+            "Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore": "10.0.3",
+            "Microsoft.Extensions.Hosting.Abstractions": "10.0.3",
+            "Microsoft.Extensions.Http": "10.0.3",
+            "Microsoft.Extensions.Logging": "10.0.3",
+            "Microsoft.Extensions.Options": "10.0.3",
+            "Microsoft.NET.Test.Sdk": "18.0.1",
+            "MimeTypes": "2.5.2",
+            "Moq": "4.18.4",
+            "Morestachio": "5.0.1.631",
+            "NEbml": "1.1.0.5",
+            "Newtonsoft.Json": "13.0.4",
+            "PlaylistsNET": "1.4.1",
+            "Polly": "8.6.5",
+            "prometheus-net": "8.2.1",
+            "prometheus-net.AspNetCore": "8.2.1",
+            "prometheus-net.DotNetRuntime": "4.4.1",
+            "Serilog.AspNetCore": "10.0.0",
+            "Serilog.Enrichers.Thread": "4.0.0",
+            "Serilog.Expressions": "5.0.0",
+            "Serilog.Settings.Configuration": "10.0.0",
+            "Serilog.Sinks.Async": "2.1.0",
+            "Serilog.Sinks.Console": "6.1.1",
+            "Serilog.Sinks.File": "7.0.0",
+            "Serilog.Sinks.Graylog": "3.1.1",
+            "SerilogAnalyzer": "0.15.0",
+            "SharpFuzz": "2.2.0",
+            "SkiaSharp": "[3.116.1]",
+            "SkiaSharp.HarfBuzz": "[3.116.1]",
+            "SkiaSharp.NativeAssets.Linux": "[3.116.1]",
+            "SmartAnalyzers.MultithreadingAnalyzer": "1.1.31",
+            "StyleCop.Analyzers": "1.2.0-beta.556",
+            "Svg.Skia": "3.4.1",
+            "Swashbuckle.AspNetCore": "7.3.2",
+            "Swashbuckle.AspNetCore.ReDoc": "6.9.0",
+            "System.Text.Json": "10.0.3",
+            "TagLibSharp": "2.3.0",
+            "TMDbLib": "2.3.0",
+            "UTF.Unknown": "2.6.0",
+            "xunit": "2.9.3",
+            "Xunit.Priority": "1.1.6",
+            "xunit.runner.visualstudio": "2.8.2",
+            "Xunit.SkippableFact": "1.5.61",
+            "z440.atl.core": "7.11.0"
+          },
+          "imports": [
+            "net461",
+            "net462",
+            "net47",
+            "net471",
+            "net472",
+            "net48",
+            "net481"
+          ],
+          "assetTargetFallback": true,
+          "warn": true,
+          "frameworkReferences": {
+            "Microsoft.NETCore.App": {
+              "privateAssets": "all"
+            }
+          },
+          "runtimeIdentifierGraphPath": "/usr/lib/dotnet/sdk/10.0.103/PortableRuntimeIdentifierGraph.json",
+          "packagesToPrune": {
+            "Microsoft.CSharp": "(,4.7.32767]",
+            "Microsoft.VisualBasic": "(,10.4.32767]",
+            "Microsoft.Win32.Primitives": "(,4.3.32767]",
+            "Microsoft.Win32.Registry": "(,5.0.32767]",
+            "runtime.any.System.Collections": "(,4.3.32767]",
+            "runtime.any.System.Diagnostics.Tools": "(,4.3.32767]",
+            "runtime.any.System.Diagnostics.Tracing": "(,4.3.32767]",
+            "runtime.any.System.Globalization": "(,4.3.32767]",
+            "runtime.any.System.Globalization.Calendars": "(,4.3.32767]",
+            "runtime.any.System.IO": "(,4.3.32767]",
+            "runtime.any.System.Reflection": "(,4.3.32767]",
+            "runtime.any.System.Reflection.Extensions": "(,4.3.32767]",
+            "runtime.any.System.Reflection.Primitives": "(,4.3.32767]",
+            "runtime.any.System.Resources.ResourceManager": "(,4.3.32767]",
+            "runtime.any.System.Runtime": "(,4.3.32767]",
+            "runtime.any.System.Runtime.Handles": "(,4.3.32767]",
+            "runtime.any.System.Runtime.InteropServices": "(,4.3.32767]",
+            "runtime.any.System.Text.Encoding": "(,4.3.32767]",
+            "runtime.any.System.Text.Encoding.Extensions": "(,4.3.32767]",
+            "runtime.any.System.Threading.Tasks": "(,4.3.32767]",
+            "runtime.any.System.Threading.Timer": "(,4.3.32767]",
+            "runtime.aot.System.Collections": "(,4.3.32767]",
+            "runtime.aot.System.Diagnostics.Tools": "(,4.3.32767]",
+            "runtime.aot.System.Diagnostics.Tracing": "(,4.3.32767]",
+            "runtime.aot.System.Globalization": "(,4.3.32767]",
+            "runtime.aot.System.Globalization.Calendars": "(,4.3.32767]",
+            "runtime.aot.System.IO": "(,4.3.32767]",
+            "runtime.aot.System.Reflection": "(,4.3.32767]",
+            "runtime.aot.System.Reflection.Extensions": "(,4.3.32767]",
+            "runtime.aot.System.Reflection.Primitives": "(,4.3.32767]",
+            "runtime.aot.System.Resources.ResourceManager": "(,4.3.32767]",
+            "runtime.aot.System.Runtime": "(,4.3.32767]",
+            "runtime.aot.System.Runtime.Handles": "(,4.3.32767]",
+            "runtime.aot.System.Runtime.InteropServices": "(,4.3.32767]",
+            "runtime.aot.System.Text.Encoding": "(,4.3.32767]",
+            "runtime.aot.System.Text.Encoding.Extensions": "(,4.3.32767]",
+            "runtime.aot.System.Threading.Tasks": "(,4.3.32767]",
+            "runtime.aot.System.Threading.Timer": "(,4.3.32767]",
+            "runtime.debian.8-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.debian.8-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.debian.8-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.debian.8-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.debian.8-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.debian.9-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.debian.9-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.debian.9-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.debian.9-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.fedora.23-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.fedora.23-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.fedora.23-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.fedora.23-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.fedora.24-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.fedora.24-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.fedora.24-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.fedora.24-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.fedora.27-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.fedora.27-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.fedora.27-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.fedora.27-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.fedora.28-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.fedora.28-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.fedora.28-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.fedora.28-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.opensuse.13.2-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.opensuse.13.2-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.opensuse.13.2-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.opensuse.13.2-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.opensuse.42.1-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.opensuse.42.1-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.opensuse.42.1-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.opensuse.42.1-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.opensuse.42.3-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.opensuse.42.3-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.opensuse.42.3-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.opensuse.42.3-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.osx.10.10-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.osx.10.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.osx.10.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.osx.10.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": "(,4.3.32767]",
+            "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.rhel.7-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.rhel.7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.rhel.7-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.rhel.7-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.ubuntu.14.04-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.ubuntu.14.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.ubuntu.16.04-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.ubuntu.16.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.ubuntu.16.10-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.ubuntu.16.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+            "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+            "runtime.ubuntu.18.04-x64.runtime.native.System": "(,4.3.32767]",
+            "runtime.ubuntu.18.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+            "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+            "runtime.unix.Microsoft.Win32.Primitives": "(,4.3.32767]",
+            "runtime.unix.System.Console": "(,4.3.32767]",
+            "runtime.unix.System.Diagnostics.Debug": "(,4.3.32767]",
+            "runtime.unix.System.IO.FileSystem": "(,4.3.32767]",
+            "runtime.unix.System.Net.Primitives": "(,4.3.32767]",
+            "runtime.unix.System.Net.Sockets": "(,4.3.32767]",
+            "runtime.unix.System.Private.Uri": "(,4.3.32767]",
+            "runtime.unix.System.Runtime.Extensions": "(,4.3.32767]",
+            "runtime.win.Microsoft.Win32.Primitives": "(,4.3.32767]",
+            "runtime.win.System.Console": "(,4.3.32767]",
+            "runtime.win.System.Diagnostics.Debug": "(,4.3.32767]",
+            "runtime.win.System.IO.FileSystem": "(,4.3.32767]",
+            "runtime.win.System.Net.Primitives": "(,4.3.32767]",
+            "runtime.win.System.Net.Sockets": "(,4.3.32767]",
+            "runtime.win.System.Runtime.Extensions": "(,4.3.32767]",
+            "runtime.win10-arm-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
+            "runtime.win10-arm64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.win10-x64-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
+            "runtime.win10-x86-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
+            "runtime.win7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.win7-x86.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "runtime.win7.System.Private.Uri": "(,4.3.32767]",
+            "runtime.win8-arm.runtime.native.System.IO.Compression": "(,4.3.32767]",
+            "System.AppContext": "(,4.3.32767]",
+            "System.Buffers": "(,5.0.32767]",
+            "System.Collections": "(,4.3.32767]",
+            "System.Collections.Concurrent": "(,4.3.32767]",
+            "System.Collections.Immutable": "(,10.0.32767]",
+            "System.Collections.NonGeneric": "(,4.3.32767]",
+            "System.Collections.Specialized": "(,4.3.32767]",
+            "System.ComponentModel": "(,4.3.32767]",
+            "System.ComponentModel.Annotations": "(,4.3.32767]",
+            "System.ComponentModel.EventBasedAsync": "(,4.3.32767]",
+            "System.ComponentModel.Primitives": "(,4.3.32767]",
+            "System.ComponentModel.TypeConverter": "(,4.3.32767]",
+            "System.Console": "(,4.3.32767]",
+            "System.Data.Common": "(,4.3.32767]",
+            "System.Data.DataSetExtensions": "(,4.4.32767]",
+            "System.Diagnostics.Contracts": "(,4.3.32767]",
+            "System.Diagnostics.Debug": "(,4.3.32767]",
+            "System.Diagnostics.DiagnosticSource": "(,10.0.32767]",
+            "System.Diagnostics.FileVersionInfo": "(,4.3.32767]",
+            "System.Diagnostics.Process": "(,4.3.32767]",
+            "System.Diagnostics.StackTrace": "(,4.3.32767]",
+            "System.Diagnostics.TextWriterTraceListener": "(,4.3.32767]",
+            "System.Diagnostics.Tools": "(,4.3.32767]",
+            "System.Diagnostics.TraceSource": "(,4.3.32767]",
+            "System.Diagnostics.Tracing": "(,4.3.32767]",
+            "System.Drawing.Primitives": "(,4.3.32767]",
+            "System.Dynamic.Runtime": "(,4.3.32767]",
+            "System.Formats.Asn1": "(,10.0.32767]",
+            "System.Formats.Tar": "(,10.0.32767]",
+            "System.Globalization": "(,4.3.32767]",
+            "System.Globalization.Calendars": "(,4.3.32767]",
+            "System.Globalization.Extensions": "(,4.3.32767]",
+            "System.IO": "(,4.3.32767]",
+            "System.IO.Compression": "(,4.3.32767]",
+            "System.IO.Compression.ZipFile": "(,4.3.32767]",
+            "System.IO.FileSystem": "(,4.3.32767]",
+            "System.IO.FileSystem.AccessControl": "(,4.4.32767]",
+            "System.IO.FileSystem.DriveInfo": "(,4.3.32767]",
+            "System.IO.FileSystem.Primitives": "(,4.3.32767]",
+            "System.IO.FileSystem.Watcher": "(,4.3.32767]",
+            "System.IO.IsolatedStorage": "(,4.3.32767]",
+            "System.IO.MemoryMappedFiles": "(,4.3.32767]",
+            "System.IO.Pipelines": "(,10.0.32767]",
+            "System.IO.Pipes": "(,4.3.32767]",
+            "System.IO.Pipes.AccessControl": "(,5.0.32767]",
+            "System.IO.UnmanagedMemoryStream": "(,4.3.32767]",
+            "System.Linq": "(,4.3.32767]",
+            "System.Linq.AsyncEnumerable": "(,10.0.32767]",
+            "System.Linq.Expressions": "(,4.3.32767]",
+            "System.Linq.Parallel": "(,4.3.32767]",
+            "System.Linq.Queryable": "(,4.3.32767]",
+            "System.Memory": "(,5.0.32767]",
+            "System.Net.Http": "(,4.3.32767]",
+            "System.Net.Http.Json": "(,10.0.32767]",
+            "System.Net.NameResolution": "(,4.3.32767]",
+            "System.Net.NetworkInformation": "(,4.3.32767]",
+            "System.Net.Ping": "(,4.3.32767]",
+            "System.Net.Primitives": "(,4.3.32767]",
+            "System.Net.Requests": "(,4.3.32767]",
+            "System.Net.Security": "(,4.3.32767]",
+            "System.Net.ServerSentEvents": "(,10.0.32767]",
+            "System.Net.Sockets": "(,4.3.32767]",
+            "System.Net.WebHeaderCollection": "(,4.3.32767]",
+            "System.Net.WebSockets": "(,4.3.32767]",
+            "System.Net.WebSockets.Client": "(,4.3.32767]",
+            "System.Numerics.Vectors": "(,5.0.32767]",
+            "System.ObjectModel": "(,4.3.32767]",
+            "System.Private.DataContractSerialization": "(,4.3.32767]",
+            "System.Private.Uri": "(,4.3.32767]",
+            "System.Reflection": "(,4.3.32767]",
+            "System.Reflection.DispatchProxy": "(,6.0.32767]",
+            "System.Reflection.Emit": "(,4.7.32767]",
+            "System.Reflection.Emit.ILGeneration": "(,4.7.32767]",
+            "System.Reflection.Emit.Lightweight": "(,4.7.32767]",
+            "System.Reflection.Extensions": "(,4.3.32767]",
+            "System.Reflection.Metadata": "(,10.0.32767]",
+            "System.Reflection.Primitives": "(,4.3.32767]",
+            "System.Reflection.TypeExtensions": "(,4.3.32767]",
+            "System.Resources.Reader": "(,4.3.32767]",
+            "System.Resources.ResourceManager": "(,4.3.32767]",
+            "System.Resources.Writer": "(,4.3.32767]",
+            "System.Runtime": "(,4.3.32767]",
+            "System.Runtime.CompilerServices.Unsafe": "(,7.0.32767]",
+            "System.Runtime.CompilerServices.VisualC": "(,4.3.32767]",
+            "System.Runtime.Extensions": "(,4.3.32767]",
+            "System.Runtime.Handles": "(,4.3.32767]",
+            "System.Runtime.InteropServices": "(,4.3.32767]",
+            "System.Runtime.InteropServices.RuntimeInformation": "(,4.3.32767]",
+            "System.Runtime.Loader": "(,4.3.32767]",
+            "System.Runtime.Numerics": "(,4.3.32767]",
+            "System.Runtime.Serialization.Formatters": "(,4.3.32767]",
+            "System.Runtime.Serialization.Json": "(,4.3.32767]",
+            "System.Runtime.Serialization.Primitives": "(,4.3.32767]",
+            "System.Runtime.Serialization.Xml": "(,4.3.32767]",
+            "System.Security.AccessControl": "(,6.0.32767]",
+            "System.Security.Claims": "(,4.3.32767]",
+            "System.Security.Cryptography.Algorithms": "(,4.3.32767]",
+            "System.Security.Cryptography.Cng": "(,5.0.32767]",
+            "System.Security.Cryptography.Csp": "(,4.3.32767]",
+            "System.Security.Cryptography.Encoding": "(,4.3.32767]",
+            "System.Security.Cryptography.OpenSsl": "(,5.0.32767]",
+            "System.Security.Cryptography.Primitives": "(,4.3.32767]",
+            "System.Security.Cryptography.X509Certificates": "(,4.3.32767]",
+            "System.Security.Principal": "(,4.3.32767]",
+            "System.Security.Principal.Windows": "(,5.0.32767]",
+            "System.Security.SecureString": "(,4.3.32767]",
+            "System.Text.Encoding": "(,4.3.32767]",
+            "System.Text.Encoding.CodePages": "(,10.0.32767]",
+            "System.Text.Encoding.Extensions": "(,4.3.32767]",
+            "System.Text.Encodings.Web": "(,10.0.32767]",
+            "System.Text.Json": "(,10.0.32767]",
+            "System.Text.RegularExpressions": "(,4.3.32767]",
+            "System.Threading": "(,4.3.32767]",
+            "System.Threading.AccessControl": "(,10.0.32767]",
+            "System.Threading.Channels": "(,10.0.32767]",
+            "System.Threading.Overlapped": "(,4.3.32767]",
+            "System.Threading.Tasks": "(,4.3.32767]",
+            "System.Threading.Tasks.Dataflow": "(,10.0.32767]",
+            "System.Threading.Tasks.Extensions": "(,5.0.32767]",
+            "System.Threading.Tasks.Parallel": "(,4.3.32767]",
+            "System.Threading.Thread": "(,4.3.32767]",
+            "System.Threading.ThreadPool": "(,4.3.32767]",
+            "System.Threading.Timer": "(,4.3.32767]",
+            "System.ValueTuple": "(,4.5.32767]",
+            "System.Xml.ReaderWriter": "(,4.3.32767]",
+            "System.Xml.XDocument": "(,4.3.32767]",
+            "System.Xml.XmlDocument": "(,4.3.32767]",
+            "System.Xml.XmlSerializer": "(,4.3.32767]",
+            "System.Xml.XPath": "(,4.3.32767]",
+            "System.Xml.XPath.XDocument": "(,5.0.32767]"
+          }
+        }
+      }
+    }
+  }
+}

src/Jellyfin.Extensions/obj/Jellyfin.Extensions.csproj.nuget.g.props

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
+    <RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
+    <ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
+    <NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">/home/wjones/.nuget/packages/</NuGetPackageRoot>
+    <NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">/home/wjones/.nuget/packages/</NuGetPackageFolders>
+    <NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
+    <NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">7.0.0</NuGetToolVersion>
+  </PropertyGroup>
+  <ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <SourceRoot Include="/home/wjones/.nuget/packages/" />
+  </ItemGroup>
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)microsoft.codeanalysis.bannedapianalyzers/4.14.0/buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.props" Condition="Exists('$(NuGetPackageRoot)microsoft.codeanalysis.bannedapianalyzers/4.14.0/buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.props')" />
+  </ImportGroup>
+  <PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <PkgStyleCop_Analyzers_Unstable Condition=" '$(PkgStyleCop_Analyzers_Unstable)' == '' ">/home/wjones/.nuget/packages/stylecop.analyzers.unstable/1.2.0.556</PkgStyleCop_Analyzers_Unstable>
+    <PkgSmartAnalyzers_MultithreadingAnalyzer Condition=" '$(PkgSmartAnalyzers_MultithreadingAnalyzer)' == '' ">/home/wjones/.nuget/packages/smartanalyzers.multithreadinganalyzer/1.1.31</PkgSmartAnalyzers_MultithreadingAnalyzer>
+    <PkgSerilogAnalyzer Condition=" '$(PkgSerilogAnalyzer)' == '' ">/home/wjones/.nuget/packages/seriloganalyzer/0.15.0</PkgSerilogAnalyzer>
+    <PkgMicrosoft_CodeAnalysis_BannedApiAnalyzers Condition=" '$(PkgMicrosoft_CodeAnalysis_BannedApiAnalyzers)' == '' ">/home/wjones/.nuget/packages/microsoft.codeanalysis.bannedapianalyzers/4.14.0</PkgMicrosoft_CodeAnalysis_BannedApiAnalyzers>
+    <PkgIDisposableAnalyzers Condition=" '$(PkgIDisposableAnalyzers)' == '' ">/home/wjones/.nuget/packages/idisposableanalyzers/4.0.8</PkgIDisposableAnalyzers>
+  </PropertyGroup>
+</Project>

src/Jellyfin.Extensions/obj/Jellyfin.Extensions.csproj.nuget.g.targets

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
+    <Import Project="$(NuGetPackageRoot)microsoft.codeanalysis.bannedapianalyzers/4.14.0/buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.targets" Condition="Exists('$(NuGetPackageRoot)microsoft.codeanalysis.bannedapianalyzers/4.14.0/buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.targets')" />
+  </ImportGroup>
+</Project>

src/Jellyfin.Extensions/obj/project.assets.json

@@ -0,0 +1,986 @@
+{
+  "version": 3,
+  "targets": {
+    "net10.0": {
+      "Diacritics/4.1.4": {
+        "type": "package",
+        "compile": {
+          "lib/net9.0/Diacritics.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/net9.0/Diacritics.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "ICU4N/60.1.0-alpha.356": {
+        "type": "package",
+        "dependencies": {
+          "J2N": "2.0.0",
+          "Microsoft.Extensions.Caching.Memory": "2.0.0"
+        },
+        "compile": {
+          "lib/netstandard2.0/ICU4N.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/netstandard2.0/ICU4N.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "ICU4N.Transliterator/60.1.0-alpha.356": {
+        "type": "package",
+        "dependencies": {
+          "ICU4N": "60.1.0-alpha.356"
+        },
+        "compile": {
+          "lib/netstandard2.0/ICU4N.Transliterator.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/netstandard2.0/ICU4N.Transliterator.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "IDisposableAnalyzers/4.0.8": {
+        "type": "package"
+      },
+      "J2N/2.0.0": {
+        "type": "package",
+        "compile": {
+          "lib/net6.0/J2N.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/net6.0/J2N.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.BannedApiAnalyzers/4.14.0": {
+        "type": "package",
+        "build": {
+          "buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.props": {},
+          "buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.targets": {}
+        }
+      },
+      "Microsoft.Extensions.Caching.Abstractions/2.0.0": {
+        "type": "package",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "2.0.0"
+        },
+        "compile": {
+          "lib/netstandard2.0/Microsoft.Extensions.Caching.Abstractions.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Caching.Abstractions.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "Microsoft.Extensions.Caching.Memory/2.0.0": {
+        "type": "package",
+        "dependencies": {
+          "Microsoft.Extensions.Caching.Abstractions": "2.0.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.0.0",
+          "Microsoft.Extensions.Options": "2.0.0"
+        },
+        "compile": {
+          "lib/netstandard2.0/Microsoft.Extensions.Caching.Memory.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Caching.Memory.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/2.0.0": {
+        "type": "package",
+        "compile": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "Microsoft.Extensions.Options/2.0.0": {
+        "type": "package",
+        "dependencies": {
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "2.0.0",
+          "Microsoft.Extensions.Primitives": "2.0.0"
+        },
+        "compile": {
+          "lib/netstandard2.0/Microsoft.Extensions.Options.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Options.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "Microsoft.Extensions.Primitives/2.0.0": {
+        "type": "package",
+        "compile": {
+          "lib/netstandard2.0/Microsoft.Extensions.Primitives.dll": {
+            "related": ".xml"
+          }
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.Primitives.dll": {
+            "related": ".xml"
+          }
+        }
+      },
+      "SerilogAnalyzer/0.15.0": {
+        "type": "package"
+      },
+      "SmartAnalyzers.MultithreadingAnalyzer/1.1.31": {
+        "type": "package"
+      },
+      "StyleCop.Analyzers/1.2.0-beta.556": {
+        "type": "package",
+        "dependencies": {
+          "StyleCop.Analyzers.Unstable": "1.2.0.556"
+        }
+      },
+      "StyleCop.Analyzers.Unstable/1.2.0.556": {
+        "type": "package"
+      },
+      "Jellyfin.CodeAnalysis/1.0.0": {
+        "type": "project",
+        "framework": ".NETStandard,Version=v2.0",
+        "compile": {
+          "bin/placeholder/Jellyfin.CodeAnalysis.dll": {}
+        },
+        "runtime": {
+          "bin/placeholder/Jellyfin.CodeAnalysis.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "Diacritics/4.1.4": {
+      "sha512": "9JK2bI+oWnzOK4Lu+5FXt7czofD28AMnZ95np5fkSClqioPnga1JVpjaUxVJaEpc/5HIlfikc6YI33lm2qu4mw==",
+      "type": "package",
+      "path": "diacritics/4.1.4",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE",
+        "README.md",
+        "diacritics.4.1.4.nupkg.sha512",
+        "diacritics.nuspec",
+        "lib/net48/Diacritics.dll",
+        "lib/net48/Diacritics.xml",
+        "lib/net7.0/Diacritics.dll",
+        "lib/net7.0/Diacritics.xml",
+        "lib/net8.0/Diacritics.dll",
+        "lib/net8.0/Diacritics.xml",
+        "lib/net9.0/Diacritics.dll",
+        "lib/net9.0/Diacritics.xml",
+        "lib/netstandard1.2/Diacritics.dll",
+        "lib/netstandard1.2/Diacritics.xml",
+        "lib/netstandard2.0/Diacritics.dll",
+        "lib/netstandard2.0/Diacritics.xml",
+        "lib/netstandard2.1/Diacritics.dll",
+        "lib/netstandard2.1/Diacritics.xml",
+        "logo.png"
+      ]
+    },
+    "ICU4N/60.1.0-alpha.356": {
+      "sha512": "YMZtDnjcqWzziOKiE7w6Ma7Rl5vuFDxzOsUlHh1QyfghbNEIZQOLRs9MMfwCWAjX6n9UitrF6vLXy55Z5q+4Fg==",
+      "type": "package",
+      "path": "icu4n/60.1.0-alpha.356",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE.txt",
+        "icu4n.60.1.0-alpha.356.nupkg.sha512",
+        "icu4n.nuspec",
+        "lib/net40/ICU4N.dll",
+        "lib/net40/ICU4N.xml",
+        "lib/net451/ICU4N.dll",
+        "lib/net451/ICU4N.xml",
+        "lib/netstandard2.0/ICU4N.dll",
+        "lib/netstandard2.0/ICU4N.xml",
+        "unicode-icon-128x128.jpg"
+      ]
+    },
+    "ICU4N.Transliterator/60.1.0-alpha.356": {
+      "sha512": "lFOSO6bbEtB6HkWMNDJAq+rFwVyi9g6xVc5O/2xHa6iZnV7wLVDqCbaQ4W4vIeBSQZAafqhxciaEkmAvSdzlCg==",
+      "type": "package",
+      "path": "icu4n.transliterator/60.1.0-alpha.356",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE.txt",
+        "icu4n.transliterator.60.1.0-alpha.356.nupkg.sha512",
+        "icu4n.transliterator.nuspec",
+        "lib/net40/ICU4N.Transliterator.dll",
+        "lib/net40/ICU4N.Transliterator.xml",
+        "lib/net451/ICU4N.Transliterator.dll",
+        "lib/net451/ICU4N.Transliterator.xml",
+        "lib/netstandard2.0/ICU4N.Transliterator.dll",
+        "lib/netstandard2.0/ICU4N.Transliterator.xml",
+        "unicode-icon-128x128.jpg"
+      ]
+    },
+    "IDisposableAnalyzers/4.0.8": {
+      "sha512": "vNi4NMG0CcJyjXxiNDcQ21FwV/whM9o9OEZKD+oP7tuxAqFEzX/x5OhC3OZJqW/w+8GOtCmJPBquYgMWgz0rfQ==",
+      "type": "package",
+      "path": "idisposableanalyzers/4.0.8",
+      "hasTools": true,
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "analyzers/dotnet/cs/IDisposableAnalyzers.dll",
+        "idisposableanalyzers.4.0.8.nupkg.sha512",
+        "idisposableanalyzers.nuspec",
+        "tools/install.ps1",
+        "tools/uninstall.ps1"
+      ]
+    },
+    "J2N/2.0.0": {
+      "sha512": "M5bwDajAARZiyqupU+rHQJnsVLxNBOHJ8vKYHd8LcLIb1FgLfzzcJvc31Qo5Xz/GEHFjDF9ScjKL/ks/zRTXuA==",
+      "type": "package",
+      "path": "j2n/2.0.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE.txt",
+        "j2n-icon-100x100.png",
+        "j2n.2.0.0.nupkg.sha512",
+        "j2n.nuspec",
+        "lib/net40/J2N.dll",
+        "lib/net40/J2N.xml",
+        "lib/net45/J2N.dll",
+        "lib/net45/J2N.xml",
+        "lib/net5.0/J2N.dll",
+        "lib/net5.0/J2N.xml",
+        "lib/net6.0/J2N.dll",
+        "lib/net6.0/J2N.xml",
+        "lib/netcoreapp3.0/J2N.dll",
+        "lib/netcoreapp3.0/J2N.xml",
+        "lib/netstandard2.0/J2N.dll",
+        "lib/netstandard2.0/J2N.xml",
+        "lib/netstandard2.1/J2N.dll",
+        "lib/netstandard2.1/J2N.xml",
+        "readme.md"
+      ]
+    },
+    "Microsoft.CodeAnalysis.BannedApiAnalyzers/4.14.0": {
+      "sha512": "gSWJlDWwmDhtbrEJGiHqvEjz9KthIiFD0qYB8zZ6a7z+xpMSPEtM9yTYELSa58iFWYlzSRqP9FXO6KoT3+ZMtg==",
+      "type": "package",
+      "path": "microsoft.codeanalysis.bannedapianalyzers/4.14.0",
+      "hasTools": true,
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "Icon.png",
+        "ThirdPartyNotices.txt",
+        "analyzers/dotnet/cs/Microsoft.CodeAnalysis.BannedApiAnalyzers.dll",
+        "analyzers/dotnet/cs/Microsoft.CodeAnalysis.CSharp.BannedApiAnalyzers.dll",
+        "analyzers/dotnet/cs/cs/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/de/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/es/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/fr/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/it/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/ja/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/ko/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/pl/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/pt-BR/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/ru/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/tr/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/zh-Hans/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/cs/zh-Hant/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/Microsoft.CodeAnalysis.BannedApiAnalyzers.dll",
+        "analyzers/dotnet/vb/Microsoft.CodeAnalysis.VisualBasic.BannedApiAnalyzers.dll",
+        "analyzers/dotnet/vb/cs/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/de/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/es/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/fr/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/it/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/ja/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/ko/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/pl/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/pt-BR/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/ru/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/tr/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/zh-Hans/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "analyzers/dotnet/vb/zh-Hant/Microsoft.CodeAnalysis.BannedApiAnalyzers.resources.dll",
+        "buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.props",
+        "buildTransitive/Microsoft.CodeAnalysis.BannedApiAnalyzers.targets",
+        "documentation/Microsoft.CodeAnalysis.BannedApiAnalyzers.md",
+        "documentation/Microsoft.CodeAnalysis.BannedApiAnalyzers.sarif",
+        "editorconfig/AllRulesDefault/.editorconfig",
+        "editorconfig/AllRulesDisabled/.editorconfig",
+        "editorconfig/AllRulesEnabled/.editorconfig",
+        "editorconfig/ApiDesignRulesDefault/.editorconfig",
+        "editorconfig/ApiDesignRulesEnabled/.editorconfig",
+        "editorconfig/DataflowRulesDefault/.editorconfig",
+        "editorconfig/DataflowRulesEnabled/.editorconfig",
+        "editorconfig/PortedFromFxCopRulesDefault/.editorconfig",
+        "editorconfig/PortedFromFxCopRulesEnabled/.editorconfig",
+        "microsoft.codeanalysis.bannedapianalyzers.4.14.0.nupkg.sha512",
+        "microsoft.codeanalysis.bannedapianalyzers.nuspec",
+        "rulesets/AllRulesDefault.ruleset",
+        "rulesets/AllRulesDisabled.ruleset",
+        "rulesets/AllRulesEnabled.ruleset",
+        "rulesets/ApiDesignRulesDefault.ruleset",
+        "rulesets/ApiDesignRulesEnabled.ruleset",
+        "rulesets/DataflowRulesDefault.ruleset",
+        "rulesets/DataflowRulesEnabled.ruleset",
+        "rulesets/PortedFromFxCopRulesDefault.ruleset",
+        "rulesets/PortedFromFxCopRulesEnabled.ruleset",
+        "tools/install.ps1",
+        "tools/uninstall.ps1"
+      ]
+    },
+    "Microsoft.Extensions.Caching.Abstractions/2.0.0": {
+      "sha512": "kGMEV53Od1ES0BDh7OOKbTW9Zu5dbbQ72yI936dvvbHlde3puuq/WRKAccFgcB2PuRjox1HFhA9+t53RYqfuEA==",
+      "type": "package",
+      "path": "microsoft.extensions.caching.abstractions/2.0.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "lib/netstandard2.0/Microsoft.Extensions.Caching.Abstractions.dll",
+        "lib/netstandard2.0/Microsoft.Extensions.Caching.Abstractions.xml",
+        "microsoft.extensions.caching.abstractions.2.0.0.nupkg.sha512",
+        "microsoft.extensions.caching.abstractions.nuspec"
+      ]
+    },
+    "Microsoft.Extensions.Caching.Memory/2.0.0": {
+      "sha512": "NqvVdYLbX7N2J2Wz9y3zjhE66JRdROiZZsGhA2u4a9IcIq/jzINC/cLM96BHA+TSOZFPxVdWneqB6/yt9u846A==",
+      "type": "package",
+      "path": "microsoft.extensions.caching.memory/2.0.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "lib/netstandard2.0/Microsoft.Extensions.Caching.Memory.dll",
+        "lib/netstandard2.0/Microsoft.Extensions.Caching.Memory.xml",
+        "microsoft.extensions.caching.memory.2.0.0.nupkg.sha512",
+        "microsoft.extensions.caching.memory.nuspec"
+      ]
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/2.0.0": {
+      "sha512": "eUdJ0Q/GfVyUJc0Jal5L1QZLceL78pvEM9wEKcHeI24KorqMDoVX+gWsMGLulQMfOwsUaPtkpQM2pFERTzSfSg==",
+      "type": "package",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/2.0.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll",
+        "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.xml",
+        "microsoft.extensions.dependencyinjection.abstractions.2.0.0.nupkg.sha512",
+        "microsoft.extensions.dependencyinjection.abstractions.nuspec"
+      ]
+    },
+    "Microsoft.Extensions.Options/2.0.0": {
+      "sha512": "sAKBgjl2gWsECBLLR9K54T7/uZaP2n9GhMYHay/oOLfvpvX0+iNAlQ2NJgVE352C9Fs5CDV3VbNTK8T2aNKQFA==",
+      "type": "package",
+      "path": "microsoft.extensions.options/2.0.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "lib/netstandard2.0/Microsoft.Extensions.Options.dll",
+        "lib/netstandard2.0/Microsoft.Extensions.Options.xml",
+        "microsoft.extensions.options.2.0.0.nupkg.sha512",
+        "microsoft.extensions.options.nuspec"
+      ]
+    },
+    "Microsoft.Extensions.Primitives/2.0.0": {
+      "sha512": "ukg53qNlqTrK38WA30b5qhw0GD7y3jdI9PHHASjdKyTcBHTevFM2o23tyk3pWCgAV27Bbkm+CPQ2zUe1ZOuYSA==",
+      "type": "package",
+      "path": "microsoft.extensions.primitives/2.0.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "lib/netstandard2.0/Microsoft.Extensions.Primitives.dll",
+        "lib/netstandard2.0/Microsoft.Extensions.Primitives.xml",
+        "microsoft.extensions.primitives.2.0.0.nupkg.sha512",
+        "microsoft.extensions.primitives.nuspec"
+      ]
+    },
+    "SerilogAnalyzer/0.15.0": {
+      "sha512": "sVpwfls4MfNnwIXLSGCgaUnV+c9kgJ8ia6GsyRcpd4Vs3gLogSDtSYBYrre2K2u/PNMo8GgG09RehwVnze70Tw==",
+      "type": "package",
+      "path": "seriloganalyzer/0.15.0",
+      "hasTools": true,
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "analyzers/dotnet/cs/SerilogAnalyzer.dll",
+        "seriloganalyzer.0.15.0.nupkg.sha512",
+        "seriloganalyzer.nuspec",
+        "tools/install.ps1",
+        "tools/uninstall.ps1"
+      ]
+    },
+    "SmartAnalyzers.MultithreadingAnalyzer/1.1.31": {
+      "sha512": "2f2k7bbhDd132ArglCKpzKoWBcp3uzbIFcb4aosnlqIKlfYKDE2HevBVRNVa+LkWFnjXFFWs47Bo96fu8iS//Q==",
+      "type": "package",
+      "path": "smartanalyzers.multithreadinganalyzer/1.1.31",
+      "hasTools": true,
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "analyzers/dotnet/cs/SmartAnalyzers.MultithreadingAnalyzer.dll",
+        "smartanalyzers.multithreadinganalyzer.1.1.31.nupkg.sha512",
+        "smartanalyzers.multithreadinganalyzer.nuspec",
+        "tools/install.ps1",
+        "tools/uninstall.ps1"
+      ]
+    },
+    "StyleCop.Analyzers/1.2.0-beta.556": {
+      "sha512": "llRPgmA1fhC0I0QyFLEcjvtM2239QzKr/tcnbsjArLMJxJlu0AA5G7Fft0OI30pHF3MW63Gf4aSSsjc5m82J1Q==",
+      "type": "package",
+      "path": "stylecop.analyzers/1.2.0-beta.556",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE",
+        "THIRD-PARTY-NOTICES.txt",
+        "stylecop.analyzers.1.2.0-beta.556.nupkg.sha512",
+        "stylecop.analyzers.nuspec"
+      ]
+    },
+    "StyleCop.Analyzers.Unstable/1.2.0.556": {
+      "sha512": "zvn9Mqs/ox/83cpYPignI8hJEM2A93s2HkHs8HYMOAQW0PkampyoErAiIyKxgTLqbbad29HX/shv/6LGSjPJNQ==",
+      "type": "package",
+      "path": "stylecop.analyzers.unstable/1.2.0.556",
+      "hasTools": true,
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE",
+        "THIRD-PARTY-NOTICES.txt",
+        "analyzers/dotnet/cs/StyleCop.Analyzers.CodeFixes.dll",
+        "analyzers/dotnet/cs/StyleCop.Analyzers.dll",
+        "analyzers/dotnet/cs/de-DE/StyleCop.Analyzers.resources.dll",
+        "analyzers/dotnet/cs/en-GB/StyleCop.Analyzers.resources.dll",
+        "analyzers/dotnet/cs/es-MX/StyleCop.Analyzers.resources.dll",
+        "analyzers/dotnet/cs/fr-FR/StyleCop.Analyzers.resources.dll",
+        "analyzers/dotnet/cs/pl-PL/StyleCop.Analyzers.resources.dll",
+        "analyzers/dotnet/cs/pt-BR/StyleCop.Analyzers.resources.dll",
+        "analyzers/dotnet/cs/ru-RU/StyleCop.Analyzers.resources.dll",
+        "rulesets/StyleCopAnalyzersDefault.ruleset",
+        "stylecop.analyzers.unstable.1.2.0.556.nupkg.sha512",
+        "stylecop.analyzers.unstable.nuspec",
+        "tools/install.ps1",
+        "tools/uninstall.ps1"
+      ]
+    },
+    "Jellyfin.CodeAnalysis/1.0.0": {
+      "type": "project",
+      "path": "../Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj",
+      "msbuildProject": "../Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj"
+    }
+  },
+  "projectFileDependencyGroups": {
+    "net10.0": [
+      "Diacritics >= 4.1.4",
+      "ICU4N.Transliterator >= 60.1.0-alpha.356",
+      "IDisposableAnalyzers >= 4.0.8",
+      "Jellyfin.CodeAnalysis >= 1.0.0",
+      "Microsoft.CodeAnalysis.BannedApiAnalyzers >= 4.14.0",
+      "SerilogAnalyzer >= 0.15.0",
+      "SmartAnalyzers.MultithreadingAnalyzer >= 1.1.31",
+      "StyleCop.Analyzers >= 1.2.0-beta.556"
+    ]
+  },
+  "packageFolders": {
+    "/home/wjones/.nuget/packages/": {}
+  },
+  "project": {
+    "version": "10.12.0",
+    "restore": {
+      "projectUniqueName": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj",
+      "projectName": "Jellyfin.Extensions",
+      "projectPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj",
+      "packagesPath": "/home/wjones/.nuget/packages/",
+      "outputPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/obj/",
+      "projectStyle": "PackageReference",
+      "centralPackageVersionsManagementEnabled": true,
+      "configFilePaths": [
+        "/srv/common_drive/Projects/pgsql-jellyfin/nuget.config",
+        "/home/wjones/.nuget/NuGet/NuGet.Config"
+      ],
+      "originalTargetFrameworks": [
+        "net10.0"
+      ],
+      "sources": {
+        "/usr/lib/dotnet/library-packs": {},
+        "https://api.nuget.org/v3/index.json": {}
+      },
+      "frameworks": {
+        "net10.0": {
+          "targetAlias": "net10.0",
+          "projectReferences": {
+            "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj": {
+              "projectPath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj"
+            }
+          }
+        }
+      },
+      "warningProperties": {
+        "allWarningsAsErrors": true,
+        "noWarn": [
+          "NU5104"
+        ],
+        "warnAsError": [
+          "NU1605"
+        ],
+        "warnNotAsError": [
+          "NU1902",
+          "NU1903"
+        ]
+      },
+      "restoreAuditProperties": {
+        "enableAudit": "true",
+        "auditLevel": "low",
+        "auditMode": "all"
+      },
+      "SdkAnalysisLevel": "10.0.100"
+    },
+    "frameworks": {
+      "net10.0": {
+        "targetAlias": "net10.0",
+        "dependencies": {
+          "Diacritics": {
+            "target": "Package",
+            "version": "[4.1.4, )",
+            "versionCentrallyManaged": true
+          },
+          "ICU4N.Transliterator": {
+            "target": "Package",
+            "version": "[60.1.0-alpha.356, )",
+            "versionCentrallyManaged": true
+          },
+          "IDisposableAnalyzers": {
+            "include": "Runtime, Build, Native, ContentFiles, Analyzers",
+            "suppressParent": "All",
+            "target": "Package",
+            "version": "[4.0.8, )",
+            "versionCentrallyManaged": true
+          },
+          "Microsoft.CodeAnalysis.BannedApiAnalyzers": {
+            "include": "Runtime, Build, Native, ContentFiles, Analyzers",
+            "suppressParent": "All",
+            "target": "Package",
+            "version": "[4.14.0, )",
+            "versionCentrallyManaged": true
+          },
+          "SerilogAnalyzer": {
+            "suppressParent": "All",
+            "target": "Package",
+            "version": "[0.15.0, )",
+            "versionCentrallyManaged": true
+          },
+          "SmartAnalyzers.MultithreadingAnalyzer": {
+            "suppressParent": "All",
+            "target": "Package",
+            "version": "[1.1.31, )",
+            "versionCentrallyManaged": true
+          },
+          "StyleCop.Analyzers": {
+            "suppressParent": "All",
+            "target": "Package",
+            "version": "[1.2.0-beta.556, )",
+            "versionCentrallyManaged": true
+          }
+        },
+        "centralPackageVersions": {
+          "AsyncKeyedLock": "8.0.2",
+          "AutoFixture": "4.18.1",
+          "AutoFixture.AutoMoq": "4.18.1",
+          "AutoFixture.Xunit2": "4.18.1",
+          "BDInfo": "0.8.0",
+          "BitFaster.Caching": "2.5.4",
+          "BlurHashSharp": "1.4.0-pre.1",
+          "BlurHashSharp.SkiaSharp": "1.4.0-pre.1",
+          "CommandLineParser": "2.9.1",
+          "coverlet.collector": "8.0.0",
+          "Diacritics": "4.1.4",
+          "DiscUtils.Udf": "0.16.13",
+          "DotNet.Glob": "3.1.3",
+          "FsCheck.Xunit": "3.3.2",
+          "HarfBuzzSharp.NativeAssets.Linux": "8.3.1.1",
+          "ICU4N.Transliterator": "60.1.0-alpha.356",
+          "IDisposableAnalyzers": "4.0.8",
+          "Ignore": "0.2.1",
+          "Jellyfin.XmlTv": "10.8.0",
+          "libse": "4.0.12",
+          "LrcParser": "2025.623.0",
+          "MetaBrainz.MusicBrainz": "8.0.1",
+          "Microsoft.AspNetCore.Authorization": "10.0.3",
+          "Microsoft.AspNetCore.Mvc.Testing": "10.0.3",
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "Microsoft.CodeAnalysis.BannedApiAnalyzers": "4.14.0",
+          "Microsoft.CodeAnalysis.Common": "5.0.0",
+          "Microsoft.CodeAnalysis.CSharp": "5.0.0",
+          "Microsoft.Data.Sqlite": "10.0.3",
+          "Microsoft.EntityFrameworkCore.Design": "10.0.3",
+          "Microsoft.EntityFrameworkCore.Relational": "10.0.3",
+          "Microsoft.EntityFrameworkCore.Sqlite": "10.0.3",
+          "Microsoft.EntityFrameworkCore.Tools": "10.0.3",
+          "Microsoft.Extensions.Caching.Abstractions": "10.0.3",
+          "Microsoft.Extensions.Caching.Memory": "10.0.3",
+          "Microsoft.Extensions.Configuration.Abstractions": "10.0.3",
+          "Microsoft.Extensions.Configuration.Binder": "10.0.3",
+          "Microsoft.Extensions.DependencyInjection": "10.0.3",
+          "Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore": "10.0.3",
+          "Microsoft.Extensions.Hosting.Abstractions": "10.0.3",
+          "Microsoft.Extensions.Http": "10.0.3",
+          "Microsoft.Extensions.Logging": "10.0.3",
+          "Microsoft.Extensions.Options": "10.0.3",
+          "Microsoft.NET.Test.Sdk": "18.0.1",
+          "MimeTypes": "2.5.2",
+          "Moq": "4.18.4",
+          "Morestachio": "5.0.1.631",
+          "NEbml": "1.1.0.5",
+          "Newtonsoft.Json": "13.0.4",
+          "PlaylistsNET": "1.4.1",
+          "Polly": "8.6.5",
+          "prometheus-net": "8.2.1",
+          "prometheus-net.AspNetCore": "8.2.1",
+          "prometheus-net.DotNetRuntime": "4.4.1",
+          "Serilog.AspNetCore": "10.0.0",
+          "Serilog.Enrichers.Thread": "4.0.0",
+          "Serilog.Expressions": "5.0.0",
+          "Serilog.Settings.Configuration": "10.0.0",
+          "Serilog.Sinks.Async": "2.1.0",
+          "Serilog.Sinks.Console": "6.1.1",
+          "Serilog.Sinks.File": "7.0.0",
+          "Serilog.Sinks.Graylog": "3.1.1",
+          "SerilogAnalyzer": "0.15.0",
+          "SharpFuzz": "2.2.0",
+          "SkiaSharp": "[3.116.1]",
+          "SkiaSharp.HarfBuzz": "[3.116.1]",
+          "SkiaSharp.NativeAssets.Linux": "[3.116.1]",
+          "SmartAnalyzers.MultithreadingAnalyzer": "1.1.31",
+          "StyleCop.Analyzers": "1.2.0-beta.556",
+          "Svg.Skia": "3.4.1",
+          "Swashbuckle.AspNetCore": "7.3.2",
+          "Swashbuckle.AspNetCore.ReDoc": "6.9.0",
+          "System.Text.Json": "10.0.3",
+          "TagLibSharp": "2.3.0",
+          "TMDbLib": "2.3.0",
+          "UTF.Unknown": "2.6.0",
+          "xunit": "2.9.3",
+          "Xunit.Priority": "1.1.6",
+          "xunit.runner.visualstudio": "2.8.2",
+          "Xunit.SkippableFact": "1.5.61",
+          "z440.atl.core": "7.11.0"
+        },
+        "imports": [
+          "net461",
+          "net462",
+          "net47",
+          "net471",
+          "net472",
+          "net48",
+          "net481"
+        ],
+        "assetTargetFallback": true,
+        "warn": true,
+        "frameworkReferences": {
+          "Microsoft.NETCore.App": {
+            "privateAssets": "all"
+          }
+        },
+        "runtimeIdentifierGraphPath": "/usr/lib/dotnet/sdk/10.0.103/PortableRuntimeIdentifierGraph.json",
+        "packagesToPrune": {
+          "Microsoft.CSharp": "(,4.7.32767]",
+          "Microsoft.VisualBasic": "(,10.4.32767]",
+          "Microsoft.Win32.Primitives": "(,4.3.32767]",
+          "Microsoft.Win32.Registry": "(,5.0.32767]",
+          "runtime.any.System.Collections": "(,4.3.32767]",
+          "runtime.any.System.Diagnostics.Tools": "(,4.3.32767]",
+          "runtime.any.System.Diagnostics.Tracing": "(,4.3.32767]",
+          "runtime.any.System.Globalization": "(,4.3.32767]",
+          "runtime.any.System.Globalization.Calendars": "(,4.3.32767]",
+          "runtime.any.System.IO": "(,4.3.32767]",
+          "runtime.any.System.Reflection": "(,4.3.32767]",
+          "runtime.any.System.Reflection.Extensions": "(,4.3.32767]",
+          "runtime.any.System.Reflection.Primitives": "(,4.3.32767]",
+          "runtime.any.System.Resources.ResourceManager": "(,4.3.32767]",
+          "runtime.any.System.Runtime": "(,4.3.32767]",
+          "runtime.any.System.Runtime.Handles": "(,4.3.32767]",
+          "runtime.any.System.Runtime.InteropServices": "(,4.3.32767]",
+          "runtime.any.System.Text.Encoding": "(,4.3.32767]",
+          "runtime.any.System.Text.Encoding.Extensions": "(,4.3.32767]",
+          "runtime.any.System.Threading.Tasks": "(,4.3.32767]",
+          "runtime.any.System.Threading.Timer": "(,4.3.32767]",
+          "runtime.aot.System.Collections": "(,4.3.32767]",
+          "runtime.aot.System.Diagnostics.Tools": "(,4.3.32767]",
+          "runtime.aot.System.Diagnostics.Tracing": "(,4.3.32767]",
+          "runtime.aot.System.Globalization": "(,4.3.32767]",
+          "runtime.aot.System.Globalization.Calendars": "(,4.3.32767]",
+          "runtime.aot.System.IO": "(,4.3.32767]",
+          "runtime.aot.System.Reflection": "(,4.3.32767]",
+          "runtime.aot.System.Reflection.Extensions": "(,4.3.32767]",
+          "runtime.aot.System.Reflection.Primitives": "(,4.3.32767]",
+          "runtime.aot.System.Resources.ResourceManager": "(,4.3.32767]",
+          "runtime.aot.System.Runtime": "(,4.3.32767]",
+          "runtime.aot.System.Runtime.Handles": "(,4.3.32767]",
+          "runtime.aot.System.Runtime.InteropServices": "(,4.3.32767]",
+          "runtime.aot.System.Text.Encoding": "(,4.3.32767]",
+          "runtime.aot.System.Text.Encoding.Extensions": "(,4.3.32767]",
+          "runtime.aot.System.Threading.Tasks": "(,4.3.32767]",
+          "runtime.aot.System.Threading.Timer": "(,4.3.32767]",
+          "runtime.debian.8-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.debian.8-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.debian.8-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.debian.8-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.debian.8-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.debian.9-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.debian.9-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.debian.9-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.debian.9-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.fedora.23-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.fedora.23-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.fedora.23-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.fedora.23-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.fedora.24-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.fedora.24-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.fedora.24-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.fedora.24-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.fedora.27-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.fedora.27-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.fedora.27-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.fedora.27-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.fedora.28-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.fedora.28-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.fedora.28-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.fedora.28-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.opensuse.13.2-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.opensuse.13.2-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.opensuse.13.2-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.opensuse.13.2-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.opensuse.42.1-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.opensuse.42.1-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.opensuse.42.1-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.opensuse.42.1-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.opensuse.42.3-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.opensuse.42.3-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.opensuse.42.3-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.opensuse.42.3-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.osx.10.10-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.osx.10.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.osx.10.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.osx.10.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.Apple": "(,4.3.32767]",
+          "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.rhel.7-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.rhel.7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.rhel.7-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.rhel.7-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.ubuntu.14.04-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.ubuntu.14.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.ubuntu.16.04-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.ubuntu.16.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.ubuntu.16.10-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.ubuntu.16.10-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography": "(,4.3.32767]",
+          "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl": "(,4.3.32767]",
+          "runtime.ubuntu.18.04-x64.runtime.native.System": "(,4.3.32767]",
+          "runtime.ubuntu.18.04-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Http": "(,4.3.32767]",
+          "runtime.ubuntu.18.04-x64.runtime.native.System.Net.Security": "(,4.3.32767]",
+          "runtime.unix.Microsoft.Win32.Primitives": "(,4.3.32767]",
+          "runtime.unix.System.Console": "(,4.3.32767]",
+          "runtime.unix.System.Diagnostics.Debug": "(,4.3.32767]",
+          "runtime.unix.System.IO.FileSystem": "(,4.3.32767]",
+          "runtime.unix.System.Net.Primitives": "(,4.3.32767]",
+          "runtime.unix.System.Net.Sockets": "(,4.3.32767]",
+          "runtime.unix.System.Private.Uri": "(,4.3.32767]",
+          "runtime.unix.System.Runtime.Extensions": "(,4.3.32767]",
+          "runtime.win.Microsoft.Win32.Primitives": "(,4.3.32767]",
+          "runtime.win.System.Console": "(,4.3.32767]",
+          "runtime.win.System.Diagnostics.Debug": "(,4.3.32767]",
+          "runtime.win.System.IO.FileSystem": "(,4.3.32767]",
+          "runtime.win.System.Net.Primitives": "(,4.3.32767]",
+          "runtime.win.System.Net.Sockets": "(,4.3.32767]",
+          "runtime.win.System.Runtime.Extensions": "(,4.3.32767]",
+          "runtime.win10-arm-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
+          "runtime.win10-arm64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.win10-x64-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
+          "runtime.win10-x86-aot.runtime.native.System.IO.Compression": "(,4.0.32767]",
+          "runtime.win7-x64.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.win7-x86.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "runtime.win7.System.Private.Uri": "(,4.3.32767]",
+          "runtime.win8-arm.runtime.native.System.IO.Compression": "(,4.3.32767]",
+          "System.AppContext": "(,4.3.32767]",
+          "System.Buffers": "(,5.0.32767]",
+          "System.Collections": "(,4.3.32767]",
+          "System.Collections.Concurrent": "(,4.3.32767]",
+          "System.Collections.Immutable": "(,10.0.32767]",
+          "System.Collections.NonGeneric": "(,4.3.32767]",
+          "System.Collections.Specialized": "(,4.3.32767]",
+          "System.ComponentModel": "(,4.3.32767]",
+          "System.ComponentModel.Annotations": "(,4.3.32767]",
+          "System.ComponentModel.EventBasedAsync": "(,4.3.32767]",
+          "System.ComponentModel.Primitives": "(,4.3.32767]",
+          "System.ComponentModel.TypeConverter": "(,4.3.32767]",
+          "System.Console": "(,4.3.32767]",
+          "System.Data.Common": "(,4.3.32767]",
+          "System.Data.DataSetExtensions": "(,4.4.32767]",
+          "System.Diagnostics.Contracts": "(,4.3.32767]",
+          "System.Diagnostics.Debug": "(,4.3.32767]",
+          "System.Diagnostics.DiagnosticSource": "(,10.0.32767]",
+          "System.Diagnostics.FileVersionInfo": "(,4.3.32767]",
+          "System.Diagnostics.Process": "(,4.3.32767]",
+          "System.Diagnostics.StackTrace": "(,4.3.32767]",
+          "System.Diagnostics.TextWriterTraceListener": "(,4.3.32767]",
+          "System.Diagnostics.Tools": "(,4.3.32767]",
+          "System.Diagnostics.TraceSource": "(,4.3.32767]",
+          "System.Diagnostics.Tracing": "(,4.3.32767]",
+          "System.Drawing.Primitives": "(,4.3.32767]",
+          "System.Dynamic.Runtime": "(,4.3.32767]",
+          "System.Formats.Asn1": "(,10.0.32767]",
+          "System.Formats.Tar": "(,10.0.32767]",
+          "System.Globalization": "(,4.3.32767]",
+          "System.Globalization.Calendars": "(,4.3.32767]",
+          "System.Globalization.Extensions": "(,4.3.32767]",
+          "System.IO": "(,4.3.32767]",
+          "System.IO.Compression": "(,4.3.32767]",
+          "System.IO.Compression.ZipFile": "(,4.3.32767]",
+          "System.IO.FileSystem": "(,4.3.32767]",
+          "System.IO.FileSystem.AccessControl": "(,4.4.32767]",
+          "System.IO.FileSystem.DriveInfo": "(,4.3.32767]",
+          "System.IO.FileSystem.Primitives": "(,4.3.32767]",
+          "System.IO.FileSystem.Watcher": "(,4.3.32767]",
+          "System.IO.IsolatedStorage": "(,4.3.32767]",
+          "System.IO.MemoryMappedFiles": "(,4.3.32767]",
+          "System.IO.Pipelines": "(,10.0.32767]",
+          "System.IO.Pipes": "(,4.3.32767]",
+          "System.IO.Pipes.AccessControl": "(,5.0.32767]",
+          "System.IO.UnmanagedMemoryStream": "(,4.3.32767]",
+          "System.Linq": "(,4.3.32767]",
+          "System.Linq.AsyncEnumerable": "(,10.0.32767]",
+          "System.Linq.Expressions": "(,4.3.32767]",
+          "System.Linq.Parallel": "(,4.3.32767]",
+          "System.Linq.Queryable": "(,4.3.32767]",
+          "System.Memory": "(,5.0.32767]",
+          "System.Net.Http": "(,4.3.32767]",
+          "System.Net.Http.Json": "(,10.0.32767]",
+          "System.Net.NameResolution": "(,4.3.32767]",
+          "System.Net.NetworkInformation": "(,4.3.32767]",
+          "System.Net.Ping": "(,4.3.32767]",
+          "System.Net.Primitives": "(,4.3.32767]",
+          "System.Net.Requests": "(,4.3.32767]",
+          "System.Net.Security": "(,4.3.32767]",
+          "System.Net.ServerSentEvents": "(,10.0.32767]",
+          "System.Net.Sockets": "(,4.3.32767]",
+          "System.Net.WebHeaderCollection": "(,4.3.32767]",
+          "System.Net.WebSockets": "(,4.3.32767]",
+          "System.Net.WebSockets.Client": "(,4.3.32767]",
+          "System.Numerics.Vectors": "(,5.0.32767]",
+          "System.ObjectModel": "(,4.3.32767]",
+          "System.Private.DataContractSerialization": "(,4.3.32767]",
+          "System.Private.Uri": "(,4.3.32767]",
+          "System.Reflection": "(,4.3.32767]",
+          "System.Reflection.DispatchProxy": "(,6.0.32767]",
+          "System.Reflection.Emit": "(,4.7.32767]",
+          "System.Reflection.Emit.ILGeneration": "(,4.7.32767]",
+          "System.Reflection.Emit.Lightweight": "(,4.7.32767]",
+          "System.Reflection.Extensions": "(,4.3.32767]",
+          "System.Reflection.Metadata": "(,10.0.32767]",
+          "System.Reflection.Primitives": "(,4.3.32767]",
+          "System.Reflection.TypeExtensions": "(,4.3.32767]",
+          "System.Resources.Reader": "(,4.3.32767]",
+          "System.Resources.ResourceManager": "(,4.3.32767]",
+          "System.Resources.Writer": "(,4.3.32767]",
+          "System.Runtime": "(,4.3.32767]",
+          "System.Runtime.CompilerServices.Unsafe": "(,7.0.32767]",
+          "System.Runtime.CompilerServices.VisualC": "(,4.3.32767]",
+          "System.Runtime.Extensions": "(,4.3.32767]",
+          "System.Runtime.Handles": "(,4.3.32767]",
+          "System.Runtime.InteropServices": "(,4.3.32767]",
+          "System.Runtime.InteropServices.RuntimeInformation": "(,4.3.32767]",
+          "System.Runtime.Loader": "(,4.3.32767]",
+          "System.Runtime.Numerics": "(,4.3.32767]",
+          "System.Runtime.Serialization.Formatters": "(,4.3.32767]",
+          "System.Runtime.Serialization.Json": "(,4.3.32767]",
+          "System.Runtime.Serialization.Primitives": "(,4.3.32767]",
+          "System.Runtime.Serialization.Xml": "(,4.3.32767]",
+          "System.Security.AccessControl": "(,6.0.32767]",
+          "System.Security.Claims": "(,4.3.32767]",
+          "System.Security.Cryptography.Algorithms": "(,4.3.32767]",
+          "System.Security.Cryptography.Cng": "(,5.0.32767]",
+          "System.Security.Cryptography.Csp": "(,4.3.32767]",
+          "System.Security.Cryptography.Encoding": "(,4.3.32767]",
+          "System.Security.Cryptography.OpenSsl": "(,5.0.32767]",
+          "System.Security.Cryptography.Primitives": "(,4.3.32767]",
+          "System.Security.Cryptography.X509Certificates": "(,4.3.32767]",
+          "System.Security.Principal": "(,4.3.32767]",
+          "System.Security.Principal.Windows": "(,5.0.32767]",
+          "System.Security.SecureString": "(,4.3.32767]",
+          "System.Text.Encoding": "(,4.3.32767]",
+          "System.Text.Encoding.CodePages": "(,10.0.32767]",
+          "System.Text.Encoding.Extensions": "(,4.3.32767]",
+          "System.Text.Encodings.Web": "(,10.0.32767]",
+          "System.Text.Json": "(,10.0.32767]",
+          "System.Text.RegularExpressions": "(,4.3.32767]",
+          "System.Threading": "(,4.3.32767]",
+          "System.Threading.AccessControl": "(,10.0.32767]",
+          "System.Threading.Channels": "(,10.0.32767]",
+          "System.Threading.Overlapped": "(,4.3.32767]",
+          "System.Threading.Tasks": "(,4.3.32767]",
+          "System.Threading.Tasks.Dataflow": "(,10.0.32767]",
+          "System.Threading.Tasks.Extensions": "(,5.0.32767]",
+          "System.Threading.Tasks.Parallel": "(,4.3.32767]",
+          "System.Threading.Thread": "(,4.3.32767]",
+          "System.Threading.ThreadPool": "(,4.3.32767]",
+          "System.Threading.Timer": "(,4.3.32767]",
+          "System.ValueTuple": "(,4.5.32767]",
+          "System.Xml.ReaderWriter": "(,4.3.32767]",
+          "System.Xml.XDocument": "(,4.3.32767]",
+          "System.Xml.XmlDocument": "(,4.3.32767]",
+          "System.Xml.XmlSerializer": "(,4.3.32767]",
+          "System.Xml.XPath": "(,4.3.32767]",
+          "System.Xml.XPath.XDocument": "(,5.0.32767]"
+        }
+      }
+    }
+  }
+}

src/Jellyfin.Extensions/obj/project.nuget.cache

@@ -0,0 +1,24 @@
+{
+  "version": 2,
+  "dgSpecHash": "ayxAauhDil8=",
+  "success": true,
+  "projectFilePath": "/srv/common_drive/Projects/pgsql-jellyfin/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj",
+  "expectedPackageFiles": [
+    "/home/wjones/.nuget/packages/diacritics/4.1.4/diacritics.4.1.4.nupkg.sha512",
+    "/home/wjones/.nuget/packages/icu4n/60.1.0-alpha.356/icu4n.60.1.0-alpha.356.nupkg.sha512",
+    "/home/wjones/.nuget/packages/icu4n.transliterator/60.1.0-alpha.356/icu4n.transliterator.60.1.0-alpha.356.nupkg.sha512",
+    "/home/wjones/.nuget/packages/idisposableanalyzers/4.0.8/idisposableanalyzers.4.0.8.nupkg.sha512",
+    "/home/wjones/.nuget/packages/j2n/2.0.0/j2n.2.0.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/microsoft.codeanalysis.bannedapianalyzers/4.14.0/microsoft.codeanalysis.bannedapianalyzers.4.14.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/microsoft.extensions.caching.abstractions/2.0.0/microsoft.extensions.caching.abstractions.2.0.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/microsoft.extensions.caching.memory/2.0.0/microsoft.extensions.caching.memory.2.0.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/microsoft.extensions.dependencyinjection.abstractions/2.0.0/microsoft.extensions.dependencyinjection.abstractions.2.0.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/microsoft.extensions.options/2.0.0/microsoft.extensions.options.2.0.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/microsoft.extensions.primitives/2.0.0/microsoft.extensions.primitives.2.0.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/seriloganalyzer/0.15.0/seriloganalyzer.0.15.0.nupkg.sha512",
+    "/home/wjones/.nuget/packages/smartanalyzers.multithreadinganalyzer/1.1.31/smartanalyzers.multithreadinganalyzer.1.1.31.nupkg.sha512",
+    "/home/wjones/.nuget/packages/stylecop.analyzers/1.2.0-beta.556/stylecop.analyzers.1.2.0-beta.556.nupkg.sha512",
+    "/home/wjones/.nuget/packages/stylecop.analyzers.unstable/1.2.0.556/stylecop.analyzers.unstable.1.2.0.556.nupkg.sha512"
+  ],
+  "logs": []
+}

src/Jellyfin.Extensions/obj/rider.project.model.nuget.info

@@ -0,0 +1 @@
+17714532042500000

src/Jellyfin.Extensions/obj/rider.project.restore.info

@@ -0,0 +1 @@
+17715044201300000