using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using FxResources.Microsoft.Extensions.Configuration;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.Configuration.Memory;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Internal;
using Microsoft.Extensions.Primitives;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Microsoft.Extensions.Configuration.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("Microsoft.Extensions.Configuration")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("Implementation of key-value pair based configuration for Microsoft.Extensions.Configuration. Includes the memory configuration provider.")]
[assembly: AssemblyFileVersion("9.0.24.52809")]
[assembly: AssemblyInformationalVersion("9.0.0+9d5a6a9aa463d6d10b0b0ba6d5982cc82f363dc3")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("Microsoft.Extensions.Configuration")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: AssemblyVersion("9.0.0.0")]
[module: RefSafetyRules(11)]
[module: System.Runtime.CompilerServices.NullablePublicOnly(true)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FxResources.Microsoft.Extensions.Configuration
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class ThrowHelper
	{
		internal static void ThrowIfNull(object? argument, [CallerArgumentExpression("argument")] string? paramName = null)
		{
			if (argument == null)
			{
				Throw(paramName);
			}
		}

		private static void Throw(string paramName)
		{
			throw new ArgumentNullException(paramName);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string IfNullOrWhitespace(string? argument, [CallerArgumentExpression("argument")] string paramName = "")
		{
			if (argument == null)
			{
				throw new ArgumentNullException(paramName);
			}
			if (string.IsNullOrWhiteSpace(argument))
			{
				if (argument == null)
				{
					throw new ArgumentNullException(paramName);
				}
				throw new ArgumentException(paramName, "Argument is whitespace");
			}
			return argument;
		}
	}
	internal static class SR
	{
		private static readonly bool s_usingResourceKeys = GetUsingResourceKeysSwitchValue();

		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(typeof(SR)));

		internal static string Error_NoSources => GetResourceString("Error_NoSources");

		internal static string InvalidNullArgument => GetResourceString("InvalidNullArgument");

		internal static string StreamConfigurationProvidersAlreadyLoaded => GetResourceString("StreamConfigurationProvidersAlreadyLoaded");

		internal static string StreamConfigurationSourceStreamCannotBeNull => GetResourceString("StreamConfigurationSourceStreamCannotBeNull");

		private static bool GetUsingResourceKeysSwitchValue()
		{
			if (!AppContext.TryGetSwitch("System.Resources.UseSystemResourceKeys", out var isEnabled))
			{
				return false;
			}
			return isEnabled;
		}

		internal static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		private static string GetResourceString(string resourceKey)
		{
			if (UsingResourceKeys())
			{
				return resourceKey;
			}
			string result = null;
			try
			{
				result = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			return result;
		}

		private static string GetResourceString(string resourceKey, string defaultString)
		{
			string resourceString = GetResourceString(resourceKey);
			if (!(resourceKey == resourceString) && resourceString != null)
			{
				return resourceString;
			}
			return defaultString;
		}

		internal static string Format(string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}

		internal static string Format(string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(provider, resourceFormat, p1);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(provider, resourceFormat, p1, p2);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(provider, resourceFormat, p1, p2, p3);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(provider, resourceFormat, args);
			}
			return resourceFormat;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class LibraryImportAttribute : Attribute
	{
		public string LibraryName { get; }

		public string? EntryPoint { get; set; }

		public StringMarshalling StringMarshalling { get; set; }

		public Type? StringMarshallingCustomType { get; set; }

		public bool SetLastError { get; set; }

		public LibraryImportAttribute(string libraryName)
		{
			LibraryName = libraryName;
		}
	}
	internal enum StringMarshalling
	{
		Custom,
		Utf8,
		Utf16
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
}
namespace Microsoft.Extensions.FileProviders
{
	internal sealed class EmptyDisposable : IDisposable
	{
		public static EmptyDisposable Instance { get; } = new EmptyDisposable();


		private EmptyDisposable()
		{
		}

		public void Dispose()
		{
		}
	}
}
namespace Microsoft.Extensions.Internal
{
	internal static class ChangeCallbackRegistrar
	{
		internal static IDisposable UnsafeRegisterChangeCallback<T>(Action<object?> callback, object? state, CancellationToken token, Action<T> onFailure, T onFailureState)
		{
			bool flag = false;
			if (!ExecutionContext.IsFlowSuppressed())
			{
				ExecutionContext.SuppressFlow();
				flag = true;
			}
			try
			{
				return token.Register(callback, state);
			}
			catch (ObjectDisposedException)
			{
				onFailure(onFailureState);
			}
			finally
			{
				if (flag)
				{
					ExecutionContext.RestoreFlow();
				}
			}
			return EmptyDisposable.Instance;
		}
	}
}
namespace Microsoft.Extensions.Configuration
{
	public static class ChainedBuilderExtensions
	{
		public static IConfigurationBuilder AddConfiguration(this IConfigurationBuilder configurationBuilder, IConfiguration config)
		{
			return configurationBuilder.AddConfiguration(config, shouldDisposeConfiguration: false);
		}

		public static IConfigurationBuilder AddConfiguration(this IConfigurationBuilder configurationBuilder, IConfiguration config, bool shouldDisposeConfiguration)
		{
			System.ThrowHelper.ThrowIfNull(configurationBuilder, "configurationBuilder");
			System.ThrowHelper.ThrowIfNull(config, "config");
			configurationBuilder.Add(new ChainedConfigurationSource
			{
				Configuration = config,
				ShouldDisposeConfiguration = shouldDisposeConfiguration
			});
			return configurationBuilder;
		}
	}
	public class ChainedConfigurationProvider : IConfigurationProvider, IDisposable
	{
		private readonly IConfiguration _config;

		private readonly bool _shouldDisposeConfig;

		public IConfiguration Configuration => _config;

		public ChainedConfigurationProvider(ChainedConfigurationSource source)
		{
			System.ThrowHelper.ThrowIfNull(source, "source");
			_config = source.Configuration ?? throw new ArgumentException(System.SR.Format(System.SR.InvalidNullArgument, "source.Configuration"), "source");
			_shouldDisposeConfig = source.ShouldDisposeConfiguration;
		}

		public bool TryGet(string key, out string? value)
		{
			value = _config[key];
			return !string.IsNullOrEmpty(value);
		}

		public void Set(string key, string? value)
		{
			_config[key] = value;
		}

		public IChangeToken GetReloadToken()
		{
			return _config.GetReloadToken();
		}

		public void Load()
		{
		}

		public IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string? parentPath)
		{
			IConfiguration configuration;
			if (parentPath != null)
			{
				IConfiguration section = _config.GetSection(parentPath);
				configuration = section;
			}
			else
			{
				configuration = _config;
			}
			List<string> list = new List<string>();
			foreach (IConfigurationSection child in configuration.GetChildren())
			{
				list.Add(child.Key);
			}
			list.AddRange(earlierKeys);
			list.Sort(ConfigurationKeyComparer.Comparison);
			return list;
		}

		public void Dispose()
		{
			if (_shouldDisposeConfig)
			{
				(_config as IDisposable)?.Dispose();
			}
		}
	}
	public class ChainedConfigurationSource : IConfigurationSource
	{
		public IConfiguration? Configuration
		{
			get; [param: DisallowNull]
			set;
		}

		public bool ShouldDisposeConfiguration { get; set; }

		public IConfigurationProvider Build(IConfigurationBuilder builder)
		{
			return new ChainedConfigurationProvider(this);
		}
	}
	public class ConfigurationBuilder : IConfigurationBuilder
	{
		private readonly List<IConfigurationSource> _sources = new List<IConfigurationSource>();

		public IList<IConfigurationSource> Sources => _sources;

		public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();


		public IConfigurationBuilder Add(IConfigurationSource source)
		{
			System.ThrowHelper.ThrowIfNull(source, "source");
			_sources.Add(source);
			return this;
		}

		public IConfigurationRoot Build()
		{
			List<IConfigurationProvider> list = new List<IConfigurationProvider>();
			foreach (IConfigurationSource source in _sources)
			{
				IConfigurationProvider item = source.Build(this);
				list.Add(item);
			}
			return new ConfigurationRoot(list);
		}
	}
	public class ConfigurationKeyComparer : IComparer<string>
	{
		private const char KeyDelimiter = ':';

		public static ConfigurationKeyComparer Instance { get; } = new ConfigurationKeyComparer();


		internal static Comparison<string> Comparison { get; } = Instance.Compare;


		public int Compare(string? x, string? y)
		{
			ReadOnlySpan<char> readOnlySpan = x.AsSpan();
			ReadOnlySpan<char> readOnlySpan2 = y.AsSpan();
			readOnlySpan = SkipAheadOnDelimiter(readOnlySpan);
			readOnlySpan2 = SkipAheadOnDelimiter(readOnlySpan2);
			while (!readOnlySpan.IsEmpty && !readOnlySpan2.IsEmpty)
			{
				int num = readOnlySpan.IndexOf(':');
				int num2 = readOnlySpan2.IndexOf(':');
				int num3 = Compare((num == -1) ? readOnlySpan : readOnlySpan.Slice(0, num), (num2 == -1) ? readOnlySpan2 : readOnlySpan2.Slice(0, num2));
				if (num3 != 0)
				{
					return num3;
				}
				readOnlySpan = ((num == -1) ? default(ReadOnlySpan<char>) : SkipAheadOnDelimiter(readOnlySpan.Slice(num + 1)));
				readOnlySpan2 = ((num2 == -1) ? default(ReadOnlySpan<char>) : SkipAheadOnDelimiter(readOnlySpan2.Slice(num2 + 1)));
			}
			if (!readOnlySpan.IsEmpty)
			{
				return 1;
			}
			if (!readOnlySpan2.IsEmpty)
			{
				return -1;
			}
			return 0;
			static int Compare(ReadOnlySpan<char> a, ReadOnlySpan<char> b)
			{
				int result;
				bool flag = int.TryParse(a.ToString(), out result);
				int result2;
				bool flag2 = int.TryParse(b.ToString(), out result2);
				if (!flag && !flag2)
				{
					return a.CompareTo(b, StringComparison.OrdinalIgnoreCase);
				}
				if (flag && flag2)
				{
					return result - result2;
				}
				return (!flag) ? 1 : (-1);
			}
			static ReadOnlySpan<char> SkipAheadOnDelimiter(ReadOnlySpan<char> a)
			{
				while (!a.IsEmpty && a[0] == ':')
				{
					a = a.Slice(1);
				}
				return a;
			}
		}
	}
	[DebuggerDisplay("{DebuggerToString(),nq}")]
	[DebuggerTypeProxy(typeof(ConfigurationManagerDebugView))]
	public sealed class ConfigurationManager : IConfigurationManager, IConfiguration, IConfigurationBuilder, IConfigurationRoot, IDisposable
	{
		private sealed class ConfigurationManagerDebugView
		{
			private readonly ConfigurationManager _current;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public ConfigurationSectionDebugView[] Items => ConfigurationSectionDebugView.FromConfiguration(_current, _current).ToArray();

			public ConfigurationManagerDebugView(ConfigurationManager current)
			{
				_current = current;
			}
		}

		private sealed class ConfigurationSources : IList<IConfigurationSource>, ICollection<IConfigurationSource>, IEnumerable<IConfigurationSource>, IEnumerable
		{
			private readonly List<IConfigurationSource> _sources = new List<IConfigurationSource>();

			private readonly ConfigurationManager _config;

			public IConfigurationSource this[int index]
			{
				get
				{
					return _sources[index];
				}
				set
				{
					_sources[index] = value;
					_config.ReloadSources();
				}
			}

			public int Count => _sources.Count;

			public bool IsReadOnly => false;

			public ConfigurationSources(ConfigurationManager config)
			{
				_config = config;
			}

			public void Add(IConfigurationSource source)
			{
				_sources.Add(source);
				_config.AddSource(source);
			}

			public void Clear()
			{
				_sources.Clear();
				_config.ReloadSources();
			}

			public bool Contains(IConfigurationSource source)
			{
				return _sources.Contains(source);
			}

			public void CopyTo(IConfigurationSource[] array, int arrayIndex)
			{
				_sources.CopyTo(array, arrayIndex);
			}

			public List<IConfigurationSource>.Enumerator GetEnumerator()
			{
				return _sources.GetEnumerator();
			}

			public int IndexOf(IConfigurationSource source)
			{
				return _sources.IndexOf(source);
			}

			public void Insert(int index, IConfigurationSource source)
			{
				_sources.Insert(index, source);
				_config.ReloadSources();
			}

			public bool Remove(IConfigurationSource source)
			{
				bool result = _sources.Remove(source);
				_config.ReloadSources();
				return result;
			}

			public void RemoveAt(int index)
			{
				_sources.RemoveAt(index);
				_config.ReloadSources();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator<IConfigurationSource> IEnumerable<IConfigurationSource>.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		private sealed class ConfigurationBuilderProperties : IDictionary<string, object>, ICollection<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string, object>>, IEnumerable
		{
			private readonly Dictionary<string, object> _properties = new Dictionary<string, object>();

			private readonly ConfigurationManager _config;

			public object this[string key]
			{
				get
				{
					return _properties[key];
				}
				set
				{
					_properties[key] = value;
					_config.ReloadSources();
				}
			}

			public ICollection<string> Keys => _properties.Keys;

			public ICollection<object> Values => _properties.Values;

			public int Count => _properties.Count;

			public bool IsReadOnly => false;

			public ConfigurationBuilderProperties(ConfigurationManager config)
			{
				_config = config;
			}

			public void Add(string key, object value)
			{
				_properties.Add(key, value);
				_config.ReloadSources();
			}

			public void Add(KeyValuePair<string, object> item)
			{
				((ICollection<KeyValuePair<string, object>>)_properties).Add(item);
				_config.ReloadSources();
			}

			public void Clear()
			{
				_properties.Clear();
				_config.ReloadSources();
			}

			public bool Contains(KeyValuePair<string, object> item)
			{
				return _properties.Contains(item);
			}

			public bool ContainsKey(string key)
			{
				return _properties.ContainsKey(key);
			}

			public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
			{
				((ICollection<KeyValuePair<string, object>>)_properties).CopyTo(array, arrayIndex);
			}

			public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
			{
				return _properties.GetEnumerator();
			}

			public bool Remove(string key)
			{
				bool result = _properties.Remove(key);
				_config.ReloadSources();
				return result;
			}

			public bool Remove(KeyValuePair<string, object> item)
			{
				bool result = ((ICollection<KeyValuePair<string, object>>)_properties).Remove(item);
				_config.ReloadSources();
				return result;
			}

			public bool TryGetValue(string key, [NotNullWhen(true)] out object value)
			{
				return _properties.TryGetValue(key, out value);
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return _properties.GetEnumerator();
			}
		}

		private readonly ConfigurationSources _sources;

		private readonly ConfigurationBuilderProperties _properties;

		private readonly ReferenceCountedProviderManager _providerManager = new ReferenceCountedProviderManager();

		private readonly List<IDisposable> _changeTokenRegistrations = new List<IDisposable>();

		private ConfigurationReloadToken _changeToken = new ConfigurationReloadToken();

		public string? this[string key]
		{
			get
			{
				using ReferenceCountedProviders referenceCountedProviders = _providerManager.GetReference();
				return ConfigurationRoot.GetConfiguration(referenceCountedProviders.Providers, key);
			}
			set
			{
				using ReferenceCountedProviders referenceCountedProviders = _providerManager.GetReference();
				ConfigurationRoot.SetConfiguration(referenceCountedProviders.Providers, key, value);
			}
		}

		IDictionary<string, object> IConfigurationBuilder.Properties => _properties;

		public IList<IConfigurationSource> Sources => _sources;

		IEnumerable<IConfigurationProvider> IConfigurationRoot.Providers => _providerManager.NonReferenceCountedProviders;

		public ConfigurationManager()
		{
			_sources = new ConfigurationSources(this);
			_properties = new ConfigurationBuilderProperties(this);
			_sources.Add(new MemoryConfigurationSource());
		}

		public IConfigurationSection GetSection(string key)
		{
			return new ConfigurationSection(this, key);
		}

		public IEnumerable<IConfigurationSection> GetChildren()
		{
			return this.GetChildrenImplementation(null);
		}

		public void Dispose()
		{
			DisposeRegistrations();
			_providerManager.Dispose();
		}

		IConfigurationBuilder IConfigurationBuilder.Add(IConfigurationSource source)
		{
			System.ThrowHelper.ThrowIfNull(source, "source");
			_sources.Add(source);
			return this;
		}

		IConfigurationRoot IConfigurationBuilder.Build()
		{
			return this;
		}

		IChangeToken IConfiguration.GetReloadToken()
		{
			return _changeToken;
		}

		void IConfigurationRoot.Reload()
		{
			using (ReferenceCountedProviders referenceCountedProviders = _providerManager.GetReference())
			{
				foreach (IConfigurationProvider provider in referenceCountedProviders.Providers)
				{
					provider.Load();
				}
			}
			RaiseChanged();
		}

		internal ReferenceCountedProviders GetProvidersReference()
		{
			return _providerManager.GetReference();
		}

		private void RaiseChanged()
		{
			Interlocked.Exchange(ref _changeToken, new ConfigurationReloadToken()).OnReload();
		}

		private void AddSource(IConfigurationSource source)
		{
			IConfigurationProvider configurationProvider = source.Build(this);
			configurationProvider.Load();
			_changeTokenRegistrations.Add(ChangeToken.OnChange(configurationProvider.GetReloadToken, RaiseChanged));
			_providerManager.AddProvider(configurationProvider);
			RaiseChanged();
		}

		private void ReloadSources()
		{
			DisposeRegistrations();
			_changeTokenRegistrations.Clear();
			List<IConfigurationProvider> list = new List<IConfigurationProvider>();
			foreach (IConfigurationSource source in _sources)
			{
				list.Add(source.Build(this));
			}
			foreach (IConfigurationProvider item in list)
			{
				item.Load();
				_changeTokenRegistrations.Add(ChangeToken.OnChange(item.GetReloadToken, RaiseChanged));
			}
			_providerManager.ReplaceProviders(list);
			RaiseChanged();
		}

		private void DisposeRegistrations()
		{
			foreach (IDisposable changeTokenRegistration in _changeTokenRegistrations)
			{
				changeTokenRegistration.Dispose();
			}
		}

		private string DebuggerToString()
		{
			return $"Sections = {ConfigurationSectionDebugView.FromConfiguration(this, this).Count}";
		}
	}
	public abstract class ConfigurationProvider : IConfigurationProvider
	{
		private ConfigurationReloadToken _reloadToken = new ConfigurationReloadToken();

		protected IDictionary<string, string?> Data { get; set; }

		protected ConfigurationProvider()
		{
			Data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
		}

		public virtual bool TryGet(string key, out string? value)
		{
			return Data.TryGetValue(key, out value);
		}

		public virtual void Set(string key, string? value)
		{
			Data[key] = value;
		}

		public virtual void Load()
		{
		}

		public virtual IEnumerable<string> GetChildKeys(IEnumerable<string> earlierKeys, string? parentPath)
		{
			List<string> list = new List<string>();
			if (parentPath == null)
			{
				foreach (KeyValuePair<string, string> datum in Data)
				{
					list.Add(Segment(datum.Key, 0));
				}
			}
			else
			{
				foreach (KeyValuePair<string, string> datum2 in Data)
				{
					if (datum2.Key.Length > parentPath.Length && datum2.Key.StartsWith(parentPath, StringComparison.OrdinalIgnoreCase) && datum2.Key[parentPath.Length] == ':')
					{
						list.Add(Segment(datum2.Key, parentPath.Length + 1));
					}
				}
			}
			list.AddRange(earlierKeys);
			list.Sort(ConfigurationKeyComparer.Comparison);
			return list;
		}

		private static string Segment(string key, int prefixLength)
		{
			int num = key.IndexOf(':', prefixLength);
			if (num >= 0)
			{
				return key.Substring(prefixLength, num - prefixLength);
			}
			return key.Substring(prefixLength);
		}

		public IChangeToken GetReloadToken()
		{
			return _reloadToken;
		}

		protected void OnReload()
		{
			Interlocked.Exchange(ref _reloadToken, new ConfigurationReloadToken()).OnReload();
		}

		public override string ToString()
		{
			return GetType().Name;
		}
	}
	public class ConfigurationReloadToken : IChangeToken
	{
		private readonly CancellationTokenSource _cts = new CancellationTokenSource();

		public bool ActiveChangeCallbacks { get; private set; } = true;


		public bool HasChanged => _cts.IsCancellationRequested;

		public IDisposable RegisterChangeCallback(Action<object?> callback, object? state)
		{
			return ChangeCallbackRegistrar.UnsafeRegisterChangeCallback(callback, state, _cts.Token, delegate(ConfigurationReloadToken s)
			{
				s.ActiveChangeCallbacks = false;
			}, this);
		}

		public void OnReload()
		{
			_cts.Cancel();
		}
	}
	[DebuggerDisplay("{DebuggerToString(),nq}")]
	[DebuggerTypeProxy(typeof(ConfigurationRootDebugView))]
	public class ConfigurationRoot : IConfigurationRoot, IConfiguration, IDisposable
	{
		private sealed class ConfigurationRootDebugView
		{
			private readonly ConfigurationRoot _current;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public ConfigurationSectionDebugView[] Items => ConfigurationSectionDebugView.FromConfiguration(_current, _current).ToArray();

			public ConfigurationRootDebugView(ConfigurationRoot current)
			{
				_current = current;
			}
		}

		private readonly IList<IConfigurationProvider> _providers;

		private readonly List<IDisposable> _changeTokenRegistrations;

		private ConfigurationReloadToken _changeToken = new ConfigurationReloadToken();

		public IEnumerable<IConfigurationProvider> Providers => _providers;

		public string? this[string key]
		{
			get
			{
				return GetConfiguration(_providers, key);
			}
			set
			{
				SetConfiguration(_providers, key, value);
			}
		}

		public ConfigurationRoot(IList<IConfigurationProvider> providers)
		{
			System.ThrowHelper.ThrowIfNull(providers, "providers");
			_providers = providers;
			_changeTokenRegistrations = new List<IDisposable>(providers.Count);
			foreach (IConfigurationProvider provider in providers)
			{
				provider.Load();
				_changeTokenRegistrations.Add(ChangeToken.OnChange(provider.GetReloadToken, RaiseChanged));
			}
		}

		public IEnumerable<IConfigurationSection> GetChildren()
		{
			return this.GetChildrenImplementation(null);
		}

		public IChangeToken GetReloadToken()
		{
			return _changeToken;
		}

		public IConfigurationSection GetSection(string key)
		{
			return new ConfigurationSection(this, key);
		}

		public void Reload()
		{
			foreach (IConfigurationProvider provider in _providers)
			{
				provider.Load();
			}
			RaiseChanged();
		}

		private void RaiseChanged()
		{
			Interlocked.Exchange(ref _changeToken, new ConfigurationReloadToken()).OnReload();
		}

		public void Dispose()
		{
			foreach (IDisposable changeTokenRegistration in _changeTokenRegistrations)
			{
				changeTokenRegistration.Dispose();
			}
			foreach (IConfigurationProvider provider in _providers)
			{
				(provider as IDisposable)?.Dispose();
			}
		}

		internal static string? GetConfiguration(IList<IConfigurationProvider> providers, string key)
		{
			for (int num = providers.Count - 1; num >= 0; num--)
			{
				if (providers[num].TryGet(key, out var value))
				{
					return value;
				}
			}
			return null;
		}

		internal static void SetConfiguration(IList<IConfigurationProvider> providers, string key, string? value)
		{
			if (providers.Count == 0)
			{
				throw new InvalidOperationException(System.SR.Error_NoSources);
			}
			foreach (IConfigurationProvider provider in providers)
			{
				provider.Set(key, value);
			}
		}

		private string DebuggerToString()
		{
			return $"Sections = {ConfigurationSectionDebugView.FromConfiguration(this, this).Count}";
		}
	}
	[DebuggerDisplay("{DebuggerToString(),nq}")]
	[DebuggerTypeProxy(typeof(ConfigurationSectionDebugView))]
	public class ConfigurationSection : IConfigurationSection, IConfiguration
	{
		private sealed class ConfigurationSectionDebugView
		{
			private readonly ConfigurationSection _current;

			private readonly IConfigurationProvider _provider;

			public string Path => _current.Path;

			public string Key => _current.Key;

			public string Value => _current.Value;

			public IConfigurationProvider Provider => _provider;

			public List<Microsoft.Extensions.Configuration.ConfigurationSectionDebugView> Sections => Microsoft.Extensions.Configuration.ConfigurationSectionDebugView.FromConfiguration(_current, _current._root);

			public ConfigurationSectionDebugView(ConfigurationSection current)
			{
				_current = current;
				_provider = Microsoft.Extensions.Configuration.ConfigurationSectionDebugView.GetValueProvider(_current._root, _current.Path);
			}
		}

		private readonly IConfigurationRoot _root;

		private readonly string _path;

		private string _key;

		public string Path => _path;

		public string Key => _key ?? (_key = ConfigurationPath.GetSectionKey(_path));

		public string? Value
		{
			get
			{
				return _root[Path];
			}
			set
			{
				_root[Path] = value;
			}
		}

		public string? this[string key]
		{
			get
			{
				return _root[Path + ConfigurationPath.KeyDelimiter + key];
			}
			set
			{
				_root[Path + ConfigurationPath.KeyDelimiter + key] = value;
			}
		}

		public ConfigurationSection(IConfigurationRoot root, string path)
		{
			System.ThrowHelper.ThrowIfNull(root, "root");
			System.ThrowHelper.ThrowIfNull(path, "path");
			_root = root;
			_path = path;
		}

		public IConfigurationSection GetSection(string key)
		{
			return _root.GetSection(Path + ConfigurationPath.KeyDelimiter + key);
		}

		public IEnumerable<IConfigurationSection> GetChildren()
		{
			return _root.GetChildrenImplementation(Path);
		}

		public IChangeToken GetReloadToken()
		{
			return _root.GetReloadToken();
		}

		private string DebuggerToString()
		{
			string text = "Path = " + Path;
			int count = Microsoft.Extensions.Configuration.ConfigurationSectionDebugView.FromConfiguration(this, _root).Count;
			if (count > 0)
			{
				text += $", Sections = {count}";
			}
			if (Value != null)
			{
				text = text + ", Value = " + Value;
				IConfigurationProvider valueProvider = Microsoft.Extensions.Configuration.ConfigurationSectionDebugView.GetValueProvider(_root, Path);
				if (valueProvider != null)
				{
					text += $", Provider = {valueProvider}";
				}
			}
			return text;
		}
	}
	internal sealed class ConfigurationSectionDebugView
	{
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private readonly IConfigurationSection _section;

		public string Path { get; }

		public string Key => _section.Key;

		public string FullPath => _section.Path;

		public string? Value => _section.Value;

		public IConfigurationProvider? Provider { get; }

		public ConfigurationSectionDebugView(IConfigurationSection section, string path, IConfigurationProvider? provider)
		{
			_section = section;
			Path = path;
			Provider = provider;
		}

		public override string ToString()
		{
			string text = "Path = " + Path;
			if (Value != null)
			{
				text = text + ", Value = " + Value;
			}
			if (Provider != null)
			{
				text += $", Provider = {Provider}";
			}
			return text;
		}

		internal static List<ConfigurationSectionDebugView> FromConfiguration(IConfiguration current, IConfigurationRoot root)
		{
			List<ConfigurationSectionDebugView> list = new List<ConfigurationSectionDebugView>();
			Stack<IConfiguration> stack = new Stack<IConfiguration>();
			stack.Push(current);
			int startIndex = ((current is IConfigurationSection configurationSection) ? (configurationSection.Path.Length + 1) : 0);
			while (stack.Count > 0)
			{
				IConfiguration configuration = stack.Pop();
				if (configuration is IConfigurationSection configurationSection2 && configuration != current)
				{
					IConfigurationProvider valueProvider = GetValueProvider(root, configurationSection2.Path);
					string path = configurationSection2.Path.Substring(startIndex);
					list.Add(new ConfigurationSectionDebugView(configurationSection2, path, valueProvider));
				}
				foreach (IConfigurationSection child in configuration.GetChildren())
				{
					stack.Push(child);
				}
			}
			list.Sort((ConfigurationSectionDebugView i1, ConfigurationSectionDebugView i2) => ConfigurationKeyComparer.Instance.Compare(i1.Path, i2.Path));
			return list;
		}

		internal static IConfigurationProvider? GetValueProvider(IConfigurationRoot root, string key)
		{
			foreach (IConfigurationProvider item in root.Providers.Reverse())
			{
				if (item.TryGet(key, out var _))
				{
					return item;
				}
			}
			return null;
		}
	}
	internal static class InternalConfigurationRootExtensions
	{
		internal static IEnumerable<IConfigurationSection> GetChildrenImplementation(this IConfigurationRoot root, string? path)
		{
			string path2 = path;
			IConfigurationRoot root2 = root;
			using ReferenceCountedProviders referenceCountedProviders = (root2 as ConfigurationManager)?.GetProvidersReference();
			IEnumerable<IConfigurationProvider> enumerable = referenceCountedProviders?.Providers;
			IEnumerable<IConfigurationSection> enumerable2 = from key in (enumerable ?? root2.Providers).Aggregate(Enumerable.Empty<string>(), (IEnumerable<string> seed, IConfigurationProvider source) => source.GetChildKeys(seed, path2)).Distinct<string>(StringComparer.OrdinalIgnoreCase)
				select root2.GetSection((path2 == null) ? key : (path2 + ConfigurationPath.KeyDelimiter + key));
			if (referenceCountedProviders == null)
			{
				return enumerable2;
			}
			return enumerable2.ToList();
		}
	}
	public static class MemoryConfigurationBuilderExtensions
	{
		public static IConfigurationBuilder AddInMemoryCollection(this IConfigurationBuilder configurationBuilder)
		{
			System.ThrowHelper.ThrowIfNull(configurationBuilder, "configurationBuilder");
			configurationBuilder.Add(new MemoryConfigurationSource());
			return configurationBuilder;
		}

		public static IConfigurationBuilder AddInMemoryCollection(this IConfigurationBuilder configurationBuilder, IEnumerable<KeyValuePair<string, string?>>? initialData)
		{
			System.ThrowHelper.ThrowIfNull(configurationBuilder, "configurationBuilder");
			configurationBuilder.Add(new MemoryConfigurationSource
			{
				InitialData = initialData
			});
			return configurationBuilder;
		}
	}
	internal abstract class ReferenceCountedProviders : IDisposable
	{
		private sealed class ActiveReferenceCountedProviders : ReferenceCountedProviders
		{
			private long _refCount = 1L;

			private volatile List<IConfigurationProvider> _providers;

			public override List<IConfigurationProvider> Providers
			{
				get
				{
					return _providers;
				}
				set
				{
					_providers = value;
				}
			}

			public override List<IConfigurationProvider> NonReferenceCountedProviders => _providers;

			public ActiveReferenceCountedProviders(List<IConfigurationProvider> providers)
			{
				_providers = providers;
			}

			public override void AddReference()
			{
				Interlocked.Increment(ref _refCount);
			}

			public override void Dispose()
			{
				if (Interlocked.Decrement(ref _refCount) != 0L)
				{
					return;
				}
				foreach (IConfigurationProvider provider in _providers)
				{
					(provider as IDisposable)?.Dispose();
				}
			}
		}

		private sealed class DisposedReferenceCountedProviders : ReferenceCountedProviders
		{
			public override List<IConfigurationProvider> Providers { get; set; }

			public override List<IConfigurationProvider> NonReferenceCountedProviders => Providers;

			public DisposedReferenceCountedProviders(List<IConfigurationProvider> providers)
			{
				Providers = providers;
			}

			public override void AddReference()
			{
			}

			public override void Dispose()
			{
			}
		}

		public abstract List<IConfigurationProvider> Providers { get; set; }

		public abstract List<IConfigurationProvider> NonReferenceCountedProviders { get; }

		public static ReferenceCountedProviders Create(List<IConfigurationProvider> providers)
		{
			return new ActiveReferenceCountedProviders(providers);
		}

		public static ReferenceCountedProviders CreateDisposed(List<IConfigurationProvider> providers)
		{
			return new DisposedReferenceCountedProviders(providers);
		}

		public abstract void AddReference();

		public abstract void Dispose();
	}
	internal sealed class ReferenceCountedProviderManager : IDisposable
	{
		private readonly object _replaceProvidersLock = new object();

		private ReferenceCountedProviders _refCountedProviders = ReferenceCountedProviders.Create(new List<IConfigurationProvider>());

		private bool _disposed;

		public IEnumerable<IConfigurationProvider> NonReferenceCountedProviders => _refCountedProviders.NonReferenceCountedProviders;

		public ReferenceCountedProviders GetReference()
		{
			lock (_replaceProvidersLock)
			{
				if (_disposed)
				{
					return ReferenceCountedProviders.CreateDisposed(_refCountedProviders.NonReferenceCountedProviders);
				}
				_refCountedProviders.AddReference();
				return _refCountedProviders;
			}
		}

		public void ReplaceProviders(List<IConfigurationProvider> providers)
		{
			ReferenceCountedProviders refCountedProviders = _refCountedProviders;
			lock (_replaceProvidersLock)
			{
				if (_disposed)
				{
					throw new ObjectDisposedException("ConfigurationManager");
				}
				_refCountedProviders = ReferenceCountedProviders.Create(providers);
			}
			refCountedProviders.Dispose();
		}

		public void AddProvider(IConfigurationProvider provider)
		{
			lock (_replaceProvidersLock)
			{
				if (_disposed)
				{
					throw new ObjectDisposedException("ConfigurationManager");
				}
				_refCountedProviders.Providers = new List<IConfigurationProvider>(_refCountedProviders.Providers) { provider };
			}
		}

		public void Dispose()
		{
			ReferenceCountedProviders refCountedProviders = _refCountedProviders;
			lock (_replaceProvidersLock)
			{
				_disposed = true;
			}
			refCountedProviders.Dispose();
		}
	}
	public abstract class StreamConfigurationProvider : ConfigurationProvider
	{
		private bool _loaded;

		public StreamConfigurationSource Source { get; }

		public StreamConfigurationProvider(StreamConfigurationSource source)
		{
			System.ThrowHelper.ThrowIfNull(source, "source");
			Source = source;
		}

		public abstract void Load(Stream stream);

		public override void Load()
		{
			if (_loaded)
			{
				throw new InvalidOperationException(System.SR.StreamConfigurationProvidersAlreadyLoaded);
			}
			if (Source.Stream == null)
			{
				throw new InvalidOperationException(System.SR.StreamConfigurationSourceStreamCannotBeNull);
			}
			Load(Source.Stream);
			_loaded = true;
		}
	}
	public abstract class StreamConfigurationSource : IConfigurationSource
	{
		public Stream? Stream
		{
			get; [param: DisallowNull]
			set;
		}

		public abstract IConfigurationProvider Build(IConfigurationBuilder builder);
	}
}
namespace Microsoft.Extensions.Configuration.Memory
{
	public class MemoryConfigurationProvider : ConfigurationProvider, IEnumerable<KeyValuePair<string, string?>>, IEnumerable
	{
		private readonly MemoryConfigurationSource _source;

		public MemoryConfigurationProvider(MemoryConfigurationSource source)
		{
			System.ThrowHelper.ThrowIfNull(source, "source");
			_source = source;
			if (_source.InitialData == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> initialDatum in _source.InitialData)
			{
				base.Data.Add(initialDatum.Key, initialDatum.Value);
			}
		}

		public void Add(string key, string? value)
		{
			base.Data.Add(key, value);
		}

		public IEnumerator<KeyValuePair<string, string?>> GetEnumerator()
		{
			return base.Data.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class MemoryConfigurationSource : IConfigurationSource
	{
		public IEnumerable<KeyValuePair<string, string?>>? InitialData { get; set; }

		public IConfigurationProvider Build(IConfigurationBuilder builder)
		{
			return new MemoryConfigurationProvider(this);
		}
	}
}