using System;
using System.Diagnostics;
using System.Diagnostics.Tracing;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using FxResources.System.Buffers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyTitle("System.Buffers")]
[assembly: AssemblyDescription("System.Buffers")]
[assembly: AssemblyDefaultAlias("System.Buffers")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyProduct("Microsoft® .NET Framework")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyFileVersion("4.6.28619.01")]
[assembly: AssemblyInformationalVersion("4.6.28619.01 @BuiltBy: dlab14-DDVSOWINAGE069 @Branch: release/2.1 @SrcCode: https://github.com/dotnet/corefx/tree/7601f4f6225089ffb291dc7d58293c7bbf5c5d4f")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata(".NETFrameworkAssembly", "")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.3.0")]
[module: UnverifiableCode]
namespace FxResources.System.Buffers
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class SR
	{
		private static ResourceManager s_resourceManager;

		private static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(ResourceType));

		internal static Type ResourceType { get; } = typeof(SR);


		internal static string ArgumentException_BufferNotFromPool => GetResourceString("ArgumentException_BufferNotFromPool", null);

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool UsingResourceKeys()
		{
			return false;
		}

		internal static string GetResourceString(string resourceKey, string defaultString)
		{
			string text = null;
			try
			{
				text = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			if (defaultString != null && resourceKey.Equals(text, StringComparison.Ordinal))
			{
				return defaultString;
			}
			return text;
		}

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

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

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

		internal static string Format(string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.All)]
	internal class __BlockReflectionAttribute : Attribute
	{
	}
}
namespace System.Buffers
{
	public abstract class ArrayPool<T>
	{
		private static ArrayPool<T> s_sharedInstance;

		public static ArrayPool<T> Shared
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return Volatile.Read(ref s_sharedInstance) ?? EnsureSharedCreated();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static ArrayPool<T> EnsureSharedCreated()
		{
			Interlocked.CompareExchange(ref s_sharedInstance, Create(), null);
			return s_sharedInstance;
		}

		public static ArrayPool<T> Create()
		{
			return new DefaultArrayPool<T>();
		}

		public static ArrayPool<T> Create(int maxArrayLength, int maxArraysPerBucket)
		{
			return new DefaultArrayPool<T>(maxArrayLength, maxArraysPerBucket);
		}

		public abstract T[] Rent(int minimumLength);

		public abstract void Return(T[] array, bool clearArray = false);
	}
	[EventSource(Name = "System.Buffers.ArrayPoolEventSource")]
	internal sealed class ArrayPoolEventSource : EventSource
	{
		internal enum BufferAllocatedReason
		{
			Pooled,
			OverMaximumSize,
			PoolExhausted
		}

		internal static readonly System.Buffers.ArrayPoolEventSource Log = new System.Buffers.ArrayPoolEventSource();

		[Event(1, Level = EventLevel.Verbose)]
		internal unsafe void BufferRented(int bufferId, int bufferSize, int poolId, int bucketId)
		{
			EventData* ptr = stackalloc EventData[4];
			*ptr = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferId)
			};
			ptr[1] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferSize)
			};
			ptr[2] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&poolId)
			};
			ptr[3] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bucketId)
			};
			WriteEventCore(1, 4, ptr);
		}

		[Event(2, Level = EventLevel.Informational)]
		internal unsafe void BufferAllocated(int bufferId, int bufferSize, int poolId, int bucketId, BufferAllocatedReason reason)
		{
			EventData* ptr = stackalloc EventData[5];
			*ptr = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferId)
			};
			ptr[1] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferSize)
			};
			ptr[2] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&poolId)
			};
			ptr[3] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bucketId)
			};
			ptr[4] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&reason)
			};
			WriteEventCore(2, 5, ptr);
		}

		[Event(3, Level = EventLevel.Verbose)]
		internal void BufferReturned(int bufferId, int bufferSize, int poolId)
		{
			WriteEvent(3, bufferId, bufferSize, poolId);
		}
	}
	internal sealed class DefaultArrayPool<T> : ArrayPool<T>
	{
		private sealed class Bucket
		{
			internal readonly int _bufferLength;

			private readonly T[][] _buffers;

			private readonly int _poolId;

			private SpinLock _lock;

			private int _index;

			internal int Id => GetHashCode();

			internal Bucket(int bufferLength, int numberOfBuffers, int poolId)
			{
				_lock = new SpinLock(Debugger.IsAttached);
				_buffers = new T[numberOfBuffers][];
				_bufferLength = bufferLength;
				_poolId = poolId;
			}

			internal T[] Rent()
			{
				T[][] buffers = _buffers;
				T[] array = null;
				bool lockTaken = false;
				bool flag = false;
				try
				{
					_lock.Enter(ref lockTaken);
					if (_index < buffers.Length)
					{
						array = buffers[_index];
						buffers[_index++] = null;
						flag = array == null;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
				if (flag)
				{
					array = new T[_bufferLength];
					System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
					if (log.IsEnabled())
					{
						log.BufferAllocated(array.GetHashCode(), _bufferLength, _poolId, Id, System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.Pooled);
					}
				}
				return array;
			}

			internal void Return(T[] array)
			{
				if (array.Length != _bufferLength)
				{
					throw new ArgumentException(System.SR.ArgumentException_BufferNotFromPool, "array");
				}
				bool lockTaken = false;
				try
				{
					_lock.Enter(ref lockTaken);
					if (_index != 0)
					{
						_buffers[--_index] = array;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
			}
		}

		private const int DefaultMaxArrayLength = 1048576;

		private const int DefaultMaxNumberOfArraysPerBucket = 50;

		private static T[] s_emptyArray;

		private readonly Bucket[] _buckets;

		private int Id => GetHashCode();

		internal DefaultArrayPool()
			: this(1048576, 50)
		{
		}

		internal DefaultArrayPool(int maxArrayLength, int maxArraysPerBucket)
		{
			if (maxArrayLength <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArrayLength");
			}
			if (maxArraysPerBucket <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArraysPerBucket");
			}
			if (maxArrayLength > 1073741824)
			{
				maxArrayLength = 1073741824;
			}
			else if (maxArrayLength < 16)
			{
				maxArrayLength = 16;
			}
			int id = Id;
			int num = System.Buffers.Utilities.SelectBucketIndex(maxArrayLength);
			Bucket[] array = new Bucket[num + 1];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Bucket(System.Buffers.Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id);
			}
			_buckets = array;
		}

		public override T[] Rent(int minimumLength)
		{
			if (minimumLength < 0)
			{
				throw new ArgumentOutOfRangeException("minimumLength");
			}
			if (minimumLength == 0)
			{
				return s_emptyArray ?? (s_emptyArray = new T[0]);
			}
			System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
			T[] array = null;
			int num = System.Buffers.Utilities.SelectBucketIndex(minimumLength);
			if (num < _buckets.Length)
			{
				int num2 = num;
				do
				{
					array = _buckets[num2].Rent();
					if (array != null)
					{
						if (log.IsEnabled())
						{
							log.BufferRented(array.GetHashCode(), array.Length, Id, _buckets[num2].Id);
						}
						return array;
					}
				}
				while (++num2 < _buckets.Length && num2 != num + 2);
				array = new T[_buckets[num]._bufferLength];
			}
			else
			{
				array = new T[minimumLength];
			}
			if (log.IsEnabled())
			{
				int hashCode = array.GetHashCode();
				int bucketId = -1;
				log.BufferRented(hashCode, array.Length, Id, bucketId);
				log.BufferAllocated(hashCode, array.Length, Id, bucketId, (num >= _buckets.Length) ? System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.OverMaximumSize : System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.PoolExhausted);
			}
			return array;
		}

		public override void Return(T[] array, bool clearArray = false)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Length == 0)
			{
				return;
			}
			int num = System.Buffers.Utilities.SelectBucketIndex(array.Length);
			if (num < _buckets.Length)
			{
				if (clearArray)
				{
					Array.Clear(array, 0, array.Length);
				}
				_buckets[num].Return(array);
			}
			System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
			if (log.IsEnabled())
			{
				log.BufferReturned(array.GetHashCode(), array.Length, Id);
			}
		}
	}
	internal static class Utilities
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int SelectBucketIndex(int bufferSize)
		{
			uint num = (uint)(bufferSize - 1) >> 4;
			int num2 = 0;
			if (num > 65535)
			{
				num >>= 16;
				num2 = 16;
			}
			if (num > 255)
			{
				num >>= 8;
				num2 += 8;
			}
			if (num > 15)
			{
				num >>= 4;
				num2 += 4;
			}
			if (num > 3)
			{
				num >>= 2;
				num2 += 2;
			}
			if (num > 1)
			{
				num >>= 1;
				num2++;
			}
			return num2 + (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetMaxSizeForBucket(int binIndex)
		{
			return 16 << binIndex;
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Numerics.Hashing;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using FxResources.Microsoft.Extensions.FileSystemGlobbing;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
using Microsoft.Extensions.FileSystemGlobbing.Internal;
using Microsoft.Extensions.FileSystemGlobbing.Internal.PathSegments;
using Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts;
using Microsoft.Extensions.FileSystemGlobbing.Internal.Patterns;
using Microsoft.Extensions.FileSystemGlobbing.Util;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Microsoft.Extensions.FileSystemGlobbing.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f33a29044fa9d740c9b3213a93e57c84b472c84e0b8a0e1ae48e67a9f8f6de9d5f7f3d52ac23e48ac51801f1dc950abe901da34d2a9e3baadb141a17c77ef3c565dd5ee5054b91cf63bb3c6ab83f72ab3aafe93d0fc3c2348b764fafb0b1c0733de51459aeab46580384bf9d74c4e28164b7cde247f891ba07891c9d872ad2bb")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("Microsoft.Extensions.FileSystemGlobbing")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("File system globbing to find files matching a specified pattern.")]
[assembly: AssemblyFileVersion("9.0.225.6610")]
[assembly: AssemblyInformationalVersion("9.0.2+80aa709f5d919c6814726788dc6dabe23e79e672")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("Microsoft.Extensions.FileSystemGlobbing")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: AssemblyVersion("9.0.0.0")]
[module: RefSafetyRules(11)]
[module: System.Runtime.CompilerServices.NullablePublicOnly(true)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	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 NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

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

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

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

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

		private static ResourceManager s_resourceManager;

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

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

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

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

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

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

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

		internal static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public string[] Members { get; }

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

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

		public string? EntryPoint { get; set; }

		public StringMarshalling StringMarshalling { get; set; }

		public Type? StringMarshallingCustomType { get; set; }

		public bool SetLastError { get; set; }

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

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
}
namespace System.Numerics.Hashing
{
	internal static class HashHelpers
	{
		public static int Combine(int h1, int h2)
		{
			return (((h1 << 5) | (h1 >>> 27)) + h1) ^ h2;
		}
	}
}
namespace Microsoft.Extensions.FileSystemGlobbing
{
	public struct FilePatternMatch : IEquatable<FilePatternMatch>
	{
		public string Path { get; }

		public string? Stem { get; }

		public FilePatternMatch(string path, string? stem)
		{
			System.ThrowHelper.ThrowIfNull(path, "path");
			Path = path;
			Stem = stem;
		}

		public bool Equals(FilePatternMatch other)
		{
			if (string.Equals(other.Path, Path, StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(other.Stem, Stem, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is FilePatternMatch other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashHelpers.Combine(GetHashCode(Path), GetHashCode(Stem));
		}

		private static int GetHashCode(string value)
		{
			if (value == null)
			{
				return 0;
			}
			return StringComparer.OrdinalIgnoreCase.GetHashCode(value);
		}
	}
	public class InMemoryDirectoryInfo : DirectoryInfoBase
	{
		private static readonly char[] DirectorySeparators = new char[2]
		{
			Path.DirectorySeparatorChar,
			Path.AltDirectorySeparatorChar
		};

		private readonly IEnumerable<string> _files;

		public override string FullName { get; }

		public override string Name { get; }

		public override DirectoryInfoBase? ParentDirectory => new InMemoryDirectoryInfo(Path.GetDirectoryName(FullName), _files, normalized: true);

		public InMemoryDirectoryInfo(string rootDir, IEnumerable<string>? files)
			: this(rootDir, files, normalized: false)
		{
		}

		private InMemoryDirectoryInfo(string rootDir, IEnumerable<string> files, bool normalized)
		{
			if (string.IsNullOrEmpty(rootDir))
			{
				throw new ArgumentNullException("rootDir");
			}
			if (files == null)
			{
				files = new List<string>();
			}
			Name = Path.GetFileName(rootDir);
			if (normalized)
			{
				_files = files;
				FullName = rootDir;
				return;
			}
			List<string> list = new List<string>(files.Count());
			string fullPath = Path.GetFullPath(rootDir.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));
			foreach (string file in files)
			{
				string text = file.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
				if (Path.IsPathRooted(file))
				{
					list.Add(Path.GetFullPath(text));
				}
				else
				{
					list.Add(Path.GetFullPath(Path.Combine(fullPath, text)));
				}
			}
			_files = list;
			FullName = fullPath;
		}

		public override IEnumerable<FileSystemInfoBase> EnumerateFileSystemInfos()
		{
			Dictionary<string, List<string>> dict = new Dictionary<string, List<string>>();
			foreach (string file in _files)
			{
				if (!IsRootDirectory(FullName, file))
				{
					continue;
				}
				int length = file.Length;
				int num = FullName.Length + 1;
				int num2 = file.IndexOfAny(DirectorySeparators, num, length - num);
				if (num2 == -1)
				{
					yield return new InMemoryFileInfo(file, this);
					continue;
				}
				string key = file.Substring(0, num2);
				if (!dict.TryGetValue(key, out var value))
				{
					dict[key] = new List<string> { file };
				}
				else
				{
					value.Add(file);
				}
			}
			foreach (KeyValuePair<string, List<string>> item in dict)
			{
				yield return new InMemoryDirectoryInfo(item.Key, item.Value, normalized: true);
			}
		}

		private static bool IsRootDirectory(string rootDir, string filePath)
		{
			int length = rootDir.Length;
			if (filePath.StartsWith(rootDir, StringComparison.Ordinal))
			{
				if (rootDir[length - 1] != Path.DirectorySeparatorChar)
				{
					return filePath.IndexOf(Path.DirectorySeparatorChar, length) == length;
				}
				return true;
			}
			return false;
		}

		public override DirectoryInfoBase GetDirectory(string path)
		{
			if (string.Equals(path, "..", StringComparison.Ordinal))
			{
				return new InMemoryDirectoryInfo(Path.Combine(FullName, path), _files, normalized: true);
			}
			return new InMemoryDirectoryInfo(Path.GetFullPath(path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar)), _files, normalized: true);
		}

		public override FileInfoBase? GetFile(string path)
		{
			string fullPath = Path.GetFullPath(path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));
			foreach (string file in _files)
			{
				if (string.Equals(file, fullPath))
				{
					return new InMemoryFileInfo(file, this);
				}
			}
			return null;
		}
	}
	public class Matcher
	{
		private readonly List<IPattern> _includePatterns = new List<IPattern>();

		private readonly List<IPattern> _excludePatterns = new List<IPattern>();

		private readonly PatternBuilder _builder;

		private readonly StringComparison _comparison;

		public Matcher()
			: this(StringComparison.OrdinalIgnoreCase)
		{
		}

		public Matcher(StringComparison comparisonType)
		{
			_comparison = comparisonType;
			_builder = new PatternBuilder(comparisonType);
		}

		public virtual Matcher AddInclude(string pattern)
		{
			_includePatterns.Add(_builder.Build(pattern));
			return this;
		}

		public virtual Matcher AddExclude(string pattern)
		{
			_excludePatterns.Add(_builder.Build(pattern));
			return this;
		}

		public virtual PatternMatchingResult Execute(DirectoryInfoBase directoryInfo)
		{
			System.ThrowHelper.ThrowIfNull(directoryInfo, "directoryInfo");
			return new MatcherContext(_includePatterns, _excludePatterns, directoryInfo, _comparison).Execute();
		}
	}
	public static class MatcherExtensions
	{
		public static void AddExcludePatterns(this Matcher matcher, params IEnumerable<string>[] excludePatternsGroups)
		{
			for (int i = 0; i < excludePatternsGroups.Length; i++)
			{
				foreach (string item in excludePatternsGroups[i])
				{
					matcher.AddExclude(item);
				}
			}
		}

		public static void AddIncludePatterns(this Matcher matcher, params IEnumerable<string>[] includePatternsGroups)
		{
			for (int i = 0; i < includePatternsGroups.Length; i++)
			{
				foreach (string item in includePatternsGroups[i])
				{
					matcher.AddInclude(item);
				}
			}
		}

		public static IEnumerable<string> GetResultsInFullPath(this Matcher matcher, string directoryPath)
		{
			PatternMatchingResult patternMatchingResult = matcher.Execute(new DirectoryInfoWrapper(new DirectoryInfo(directoryPath)));
			if (!patternMatchingResult.HasMatches)
			{
				return Array.Empty<string>();
			}
			IEnumerable<FilePatternMatch> files = patternMatchingResult.Files;
			List<string> list = ((files is ICollection collection) ? new List<string>(collection.Count) : new List<string>());
			foreach (FilePatternMatch item in files)
			{
				list.Add(Path.GetFullPath(Path.Combine(directoryPath, item.Path)));
			}
			return list;
		}

		public static PatternMatchingResult Match(this Matcher matcher, string file)
		{
			return matcher.Match(Directory.GetCurrentDirectory(), new List<string> { file });
		}

		public static PatternMatchingResult Match(this Matcher matcher, string rootDir, string file)
		{
			return matcher.Match(rootDir, new List<string> { file });
		}

		public static PatternMatchingResult Match(this Matcher matcher, IEnumerable<string>? files)
		{
			return matcher.Match(Directory.GetCurrentDirectory(), files);
		}

		public static PatternMatchingResult Match(this Matcher matcher, string rootDir, IEnumerable<string>? files)
		{
			System.ThrowHelper.ThrowIfNull(matcher, "matcher");
			return matcher.Execute(new InMemoryDirectoryInfo(rootDir, files));
		}
	}
	public class PatternMatchingResult
	{
		public IEnumerable<FilePatternMatch> Files { get; set; }

		public bool HasMatches { get; }

		public PatternMatchingResult(IEnumerable<FilePatternMatch> files)
			: this(files, files.Any())
		{
			Files = files;
		}

		public PatternMatchingResult(IEnumerable<FilePatternMatch> files, bool hasMatches)
		{
			System.ThrowHelper.ThrowIfNull(files, "files");
			Files = files;
			HasMatches = hasMatches;
		}
	}
}
namespace Microsoft.Extensions.FileSystemGlobbing.Util
{
	internal static class StringComparisonHelper
	{
		public static StringComparer GetStringComparer(StringComparison comparisonType)
		{
			return comparisonType switch
			{
				StringComparison.CurrentCulture => StringComparer.CurrentCulture, 
				StringComparison.CurrentCultureIgnoreCase => StringComparer.CurrentCultureIgnoreCase, 
				StringComparison.Ordinal => StringComparer.Ordinal, 
				StringComparison.OrdinalIgnoreCase => StringComparer.OrdinalIgnoreCase, 
				StringComparison.InvariantCulture => StringComparer.InvariantCulture, 
				StringComparison.InvariantCultureIgnoreCase => StringComparer.InvariantCultureIgnoreCase, 
				_ => throw new InvalidOperationException(System.SR.Format(System.SR.UnexpectedStringComparisonType, comparisonType)), 
			};
		}
	}
}
namespace Microsoft.Extensions.FileSystemGlobbing.Internal
{
	public interface ILinearPattern : IPattern
	{
		IList<IPathSegment> Segments { get; }
	}
	internal sealed class InMemoryFileInfo : FileInfoBase
	{
		private readonly InMemoryDirectoryInfo _parent;

		public override string FullName { get; }

		public override string Name { get; }

		public override DirectoryInfoBase ParentDirectory => _parent;

		public InMemoryFileInfo(string file, InMemoryDirectoryInfo parent)
		{
			FullName = file;
			Name = Path.GetFileName(file);
			_parent = parent;
		}
	}
	public interface IPathSegment
	{
		bool CanProduceStem { get; }

		bool Match(string value);
	}
	public interface IPattern
	{
		IPatternContext CreatePatternContextForInclude();

		IPatternContext CreatePatternContextForExclude();
	}
	public interface IPatternContext
	{
		void Declare(Action<IPathSegment, bool> onDeclare);

		bool Test(DirectoryInfoBase directory);

		PatternTestResult Test(FileInfoBase file);

		void PushDirectory(DirectoryInfoBase directory);

		void PopDirectory();
	}
	public interface IRaggedPattern : IPattern
	{
		IList<IPathSegment> Segments { get; }

		IList<IPathSegment> StartsWith { get; }

		IList<IList<IPathSegment>> Contains { get; }

		IList<IPathSegment> EndsWith { get; }
	}
	public class MatcherContext
	{
		private readonly DirectoryInfoBase _root;

		private readonly IPatternContext[] _includePatternContexts;

		private readonly IPatternContext[] _excludePatternContexts;

		private readonly List<FilePatternMatch> _files;

		private readonly HashSet<string> _declaredLiteralFolderSegmentInString;

		private readonly HashSet<LiteralPathSegment> _declaredLiteralFileSegments = new HashSet<LiteralPathSegment>();

		private bool _declaredParentPathSegment;

		private bool _declaredWildcardPathSegment;

		private readonly StringComparison _comparisonType;

		public MatcherContext(IEnumerable<IPattern> includePatterns, IEnumerable<IPattern> excludePatterns, DirectoryInfoBase directoryInfo, StringComparison comparison)
		{
			_root = directoryInfo;
			_files = new List<FilePatternMatch>();
			_comparisonType = comparison;
			_includePatternContexts = includePatterns.Select((IPattern pattern) => pattern.CreatePatternContextForInclude()).ToArray();
			_excludePatternContexts = excludePatterns.Select((IPattern pattern) => pattern.CreatePatternContextForExclude()).ToArray();
			_declaredLiteralFolderSegmentInString = new HashSet<string>(StringComparisonHelper.GetStringComparer(comparison));
		}

		public PatternMatchingResult Execute()
		{
			_files.Clear();
			Match(_root, null);
			return new PatternMatchingResult(_files, _files.Count > 0);
		}

		private void Match(DirectoryInfoBase directory, string parentRelativePath)
		{
			PushDirectory(directory);
			Declare();
			List<FileSystemInfoBase> list = new List<FileSystemInfoBase>();
			if (_declaredWildcardPathSegment || _declaredLiteralFileSegments.Count != 0)
			{
				list.AddRange(directory.EnumerateFileSystemInfos());
			}
			else
			{
				foreach (FileSystemInfoBase item in directory.EnumerateFileSystemInfos())
				{
					if (item is DirectoryInfoBase && _declaredLiteralFolderSegmentInString.Contains(item.Name))
					{
						list.Add(item);
					}
				}
			}
			if (_declaredParentPathSegment)
			{
				list.Add(directory.GetDirectory(".."));
			}
			List<DirectoryInfoBase> list2 = new List<DirectoryInfoBase>();
			foreach (FileSystemInfoBase item2 in list)
			{
				if (item2 is FileInfoBase fileInfoBase)
				{
					PatternTestResult patternTestResult = MatchPatternContexts(fileInfoBase, (IPatternContext pattern, FileInfoBase file) => pattern.Test(file));
					if (patternTestResult.IsSuccessful)
					{
						_files.Add(new FilePatternMatch(CombinePath(parentRelativePath, fileInfoBase.Name), patternTestResult.Stem));
					}
				}
				else if (item2 is DirectoryInfoBase directoryInfoBase && MatchPatternContexts(directoryInfoBase, (IPatternContext pattern, DirectoryInfoBase dir) => pattern.Test(dir)))
				{
					list2.Add(directoryInfoBase);
				}
			}
			foreach (DirectoryInfoBase item3 in list2)
			{
				string parentRelativePath2 = CombinePath(parentRelativePath, item3.Name);
				Match(item3, parentRelativePath2);
			}
			PopDirectory();
		}

		private void Declare()
		{
			_declaredLiteralFileSegments.Clear();
			_declaredParentPathSegment = false;
			_declaredWildcardPathSegment = false;
			IPatternContext[] includePatternContexts = _includePatternContexts;
			for (int i = 0; i < includePatternContexts.Length; i++)
			{
				includePatternContexts[i].Declare(DeclareInclude);
			}
		}

		private void DeclareInclude(IPathSegment patternSegment, bool isLastSegment)
		{
			if (patternSegment is LiteralPathSegment literalPathSegment)
			{
				if (isLastSegment)
				{
					_declaredLiteralFileSegments.Add(literalPathSegment);
				}
				else
				{
					_declaredLiteralFolderSegmentInString.Add(literalPathSegment.Value);
				}
			}
			else if (patternSegment is ParentPathSegment)
			{
				_declaredParentPathSegment = true;
			}
			else if (patternSegment is WildcardPathSegment)
			{
				_declaredWildcardPathSegment = true;
			}
		}

		internal static string CombinePath(string? left, string right)
		{
			if (string.IsNullOrEmpty(left))
			{
				return right;
			}
			return left + "/" + right;
		}

		private bool MatchPatternContexts<TFileInfoBase>(TFileInfoBase fileinfo, Func<IPatternContext, TFileInfoBase, bool> test)
		{
			return MatchPatternContexts(fileinfo, (IPatternContext ctx, TFileInfoBase file) => test(ctx, file) ? PatternTestResult.Success(string.Empty) : PatternTestResult.Failed).IsSuccessful;
		}

		private PatternTestResult MatchPatternContexts<TFileInfoBase>(TFileInfoBase fileinfo, Func<IPatternContext, TFileInfoBase, PatternTestResult> test)
		{
			PatternTestResult result = PatternTestResult.Failed;
			IPatternContext[] includePatternContexts = _includePatternContexts;
			foreach (IPatternContext arg in includePatternContexts)
			{
				PatternTestResult patternTestResult = test(arg, fileinfo);
				if (patternTestResult.IsSuccessful)
				{
					result = patternTestResult;
					break;
				}
			}
			if (!result.IsSuccessful)
			{
				return PatternTestResult.Failed;
			}
			includePatternContexts = _excludePatternContexts;
			foreach (IPatternContext arg2 in includePatternContexts)
			{
				if (test(arg2, fileinfo).IsSuccessful)
				{
					return PatternTestResult.Failed;
				}
			}
			return result;
		}

		private void PopDirectory()
		{
			IPatternContext[] excludePatternContexts = _excludePatternContexts;
			for (int i = 0; i < excludePatternContexts.Length; i++)
			{
				excludePatternContexts[i].PopDirectory();
			}
			excludePatternContexts = _includePatternContexts;
			for (int i = 0; i < excludePatternContexts.Length; i++)
			{
				excludePatternContexts[i].PopDirectory();
			}
		}

		private void PushDirectory(DirectoryInfoBase directory)
		{
			IPatternContext[] includePatternContexts = _includePatternContexts;
			for (int i = 0; i < includePatternContexts.Length; i++)
			{
				includePatternContexts[i].PushDirectory(directory);
			}
			includePatternContexts = _excludePatternContexts;
			for (int i = 0; i < includePatternContexts.Length; i++)
			{
				includePatternContexts[i].PushDirectory(directory);
			}
		}
	}
	public struct PatternTestResult
	{
		public static readonly PatternTestResult Failed = new PatternTestResult(isSuccessful: false, null);

		public bool IsSuccessful { get; }

		public string? Stem { get; }

		private PatternTestResult(bool isSuccessful, string stem)
		{
			IsSuccessful = isSuccessful;
			Stem = stem;
		}

		public static PatternTestResult Success(string? stem)
		{
			return new PatternTestResult(isSuccessful: true, stem);
		}
	}
}
namespace Microsoft.Extensions.FileSystemGlobbing.Internal.Patterns
{
	public class PatternBuilder
	{
		private sealed class LinearPattern : ILinearPattern, IPattern
		{
			public IList<IPathSegment> Segments { get; }

			public LinearPattern(List<IPathSegment> allSegments)
			{
				Segments = allSegments;
			}

			public IPatternContext CreatePatternContextForInclude()
			{
				return new PatternContextLinearInclude(this);
			}

			public IPatternContext CreatePatternContextForExclude()
			{
				return new PatternContextLinearExclude(this);
			}
		}

		private sealed class RaggedPattern : IRaggedPattern, IPattern
		{
			public IList<IList<IPathSegment>> Contains { get; }

			public IList<IPathSegment> EndsWith { get; }

			public IList<IPathSegment> Segments { get; }

			public IList<IPathSegment> StartsWith { get; }

			public RaggedPattern(List<IPathSegment> allSegments, IList<IPathSegment> segmentsPatternStartsWith, IList<IPathSegment> segmentsPatternEndsWith, IList<IList<IPathSegment>> segmentsPatternContains)
			{
				Segments = allSegments;
				StartsWith = segmentsPatternStartsWith;
				Contains = segmentsPatternContains;
				EndsWith = segmentsPatternEndsWith;
			}

			public IPatternContext CreatePatternContextForInclude()
			{
				return new PatternContextRaggedInclude(this);
			}

			public IPatternContext CreatePatternContextForExclude()
			{
				return new PatternContextRaggedExclude(this);
			}
		}

		private static readonly char[] _slashes = new char[2] { '/', '\\' };

		private static readonly char[] _star = new char[1] { '*' };

		public StringComparison ComparisonType { get; }

		public PatternBuilder()
		{
			ComparisonType = StringComparison.OrdinalIgnoreCase;
		}

		public PatternBuilder(StringComparison comparisonType)
		{
			ComparisonType = comparisonType;
		}

		public IPattern Build(string pattern)
		{
			System.ThrowHelper.ThrowIfNull(pattern, "pattern");
			pattern = pattern.TrimStart(_slashes);
			if (pattern.TrimEnd(_slashes).Length < pattern.Length)
			{
				pattern = pattern.TrimEnd(_slashes) + "/**";
			}
			List<IPathSegment> list = new List<IPathSegment>();
			bool flag = true;
			List<IPathSegment> list2 = null;
			List<IList<IPathSegment>> list3 = null;
			List<IPathSegment> list4 = null;
			int length = pattern.Length;
			int num = 0;
			while (num < length)
			{
				int num2 = num;
				int num3 = NextIndex(pattern, _slashes, num, length);
				IPathSegment pathSegment = null;
				if (pathSegment == null && num3 - num2 == 3 && pattern[num2] == '*' && pattern[num2 + 1] == '.' && pattern[num2 + 2] == '*')
				{
					num2 += 2;
				}
				if (pathSegment == null && num3 - num2 == 2)
				{
					if (pattern[num2] == '*' && pattern[num2 + 1] == '*')
					{
						pathSegment = new RecursiveWildcardSegment();
					}
					else if (pattern[num2] == '.' && pattern[num2 + 1] == '.')
					{
						if (!flag)
						{
							throw new ArgumentException("\"..\" can be only added at the beginning of the pattern.");
						}
						pathSegment = new ParentPathSegment();
					}
				}
				if (pathSegment == null && num3 - num2 == 1 && pattern[num2] == '.')
				{
					pathSegment = new CurrentPathSegment();
				}
				if (pathSegment == null && num3 - num2 > 2 && pattern[num2] == '*' && pattern[num2 + 1] == '*' && pattern[num2 + 2] == '.')
				{
					pathSegment = new RecursiveWildcardSegment();
					num3 = num2;
				}
				if (pathSegment == null)
				{
					string beginsWith = string.Empty;
					List<string> list5 = new List<string>();
					string endsWith = string.Empty;
					int num4 = num2;
					while (num4 < num3)
					{
						int num5 = num4;
						int num6 = NextIndex(pattern, _star, num4, num3);
						if (num5 == num2)
						{
							if (num6 == num3)
							{
								pathSegment = new LiteralPathSegment(Portion(pattern, num5, num6), ComparisonType);
							}
							else
							{
								beginsWith = Portion(pattern, num5, num6);
							}
						}
						else if (num6 == num3)
						{
							endsWith = Portion(pattern, num5, num6);
						}
						else if (num5 != num6)
						{
							list5.Add(Portion(pattern, num5, num6));
						}
						num4 = num6 + 1;
					}
					if (pathSegment == null)
					{
						pathSegment = new WildcardPathSegment(beginsWith, list5, endsWith, ComparisonType);
					}
				}
				if (!(pathSegment is ParentPathSegment))
				{
					flag = false;
				}
				if (!(pathSegment is CurrentPathSegment))
				{
					if (pathSegment is RecursiveWildcardSegment)
					{
						if (list2 == null)
						{
							list2 = new List<IPathSegment>(list);
							list4 = new List<IPathSegment>();
							list3 = new List<IList<IPathSegment>>();
						}
						else if (list4.Count != 0)
						{
							list3.Add(list4);
							list4 = new List<IPathSegment>();
						}
					}
					else
					{
						list4?.Add(pathSegment);
					}
					list.Add(pathSegment);
				}
				num = num3 + 1;
			}
			if (list2 == null)
			{
				return new LinearPattern(list);
			}
			return new RaggedPattern(list, list2, list4, list3);
		}

		private static int NextIndex(string pattern, char[] anyOf, int beginIndex, int endIndex)
		{
			int num = pattern.IndexOfAny(anyOf, beginIndex, endIndex - beginIndex);
			if (num != -1)
			{
				return num;
			}
			return endIndex;
		}

		private static string Portion(string pattern, int beginIndex, int endIndex)
		{
			return pattern.Substring(beginIndex, endIndex - beginIndex);
		}
	}
}
namespace Microsoft.Extensions.FileSystemGlobbing.Internal.PatternContexts
{
	public abstract class PatternContext<TFrame> : IPatternContext where TFrame : struct
	{
		private readonly Stack<TFrame> _stack = new Stack<TFrame>();

		protected TFrame Frame;

		public virtual void Declare(Action<IPathSegment, bool> declare)
		{
		}

		public abstract PatternTestResult Test(FileInfoBase file);

		public abstract bool Test(DirectoryInfoBase directory);

		public abstract void PushDirectory(DirectoryInfoBase directory);

		public virtual void PopDirectory()
		{
			Frame = _stack.Pop();
		}

		protected void PushDataFrame(TFrame frame)
		{
			_stack.Push(Frame);
			Frame = frame;
		}

		protected bool IsStackEmpty()
		{
			return _stack.Count == 0;
		}
	}
	public abstract class PatternContextLinear : PatternContext<PatternContextLinear.FrameData>
	{
		public struct FrameData
		{
			public bool IsNotApplicable;

			public int SegmentIndex;

			public bool InStem;

			private IList<string> _stemItems;

			public IList<string> StemItems => _stemItems ?? (_stemItems = new List<string>());

			public string? Stem
			{
				get
				{
					if (_stemItems != null)
					{
						return string.Join("/", _stemItems);
					}
					return null;
				}
			}
		}

		protected ILinearPattern Pattern { get; }

		public PatternContextLinear(ILinearPattern pattern)
		{
			System.ThrowHelper.ThrowIfNull(pattern, "pattern");
			Pattern = pattern;
		}

		public override PatternTestResult Test(FileInfoBase file)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotTestFile);
			}
			if (!Frame.IsNotApplicable && IsLastSegment() && TestMatchingSegment(file.Name))
			{
				return PatternTestResult.Success(CalculateStem(file));
			}
			return PatternTestResult.Failed;
		}

		public override void PushDirectory(DirectoryInfoBase directory)
		{
			FrameData frame = Frame;
			if (!IsStackEmpty() && !Frame.IsNotApplicable)
			{
				if (!TestMatchingSegment(directory.Name))
				{
					frame.IsNotApplicable = true;
				}
				else
				{
					IPathSegment pathSegment = Pattern.Segments[Frame.SegmentIndex];
					if (frame.InStem || pathSegment.CanProduceStem)
					{
						frame.InStem = true;
						frame.StemItems.Add(directory.Name);
					}
					frame.SegmentIndex++;
				}
			}
			PushDataFrame(frame);
		}

		protected bool IsLastSegment()
		{
			return Frame.SegmentIndex == Pattern.Segments.Count - 1;
		}

		protected bool TestMatchingSegment(string value)
		{
			if (Frame.SegmentIndex >= Pattern.Segments.Count)
			{
				return false;
			}
			return Pattern.Segments[Frame.SegmentIndex].Match(value);
		}

		protected string CalculateStem(FileInfoBase matchedFile)
		{
			return MatcherContext.CombinePath(Frame.Stem, matchedFile.Name);
		}
	}
	public class PatternContextLinearExclude : PatternContextLinear
	{
		public PatternContextLinearExclude(ILinearPattern pattern)
			: base(pattern)
		{
		}

		public override bool Test(DirectoryInfoBase directory)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotTestDirectory);
			}
			if (Frame.IsNotApplicable)
			{
				return false;
			}
			if (IsLastSegment())
			{
				return TestMatchingSegment(directory.Name);
			}
			return false;
		}
	}
	public class PatternContextLinearInclude : PatternContextLinear
	{
		public PatternContextLinearInclude(ILinearPattern pattern)
			: base(pattern)
		{
		}

		public override void Declare(Action<IPathSegment, bool> onDeclare)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotDeclarePathSegment);
			}
			if (!Frame.IsNotApplicable && Frame.SegmentIndex < base.Pattern.Segments.Count)
			{
				onDeclare(base.Pattern.Segments[Frame.SegmentIndex], IsLastSegment());
			}
		}

		public override bool Test(DirectoryInfoBase directory)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotTestDirectory);
			}
			if (Frame.IsNotApplicable)
			{
				return false;
			}
			if (!IsLastSegment())
			{
				return TestMatchingSegment(directory.Name);
			}
			return false;
		}
	}
	public abstract class PatternContextRagged : PatternContext<PatternContextRagged.FrameData>
	{
		public struct FrameData
		{
			public bool IsNotApplicable;

			public int SegmentGroupIndex;

			public IList<IPathSegment> SegmentGroup;

			public int BacktrackAvailable;

			public int SegmentIndex;

			public bool InStem;

			private IList<string> _stemItems;

			public IList<string> StemItems => _stemItems ?? (_stemItems = new List<string>());

			public string? Stem
			{
				get
				{
					if (_stemItems != null)
					{
						return string.Join("/", _stemItems);
					}
					return null;
				}
			}
		}

		protected IRaggedPattern Pattern { get; }

		public PatternContextRagged(IRaggedPattern pattern)
		{
			System.ThrowHelper.ThrowIfNull(pattern, "pattern");
			Pattern = pattern;
		}

		public override PatternTestResult Test(FileInfoBase file)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotTestFile);
			}
			if (!Frame.IsNotApplicable && IsEndingGroup() && TestMatchingGroup(file))
			{
				return PatternTestResult.Success(CalculateStem(file));
			}
			return PatternTestResult.Failed;
		}

		public sealed override void PushDirectory(DirectoryInfoBase directory)
		{
			FrameData frame = Frame;
			if (IsStackEmpty())
			{
				frame.SegmentGroupIndex = -1;
				frame.SegmentGroup = Pattern.StartsWith;
			}
			else if (!Frame.IsNotApplicable)
			{
				if (IsStartingGroup())
				{
					if (!TestMatchingSegment(directory.Name))
					{
						frame.IsNotApplicable = true;
					}
					else
					{
						frame.SegmentIndex++;
					}
				}
				else if (!IsStartingGroup() && directory.Name == "..")
				{
					frame.IsNotApplicable = true;
				}
				else if (!IsStartingGroup() && !IsEndingGroup() && TestMatchingGroup(directory))
				{
					frame.SegmentIndex = Frame.SegmentGroup.Count;
					frame.BacktrackAvailable = 0;
				}
				else
				{
					frame.BacktrackAvailable++;
				}
			}
			if (frame.InStem)
			{
				frame.StemItems.Add(directory.Name);
			}
			while (frame.SegmentIndex == frame.SegmentGroup.Count && frame.SegmentGroupIndex != Pattern.Contains.Count)
			{
				frame.SegmentGroupIndex++;
				frame.SegmentIndex = 0;
				if (frame.SegmentGroupIndex < Pattern.Contains.Count)
				{
					frame.SegmentGroup = Pattern.Contains[frame.SegmentGroupIndex];
				}
				else
				{
					frame.SegmentGroup = Pattern.EndsWith;
				}
				frame.InStem = true;
			}
			PushDataFrame(frame);
		}

		public override void PopDirectory()
		{
			base.PopDirectory();
			if (Frame.StemItems.Count > 0)
			{
				Frame.StemItems.RemoveAt(Frame.StemItems.Count - 1);
			}
		}

		protected bool IsStartingGroup()
		{
			return Frame.SegmentGroupIndex == -1;
		}

		protected bool IsEndingGroup()
		{
			return Frame.SegmentGroupIndex == Pattern.Contains.Count;
		}

		protected bool TestMatchingSegment(string value)
		{
			if (Frame.SegmentIndex >= Frame.SegmentGroup.Count)
			{
				return false;
			}
			return Frame.SegmentGroup[Frame.SegmentIndex].Match(value);
		}

		protected bool TestMatchingGroup(FileSystemInfoBase value)
		{
			int count = Frame.SegmentGroup.Count;
			if (Frame.BacktrackAvailable + 1 < count)
			{
				return false;
			}
			FileSystemInfoBase fileSystemInfoBase = value;
			for (int i = 0; i != count; i++)
			{
				IPathSegment pathSegment = Frame.SegmentGroup[count - i - 1];
				if (fileSystemInfoBase == null || !pathSegment.Match(fileSystemInfoBase.Name))
				{
					return false;
				}
				fileSystemInfoBase = fileSystemInfoBase.ParentDirectory;
			}
			return true;
		}

		protected string CalculateStem(FileInfoBase matchedFile)
		{
			return MatcherContext.CombinePath(Frame.Stem, matchedFile.Name);
		}
	}
	public class PatternContextRaggedExclude : PatternContextRagged
	{
		public PatternContextRaggedExclude(IRaggedPattern pattern)
			: base(pattern)
		{
		}

		public override bool Test(DirectoryInfoBase directory)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotTestDirectory);
			}
			if (Frame.IsNotApplicable)
			{
				return false;
			}
			if (IsEndingGroup() && TestMatchingGroup(directory))
			{
				return true;
			}
			if (base.Pattern.EndsWith.Count == 0 && Frame.SegmentGroupIndex == base.Pattern.Contains.Count - 1 && TestMatchingGroup(directory))
			{
				return true;
			}
			return false;
		}
	}
	public class PatternContextRaggedInclude : PatternContextRagged
	{
		public PatternContextRaggedInclude(IRaggedPattern pattern)
			: base(pattern)
		{
		}

		public override void Declare(Action<IPathSegment, bool> onDeclare)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotDeclarePathSegment);
			}
			if (!Frame.IsNotApplicable)
			{
				if (IsStartingGroup() && Frame.SegmentIndex < Frame.SegmentGroup.Count)
				{
					onDeclare(Frame.SegmentGroup[Frame.SegmentIndex], arg2: false);
				}
				else
				{
					onDeclare(WildcardPathSegment.MatchAll, arg2: false);
				}
			}
		}

		public override bool Test(DirectoryInfoBase directory)
		{
			if (IsStackEmpty())
			{
				throw new InvalidOperationException(System.SR.CannotTestDirectory);
			}
			if (Frame.IsNotApplicable)
			{
				return false;
			}
			if (IsStartingGroup() && !TestMatchingSegment(directory.Name))
			{
				return false;
			}
			return true;
		}
	}
}
namespace Microsoft.Extensions.FileSystemGlobbing.Internal.PathSegments
{
	public class CurrentPathSegment : IPathSegment
	{
		public bool CanProduceStem => false;

		public bool Match(string value)
		{
			return false;
		}
	}
	public class LiteralPathSegment : IPathSegment
	{
		private readonly StringComparison _comparisonType;

		public bool CanProduceStem => false;

		public string Value { get; }

		public LiteralPathSegment(string value, StringComparison comparisonType)
		{
			System.ThrowHelper.ThrowIfNull(value, "value");
			Value = value;
			_comparisonType = comparisonType;
		}

		public bool Match(string value)
		{
			return string.Equals(Value, value, _comparisonType);
		}

		public override bool Equals([NotNullWhen(true)] object? obj)
		{
			if (obj is LiteralPathSegment literalPathSegment && _comparisonType == literalPathSegment._comparisonType)
			{
				return string.Equals(literalPathSegment.Value, Value, _comparisonType);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return StringComparisonHelper.GetStringComparer(_comparisonType).GetHashCode(Value);
		}
	}
	public class ParentPathSegment : IPathSegment
	{
		private const string LiteralParent = "..";

		public bool CanProduceStem => false;

		public bool Match(string value)
		{
			return string.Equals("..", value, StringComparison.Ordinal);
		}
	}
	public class RecursiveWildcardSegment : IPathSegment
	{
		public bool CanProduceStem => true;

		public bool Match(string value)
		{
			return false;
		}
	}
	public class WildcardPathSegment : IPathSegment
	{
		public static readonly WildcardPathSegment MatchAll = new WildcardPathSegment(string.Empty, new List<string>(), string.Empty, StringComparison.OrdinalIgnoreCase);

		private readonly StringComparison _comparisonType;

		public bool CanProduceStem => true;

		public string BeginsWith { get; }

		public List<string> Contains { get; }

		public string EndsWith { get; }

		public WildcardPathSegment(string beginsWith, List<string> contains, string endsWith, StringComparison comparisonType)
		{
			System.ThrowHelper.ThrowIfNull(beginsWith, "beginsWith");
			System.ThrowHelper.ThrowIfNull(contains, "contains");
			System.ThrowHelper.ThrowIfNull(endsWith, "endsWith");
			if ((uint)(comparisonType - 4) > 1u)
			{
				throw new InvalidOperationException(System.SR.Format(System.SR.StringComparisonTypeShouldBeOrdinal, comparisonType));
			}
			_comparisonType = comparisonType;
			BeginsWith = beginsWith;
			Contains = contains;
			EndsWith = endsWith;
		}

		public bool Match(string value)
		{
			if (value.Length < BeginsWith.Length + EndsWith.Length)
			{
				return false;
			}
			if (!value.StartsWith(BeginsWith, _comparisonType))
			{
				return false;
			}
			if (!value.EndsWith(EndsWith, _comparisonType))
			{
				return false;
			}
			int num = BeginsWith.Length;
			int num2 = value.Length - EndsWith.Length;
			for (int i = 0; i != Contains.Count; i++)
			{
				string text = Contains[i];
				int num3 = value.IndexOf(text, num, num2 - num, _comparisonType);
				if (num3 == -1)
				{
					return false;
				}
				num = num3 + text.Length;
			}
			return true;
		}
	}
}
namespace Microsoft.Extensions.FileSystemGlobbing.Abstractions
{
	public abstract class DirectoryInfoBase : FileSystemInfoBase
	{
		public abstract IEnumerable<FileSystemInfoBase> EnumerateFileSystemInfos();

		public abstract DirectoryInfoBase? GetDirectory(string path);

		public abstract FileInfoBase? GetFile(string path);
	}
	public class DirectoryInfoWrapper : DirectoryInfoBase
	{
		private readonly DirectoryInfo _directoryInfo;

		private readonly bool _isParentPath;

		public override string Name
		{
			get
			{
				if (!_isParentPath)
				{
					return _directoryInfo.Name;
				}
				return "..";
			}
		}

		public override string FullName => _directoryInfo.FullName;

		public override DirectoryInfoBase? ParentDirectory => new DirectoryInfoWrapper(_directoryInfo.Parent);

		public DirectoryInfoWrapper(DirectoryInfo directoryInfo)
			: this(directoryInfo, isParentPath: false)
		{
		}

		private DirectoryInfoWrapper(DirectoryInfo directoryInfo, bool isParentPath)
		{
			_directoryInfo = directoryInfo;
			_isParentPath = isParentPath;
		}

		public override IEnumerable<FileSystemInfoBase> EnumerateFileSystemInfos()
		{
			if (!_directoryInfo.Exists)
			{
				yield break;
			}
			IEnumerable<FileSystemInfo> enumerable;
			try
			{
				enumerable = _directoryInfo.EnumerateFileSystemInfos("*", SearchOption.TopDirectoryOnly);
			}
			catch (DirectoryNotFoundException)
			{
				yield break;
			}
			foreach (FileSystemInfo item in enumerable)
			{
				if (item is DirectoryInfo directoryInfo)
				{
					yield return new DirectoryInfoWrapper(directoryInfo);
				}
				else
				{
					yield return new FileInfoWrapper((FileInfo)item);
				}
			}
		}

		public override DirectoryInfoBase? GetDirectory(string name)
		{
			bool flag = string.Equals(name, "..", StringComparison.Ordinal);
			if (flag)
			{
				return new DirectoryInfoWrapper(new DirectoryInfo(Path.Combine(_directoryInfo.FullName, name)), flag);
			}
			DirectoryInfo[] directories = _directoryInfo.GetDirectories(name);
			if (directories.Length == 1)
			{
				return new DirectoryInfoWrapper(directories[0], flag);
			}
			if (directories.Length == 0)
			{
				return null;
			}
			throw new InvalidOperationException("More than one sub directories are found under " + _directoryInfo.FullName + " with name " + name + ".");
		}

		public override FileInfoBase GetFile(string name)
		{
			return new FileInfoWrapper(new FileInfo(Path.Combine(_directoryInfo.FullName, name)));
		}
	}
	public abstract class FileInfoBase : FileSystemInfoBase
	{
	}
	public class FileInfoWrapper : FileInfoBase
	{
		private readonly FileInfo _fileInfo;

		public override string Name => _fileInfo.Name;

		public override string FullName => _fileInfo.FullName;

		public override DirectoryInfoBase? ParentDirectory => new DirectoryInfoWrapper(_fileInfo.Directory);

		public FileInfoWrapper(FileInfo fileInfo)
		{
			System.ThrowHelper.ThrowIfNull(fileInfo, "fileInfo");
			_fileInfo = fileInfo;
		}
	}
	public abstract class FileSystemInfoBase
	{
		public abstract string Name { get; }

		public abstract string FullName { get; }

		public abstract DirectoryInfoBase? ParentDirectory { get; }
	}
}