using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Serilog.Capturing;
using Serilog.Configuration;
using Serilog.Context;
using Serilog.Core;
using Serilog.Core.Enrichers;
using Serilog.Core.Filters;
using Serilog.Core.Pipeline;
using Serilog.Core.Sinks;
using Serilog.Core.Sinks.Batching;
using Serilog.Data;
using Serilog.Debugging;
using Serilog.Events;
using Serilog.Formatting.Json;
using Serilog.Parsing;
using Serilog.Policies;
using Serilog.Rendering;
using Serilog.Settings.KeyValuePairs;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: CLSCompliant(true)]
[assembly: InternalsVisibleTo("Serilog.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100fb8d13fd344a1c6fe0fe83ef33c1080bf30690765bc6eb0df26ebfdf8f21670c64265b30db09f73a0dea5b3db4c9d18dbf6d5a25af5ce9016f281014d79dc3b4201ac646c451830fc7e61a2dfd633d34c39f87b81894191652df5ac63cc40c77f3542f702bda692e6e8a9158353df189007a49da0f3cfd55eb250066b19485ec")]
[assembly: InternalsVisibleTo("Serilog.PerformanceTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100fb8d13fd344a1c6fe0fe83ef33c1080bf30690765bc6eb0df26ebfdf8f21670c64265b30db09f73a0dea5b3db4c9d18dbf6d5a25af5ce9016f281014d79dc3b4201ac646c451830fc7e61a2dfd633d34c39f87b81894191652df5ac63cc40c77f3542f702bda692e6e8a9158353df189007a49da0f3cfd55eb250066b19485ec")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Serilog Contributors")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2013-24 Serilog Contributors")]
[assembly: AssemblyDescription("Simple .NET logging with fully-structured events")]
[assembly: AssemblyFileVersion("4.0.0.0")]
[assembly: AssemblyInformationalVersion("4.0.0-main-573a6287+573a62874260d7a1708f620076b5469f69bc79b3")]
[assembly: AssemblyProduct("Serilog")]
[assembly: AssemblyTitle("Serilog")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/serilog/serilog.git")]
[assembly: AssemblyVersion("4.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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 RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
internal static class Guard
{
	public static T AgainstNull<T>([NoEnumeration][NotNull] T? argument, [CallerArgumentExpression("argument")] string? paramName = null) where T : class
	{
		if (argument == null)
		{
			throw new ArgumentNullException(paramName);
		}
		return argument;
	}
}
namespace System
{
	[ExcludeFromCodeCoverage]
	internal readonly struct Index : IEquatable<Index>
	{
		private static class ThrowHelper
		{
			[DoesNotReturn]
			public static void ThrowValueArgumentOutOfRange_NeedNonNegNumException()
			{
				throw new ArgumentOutOfRangeException("value", "Non-negative number required.");
			}
		}

		private readonly int _value;

		public static Index Start => new Index(0);

		public static Index End => new Index(-1);

		public int Value
		{
			get
			{
				if (_value < 0)
				{
					return ~_value;
				}
				return _value;
			}
		}

		public bool IsFromEnd => _value < 0;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Index(int value, bool fromEnd = false)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			if (fromEnd)
			{
				_value = ~value;
			}
			else
			{
				_value = value;
			}
		}

		private Index(int value)
		{
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Index FromStart(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Index FromEnd(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(~value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int GetOffset(int length)
		{
			int num = _value;
			if (IsFromEnd)
			{
				num += length + 1;
			}
			return num;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Index)
			{
				return _value == ((Index)value)._value;
			}
			return false;
		}

		public bool Equals(Index other)
		{
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value;
		}

		public static implicit operator Index(int value)
		{
			return FromStart(value);
		}

		public override string ToString()
		{
			if (IsFromEnd)
			{
				return ToStringFromEnd();
			}
			return ((uint)Value).ToString();
		}

		private string ToStringFromEnd()
		{
			return "^" + Value;
		}
	}
	[ExcludeFromCodeCoverage]
	internal readonly struct Range : IEquatable<Range>
	{
		private static class HashHelpers
		{
			public static int Combine(int h1, int h2)
			{
				return (((h1 << 5) | (h1 >>> 27)) + h1) ^ h2;
			}
		}

		private static class ThrowHelper
		{
			[DoesNotReturn]
			public static void ThrowArgumentOutOfRangeException()
			{
				throw new ArgumentOutOfRangeException("length");
			}
		}

		public Index Start { get; }

		public Index End { get; }

		public static Range All => Index.Start..Index.End;

		public Range(Index start, Index end)
		{
			Start = start;
			End = end;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Range range && range.Start.Equals(Start))
			{
				return range.End.Equals(End);
			}
			return false;
		}

		public bool Equals(Range other)
		{
			if (other.Start.Equals(Start))
			{
				return other.End.Equals(End);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashHelpers.Combine(Start.GetHashCode(), End.GetHashCode());
		}

		public override string ToString()
		{
			return Start.ToString() + ".." + End;
		}

		public static Range StartAt(Index start)
		{
			return start..Index.End;
		}

		public static Range EndAt(Index end)
		{
			return Index.Start..end;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (int Offset, int Length) GetOffsetAndLength(int length)
		{
			Index start = Start;
			int num = ((!start.IsFromEnd) ? start.Value : (length - start.Value));
			Index end = End;
			int num2 = ((!end.IsFromEnd) ? end.Value : (length - end.Value));
			if ((uint)num2 > (uint)length || (uint)num > (uint)num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return (num, num2 - num);
		}
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class SuppressGCTransitionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnmanagedCallersOnlyAttribute : Attribute
	{
		public Type[]? CallConvs;

		public string? EntryPoint;
	}
}
namespace System.Runtime.CompilerServices2
{
	[AttributeUsage(AttributeTargets.Struct, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class InlineArrayAttribute : Attribute
	{
		public int Length { get; }

		public InlineArrayAttribute(int length)
		{
			Length = length;
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class ObsoletedOSPlatformAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public ObsoletedOSPlatformAttribute(string platformName)
		{
		}

		public ObsoletedOSPlatformAttribute(string platformName, string? message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class SupportedOSPlatformAttribute : Attribute
	{
		public SupportedOSPlatformAttribute(string platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class SupportedOSPlatformGuardAttribute : Attribute
	{
		public SupportedOSPlatformGuardAttribute(string platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class TargetPlatformAttribute : Attribute
	{
		public TargetPlatformAttribute(string platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnsupportedOSPlatformAttribute : Attribute
	{
		public string? Message { get; }

		public UnsupportedOSPlatformAttribute(string platformName)
		{
		}

		public UnsupportedOSPlatformAttribute(string platformName, string? message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnsupportedOSPlatformGuardAttribute : Attribute
	{
		public UnsupportedOSPlatformGuardAttribute(string platformName)
		{
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class DisableRuntimeMarshallingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnsafeAccessorAttribute : Attribute
	{
		public UnsafeAccessorKind Kind { get; }

		public string? Name { get; set; }

		public UnsafeAccessorAttribute(UnsafeAccessorKind kind)
		{
			Kind = kind;
		}
	}
	internal enum UnsafeAccessorKind
	{
		Constructor,
		Method,
		StaticMethod,
		Field,
		StaticField
	}
}
namespace System.Diagnostics
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class StackTraceHiddenAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	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)]
	[ExcludeFromCodeCoverage]
	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;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

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

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class DynamicallyAccessedMembersAttribute : Attribute
	{
		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes = memberTypes;
		}
	}
	[Flags]
	internal enum DynamicallyAccessedMemberTypes
	{
		None = 0,
		PublicParameterlessConstructor = 1,
		PublicConstructors = 3,
		NonPublicConstructors = 4,
		PublicMethods = 8,
		NonPublicMethods = 0x10,
		PublicFields = 0x20,
		NonPublicFields = 0x40,
		PublicNestedTypes = 0x80,
		NonPublicNestedTypes = 0x100,
		PublicProperties = 0x200,
		NonPublicProperties = 0x400,
		PublicEvents = 0x800,
		NonPublicEvents = 0x1000,
		Interfaces = 0x2000,
		All = -1
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class DynamicDependencyAttribute : Attribute
	{
		public string? MemberSignature { get; }

		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public Type? Type { get; }

		public string? TypeName { get; }

		public string? AssemblyName { get; }

		public string? Condition { get; set; }

		public DynamicDependencyAttribute(string memberSignature)
		{
			MemberSignature = memberSignature;
		}

		public DynamicDependencyAttribute(string memberSignature, Type type)
		{
			MemberSignature = memberSignature;
			Type = type;
		}

		public DynamicDependencyAttribute(string memberSignature, string typeName, string assemblyName)
		{
			MemberSignature = memberSignature;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}

		public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, Type type)
		{
			MemberTypes = memberTypes;
			Type = type;
		}

		public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, string typeName, string assemblyName)
		{
			MemberTypes = memberTypes;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event, Inherited = false, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class RequiresAssemblyFilesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresAssemblyFilesAttribute()
		{
		}

		public RequiresAssemblyFilesAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class RequiresDynamicCodeAttribute : Attribute
	{
		public string Message { get; }

		public string? Url { get; set; }

		public RequiresDynamicCodeAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class RequiresUnreferencedCodeAttribute : Attribute
	{
		public string Message { get; }

		public string? Url { get; set; }

		public RequiresUnreferencedCodeAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnconditionalSuppressMessageAttribute : Attribute
	{
		public string Category { get; }

		public string CheckId { get; }

		public string? Scope { get; set; }

		public string? Target { get; set; }

		public string? MessageId { get; set; }

		public string? Justification { get; set; }

		public UnconditionalSuppressMessageAttribute(string category, string checkId)
		{
			Category = category;
			CheckId = checkId;
		}
	}
}
namespace JetBrains.Annotations
{
	[AttributeUsage(AttributeTargets.Parameter)]
	internal sealed class NoEnumerationAttribute : Attribute
	{
	}
}
namespace Serilog
{
	public interface ILogger
	{
		ILogger ForContext(ILogEventEnricher enricher);

		ILogger ForContext(IEnumerable<ILogEventEnricher> enrichers);

		ILogger ForContext(string propertyName, object? value, bool destructureObjects = false);

		ILogger ForContext<TSource>();

		ILogger ForContext(Type source);

		void Write(LogEvent logEvent);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write(LogEventLevel level, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write<T>(LogEventLevel level, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write<T0, T1>(LogEventLevel level, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write<T0, T1, T2>(LogEventLevel level, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write(LogEventLevel level, string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write(LogEventLevel level, Exception? exception, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write<T>(LogEventLevel level, Exception? exception, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write<T0, T1>(LogEventLevel level, Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write<T0, T1, T2>(LogEventLevel level, Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Write(LogEventLevel level, Exception? exception, string messageTemplate, params object?[]? propertyValues);

		bool IsEnabled(LogEventLevel level);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose(string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose<T>(string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose(string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose(Exception? exception, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose<T>(Exception? exception, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Verbose(Exception? exception, string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug(string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug<T>(string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug(string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug(Exception? exception, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug<T>(Exception? exception, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Debug(Exception? exception, string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information(string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information<T>(string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information(string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information(Exception? exception, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information<T>(Exception? exception, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Information(Exception? exception, string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning(string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning<T>(string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning(string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning(Exception? exception, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning<T>(Exception? exception, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Warning(Exception? exception, string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error(string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error<T>(string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error(string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error(Exception? exception, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error<T>(Exception? exception, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Error(Exception? exception, string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal(string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal<T>(string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal(string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal(Exception? exception, string messageTemplate);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal<T>(Exception? exception, string messageTemplate, T propertyValue);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2);

		[MessageTemplateFormatMethod("messageTemplate")]
		void Fatal(Exception? exception, string messageTemplate, params object?[]? propertyValues);

		[MessageTemplateFormatMethod("messageTemplate")]
		bool BindMessageTemplate(string messageTemplate, object?[]? propertyValues, [NotNullWhen(true)] out MessageTemplate? parsedTemplate, [NotNullWhen(true)] out IEnumerable<LogEventProperty>? boundProperties);

		bool BindProperty(string? propertyName, object? value, bool destructureObjects, [NotNullWhen(true)] out LogEventProperty? property);
	}
	public static class Log
	{
		private static ILogger _logger = Serilog.Core.Logger.None;

		public static ILogger Logger
		{
			get
			{
				return _logger;
			}
			set
			{
				_logger = Guard.AgainstNull(value, "value");
			}
		}

		public static void CloseAndFlush()
		{
			(Interlocked.Exchange(ref _logger, Serilog.Core.Logger.None) as IDisposable)?.Dispose();
		}

		public static ILogger ForContext(ILogEventEnricher enricher)
		{
			return Logger.ForContext(enricher);
		}

		public static ILogger ForContext(ILogEventEnricher[] enrichers)
		{
			return Logger.ForContext(enrichers);
		}

		public static ILogger ForContext(string propertyName, object? value, bool destructureObjects = false)
		{
			return Logger.ForContext(propertyName, value, destructureObjects);
		}

		public static ILogger ForContext<TSource>()
		{
			return Logger.ForContext<TSource>();
		}

		public static ILogger ForContext(Type source)
		{
			return Logger.ForContext(source);
		}

		public static void Write(LogEvent logEvent)
		{
			Logger.Write(logEvent);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write(LogEventLevel level, string messageTemplate)
		{
			Logger.Write(level, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write<T>(LogEventLevel level, string messageTemplate, T propertyValue)
		{
			Logger.Write(level, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write<T0, T1>(LogEventLevel level, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Logger.Write(level, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write<T0, T1, T2>(LogEventLevel level, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Logger.Write(level, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write(LogEventLevel level, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Write(level, messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write(LogEventLevel level, Exception? exception, string messageTemplate)
		{
			Logger.Write(level, exception, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write<T>(LogEventLevel level, Exception? exception, string messageTemplate, T propertyValue)
		{
			Logger.Write(level, exception, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write<T0, T1>(LogEventLevel level, Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Logger.Write(level, exception, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write<T0, T1, T2>(LogEventLevel level, Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Logger.Write(level, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Write(LogEventLevel level, Exception? exception, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Write(level, exception, messageTemplate, propertyValues);
		}

		public static bool IsEnabled(LogEventLevel level)
		{
			return Logger.IsEnabled(level);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose(string messageTemplate)
		{
			Write(LogEventLevel.Verbose, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose<T>(string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Verbose, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Verbose, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Verbose, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose(string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Verbose(messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose(Exception? exception, string messageTemplate)
		{
			Write(LogEventLevel.Verbose, exception, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose<T>(Exception? exception, string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Verbose, exception, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Verbose, exception, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Verbose, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Verbose(Exception? exception, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Verbose(exception, messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug(string messageTemplate)
		{
			Write(LogEventLevel.Debug, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug<T>(string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Debug, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Debug, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Debug, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug(string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Debug(messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug(Exception? exception, string messageTemplate)
		{
			Write(LogEventLevel.Debug, exception, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug<T>(Exception? exception, string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Debug, exception, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Debug, exception, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Debug, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Debug(Exception? exception, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Debug(exception, messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information(string messageTemplate)
		{
			Write(LogEventLevel.Information, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information<T>(string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Information, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Information, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Information, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information(string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Information(messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information(Exception? exception, string messageTemplate)
		{
			Write(LogEventLevel.Information, exception, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information<T>(Exception? exception, string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Information, exception, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Information, exception, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Information, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Information(Exception? exception, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Information(exception, messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning(string messageTemplate)
		{
			Write(LogEventLevel.Warning, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning<T>(string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Warning, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Warning, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Warning, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning(string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Warning(messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning(Exception? exception, string messageTemplate)
		{
			Write(LogEventLevel.Warning, exception, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning<T>(Exception? exception, string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Warning, exception, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Warning, exception, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Warning, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Warning(Exception? exception, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Warning(exception, messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error(string messageTemplate)
		{
			Write(LogEventLevel.Error, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error<T>(string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Error, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Error, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Error, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error(string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Error(messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error(Exception? exception, string messageTemplate)
		{
			Write(LogEventLevel.Error, exception, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error<T>(Exception? exception, string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Error, exception, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Error, exception, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Error, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Error(Exception? exception, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Error(exception, messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal(string messageTemplate)
		{
			Write(LogEventLevel.Fatal, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal<T>(string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Fatal, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal<T0, T1>(string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Fatal, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal<T0, T1, T2>(string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Fatal, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal(string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Fatal(messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal(Exception? exception, string messageTemplate)
		{
			Write(LogEventLevel.Fatal, exception, messageTemplate);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal<T>(Exception? exception, string messageTemplate, T propertyValue)
		{
			Write(LogEventLevel.Fatal, exception, messageTemplate, propertyValue);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal<T0, T1>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1)
		{
			Write(LogEventLevel.Fatal, exception, messageTemplate, propertyValue0, propertyValue1);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal<T0, T1, T2>(Exception? exception, string messageTemplate, T0 propertyValue0, T1 propertyValue1, T2 propertyValue2)
		{
			Write(LogEventLevel.Fatal, exception, messageTemplate, propertyValue0, propertyValue1, propertyValue2);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static void Fatal(Exception? exception, string messageTemplate, params object?[]? propertyValues)
		{
			Logger.Fatal(exception, messageTemplate, propertyValues);
		}

		[MessageTemplateFormatMethod("messageTemplate")]
		public static bool BindMessageTemplate(string messageTemplate, object?[] propertyValues, [NotNullWhen(true)] out MessageTemplate? parsedTemplate, [NotNullWhen(true)] out IEnumerable<LogEventProperty>? boundProperties)
		{
			return Logger.BindMessageTemplate(messageTemplate, propertyValues, out parsedTemplate, out boundProperties);
		}

		public static bool BindProperty(string propertyName, object? value, bool destructureObjects, [NotNullWhen(true)] out LogEventProperty? property)
		{
			return Logger.BindProperty(propertyName, value, destructureObjects, out property);
		}
	}
	public class LoggerConfiguration
	{
		private readonly List<ILogEventSink> _logEventSinks = new List<ILogEventSink>();

		private readonly List<ILogEventSink> _auditSinks = new List<ILogEventSink>();

		private readonly List<ILogEventEnricher> _enrichers = new List<ILogEventEnricher>();

		private readonly List<ILogEventFilter> _filters = new List<ILogEventFilter>();

		private readonly List<Type> _additionalScalarTypes = new List<Type>();

		private readonly HashSet<Type> _additionalDictionaryTypes = new HashSet<Type>();

		private readonly List<IDestructuringPolicy> _additionalDestructuringPolicies = new List<IDestructuringPolicy>();

		private readonly Dictionary<string, LoggingLevelSwitch> _overrides = new Dictionary<string, LoggingLevelSwitch>();

		private LogEventLevel _minimumLevel = LogEventLevel.Information;

		private LoggingLevelSwitch? _levelSwitch;

		private int _maximumDestructuringDepth = 10;

		private int _maximumStringLength = int.MaxValue;

		private int _maximumCollectionCount = int.MaxValue;

		private bool _loggerCreated;

		public LoggerSinkConfiguration WriteTo { get; internal set; }

		public LoggerAuditSinkConfiguration AuditTo => new LoggerAuditSinkConfiguration(this, delegate(ILogEventSink s)
		{
			_auditSinks.Add(s);
		});

		public LoggerMinimumLevelConfiguration MinimumLevel => new LoggerMinimumLevelConfiguration(this, delegate(LogEventLevel l)
		{
			_minimumLevel = l;
			_levelSwitch = null;
		}, delegate(LoggingLevelSwitch sw)
		{
			_levelSwitch = sw;
		}, delegate(string s, LoggingLevelSwitch lls)
		{
			_overrides[s] = lls;
		});

		public LoggerEnrichmentConfiguration Enrich { get; internal set; }

		public LoggerFilterConfiguration Filter => new LoggerFilterConfiguration(this, delegate(ILogEventFilter f)
		{
			_filters.Add(f);
		});

		public LoggerDestructuringConfiguration Destructure => new LoggerDestructuringConfiguration(this, _additionalScalarTypes.Add, delegate(Type type)
		{
			_additionalDictionaryTypes.Add(type);
		}, _additionalDestructuringPolicies.Add, delegate(int depth)
		{
			_maximumDestructuringDepth = depth;
		}, delegate(int length)
		{
			_maximumStringLength = length;
		}, delegate(int count)
		{
			_maximumCollectionCount = count;
		});

		public LoggerSettingsConfiguration ReadFrom => new LoggerSettingsConfiguration(this);

		public LoggerConfiguration()
		{
			WriteTo = new LoggerSinkConfiguration(this, delegate(ILogEventSink s)
			{
				_logEventSinks.Add(s);
			});
			Enrich = new LoggerEnrichmentConfiguration(this, delegate(ILogEventEnricher e)
			{
				_enrichers.Add(e);
			});
		}

		public Logger CreateLogger()
		{
			if (_loggerCreated)
			{
				throw new InvalidOperationException("CreateLogger() was previously called and can only be called once.");
			}
			_loggerCreated = true;
			ILogEventSink logEventSink = null;
			if (_logEventSinks.Count > 0)
			{
				logEventSink = new SafeAggregateSink(_logEventSinks);
			}
			bool flag = _auditSinks.Any();
			if (flag)
			{
				IEnumerable<ILogEventSink> sinks;
				if (logEventSink != null)
				{
					sinks = new ILogEventSink[1] { logEventSink }.Concat(_auditSinks);
				}
				else
				{
					IEnumerable<ILogEventSink> auditSinks = _auditSinks;
					sinks = auditSinks;
				}
				logEventSink = new AggregateSink(sinks);
			}
			if (logEventSink == null)
			{
				logEventSink = new SafeAggregateSink(Array.Empty<ILogEventSink>());
			}
			if (_filters.Any())
			{
				logEventSink = new FilteringSink(logEventSink, _filters, flag);
			}
			MessageTemplateProcessor messageTemplateProcessor = new MessageTemplateProcessor(new PropertyValueConverter(_maximumDestructuringDepth, _maximumStringLength, _maximumCollectionCount, _additionalScalarTypes, _additionalDictionaryTypes, _additionalDestructuringPolicies, flag));
			ILogEventEnricher enricher = _enrichers.Count switch
			{
				0 => new EmptyEnricher(), 
				1 => _enrichers[0], 
				_ => new SafeAggregateEnricher(_enrichers), 
			};
			LevelOverrideMap overrideMap = null;
			if (_overrides.Count != 0)
			{
				overrideMap = new LevelOverrideMap(_overrides, _minimumLevel, _levelSwitch);
			}
			ILogEventSink[] disposableSinks = (from s in _logEventSinks.Concat(_auditSinks)
				where s is IDisposable
				select s).ToArray();
			return new Logger(messageTemplateProcessor, (_levelSwitch == null) ? _minimumLevel : LogEventLevel.Verbose, _levelSwitch, logEventSink, enricher, Dispose, overrideMap);
			void Dispose()
			{
				ILogEventSink[] array = disposableSinks;
				for (int i = 0; i < array.Length; i++)
				{
					(array[i] as IDisposable)?.Dispose();
				}
			}
		}
	}
	public static class LoggerExtensions
	{
		public static ILogger ForContext<TValue>(this ILogger logger, LogEventLevel level, string propertyName, TValue value, bool destructureObjects = false)
		{
			Guard.AgainstNull(logger, "logger");
			if (!logger.IsEnabled(level))
			{
				return logger;
			}
			return logger.ForContext(propertyName, value, destructureObjects);
		}
	}
}
namespace Serilog.Settings.KeyValuePairs
{
	internal static class CallableConfigurationMethodFinder
	{
		internal static IList<MethodInfo> FindConfigurationMethods(IEnumerable<Assembly> configurationAssemblies, Type configType)
		{
			Type configType2 = configType;
			List<MethodInfo> list = (from m in configurationAssemblies.SelectMany((Assembly a) => a.ExportedTypes.Where((Type t) => t.IsSealed && t.IsAbstract && !t.IsNested)).SelectMany((Type t) => t.GetMethods(BindingFlags.Static | BindingFlags.Public))
				where m.IsDefined(typeof(ExtensionAttribute), inherit: false) && m.GetParameters()[0].ParameterType == configType2
				select m).ToList();
			if (configType2 == typeof(LoggerSinkConfiguration))
			{
				list.AddRange(SurrogateConfigurationMethods.WriteTo);
			}
			if (configType2 == typeof(LoggerAuditSinkConfiguration))
			{
				list.AddRange(SurrogateConfigurationMethods.AuditTo);
			}
			if (configType2 == typeof(LoggerEnrichmentConfiguration))
			{
				list.AddRange(SurrogateConfigurationMethods.Enrich);
			}
			if (configType2 == typeof(LoggerDestructuringConfiguration))
			{
				list.AddRange(SurrogateConfigurationMethods.Destructure);
			}
			if (configType2 == typeof(LoggerFilterConfiguration))
			{
				list.AddRange(SurrogateConfigurationMethods.Filter);
			}
			return list;
		}
	}
	internal class KeyValuePairSettings : ILoggerSettings
	{
		internal class ConfigurationMethodCall
		{
			public string MethodName { get; }

			public string ArgumentName { get; }

			public string Value { get; }

			public ConfigurationMethodCall(string methodName, string argumentName, string value)
			{
				MethodName = methodName;
				ArgumentName = argumentName;
				Value = value;
			}
		}

		private const string UsingDirective = "using";

		private const string LevelSwitchDirective = "level-switch";

		private const string AuditToDirective = "audit-to";

		private const string WriteToDirective = "write-to";

		private const string MinimumLevelDirective = "minimum-level";

		private const string MinimumLevelControlledByDirective = "minimum-level:controlled-by";

		private const string EnrichWithDirective = "enrich";

		private const string EnrichWithPropertyDirective = "enrich:with-property";

		private const string FilterDirective = "filter";

		private const string DestructureDirective = "destructure";

		private const string UsingDirectiveFullFormPrefix = "using:";

		private const string EnrichWithPropertyDirectivePrefix = "enrich:with-property:";

		private const string MinimumLevelOverrideDirectivePrefix = "minimum-level:override:";

		private const string CallableDirectiveRegex = "^(?<directive>audit-to|write-to|enrich|filter|destructure):(?<method>[A-Za-z0-9]*)(\\.(?<argument>[A-Za-z0-9]*)){0,1}$";

		private const string LevelSwitchDeclarationDirectiveRegex = "^level-switch:(?<switchName>.*)$";

		private const string LevelSwitchNameRegex = "^\\$[A-Za-z]+[A-Za-z0-9]*$";

		private static readonly string[] _supportedDirectives = new string[10] { "using", "level-switch", "audit-to", "write-to", "minimum-level", "minimum-level:controlled-by", "enrich:with-property", "enrich", "filter", "destructure" };

		private static readonly Dictionary<string, Type> CallableDirectiveReceiverTypes = new Dictionary<string, Type>
		{
			["audit-to"] = typeof(LoggerAuditSinkConfiguration),
			["write-to"] = typeof(LoggerSinkConfiguration),
			["enrich"] = typeof(LoggerEnrichmentConfiguration),
			["filter"] = typeof(LoggerFilterConfiguration),
			["destructure"] = typeof(LoggerDestructuringConfiguration)
		};

		private static readonly Dictionary<Type, Func<LoggerConfiguration, object>> CallableDirectiveReceivers = new Dictionary<Type, Func<LoggerConfiguration, object>>
		{
			[typeof(LoggerAuditSinkConfiguration)] = (LoggerConfiguration lc) => lc.AuditTo,
			[typeof(LoggerSinkConfiguration)] = (LoggerConfiguration lc) => lc.WriteTo,
			[typeof(LoggerEnrichmentConfiguration)] = (LoggerConfiguration lc) => lc.Enrich,
			[typeof(LoggerFilterConfiguration)] = (LoggerConfiguration lc) => lc.Filter,
			[typeof(LoggerDestructuringConfiguration)] = (LoggerConfiguration lc) => lc.Destructure
		};

		private readonly IReadOnlyDictionary<string, string> _settings;

		public KeyValuePairSettings(IReadOnlyDictionary<string, string> settings)
		{
			_settings = Guard.AgainstNull(settings, "settings");
		}

		public void Configure(LoggerConfiguration loggerConfiguration)
		{
			Guard.AgainstNull(loggerConfiguration, "loggerConfiguration");
			Dictionary<string, string> dictionary = _settings.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> kvp) => _supportedDirectives.Any(kvp.Key.StartsWith)).ToDictionary((KeyValuePair<string, string> kvp) => kvp.Key, (KeyValuePair<string, string> kvp) => kvp.Value);
			IReadOnlyDictionary<string, LoggingLevelSwitch> readOnlyDictionary = ParseNamedLevelSwitchDeclarationDirectives(dictionary);
			if (dictionary.TryGetValue("minimum-level", out var value) && Enum.TryParse<LogEventLevel>(value, out var result))
			{
				loggerConfiguration.MinimumLevel.Is(result);
			}
			foreach (KeyValuePair<string, string> item in dictionary.Where((KeyValuePair<string, string> dir) => dir.Key.StartsWith("enrich:with-property:") && dir.Key.Length > "enrich:with-property:".Length))
			{
				string name = item.Key.Substring("enrich:with-property:".Length);
				loggerConfiguration.Enrich.WithProperty(name, item.Value);
			}
			if (dictionary.TryGetValue("minimum-level:controlled-by", out var value2))
			{
				LoggingLevelSwitch levelSwitch = LookUpSwitchByName(value2, readOnlyDictionary);
				loggerConfiguration.MinimumLevel.ControlledBy(levelSwitch);
			}
			foreach (KeyValuePair<string, string> item2 in dictionary.Where((KeyValuePair<string, string> dir) => dir.Key.StartsWith("minimum-level:override:") && dir.Key.Length > "minimum-level:override:".Length))
			{
				string source = item2.Key.Substring("minimum-level:override:".Length);
				if (Enum.TryParse<LogEventLevel>(item2.Value, out var result2))
				{
					loggerConfiguration.MinimumLevel.Override(source, result2);
					continue;
				}
				LoggingLevelSwitch levelSwitch2 = LookUpSwitchByName(item2.Value, readOnlyDictionary);
				loggerConfiguration.MinimumLevel.Override(source, levelSwitch2);
			}
			Regex matchCallables = new Regex("^(?<directive>audit-to|write-to|enrich|filter|destructure):(?<method>[A-Za-z0-9]*)(\\.(?<argument>[A-Za-z0-9]*)){0,1}$");
			var source2 = (from <>h__TransparentIdentifier0 in dictionary.Where(delegate(KeyValuePair<string, string> wt)
				{
					Regex regex2 = matchCallables;
					KeyValuePair<string, string> keyValuePair2 = wt;
					return regex2.IsMatch(keyValuePair2.Key);
				}).Select(delegate(KeyValuePair<string, string> wt)
				{
					Regex regex = matchCallables;
					KeyValuePair<string, string> keyValuePair = wt;
					return new
					{
						wt = wt,
						match = regex.Match(keyValuePair.Key)
					};
				})
				select new
				{
					ReceiverType = CallableDirectiveReceiverTypes[<>h__TransparentIdentifier0.match.Groups["directive"].Value],
					Call = new ConfigurationMethodCall(<>h__TransparentIdentifier0.match.Groups["method"].Value, <>h__TransparentIdentifier0.match.Groups["argument"].Value, <>h__TransparentIdentifier0.wt.Value)
				}).ToList();
			if (!source2.Any())
			{
				return;
			}
			List<Assembly> configurationAssemblies = LoadConfigurationAssemblies(dictionary).ToList();
			foreach (var item3 in from d in source2
				group d by d.ReceiverType)
			{
				IList<MethodInfo> configurationMethods = CallableConfigurationMethodFinder.FindConfigurationMethods(configurationAssemblies, item3.Key);
				ApplyDirectives((from d in item3
					select d.Call into call
					group call by call.MethodName).ToList(), configurationMethods, CallableDirectiveReceivers[item3.Key](loggerConfiguration), readOnlyDictionary);
			}
		}

		internal static bool IsValidSwitchName(string input)
		{
			return Regex.IsMatch(input, "^\\$[A-Za-z]+[A-Za-z0-9]*$");
		}

		private static IReadOnlyDictionary<string, LoggingLevelSwitch> ParseNamedLevelSwitchDeclarationDirectives(IReadOnlyDictionary<string, string> directives)
		{
			Regex matchLevelSwitchDeclarations = new Regex("^level-switch:(?<switchName>.*)$");
			var list = (from <>h__TransparentIdentifier0 in directives.Where<KeyValuePair<string, string>>(delegate(KeyValuePair<string, string> wt)
				{
					Regex regex2 = matchLevelSwitchDeclarations;
					KeyValuePair<string, string> keyValuePair2 = wt;
					return regex2.IsMatch(keyValuePair2.Key);
				}).Select(delegate(KeyValuePair<string, string> wt)
				{
					Regex regex = matchLevelSwitchDeclarations;
					KeyValuePair<string, string> keyValuePair = wt;
					return new
					{
						wt = wt,
						match = regex.Match(keyValuePair.Key)
					};
				})
				select new
				{
					SwitchName = <>h__TransparentIdentifier0.match.Groups["switchName"].Value,
					InitialSwitchLevel = <>h__TransparentIdentifier0.wt.Value
				}).ToList();
			Dictionary<string, LoggingLevelSwitch> dictionary = new Dictionary<string, LoggingLevelSwitch>();
			foreach (var item in list)
			{
				string switchName = item.SwitchName;
				string initialSwitchLevel = item.InitialSwitchLevel;
				if (!IsValidSwitchName(switchName))
				{
					throw new FormatException("\"" + switchName + "\" is not a valid name for a Level Switch declaration. Level switch must be declared with a '$' sign, like \"level-switch:$switchName\"");
				}
				LoggingLevelSwitch value = ((!(initialSwitchLevel == string.Empty)) ? new LoggingLevelSwitch((LogEventLevel)Enum.Parse(typeof(LogEventLevel), initialSwitchLevel)) : new LoggingLevelSwitch());
				dictionary.Add(switchName, value);
			}
			return dictionary;
		}

		private static LoggingLevelSwitch LookUpSwitchByName(string switchName, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredLevelSwitches)
		{
			if (declaredLevelSwitches.TryGetValue(switchName, out LoggingLevelSwitch value))
			{
				return value;
			}
			throw new InvalidOperationException("No LoggingLevelSwitch has been declared with name \"" + switchName + "\". You might be missing a key \"level-switch:" + switchName + "\"");
		}

		private static object ConvertOrLookupByName(string valueOrSwitchName, Type type, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredSwitches)
		{
			if (type == typeof(LoggingLevelSwitch))
			{
				return LookUpSwitchByName(valueOrSwitchName, declaredSwitches);
			}
			return SettingValueConversions.ConvertToType(valueOrSwitchName, type);
		}

		private static void ApplyDirectives(List<IGrouping<string, ConfigurationMethodCall>> directives, IList<MethodInfo> configurationMethods, object loggerConfigMethod, IReadOnlyDictionary<string, LoggingLevelSwitch> declaredSwitches)
		{
			IReadOnlyDictionary<string, LoggingLevelSwitch> declaredSwitches2 = declaredSwitches;
			foreach (IGrouping<string, ConfigurationMethodCall> directiveInfo in directives)
			{
				MethodInfo methodInfo = SelectConfigurationMethod(configurationMethods, directiveInfo.Key, directiveInfo);
				if (methodInfo == null)
				{
					SelfLog.WriteLine("Setting \"{0}\" could not be matched to an implementation in any of the loaded assemblies. To use settings from additional assemblies, specify them with the \"serilog:using\" key.", directiveInfo.Key);
					continue;
				}
				List<object> list = (from p in methodInfo.GetParameters().Skip(1)
					let directive = directiveInfo.FirstOrDefault((ConfigurationMethodCall s) => s.ArgumentName == p.Name)
					select SuppressConvertCall(directive, p)).ToList();
				list.Insert(0, loggerConfigMethod);
				methodInfo.Invoke(null, list.ToArray());
			}
			object? SuppressConvertCall(ConfigurationMethodCall? directive, ParameterInfo p)
			{
				if (directive != null)
				{
					return ConvertOrLookupByName(directive.Value, p.ParameterType, declaredSwitches2);
				}
				return p.DefaultValue;
			}
		}

		internal static MethodInfo? SelectConfigurationMethod(IEnumerable<MethodInfo> candidateMethods, string name, IEnumerable<ConfigurationMethodCall> suppliedArgumentValues)
		{
			string name2 = name;
			IEnumerable<ConfigurationMethodCall> suppliedArgumentValues2 = suppliedArgumentValues;
			return (from m in candidateMethods
				where m.Name == name2 && m.GetParameters().Skip(1).All((ParameterInfo p) => p.HasDefaultValue || suppliedArgumentValues2.Any((ConfigurationMethodCall s) => s.ArgumentName == p.Name))
				orderby m.GetParameters().Count((ParameterInfo p) => suppliedArgumentValues2.Any((ConfigurationMethodCall s) => s.ArgumentName == p.Name)) descending
				select m).FirstOrDefault();
		}

		internal static IEnumerable<Assembly> LoadConfigurationAssemblies(IReadOnlyDictionary<string, string> directives)
		{
			List<Assembly> list = new List<Assembly> { typeof(ILogger).Assembly };
			foreach (KeyValuePair<string, string> item in directives.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> d) => d.Key.Equals("using") || d.Key.StartsWith("using:")))
			{
				if (string.IsNullOrWhiteSpace(item.Value))
				{
					throw new InvalidOperationException("A zero-length or whitespace assembly name was supplied to a serilog:using configuration statement.");
				}
				AssemblyName assemblyRef = new AssemblyName(item.Value);
				list.Add(Assembly.Load(assemblyRef));
			}
			return list.Distinct();
		}
	}
	internal class SettingValueConversions
	{
		private static Regex StaticMemberAccessorRegex = new Regex("^(?<shortTypeName>[^:]+)::(?<memberName>[A-Za-z][A-Za-z0-9]*)(?<typeNameExtraQualifiers>[^:]*)$");

		private static Dictionary<Type, Func<string, object>> ExtendedTypeConversions = new Dictionary<Type, Func<string, object>>
		{
			{
				typeof(Uri),
				(string s) => new Uri(s)
			},
			{
				typeof(TimeSpan),
				(string s) => TimeSpan.Parse(s)
			},
			{
				typeof(Type),
				(string s) => Type.GetType(s, throwOnError: true)
			}
		};

		public static object? ConvertToType(string value, Type toType)
		{
			Type toType2 = toType;
			if (toType2.IsGenericType && toType2.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				if (value == string.Empty)
				{
					return null;
				}
				toType2 = toType2.GenericTypeArguments[0];
			}
			if (toType2.IsEnum)
			{
				return Enum.Parse(toType2, value);
			}
			Func<string, object> func = (from t in ExtendedTypeConversions
				where t.Key.IsAssignableFrom(toType2)
				select t.Value).FirstOrDefault();
			if (func != null)
			{
				return func(value);
			}
			if ((toType2.IsInterface || toType2.IsAbstract) && !string.IsNullOrWhiteSpace(value))
			{
				if (TryParseStaticMemberAccessor(value, out string accessorTypeName, out string memberName))
				{
					Type type = Type.GetType(accessorTypeName, throwOnError: true);
					PropertyInfo propertyInfo = type.GetProperties(BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo x) => x.Name == memberName && x.GetMethod != null);
					if (propertyInfo != null)
					{
						return propertyInfo.GetValue(null);
					}
					FieldInfo fieldInfo = type.GetFields(BindingFlags.Static | BindingFlags.Public).FirstOrDefault((FieldInfo x) => x.Name == memberName);
					if (fieldInfo != null)
					{
						return fieldInfo.GetValue(null);
					}
					throw new InvalidOperationException("Could not find a public static property or field with name `" + memberName + "` on type `" + accessorTypeName + "`");
				}
				Type type2 = Type.GetType(value.Trim(), throwOnError: false);
				if (type2 != null)
				{
					ConstructorInfo? constructorInfo = type2.GetConstructors(BindingFlags.Instance | BindingFlags.Public).FirstOrDefault(delegate(ConstructorInfo ci)
					{
						ParameterInfo[] parameters2 = ci.GetParameters();
						return parameters2.Length == 0 || parameters2.All((ParameterInfo pi) => pi.HasDefaultValue);
					});
					if (constructorInfo == null)
					{
						throw new InvalidOperationException("A default constructor was not found on " + type2.FullName + ".");
					}
					object[] parameters = (from pi in constructorInfo.GetParameters()
						select pi.DefaultValue).ToArray();
					return constructorInfo.Invoke(parameters);
				}
			}
			if (toType2.IsArray && toType2.GetArrayRank() == 1)
			{
				Type elementType = toType2.GetElementType();
				if (string.IsNullOrEmpty(value))
				{
					return Array.CreateInstance(elementType, 0);
				}
				string[] array = value.Split(new char[1] { ',' });
				int num = array.Length;
				Array array2 = Array.CreateInstance(elementType, array.Length);
				for (int i = 0; i < num; i++)
				{
					object value2 = ConvertToType(array[i], elementType);
					array2.SetValue(value2, i);
				}
				return array2;
			}
			return Convert.ChangeType(value, toType2);
		}

		internal static bool TryParseStaticMemberAccessor(string input, [NotNullWhen(true)] out string? accessorTypeName, [NotNullWhen(true)] out string? memberName)
		{
			if (StaticMemberAccessorRegex.IsMatch(input))
			{
				Match match = StaticMemberAccessorRegex.Match(input);
				string value = match.Groups["shortTypeName"].Value;
				string value2 = match.Groups["memberName"].Value;
				string value3 = match.Groups["typeNameExtraQualifiers"].Value;
				memberName = value2.Trim();
				accessorTypeName = value.Trim() + value3.TrimEnd(Array.Empty<char>());
				return true;
			}
			accessorTypeName = null;
			memberName = null;
			return false;
		}
	}
	internal static class SurrogateConfigurationMethods
	{
		private static readonly Dictionary<Type, MethodInfo[]> SurrogateMethodCandidates = (from m in typeof(SurrogateConfigurationMethods).GetTypeInfo().DeclaredMethods
			group m by m.GetParameters().First().ParameterType).ToDictionary((IGrouping<Type, MethodInfo> g) => g.Key, (IGrouping<Type, MethodInfo> g) => g.ToArray());

		internal static readonly MethodInfo[] WriteTo = SurrogateMethodCandidates[typeof(LoggerSinkConfiguration)];

		internal static readonly MethodInfo[] AuditTo = SurrogateMethodCandidates[typeof(LoggerAuditSinkConfiguration)];

		internal static readonly MethodInfo[] Enrich = SurrogateMethodCandidates[typeof(LoggerEnrichmentConfiguration)];

		internal static readonly MethodInfo[] Destructure = SurrogateMethodCandidates[typeof(LoggerDestructuringConfiguration)];

		internal static readonly MethodInfo[] Filter = SurrogateMethodCandidates[typeof(LoggerFilterConfiguration)];

		internal static LoggerConfiguration Sink(LoggerSinkConfiguration loggerSinkConfiguration, ILogEventSink sink, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, LoggingLevelSwitch? levelSwitch = null)
		{
			return loggerSinkConfiguration.Sink(sink, restrictedToMinimumLevel, levelSwitch);
		}

		internal static LoggerConfiguration Sink(LoggerAuditSinkConfiguration auditSinkConfiguration, ILogEventSink sink, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, LoggingLevelSwitch? levelSwitch = null)
		{
			return auditSinkConfiguration.Sink(sink, restrictedToMinimumLevel, levelSwitch);
		}

		internal static LoggerConfiguration With(LoggerEnrichmentConfiguration loggerEnrichmentConfiguration, ILogEventEnricher enricher)
		{
			return loggerEnrichmentConfiguration.With(enricher);
		}

		internal static LoggerConfiguration FromLogContext(LoggerEnrichmentConfiguration loggerEnrichmentConfiguration)
		{
			return loggerEnrichmentConfiguration.FromLogContext();
		}

		internal static LoggerConfiguration With(LoggerDestructuringConfiguration loggerDestructuringConfiguration, IDestructuringPolicy policy)
		{
			return loggerDestructuringConfiguration.With(policy);
		}

		internal static LoggerConfiguration AsScalar(LoggerDestructuringConfiguration loggerDestructuringConfiguration, Type scalarType)
		{
			return loggerDestructuringConfiguration.AsScalar(scalarType);
		}

		internal static LoggerConfiguration ToMaximumCollectionCount(LoggerDestructuringConfiguration loggerDestructuringConfiguration, int maximumCollectionCount)
		{
			return loggerDestructuringConfiguration.ToMaximumCollectionCount(maximumCollectionCount);
		}

		internal static LoggerConfiguration ToMaximumDepth(LoggerDestructuringConfiguration loggerDestructuringConfiguration, int maximumDestructuringDepth)
		{
			return loggerDestructuringConfiguration.ToMaximumDepth(maximumDestructuringDepth);
		}

		internal static LoggerConfiguration ToMaximumStringLength(LoggerDestructuringConfiguration loggerDestructuringConfiguration, int maximumStringLength)
		{
			return loggerDestructuringConfiguration.ToMaximumStringLength(maximumStringLength);
		}

		internal static LoggerConfiguration With(LoggerFilterConfiguration loggerFilterConfiguration, ILogEventFilter filter)
		{
			return loggerFilterConfiguration.With(filter);
		}
	}
}
namespace Serilog.Rendering
{
	internal static class Casing
	{
		public static string Format(string value, string? format = null)
		{
			if (!(format == "u"))
			{
				if (format == "w")
				{
					return value.ToLowerInvariant();
				}
				return value;
			}
			return value.ToUpperInvariant();
		}
	}
	internal static class MessageTemplateRenderer
	{
		private static readonly JsonValueFormatter JsonValueFormatter = new JsonValueFormatter("$type");

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Render(MessageTemplate messageTemplate, IReadOnlyDictionary<string, LogEventPropertyValue> properties, TextWriter output, string? format = null, IFormatProvider? formatProvider = null)
		{
			bool isLiteral = false;
			bool isJson = false;
			if (format != null)
			{
				for (int i = 0; i < format.Length; i++)
				{
					if (format[i] == 'l')
					{
						isLiteral = true;
					}
					else if (format[i] == 'j')
					{
						isJson = true;
					}
				}
			}
			for (int j = 0; j < messageTemplate.TokenArray.Length; j++)
			{
				MessageTemplateToken messageTemplateToken = messageTemplate.TokenArray[j];
				if (messageTemplateToken is TextToken tt)
				{
					RenderTextToken(tt, output);
				}
				else
				{
					RenderPropertyToken((PropertyToken)messageTemplateToken, properties, output, formatProvider, isLiteral, isJson);
				}
			}
		}

		public static void RenderTextToken(TextToken tt, TextWriter output)
		{
			output.Write(tt.Text);
		}

		public static void RenderPropertyToken(PropertyToken pt, IReadOnlyDictionary<string, LogEventPropertyValue> properties, TextWriter output, IFormatProvider? formatProvider, bool isLiteral, bool isJson)
		{
			if (!properties.TryGetValue(pt.PropertyName, out LogEventPropertyValue value))
			{
				output.Write(pt.RawText);
				return;
			}
			if (!pt.Alignment.HasValue)
			{
				RenderValue(value, isLiteral, isJson, output, pt.Format, formatProvider);
				return;
			}
			using StringWriter stringWriter = ReusableStringWriter.GetOrCreate();
			RenderValue(value, isLiteral, isJson, stringWriter, pt.Format, formatProvider);
			StringBuilder stringBuilder = stringWriter.GetStringBuilder();
			if (stringBuilder.Length >= pt.Alignment.Value.Width)
			{
				output.Write(stringBuilder.ToString());
				return;
			}
			string value2 = stringBuilder.ToString();
			Alignment? alignment = pt.Alignment.Value;
			Padding.Apply(output, value2, in alignment);
		}

		private static void RenderValue(LogEventPropertyValue propertyValue, bool literal, bool json, TextWriter output, string? format, IFormatProvider? formatProvider)
		{
			if (literal && propertyValue is ScalarValue scalarValue && scalarValue.Value is string value)
			{
				output.Write(value);
			}
			else if (json && format == null)
			{
				JsonValueFormatter.Format(propertyValue, output);
			}
			else
			{
				propertyValue.Render(output, format, formatProvider);
			}
		}
	}
	internal static class Padding
	{
		private static readonly char[] PaddingChars = Enumerable.Repeat(' ', 80).ToArray();

		public static void Apply(TextWriter output, string value, in Alignment? alignment)
		{
			if (!alignment.HasValue || value.Length >= alignment.Value.Width)
			{
				output.Write(value);
				return;
			}
			int num = alignment.Value.Width - value.Length;
			if (alignment.Value.Direction == AlignmentDirection.Left)
			{
				output.Write(value);
			}
			if (num <= PaddingChars.Length)
			{
				output.Write(PaddingChars, 0, num);
			}
			else
			{
				output.Write(new string(' ', num));
			}
			if (alignment.Value.Direction == AlignmentDirection.Right)
			{
				output.Write(value);
			}
		}
	}
	internal class ReusableStringWriter : StringWriter
	{
		[ThreadStatic]
		private static ReusableStringWriter? _pooledWriter;

		internal const int StringBuilderCapacityThreshold = 32768;

		public static StringWriter GetOrCreate(IFormatProvider? formatProvider = null)
		{
			IFormatProvider objB = formatProvider ?? CultureInfo.CurrentCulture;
			ReusableStringWriter reusableStringWriter = _pooledWriter;
			_pooledWriter = null;
			if (reusableStringWriter == null || !object.Equals(reusableStringWriter.FormatProvider, objB))
			{
				reusableStringWriter = new ReusableStringWriter(formatProvider);
			}
			return reusableStringWriter;
		}

		private ReusableStringWriter(IFormatProvider? formatProvider)
			: base(formatProvider ?? CultureInfo.CurrentCulture)
		{
		}

		protected override void Dispose(bool disposing)
		{
			if (!disposing)
			{
				base.Dispose(disposing);
				return;
			}
			StringBuilder stringBuilder = GetStringBuilder();
			if (stringBuilder.Capacity > 32768)
			{
				base.Dispose(disposing);
				return;
			}
			stringBuilder.Clear();
			_pooledWriter = this;
		}
	}
}
namespace Serilog.Policies
{
	internal class ByteArrayScalarConversionPolicy : IScalarConversionPolicy
	{
		private const int MaximumByteArrayLength = 1024;

		public bool TryConvertToScalar(object value, [NotNullWhen(true)] out ScalarValue? result)
		{
			if (!(value is byte[] array))
			{
				result = null;
				return false;
			}
			if (array.Length > 1024)
			{
				string value2 = string.Concat(string.Concat(from b in array.Take(16)
					select b.ToString("X2")), "... (", array.Length.ToString(), " bytes)");
				result = new ScalarValue(value2);
			}
			else
			{
				result = new ScalarValue(string.Concat(array.Select((byte b) => b.ToString("X2"))));
			}
			return true;
		}
	}
	internal class DelegateDestructuringPolicy : IDestructuringPolicy
	{
		public bool TryDestructure(object value, ILogEventPropertyValueFactory propertyValueFactory, [NotNullWhen(true)] out LogEventPropertyValue? result)
		{
			if (value is Delegate @delegate)
			{
				result = new ScalarValue(@delegate.ToString());
				return true;
			}
			result = null;
			return false;
		}
	}
	internal class EnumScalarConversionPolicy : IScalarConversionPolicy
	{
		public bool TryConvertToScalar(object value, [NotNullWhen(true)] out ScalarValue? result)
		{
			if (value is Enum)
			{
				result = new ScalarValue(value);
				return true;
			}
			result = null;
			return false;
		}
	}
	internal class PrimitiveScalarConversionPolicy : IScalarConversionPolicy
	{
		public bool TryConvertToScalar(object value, [NotNullWhen(true)] out ScalarValue? result)
		{
			if (value.GetType().IsPrimitive)
			{
				result = new ScalarValue(value);
				return true;
			}
			result = null;
			return false;
		}
	}
	internal class ProjectedDestructuringPolicy : IDestructuringPolicy
	{
		private readonly Func<Type, bool> _canApply;

		private readonly Func<object, object> _projection;

		public ProjectedDestructuringPolicy(Func<Type, bool> canApply, Func<object, object> projection)
		{
			_canApply = Guard.AgainstNull(canApply, "canApply");
			_projection = Guard.AgainstNull(projection, "projection");
		}

		public bool TryDestructure(object value, ILogEventPropertyValueFactory propertyValueFactory, [NotNullWhen(true)] out LogEventPropertyValue? result)
		{
			Guard.AgainstNull(value, "value");
			if (!_canApply(value.GetType()))
			{
				result = null;
				return false;
			}
			object value2 = _projection(value);
			result = propertyValueFactory.CreatePropertyValue(value2, destructureObjects: true);
			return true;
		}
	}
	internal class ReflectionTypesScalarDestructuringPolicy : IDestructuringPolicy
	{
		public bool TryDestructure(object value, ILogEventPropertyValueFactory propertyValueFactory, [NotNullWhen(true)] out LogEventPropertyValue? result)
		{
			if ((value is Type || value is MemberInfo) ? true : false)
			{
				result = new ScalarValue(value);
				return true;
			}
			result = null;
			return false;
		}
	}
	internal class SimpleScalarConversionPolicy : IScalarConversionPolicy
	{
		private readonly HashSet<Type> _scalarTypes;

		public SimpleScalarConversionPolicy(IEnumerable<Type> scalarTypes)
		{
			HashSet<Type> hashSet = new HashSet<Type>();
			foreach (Type scalarType in scalarTypes)
			{
				hashSet.Add(scalarType);
			}
			_scalarTypes = hashSet;
		}

		public bool TryConvertToScalar(object value, [NotNullWhen(true)] out ScalarValue? result)
		{
			if (_scalarTypes.Contains(value.GetType()))
			{
				result = new ScalarValue(value);
				return true;
			}
			result = null;
			return false;
		}
	}
}
namespace Serilog.Parsing
{
	public readonly struct Alignment
	{
		public AlignmentDirection Direction { get; }

		public int Width { get; }

		public Alignment(AlignmentDirection direction, int width)
		{
			Direction = direction;
			Width = width;
		}
	}
	public enum AlignmentDirection
	{
		Left,
		Right
	}
	public enum Destructuring
	{
		Default,
		Stringify,
		Destructure
	}
	public class MessageTemplateParser : IMessageTemplateParser
	{
		private static readonly bool DefaultAcceptDottedPropertyNames = AppContext.TryGetSwitch("Serilog.Parsing.MessageTemplateParser.AcceptDottedPropertyNames", out var isEnabled) && isEnabled;

		private static readonly TextToken EmptyTextToken = new TextToken("");

		private readonly bool _acceptDottedPropertyNames;

		public MessageTemplateParser()
			: this(DefaultAcceptDottedPropertyNames)
		{
		}

		internal MessageTemplateParser(bool acceptDottedPropertyNames)
		{
			_acceptDottedPropertyNames = acceptDottedPropertyNames;
		}

		public MessageTemplate Parse(string messageTemplate)
		{
			Guard.AgainstNull(messageTemplate, "messageTemplate");
			return new MessageTemplate(messageTemplate, Tokenize(messageTemplate));
		}

		private IEnumerable<MessageTemplateToken> Tokenize(string messageTemplate)
		{
			if (messageTemplate.Length == 0)
			{
				yield return EmptyTextToken;
				yield break;
			}
			int nextIndex = 0;
			do
			{
				int num = nextIndex;
				TextToken textToken = ParseTextToken(nextIndex, messageTemplate, out nextIndex);
				if (nextIndex > num)
				{
					yield return textToken;
				}
				if (nextIndex == messageTemplate.Length)
				{
					break;
				}
				int num2 = nextIndex;
				MessageTemplateToken messageTemplateToken = ParsePropertyToken(nextIndex, messageTemplate, out nextIndex);
				if (num2 < nextIndex)
				{
					yield return messageTemplateToken;
				}
			}
			while (nextIndex != messageTemplate.Length);
		}

		private MessageTemplateToken ParsePropertyToken(int startAt, string messageTemplate, out int next)
		{
			int num = startAt;
			startAt++;
			startAt = messageTemplate.IndexOf('}', startAt);
			if (startAt == -1)
			{
				next = messageTemplate.Length;
				return new TextToken(messageTemplate.Substring(num));
			}
			next = startAt + 1;
			string text = messageTemplate.Substring(num, next - num);
			string text2 = text.Substring(1, next - (num + 2));
			if (text2.Length == 0)
			{
				return new TextToken(text);
			}
			if (!TrySplitTagContent(text2, out string propertyNameAndDestructuring, out string format, out string alignment))
			{
				return new TextToken(text);
			}
			string text3 = propertyNameAndDestructuring;
			Destructuring destructuring = Destructuring.Default;
			if (text3.Length != 0 && TryGetDestructuringHint(text3[0], out destructuring))
			{
				text3 = text3.Substring(1);
			}
			if (text3.Length == 0)
			{
				return new TextToken(text);
			}
			foreach (char c in text3)
			{
				if (!IsValidInPropertyName(c))
				{
					return new TextToken(text);
				}
			}
			if (format != null)
			{
				for (int j = 0; j < format.Length; j++)
				{
					if (!IsValidInFormat(format[j]))
					{
						return new TextToken(text);
					}
				}
			}
			Alignment? alignment2 = null;
			if (alignment != null)
			{
				if (alignment[0] == '+')
				{
					return new TextToken(text);
				}
				if (!int.TryParse(alignment, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var result))
				{
					return new TextToken(text);
				}
				AlignmentDirection direction = ((alignment[0] != '-') ? AlignmentDirection.Right : AlignmentDirection.Left);
				alignment2 = new Alignment(direction, Math.Abs(result));
			}
			return new PropertyToken(text3, text, format, in alignment2, destructuring);
		}

		private static bool TrySplitTagContent(string tagContent, [NotNullWhen(true)] out string? propertyNameAndDestructuring, out string? format, out string? alignment)
		{
			int num = tagContent.IndexOf(':');
			int num2 = tagContent.IndexOf(',');
			if (num == -1 && num2 == -1)
			{
				propertyNameAndDestructuring = tagContent;
				format = null;
				alignment = null;
				return true;
			}
			if (num2 == -1 || (num != -1 && num2 > num))
			{
				propertyNameAndDestructuring = tagContent.Substring(0, num);
				format = ((num == tagContent.Length - 1) ? null : tagContent.Substring(num + 1));
				alignment = null;
				return true;
			}
			propertyNameAndDestructuring = tagContent.Substring(0, num2);
			if (num == -1)
			{
				if (num2 == tagContent.Length - 1)
				{
					alignment = (format = null);
					return false;
				}
				format = null;
				alignment = tagContent.Substring(num2 + 1);
				return true;
			}
			if (num2 == num - 1)
			{
				alignment = (format = null);
				return false;
			}
			alignment = tagContent.Substring(num2 + 1, num - num2 - 1);
			format = ((num == tagContent.Length - 1) ? null : tagContent.Substring(num + 1));
			return true;
		}

		private bool IsValidInPropertyName(char c)
		{
			if (!char.IsLetterOrDigit(c) && c != '_')
			{
				if (_acceptDottedPropertyNames)
				{
					return c == '.';
				}
				return false;
			}
			return true;
		}

		private static bool TryGetDestructuringHint(char c, out Destructuring destructuring)
		{
			switch (c)
			{
			case '@':
				destructuring = Destructuring.Destructure;
				return true;
			case '$':
				destructuring = Destructuring.Stringify;
				return true;
			default:
				destructuring = Destructuring.Default;
				return false;
			}
		}

		private static bool IsValidInFormat(char c)
		{
			return c != '}';
		}

		private static TextToken ParseTextToken(int startAt, string messageTemplate, out int next)
		{
			int num = messageTemplate.IndexOfAny(new char[2] { '{', '}' }, startAt);
			if (num == -1)
			{
				next = messageTemplate.Length;
				return new TextToken(messageTemplate.Substring(startAt, messageTemplate.Length - startAt));
			}
			char c = messageTemplate[num];
			num++;
			StringBuilder stringBuilder;
			if (c == '{')
			{
				if (num >= messageTemplate.Length || messageTemplate[num] != '{')
				{
					next = num - 1;
					if (next != startAt)
					{
						return new TextToken(messageTemplate.Substring(startAt, num - 1 - startAt));
					}
					return EmptyTextToken;
				}
				stringBuilder = new StringBuilder(messageTemplate, startAt, num - startAt, messageTemplate.Length - startAt);
				num++;
			}
			else
			{
				stringBuilder = new StringBuilder(messageTemplate, startAt, num - startAt, messageTemplate.Length - startAt);
				if (num < messageTemplate.Length && messageTemplate[num] == '}')
				{
					num++;
				}
			}
			while (num < messageTemplate.Length)
			{
				c = messageTemplate[num];
				num++;
				if (c == '{')
				{
					if (num >= messageTemplate.Length || messageTemplate[num] != '{')
					{
						next = num - 1;
						return new TextToken(stringBuilder.ToString());
					}
					stringBuilder.Append(c);
					num++;
				}
				else
				{
					stringBuilder.Append(c);
					if (c == '}' && num < messageTemplate.Length && messageTemplate[num] == '}')
					{
						num++;
					}
				}
			}
			next = num;
			return new TextToken(stringBuilder.ToString());
		}
	}
	public abstract class MessageTemplateToken
	{
		public abstract int Length { get; }

		public abstract void Render(IReadOnlyDictionary<string, LogEventPropertyValue> properties, TextWriter output, IFormatProvider? formatProvider = null);
	}
	public sealed class PropertyToken : MessageTemplateToken
	{
		private readonly int? _position;

		public override int Length => RawText.Length;

		public string PropertyName { get; }

		public Destructuring Destructuring { get; }

		public string? Format { get; }

		public Alignment? Alignment { get; }

		public bool IsPositional => _position.HasValue;

		internal string RawText { get; }

		public PropertyToken(string propertyName, string rawText, string? format = null, in Alignment? alignment = null, Destructuring destructuring = Destructuring.Default)
		{
			PropertyName = Guard.AgainstNull(propertyName, "propertyName");
			Format = format;
			Destructuring = destructuring;
			RawText = Guard.AgainstNull(rawText, "rawText");
			Alignment = alignment;
			if (int.TryParse(PropertyName, NumberStyles.None, CultureInfo.InvariantCulture, out var result) && result >= 0)
			{
				_position = result;
			}
		}

		public override void Render(IReadOnlyDictionary<string, LogEventPropertyValue> properties, TextWriter output, IFormatProvider? formatProvider = null)
		{
			Guard.AgainstNull(properties, "properties");
			Guard.AgainstNull(output, "output");
			MessageTemplateRenderer.RenderPropertyToken(this, properties, output, formatProvider, isLiteral: false, isJson: false);
		}

		public bool TryGetPositionalValue(out int position)
		{
			if (!_position.HasValue)
			{
				position = 0;
				return false;
			}
			position = _position.Value;
			return true;
		}

		public override bool Equals(object? obj)
		{
			if (obj is PropertyToken propertyToken && propertyToken.Destructuring == Destructuring && propertyToken.Format == Format && propertyToken.PropertyName == PropertyName)
			{
				return propertyToken.RawText == RawText;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return PropertyName.GetHashCode();
		}

		public override string ToString()
		{
			return RawText;
		}
	}
	public sealed class TextToken : MessageTemplateToken
	{
		public override int Length => Text.Length;

		public string Text { get; }

		public TextToken(string text)
		{
			Text = Guard.AgainstNull(text, "text");
		}

		public override void Render(IReadOnlyDictionary<string, LogEventPropertyValue> properties, TextWriter output, IFormatProvider? formatProvider = null)
		{
			Guard.AgainstNull(output, "output");
			MessageTemplateRenderer.RenderTextToken(this, output);
		}

		public override bool Equals(object? obj)
		{
			if (obj is TextToken textToken)
			{
				return textToken.Text == Text;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Text.GetHashCode();
		}

		public override string ToString()
		{
			return Text;
		}
	}
}
namespace Serilog.Formatting
{
	public interface ITextFormatter
	{
		void Format(LogEvent logEvent, TextWriter output);
	}
}
namespace Serilog.Formatting.Json
{
	public sealed class JsonFormatter : ITextFormatter
	{
		private readonly string _closingDelimiter;

		private readonly bool _renderMessage;

		private readonly IFormatProvider? _formatProvider;

		private readonly JsonValueFormatter _jsonValueFormatter = new JsonValueFormatter();

		public JsonFormatter(string? closingDelimiter = null, bool renderMessage = false, IFormatProvider? formatProvider = null)
		{
			_closingDelimiter = closingDelimiter ?? Environment.NewLine;
			_renderMessage = renderMessage;
			_formatProvider = formatProvider;
		}

		public void Format(LogEvent logEvent, TextWriter output)
		{
			Guard.AgainstNull(logEvent, "logEvent");
			Guard.AgainstNull(output, "output");
			output.Write("{\"Timestamp\":\"");
			output.Write(logEvent.Timestamp.ToString("O"));
			output.Write("\",\"Level\":\"");
			output.Write(logEvent.Level);
			output.Write("\",\"MessageTemplate\":");
			JsonValueFormatter.WriteQuotedJsonString(logEvent.MessageTemplate.Text, output);
			if (_renderMessage)
			{
				output.Write(",\"RenderedMessage\":");
				JsonValueFormatter.WriteQuotedJsonString(logEvent.MessageTemplate.Render(logEvent.Properties), output);
			}
			if (logEvent.TraceId.HasValue)
			{
				output.Write(",\"TraceId\":");
				JsonValueFormatter.WriteQuotedJsonString(logEvent.TraceId.ToString(), output);
			}
			if (logEvent.SpanId.HasValue)
			{
				output.Write(",\"SpanId\":");
				JsonValueFormatter.WriteQuotedJsonString(logEvent.SpanId.ToString(), output);
			}
			if (logEvent.Exception != null)
			{
				output.Write(",\"Exception\":");
				JsonValueFormatter.WriteQuotedJsonString(logEvent.Exception.ToString(), output);
			}
			if (logEvent.Properties.Count != 0)
			{
				output.Write(",\"Properties\":{");
				char? c = null;
				foreach (KeyValuePair<string, LogEventPropertyValue> property in logEvent.Properties)
				{
					if (c.HasValue)
					{
						output.Write(c.Value);
					}
					else
					{
						c = ',';
					}
					JsonValueFormatter.WriteQuotedJsonString(property.Key, output);
					output.Write(':');
					_jsonValueFormatter.Format(property.Value, output);