using System;
using System.CodeDom.Compiler;
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.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Markup;
using System.Windows.Media;
using System.Windows.Resources;
using System.Windows.Threading;
using AurieInstaller.Services;
using AurieInstaller.ViewModels.Pages;
using AurieInstaller.ViewModels.Windows;
using AurieInstaller.Views.Pages;
using AurieInstaller.Views.Windows;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.ComponentModel.__Internals;
using CommunityToolkit.Mvvm.Input;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Win32;
using Wpf.Ui.Appearance;
using Wpf.Ui.Common;
using Wpf.Ui.Contracts;
using Wpf.Ui.Controls;
using Wpf.Ui.Services;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: ThemeInfo(/*Could not decode attribute arguments.*/)]
[assembly: AssemblyAssociatedContentFile("wpfui-icon.ico")]
[assembly: TargetFramework(".NETCoreApp,Version=v7.0", FrameworkDisplayName = ".NET 7.0")]
[assembly: AssemblyCompany("AurieInstaller")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f65341a37e751bdd428c64e3ea1725d27ffb292a")]
[assembly: AssemblyProduct("AurieInstaller")]
[assembly: AssemblyTitle("AurieInstaller")]
[assembly: TargetPlatform("Windows7.0")]
[assembly: SupportedOSPlatform("Windows7.0")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : System.Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class NullableAttribute : System.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]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class NullableContextAttribute : System.Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class RefSafetyRulesAttribute : System.Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CommunityToolkit.Mvvm.ComponentModel.__Internals
{
	[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
	[Obsolete("This type is not intended to be used directly by user code")]
	internal static class __KnownINotifyPropertyChangingArgs
	{
		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangingEventArgs AppVersion = new PropertyChangingEventArgs("AppVersion");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangingEventArgs CurrentTheme = new PropertyChangingEventArgs("CurrentTheme");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangingEventArgs ApplicationTitle = new PropertyChangingEventArgs("ApplicationTitle");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangingEventArgs MenuItems = new PropertyChangingEventArgs("MenuItems");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangingEventArgs FooterMenuItems = new PropertyChangingEventArgs("FooterMenuItems");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangingEventArgs TrayMenuItems = new PropertyChangingEventArgs("TrayMenuItems");
	}
	[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
	[Obsolete("This type is not intended to be used directly by user code")]
	internal static class __KnownINotifyPropertyChangedArgs
	{
		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangedEventArgs AppVersion = new PropertyChangedEventArgs("AppVersion");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangedEventArgs CurrentTheme = new PropertyChangedEventArgs("CurrentTheme");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangedEventArgs ApplicationTitle = new PropertyChangedEventArgs("ApplicationTitle");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangedEventArgs MenuItems = new PropertyChangedEventArgs("MenuItems");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangedEventArgs FooterMenuItems = new PropertyChangedEventArgs("FooterMenuItems");

		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		[Obsolete("This field is not intended to be referenced directly by user code")]
		public static readonly PropertyChangedEventArgs TrayMenuItems = new PropertyChangedEventArgs("TrayMenuItems");
	}
}
namespace XamlGeneratedNamespace
{
	[DebuggerNonUserCode]
	[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
	[EditorBrowsable(/*Could not decode attribute arguments.*/)]
	public sealed class GeneratedInternalTypeHelper : InternalTypeHelper
	{
		protected override object CreateInstance(System.Type type, CultureInfo culture)
		{
			return Activator.CreateInstance(type, (BindingFlags)564, (Binder)null, (object[])null, culture);
		}

		protected override object GetPropertyValue(PropertyInfo propertyInfo, object target, CultureInfo culture)
		{
			return propertyInfo.GetValue(target, (BindingFlags)0, (Binder)null, (object[])null, culture);
		}

		protected override void SetPropertyValue(PropertyInfo propertyInfo, object target, object value, CultureInfo culture)
		{
			propertyInfo.SetValue(target, value, (BindingFlags)0, (Binder)null, (object[])null, culture);
		}

		protected override System.Delegate CreateDelegate(System.Type delegateType, object target, string handler)
		{
			return (System.Delegate)target.GetType().InvokeMember("_CreateDelegate", (BindingFlags)292, (Binder)null, target, new object[2] { delegateType, handler }, (CultureInfo)null);
		}

		protected override void AddEventHandler(EventInfo eventInfo, object target, System.Delegate handler)
		{
			eventInfo.AddEventHandler(target, handler);
		}
	}
}
namespace AurieInstaller
{
	public class App : Application
	{
		[StructLayout(3)]
		[CompilerGenerated]
		private struct <OnExit>d__3 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncVoidMethodBuilder <>t__builder;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				try
				{
					TaskAwaiter awaiter;
					if (num != 0)
					{
						awaiter = _host.StopAsync(default(CancellationToken)).GetAwaiter();
						if (!((TaskAwaiter)(ref awaiter)).IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							((AsyncVoidMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <OnExit>d__3>(ref awaiter, ref this);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
					}
					((TaskAwaiter)(ref awaiter)).GetResult();
					((System.IDisposable)_host).Dispose();
				}
				catch (System.Exception exception)
				{
					<>1__state = -2;
					((AsyncVoidMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncVoidMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				((AsyncVoidMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
			}
		}

		private static readonly IHost _host = HostingHostBuilderExtensions.ConfigureAppConfiguration(Host.CreateDefaultBuilder(), (Action<IConfigurationBuilder>)delegate(IConfigurationBuilder c)
		{
			FileConfigurationExtensions.SetBasePath(c, Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
		}).ConfigureServices((Action<HostBuilderContext, IServiceCollection>)delegate(HostBuilderContext context, IServiceCollection services)
		{
			ServiceCollectionHostedServiceExtensions.AddHostedService<ApplicationHostService>(services);
			ServiceCollectionServiceExtensions.AddSingleton<MainWindow>(services);
			ServiceCollectionServiceExtensions.AddSingleton<MainWindowViewModel>(services);
			ServiceCollectionServiceExtensions.AddSingleton<INavigationService, NavigationService>(services);
			ServiceCollectionServiceExtensions.AddSingleton<ISnackbarService, SnackbarService>(services);
			ServiceCollectionServiceExtensions.AddSingleton<IContentDialogService, ContentDialogService>(services);
			ServiceCollectionServiceExtensions.AddSingleton<DashboardPage>(services);
			ServiceCollectionServiceExtensions.AddSingleton<DashboardViewModel>(services);
			ServiceCollectionServiceExtensions.AddSingleton<SettingsPage>(services);
			ServiceCollectionServiceExtensions.AddSingleton<SettingsViewModel>(services);
		}).Build();

		private bool _contentLoaded;

		public static T GetService<T>() where T : class
		{
			return _host.Services.GetService(typeof(T)) as T;
		}

		private void OnStartup(object sender, StartupEventArgs e)
		{
			HostingAbstractionsHostExtensions.Start(_host);
		}

		[AsyncStateMachine(typeof(<OnExit>d__3))]
		private void OnExit(object sender, ExitEventArgs e)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			<OnExit>d__3 <OnExit>d__ = default(<OnExit>d__3);
			<OnExit>d__.<>t__builder = AsyncVoidMethodBuilder.Create();
			<OnExit>d__.<>1__state = -1;
			((AsyncVoidMethodBuilder)(ref <OnExit>d__.<>t__builder)).Start<<OnExit>d__3>(ref <OnExit>d__);
		}

		private void OnDispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		public void InitializeComponent()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			if (!_contentLoaded)
			{
				_contentLoaded = true;
				((Application)this).DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler(OnDispatcherUnhandledException);
				((Application)this).Exit += new ExitEventHandler(OnExit);
				((Application)this).Startup += new StartupEventHandler(OnStartup);
				Uri val = new Uri("/AurieInstaller;component/app.xaml", (UriKind)2);
				Application.LoadComponent((object)this, val);
			}
		}

		[STAThread]
		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		public static void Main()
		{
			App app = new App();
			app.InitializeComponent();
			((Application)app).Run();
		}
	}
}
namespace AurieInstaller.Views.Windows
{
	public class MainWindow : FluentWindow, IComponentConnector
	{
		internal TitleBar TitleBar;

		internal NavigationView NavigationView;

		internal BreadcrumbBar BreadcrumbBar;

		internal AutoSuggestBox AutoSuggestBox;

		internal SnackbarPresenter SnackbarPresenter;

		internal ContentPresenter RootContentDialog;

		private bool _contentLoaded;

		[field: CompilerGenerated]
		public MainWindowViewModel ViewModel
		{
			[CompilerGenerated]
			get;
		}

		public MainWindow(MainWindowViewModel viewModel, INavigationService navigationService, IServiceProvider serviceProvider, ISnackbarService snackbarService, IContentDialogService contentDialogService)
		{
			Watcher.Watch((Window)(object)this, (WindowBackdropType)2, true, false);
			ViewModel = viewModel;
			((FrameworkElement)this).DataContext = this;
			InitializeComponent();
			navigationService.SetNavigationControl((INavigationView)(object)NavigationView);
			snackbarService.SetSnackbarPresenter(SnackbarPresenter);
			contentDialogService.SetContentPresenter(RootContentDialog);
			NavigationView.SetServiceProvider(serviceProvider);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		public void InitializeComponent()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (!_contentLoaded)
			{
				_contentLoaded = true;
				Uri val = new Uri("/AurieInstaller;component/views/windows/mainwindow.xaml", (UriKind)2);
				Application.LoadComponent((object)this, val);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		void IComponentConnector.Connect(int connectionId, object target)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			switch (connectionId)
			{
			case 1:
				TitleBar = (TitleBar)target;
				break;
			case 2:
				NavigationView = (NavigationView)target;
				break;
			case 3:
				BreadcrumbBar = (BreadcrumbBar)target;
				break;
			case 4:
				AutoSuggestBox = (AutoSuggestBox)target;
				break;
			case 5:
				SnackbarPresenter = (SnackbarPresenter)target;
				break;
			case 6:
				RootContentDialog = (ContentPresenter)target;
				break;
			default:
				_contentLoaded = true;
				break;
			}
		}
	}
}
namespace AurieInstaller.Views.Pages
{
	public class DashboardPage : Page, INavigableView<DashboardViewModel>, IComponentConnector
	{
		private bool _contentLoaded;

		[field: CompilerGenerated]
		public DashboardViewModel ViewModel
		{
			[CompilerGenerated]
			get;
		}

		public DashboardPage(DashboardViewModel viewModel)
		{
			ViewModel = viewModel;
			((FrameworkElement)this).DataContext = this;
			InitializeComponent();
		}

		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		public void InitializeComponent()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (!_contentLoaded)
			{
				_contentLoaded = true;
				Uri val = new Uri("/AurieInstaller;component/views/pages/dashboardpage.xaml", (UriKind)2);
				Application.LoadComponent((object)this, val);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		void IComponentConnector.Connect(int connectionId, object target)
		{
			_contentLoaded = true;
		}
	}
	public class SettingsPage : Page, INavigableView<SettingsViewModel>, IComponentConnector
	{
		private bool _contentLoaded;

		[field: CompilerGenerated]
		public SettingsViewModel ViewModel
		{
			[CompilerGenerated]
			get;
		}

		public SettingsPage(SettingsViewModel viewModel)
		{
			ViewModel = viewModel;
			((FrameworkElement)this).DataContext = this;
			InitializeComponent();
		}

		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		public void InitializeComponent()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (!_contentLoaded)
			{
				_contentLoaded = true;
				Uri val = new Uri("/AurieInstaller;component/views/pages/settingspage.xaml", (UriKind)2);
				Application.LoadComponent((object)this, val);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("PresentationBuildTasks", "8.0.0.0")]
		[EditorBrowsable(/*Could not decode attribute arguments.*/)]
		void IComponentConnector.Connect(int connectionId, object target)
		{
			_contentLoaded = true;
		}
	}
}
namespace AurieInstaller.ViewModels.Windows
{
	public class MainWindowViewModel : ObservableObject
	{
		[ObservableProperty]
		private string _applicationTitle = "Aurie Framework Installer";

		[ObservableProperty]
		private ObservableCollection<object> _menuItems;

		[ObservableProperty]
		private ObservableCollection<object> _footerMenuItems;

		[ObservableProperty]
		private ObservableCollection<MenuItem> _trayMenuItems;

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public string ApplicationTitle
		{
			get
			{
				return _applicationTitle;
			}
			[MemberNotNull("_applicationTitle")]
			set
			{
				if (!EqualityComparer<string>.Default.Equals(_applicationTitle, value))
				{
					((ObservableObject)this).OnPropertyChanging(__KnownINotifyPropertyChangingArgs.ApplicationTitle);
					_applicationTitle = value;
					((ObservableObject)this).OnPropertyChanged(__KnownINotifyPropertyChangedArgs.ApplicationTitle);
				}
			}
		}

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public ObservableCollection<object> MenuItems
		{
			get
			{
				return _menuItems;
			}
			[MemberNotNull("_menuItems")]
			set
			{
				if (!EqualityComparer<ObservableCollection<object>>.Default.Equals(_menuItems, value))
				{
					((ObservableObject)this).OnPropertyChanging(__KnownINotifyPropertyChangingArgs.MenuItems);
					_menuItems = value;
					((ObservableObject)this).OnPropertyChanged(__KnownINotifyPropertyChangedArgs.MenuItems);
				}
			}
		}

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public ObservableCollection<object> FooterMenuItems
		{
			get
			{
				return _footerMenuItems;
			}
			[MemberNotNull("_footerMenuItems")]
			set
			{
				if (!EqualityComparer<ObservableCollection<object>>.Default.Equals(_footerMenuItems, value))
				{
					((ObservableObject)this).OnPropertyChanging(__KnownINotifyPropertyChangingArgs.FooterMenuItems);
					_footerMenuItems = value;
					((ObservableObject)this).OnPropertyChanged(__KnownINotifyPropertyChangedArgs.FooterMenuItems);
				}
			}
		}

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public ObservableCollection<MenuItem> TrayMenuItems
		{
			get
			{
				return _trayMenuItems;
			}
			[MemberNotNull("_trayMenuItems")]
			set
			{
				if (!EqualityComparer<ObservableCollection<MenuItem>>.Default.Equals(_trayMenuItems, value))
				{
					((ObservableObject)this).OnPropertyChanging(__KnownINotifyPropertyChangingArgs.TrayMenuItems);
					_trayMenuItems = value;
					((ObservableObject)this).OnPropertyChanged(__KnownINotifyPropertyChangedArgs.TrayMenuItems);
				}
			}
		}

		public MainWindowViewModel()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			ObservableCollection<object> obj = new ObservableCollection<object>();
			((Collection<object>)(object)obj).Add((object)new NavigationViewItem
			{
				Content = "Main",
				Icon = (IconElement)new SymbolIcon
				{
					Symbol = (SymbolRegular)62593
				},
				TargetPageType = typeof(DashboardPage)
			});
			_menuItems = obj;
			ObservableCollection<object> obj2 = new ObservableCollection<object>();
			((Collection<object>)(object)obj2).Add((object)new NavigationViewItem
			{
				Content = "About",
				Icon = (IconElement)new SymbolIcon
				{
					Symbol = (SymbolRegular)63146
				},
				TargetPageType = typeof(SettingsPage)
			});
			_footerMenuItems = obj2;
			ObservableCollection<MenuItem> obj3 = new ObservableCollection<MenuItem>();
			((Collection<MenuItem>)(object)obj3).Add(new MenuItem
			{
				Header = "Home",
				Tag = "tray_home"
			});
			_trayMenuItems = obj3;
			((ObservableObject)this)..ctor();
		}
	}
}
namespace AurieInstaller.ViewModels.Pages
{
	public class DashboardViewModel : ObservableObject
	{
		private static readonly string m_IFEOPath = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options";

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator", "8.2.0.0")]
		private RelayCommand? uninstallButtonCommand;

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator", "8.2.0.0")]
		private RelayCommand? installButtonCommand;

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public IRelayCommand UninstallButtonCommand
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				//IL_0023: Expected O, but got Unknown
				RelayCommand obj = uninstallButtonCommand;
				if (obj == null)
				{
					RelayCommand val = new RelayCommand(new Action(OnUninstallButton));
					RelayCommand val2 = val;
					uninstallButtonCommand = val;
					obj = val2;
				}
				return (IRelayCommand)(object)obj;
			}
		}

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public IRelayCommand InstallButtonCommand
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				//IL_0023: Expected O, but got Unknown
				RelayCommand obj = installButtonCommand;
				if (obj == null)
				{
					RelayCommand val = new RelayCommand(new Action(OnInstallButton));
					RelayCommand val2 = val;
					installButtonCommand = val;
					obj = val2;
				}
				return (IRelayCommand)(object)obj;
			}
		}

		internal static void ThrowError(string Message)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			MessageBox.Show(Message, "Fatal Error", (MessageBoxButton)0, (MessageBoxImage)16);
		}

		internal static OpenFileDialog PickGame(string Title, string Filter)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return new OpenFileDialog
			{
				Title = Title,
				Filter = Filter
			};
		}

		internal static RegistryKey? GetIFEOKey(bool WriteAccess)
		{
			return Registry.LocalMachine.OpenSubKey(m_IFEOPath, WriteAccess);
		}

		internal static RegistryKey? GetRunnerKey(string RunnerName, bool WriteAccess)
		{
			RegistryKey iFEOKey = GetIFEOKey(WriteAccess);
			try
			{
				return (iFEOKey != null) ? iFEOKey.CreateSubKey(RunnerName, true) : null;
			}
			finally
			{
				((System.IDisposable)iFEOKey)?.Dispose();
			}
		}

		internal static List<RegistryKey> GetAurieInstallerKeys()
		{
			List<RegistryKey> val = new List<RegistryKey>();
			RegistryKey iFEOKey = GetIFEOKey(WriteAccess: false);
			try
			{
				if (iFEOKey == null)
				{
					ThrowError("Failed to get runner IFEO key!");
					return val;
				}
				string[] subKeyNames = iFEOKey.GetSubKeyNames();
				foreach (string text in subKeyNames)
				{
					RegistryKey val2 = iFEOKey.OpenSubKey(text, false);
					if (val2 != null && Enumerable.Contains<string>((System.Collections.Generic.IEnumerable<string>)val2.GetValueNames(), "IsAurieInstallerKey"))
					{
						val.Add(val2);
					}
				}
				return val;
			}
			finally
			{
				((System.IDisposable)iFEOKey)?.Dispose();
			}
		}

		[RelayCommand]
		private void OnUninstallButton()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			OpenFileDialog val = PickGame("Select the game executable...", "PE Files|*.exe|All Files|*.*");
			if (!((CommonDialog)val).ShowDialog().GetValueOrDefault())
			{
				return;
			}
			string fileName = ((FileDialog)val).FileName;
			string safeFileName = ((FileDialog)val).SafeFileName;
			try
			{
				RegistryKey runnerKey = GetRunnerKey(safeFileName, WriteAccess: true);
				try
				{
					if (runnerKey == null)
					{
						ThrowError("Failed to get runner IFEO key!");
						return;
					}
					string text = fileName.Replace('\\', '_');
					if (!Enumerable.Contains<string>((System.Collections.Generic.IEnumerable<string>)runnerKey.GetValueNames(), "IsAurieInstallerKey"))
					{
						MessageBox.Show("The Aurie Framework registry key is corrupt.\nReinstall the framework and try again.", "Key is corrupt.", (MessageBoxButton)0, (MessageBoxImage)16);
						return;
					}
					if (!Enumerable.Contains<string>((System.Collections.Generic.IEnumerable<string>)runnerKey.GetSubKeyNames(), text))
					{
						MessageBox.Show("The Aurie Framework not installed for this executable!", "Framework not installed", (MessageBoxButton)0, (MessageBoxImage)16);
						return;
					}
					runnerKey.DeleteSubKeyTree(text);
					if (runnerKey.GetSubKeyNames().Length == 0)
					{
						RegistryKey iFEOKey = GetIFEOKey(WriteAccess: true);
						try
						{
							if (iFEOKey != null)
							{
								iFEOKey.DeleteSubKeyTree(safeFileName);
							}
						}
						finally
						{
							((System.IDisposable)iFEOKey)?.Dispose();
						}
					}
				}
				finally
				{
					((System.IDisposable)runnerKey)?.Dispose();
				}
				MessageBox.Show("Aurie Framework was uninstalled successfully.", "Success!", (MessageBoxButton)0, (MessageBoxImage)64);
			}
			catch (System.Exception ex)
			{
				ThrowError("Failed to access the required registry keys!\n" + ex.Message);
			}
		}

		[RelayCommand]
		private void OnInstallButton()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			OpenFileDialog val = PickGame("Select the game executable...", "PE Files|*.exe|All Files|*.*");
			if (!((CommonDialog)val).ShowDialog().GetValueOrDefault())
			{
				return;
			}
			string fileName = ((FileDialog)val).FileName;
			string safeFileName = ((FileDialog)val).SafeFileName;
			try
			{
				RegistryKey runnerKey = GetRunnerKey(safeFileName, WriteAccess: true);
				try
				{
					if (runnerKey == null)
					{
						ThrowError("Failed to get runner IFEO key!");
						return;
					}
					runnerKey.SetValue("IsAurieInstallerKey", (object)1, (RegistryValueKind)4);
					runnerKey.SetValue("UseFilter", (object)1, (RegistryValueKind)4);
					string text = fileName.Replace('\\', '_');
					if (Enumerable.Contains<string>((System.Collections.Generic.IEnumerable<string>)runnerKey.GetSubKeyNames(), text))
					{
						MessageBox.Show("The Aurie Framework is already installed for this executable!", "Framework already installed", (MessageBoxButton)0, (MessageBoxImage)48);
						return;
					}
					RegistryKey val2 = runnerKey.CreateSubKey(text, true);
					try
					{
						if (val2 == null)
						{
							ThrowError("Failed to create runner filter subkey!");
							return;
						}
						DirectoryInfo parent = Directory.GetParent(fileName);
						string text2 = ((parent != null) ? ((FileSystemInfo)parent).FullName : null) ?? "";
						if (text2.Equals(string.Empty))
						{
							ThrowError("Failed to get game folder!");
							return;
						}
						text2 = Path.Combine(text2, "mods", "AurieLoader.exe");
						val2.SetValue("Debugger", (object)text2);
						val2.SetValue("FilterFullPath", (object)fileName);
					}
					finally
					{
						((System.IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((System.IDisposable)runnerKey)?.Dispose();
				}
				MessageBox.Show("Aurie Framework was installed successfully.", "Success!", (MessageBoxButton)0, (MessageBoxImage)64);
			}
			catch (System.Exception ex)
			{
				ThrowError("Failed to access the required registry keys!\n" + ex.Message);
			}
		}
	}
	public class SettingsViewModel : ObservableObject, INavigationAware
	{
		private bool _isInitialized;

		[ObservableProperty]
		private string _appVersion = string.Empty;

		[ObservableProperty]
		private ThemeType _currentTheme;

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator", "8.2.0.0")]
		private RelayCommand<string>? changeThemeCommand;

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public string AppVersion
		{
			get
			{
				return _appVersion;
			}
			[MemberNotNull("_appVersion")]
			set
			{
				if (!EqualityComparer<string>.Default.Equals(_appVersion, value))
				{
					((ObservableObject)this).OnPropertyChanging(__KnownINotifyPropertyChangingArgs.AppVersion);
					_appVersion = value;
					((ObservableObject)this).OnPropertyChanged(__KnownINotifyPropertyChangedArgs.AppVersion);
				}
			}
		}

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public ThemeType CurrentTheme
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _currentTheme;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				if (!EqualityComparer<ThemeType>.Default.Equals(_currentTheme, value))
				{
					((ObservableObject)this).OnPropertyChanging(__KnownINotifyPropertyChangingArgs.CurrentTheme);
					_currentTheme = value;
					((ObservableObject)this).OnPropertyChanged(__KnownINotifyPropertyChangedArgs.CurrentTheme);
				}
			}
		}

		[GeneratedCode("CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator", "8.2.0.0")]
		[ExcludeFromCodeCoverage]
		public IRelayCommand<string> ChangeThemeCommand => (IRelayCommand<string>)(object)(changeThemeCommand ?? (changeThemeCommand = new RelayCommand<string>((Action<string>)OnChangeTheme)));

		public void OnNavigatedTo()
		{
			if (!_isInitialized)
			{
				InitializeViewModel();
			}
		}

		public void OnNavigatedFrom()
		{
		}

		private void InitializeViewModel()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CurrentTheme = Theme.GetAppTheme();
			AppVersion = "AurieInstaller - " + GetAssemblyVersion();
			_isInitialized = true;
		}

		private static string GetAssemblyVersion()
		{
			return ((object)Assembly.GetExecutingAssembly().GetName().Version)?.ToString() ?? string.Empty;
		}

		[RelayCommand]
		private void OnChangeTheme(string parameter)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			if (parameter == "theme_light")
			{
				if ((int)CurrentTheme != 2)
				{
					Theme.Apply((ThemeType)2, (WindowBackdropType)2, false, false);
					CurrentTheme = (ThemeType)2;
				}
			}
			else if ((int)CurrentTheme != 1)
			{
				Theme.Apply((ThemeType)1, (WindowBackdropType)2, false, false);
				CurrentTheme = (ThemeType)1;
			}
		}
	}
}
namespace AurieInstaller.Services
{
	public class ApplicationHostService : IHostedService
	{
		[StructLayout(3)]
		[CompilerGenerated]
		private struct <HandleActivationAsync>d__4 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public ApplicationHostService <>4__this;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				int num = <>1__state;
				ApplicationHostService applicationHostService = <>4__this;
				try
				{
					TaskAwaiter awaiter;
					if (num != 0)
					{
						awaiter = System.Threading.Tasks.Task.CompletedTask.GetAwaiter();
						if (!((TaskAwaiter)(ref awaiter)).IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <HandleActivationAsync>d__4>(ref awaiter, ref this);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
					}
					((TaskAwaiter)(ref awaiter)).GetResult();
					if (!Enumerable.Any<MainWindow>(Enumerable.OfType<MainWindow>((System.Collections.IEnumerable)Application.Current.Windows)))
					{
						MainWindow requiredService = ServiceProviderServiceExtensions.GetRequiredService<MainWindow>(applicationHostService._serviceProvider);
						((FrameworkElement)requiredService).Loaded += new RoutedEventHandler(applicationHostService.OnNavigationWindowLoaded);
						((Window)requiredService).Show();
					}
				}
				catch (System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
			}
		}

		[StructLayout(3)]
		[CompilerGenerated]
		private struct <StartAsync>d__2 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public ApplicationHostService <>4__this;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ApplicationHostService applicationHostService = <>4__this;
				try
				{
					TaskAwaiter awaiter;
					if (num != 0)
					{
						awaiter = applicationHostService.HandleActivationAsync().GetAwaiter();
						if (!((TaskAwaiter)(ref awaiter)).IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <StartAsync>d__2>(ref awaiter, ref this);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
					}
					((TaskAwaiter)(ref awaiter)).GetResult();
				}
				catch (System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
			}
		}

		[StructLayout(3)]
		[CompilerGenerated]
		private struct <StopAsync>d__3 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			private TaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				try
				{
					TaskAwaiter awaiter;
					if (num != 0)
					{
						awaiter = System.Threading.Tasks.Task.CompletedTask.GetAwaiter();
						if (!((TaskAwaiter)(ref awaiter)).IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = awaiter;
							((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<TaskAwaiter, <StopAsync>d__3>(ref awaiter, ref this);
							return;
						}
					}
					else
					{
						awaiter = <>u__1;
						<>u__1 = default(TaskAwaiter);
						num = (<>1__state = -1);
					}
					((TaskAwaiter)(ref awaiter)).GetResult();
				}
				catch (System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
			}
		}

		private readonly IServiceProvider _serviceProvider;

		public ApplicationHostService(IServiceProvider serviceProvider)
		{
			_serviceProvider = serviceProvider;
		}

		[AsyncStateMachine(typeof(<StartAsync>d__2))]
		public System.Threading.Tasks.Task StartAsync(CancellationToken cancellationToken)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			<StartAsync>d__2 <StartAsync>d__ = default(<StartAsync>d__2);
			<StartAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
			<StartAsync>d__.<>4__this = this;
			<StartAsync>d__.<>1__state = -1;
			((AsyncTaskMethodBuilder)(ref <StartAsync>d__.<>t__builder)).Start<<StartAsync>d__2>(ref <StartAsync>d__);
			return ((AsyncTaskMethodBuilder)(ref <StartAsync>d__.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<StopAsync>d__3))]
		public System.Threading.Tasks.Task StopAsync(CancellationToken cancellationToken)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			<StopAsync>d__3 <StopAsync>d__ = default(<StopAsync>d__3);
			<StopAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
			<StopAsync>d__.<>1__state = -1;
			((AsyncTaskMethodBuilder)(ref <StopAsync>d__.<>t__builder)).Start<<StopAsync>d__3>(ref <StopAsync>d__);
			return ((AsyncTaskMethodBuilder)(ref <StopAsync>d__.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<HandleActivationAsync>d__4))]
		private System.Threading.Tasks.Task HandleActivationAsync()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			<HandleActivationAsync>d__4 <HandleActivationAsync>d__ = default(<HandleActivationAsync>d__4);
			<HandleActivationAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
			<HandleActivationAsync>d__.<>4__this = this;
			<HandleActivationAsync>d__.<>1__state = -1;
			((AsyncTaskMethodBuilder)(ref <HandleActivationAsync>d__.<>t__builder)).Start<<HandleActivationAsync>d__4>(ref <HandleActivationAsync>d__);
			return ((AsyncTaskMethodBuilder)(ref <HandleActivationAsync>d__.<>t__builder)).Task;
		}

		private void OnNavigationWindowLoaded(object sender, RoutedEventArgs e)
		{
			if (sender is MainWindow mainWindow)
			{
				mainWindow.NavigationView.Navigate(typeof(DashboardPage), (object)null);
			}
		}
	}
}
namespace AurieInstaller.Resources
{
	public class Translations
	{
	}
}
namespace AurieInstaller.Models
{
	public class AppConfig
	{
		[field: CompilerGenerated]
		public string ConfigurationsFolder
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		[field: CompilerGenerated]
		public string AppPropertiesFileName
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}
	}
	public struct DataColor
	{
		[field: CompilerGenerated]
		public Brush Color
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}
	}
}
namespace AurieInstaller.Helpers
{
	internal class EnumToBooleanConverter : IValueConverter
	{
		public object Convert(object value, System.Type targetType, object parameter, CultureInfo culture)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!(parameter is string text))
			{
				throw new ArgumentException("ExceptionEnumToBooleanConverterParameterMustBeAnEnumName");
			}
			if (!System.Enum.IsDefined(typeof(ThemeType), value))
			{
				throw new ArgumentException("ExceptionEnumToBooleanConverterValueMustBeAnEnum");
			}
			return System.Enum.Parse(typeof(ThemeType), text).Equals(value);
		}

		public object ConvertBack(object value, System.Type targetType, object parameter, CultureInfo culture)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!(parameter is string text))
			{
				throw new ArgumentException("ExceptionEnumToBooleanConverterParameterMustBeAnEnumName");
			}
			return System.Enum.Parse(typeof(ThemeType), text);
		}
	}
}

using System;
using System.Buffers;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;
using CommunityToolkit.Mvvm.Collections.Internals;
using CommunityToolkit.Mvvm.ComponentModel.__Internals;
using CommunityToolkit.Mvvm.Input.Internals;
using CommunityToolkit.Mvvm.Messaging;
using CommunityToolkit.Mvvm.Messaging.Internals;
using CommunityToolkit.Mvvm.Messaging.Messages;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("8.2.1.1")]
[assembly: AssemblyInformationalVersion("8.2.1.1+2258fd3103")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: AssemblyMetadata("CommitHash", "2258fd310359fb7434d2040b34f04366efbacbf8")]
[assembly: AssemblyCompany("Microsoft")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("(c) .NET Foundation and Contributors. All rights reserved.")]
[assembly: AssemblyDescription("\r\n      This package includes a .NET MVVM library with helpers such as:\r\n      - ObservableObject: a base class for objects implementing the INotifyPropertyChanged interface.\r\n      - ObservableRecipient: a base class for observable objects with support for the IMessenger service.\r\n      - ObservableValidator: a base class for objects implementing the INotifyDataErrorInfo interface.\r\n      - RelayCommand: a simple delegate command implementing the ICommand interface.\r\n      - AsyncRelayCommand: a delegate command supporting asynchronous operations and cancellation.\r\n      - WeakReferenceMessenger: a messaging system to exchange messages through different loosely-coupled objects.\r\n      - StrongReferenceMessenger: a high-performance messaging system that trades weak references for speed.\r\n      - Ioc: a helper class to configure dependency injection service containers.\r\n    ")]
[assembly: AssemblyProduct(".NET Community Toolkit")]
[assembly: AssemblyTitle("CommunityToolkit.Mvvm")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/CommunityToolkit/dotnet")]
[assembly: InternalsVisibleTo("CommunityToolkit.Mvvm.Internals.UnitTests, PublicKey=002400000480000094000000060200000024000052534131000400000100010041753AF735AE6140C9508567666C51C6AB929806ADB0D210694B30AB142A060237BC741F9682E7D8D4310364B4BBA4EE89CC9D3D5CE7E5583587E8EA44DCA09977996582875E71FB54FA7B170798D853D5D8010B07219633BDB761D01AC924DA44576D6180CDCEAE537973982BB461C541541D58417A3794E34F45E6F2D129E2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("8.2.0.0")]
[assembly: TypeForwardedTo(typeof(IsExternalInit))]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: SkipLocalsInit]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.6.128.36433")]
[ExcludeFromCodeCoverage]
internal static class ThisAssembly
{
	internal const string AssemblyConfiguration = "Release";

	internal const string AssemblyFileVersion = "8.2.1.1";

	internal const string AssemblyInformationalVersion = "8.2.1.1+2258fd3103";

	internal const string AssemblyName = "CommunityToolkit.Mvvm";

	internal const string AssemblyTitle = "CommunityToolkit.Mvvm";

	internal const string AssemblyVersion = "8.2.0.0";

	internal static readonly DateTime GitCommitDate = new DateTime(638241791050000000L, DateTimeKind.Utc);

	internal const string GitCommitId = "2258fd310359fb7434d2040b34f04366efbacbf8";

	internal const bool IsPrerelease = false;

	internal const bool IsPublicRelease = true;

	internal const string PublicKey = "002400000480000094000000060200000024000052534131000400000100010041753af735ae6140c9508567666c51c6ab929806adb0d210694b30ab142a060237bc741f9682e7d8d4310364b4bba4ee89cc9d3d5ce7e5583587e8ea44dca09977996582875e71fb54fa7b170798d853d5d8010b07219633bdb761d01ac924da44576d6180cdceae537973982bb461c541541d58417a3794e34f45e6f2d129e2";

	internal const string PublicKeyToken = "4aff67a105548ee2";

	internal const string RootNamespace = "CommunityToolkit.Mvvm";
}
internal static class Configuration
{
	private const string DisableINotifyPropertyChangingSupport = "MVVMTOOLKIT_DISABLE_INOTIFYPROPERTYCHANGING";

	public static readonly bool IsINotifyPropertyChangingDisabled = GetConfigurationValue("MVVMTOOLKIT_DISABLE_INOTIFYPROPERTYCHANGING");

	private static bool GetConfigurationValue(string propertyName)
	{
		if (AppContext.TryGetSwitch(propertyName, out var isEnabled))
		{
			return isEnabled;
		}
		return false;
	}
}
namespace System
{
	internal sealed class Gen2GcCallback : CriticalFinalizerObject
	{
		private readonly Action<object> callback;

		private GCHandle handle;

		private Gen2GcCallback(Action<object> callback, object target)
		{
			this.callback = callback;
			handle = GCHandle.Alloc(target, GCHandleType.Weak);
		}

		public static void Register(Action<object> callback, object target)
		{
			new System.Gen2GcCallback(callback, target);
		}

		~Gen2GcCallback()
		{
			object target = handle.Target;
			if (target != null)
			{
				try
				{
					callback(target);
				}
				catch
				{
				}
				GC.ReRegisterForFinalize(this);
			}
			else
			{
				handle.Free();
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	internal sealed class ConditionalWeakTable2<TKey, TValue> where TKey : class where TValue : class?
	{
		public ref struct Enumerator
		{
			private ConditionalWeakTable2<TKey, TValue> table;

			private readonly int maxIndexInclusive;

			private int currentIndex;

			private TKey? key;

			private TValue? value;

			public Enumerator(ConditionalWeakTable2<TKey, TValue> table)
			{
				this.table = table;
				Container container = table.container;
				if (container == null || container.FirstFreeEntry == 0)
				{
					maxIndexInclusive = -1;
				}
				else
				{
					maxIndexInclusive = container.FirstFreeEntry - 1;
				}
				currentIndex = -1;
				key = null;
				value = null;
			}

			public void Dispose()
			{
				Monitor.Exit(table.lockObject);
				table = null;
				key = null;
				value = null;
			}

			public bool MoveNext()
			{
				Container container = table.container;
				int num = currentIndex;
				int num2 = maxIndexInclusive;
				while (num < num2)
				{
					num++;
					if (container.TryGetEntry(num, out key, out value))
					{
						currentIndex = num;
						return true;
					}
				}
				currentIndex = num;
				return false;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public TKey GetKey()
			{
				return key;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public TValue GetValue()
			{
				return value;
			}
		}

		private struct Entry
		{
			public DependentHandle depHnd;

			public int HashCode;

			public int Next;
		}

		private sealed class Container
		{
			private readonly ConditionalWeakTable2<TKey, TValue> parent;

			private int[] buckets;

			private Entry[] entries;

			private int firstFreeEntry;

			private bool invalid;

			private bool finalized;

			private volatile object? oldKeepAlive;

			internal bool HasCapacity => firstFreeEntry < entries.Length;

			internal int FirstFreeEntry => firstFreeEntry;

			internal Container(ConditionalWeakTable2<TKey, TValue> parent)
			{
				buckets = new int[8];
				for (int i = 0; i < buckets.Length; i++)
				{
					buckets[i] = -1;
				}
				entries = new Entry[8];
				this.parent = parent;
			}

			private Container(ConditionalWeakTable2<TKey, TValue> parent, int[] buckets, Entry[] entries, int firstFreeEntry)
			{
				this.parent = parent;
				this.buckets = buckets;
				this.entries = entries;
				this.firstFreeEntry = firstFreeEntry;
			}

			internal void CreateEntryNoResize(TKey key, TValue value)
			{
				VerifyIntegrity();
				invalid = true;
				int num = RuntimeHelpers.GetHashCode(key) & 0x7FFFFFFF;
				int num2 = firstFreeEntry++;
				entries[num2].HashCode = num;
				entries[num2].depHnd = new DependentHandle(key, value);
				int num3 = num & (buckets.Length - 1);
				entries[num2].Next = buckets[num3];
				Volatile.Write(ref buckets[num3], num2);
				invalid = false;
			}

			internal bool TryGetValueWorker(TKey key, [MaybeNullWhen(false)] out TValue value)
			{
				object value2;
				int num = FindEntry(key, out value2);
				value = Unsafe.As<TValue>(value2);
				return num != -1;
			}

			internal int FindEntry(TKey key, out object? value)
			{
				int num = RuntimeHelpers.GetHashCode(key) & 0x7FFFFFFF;
				int num2 = num & (buckets.Length - 1);
				for (int num3 = Volatile.Read(ref buckets[num2]); num3 != -1; num3 = entries[num3].Next)
				{
					if (entries[num3].HashCode == num)
					{
						object obj;
						(obj, value) = entries[num3].depHnd.TargetAndDependent;
						if (obj == key)
						{
							GC.KeepAlive(this);
							return num3;
						}
					}
				}
				GC.KeepAlive(this);
				value = null;
				return -1;
			}

			internal bool TryGetEntry(int index, [NotNullWhen(true)] out TKey? key, [MaybeNullWhen(false)] out TValue value)
			{
				if (index < entries.Length)
				{
					var (obj, o) = entries[index].depHnd.TargetAndDependent;
					GC.KeepAlive(this);
					if (obj != null)
					{
						key = Unsafe.As<TKey>(obj);
						value = Unsafe.As<TValue>(o);
						return true;
					}
				}
				key = null;
				value = null;
				return false;
			}

			internal bool Remove(TKey key)
			{
				VerifyIntegrity();
				object value;
				int num = FindEntry(key, out value);
				if (num != -1)
				{
					RemoveIndex(num);
					return true;
				}
				return false;
			}

			private void RemoveIndex(int entryIndex)
			{
				ref Entry reference = ref entries[entryIndex];
				Volatile.Write(ref reference.HashCode, -1);
				reference.depHnd.Target = null;
			}

			internal Container Resize()
			{
				bool flag = false;
				int newSize = buckets.Length;
				for (int i = 0; i < entries.Length; i++)
				{
					ref Entry reference = ref entries[i];
					if (reference.HashCode == -1)
					{
						flag = true;
						break;
					}
					if (reference.depHnd.IsAllocated && reference.depHnd.Target == null)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					newSize = buckets.Length * 2;
				}
				return Resize(newSize);
			}

			internal Container Resize(int newSize)
			{
				int[] array = new int[newSize];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = -1;
				}
				Entry[] array2 = new Entry[newSize];
				int num = 0;
				for (int j = 0; j < entries.Length; j++)
				{
					ref Entry reference = ref entries[j];
					int hashCode = reference.HashCode;
					DependentHandle depHnd = reference.depHnd;
					if (hashCode != -1 && depHnd.IsAllocated)
					{
						if (depHnd.Target != null)
						{
							ref Entry reference2 = ref array2[num];
							reference2.HashCode = hashCode;
							reference2.depHnd = depHnd;
							int num2 = hashCode & (array.Length - 1);
							reference2.Next = array[num2];
							array[num2] = num;
							num++;
						}
						else
						{
							Volatile.Write(ref reference.HashCode, -1);
						}
					}
				}
				Container result = (Container)(oldKeepAlive = new Container(parent, array, array2, num));
				GC.KeepAlive(this);
				return result;
			}

			private void VerifyIntegrity()
			{
				if (invalid)
				{
					Throw();
				}
				static void Throw()
				{
					throw new InvalidOperationException("The current collection is in a corrupted state.");
				}
			}

			~Container()
			{
				if (invalid || parent == null)
				{
					return;
				}
				if (!finalized)
				{
					finalized = true;
					lock (parent.lockObject)
					{
						if (parent.container == this)
						{
							parent.container = null;
						}
					}
					GC.ReRegisterForFinalize(this);
					return;
				}
				Entry[] array = entries;
				invalid = true;
				entries = null;
				buckets = null;
				if (array == null)
				{
					return;
				}
				int i = 0;
				for (; i < array.Length; i++)
				{
					if (oldKeepAlive == null || array[i].HashCode == -1)
					{
						array[i].depHnd.Dispose();
					}
				}
			}
		}

		private const int InitialCapacity = 8;

		private readonly object lockObject;

		private volatile Container container;

		public ConditionalWeakTable2()
		{
			lockObject = new object();
			container = new Container(this);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return container.TryGetValueWorker(key, out value);
		}

		public bool TryAdd(TKey key, TValue value)
		{
			lock (lockObject)
			{
				if (container.FindEntry(key, out object _) != -1)
				{
					return false;
				}
				CreateEntry(key, value);
				return true;
			}
		}

		public bool Remove(TKey key)
		{
			lock (lockObject)
			{
				return container.Remove(key);
			}
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2091", Justification = "ConditionalWeakTable<TKey, TValue> is only referenced to reuse the callback delegate type, but no value is ever created through reflection.")]
		public TValue GetValue(TKey key, ConditionalWeakTable<TKey, TValue>.CreateValueCallback createValueCallback)
		{
			if (!TryGetValue(key, out var value))
			{
				return GetValueLocked(key, createValueCallback);
			}
			return value;
		}

		[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2091", Justification = "ConditionalWeakTable<TKey, TValue> is only referenced to reuse the callback delegate type, but no value is ever created through reflection.")]
		private TValue GetValueLocked(TKey key, ConditionalWeakTable<TKey, TValue>.CreateValueCallback createValueCallback)
		{
			TValue val = createValueCallback(key);
			lock (lockObject)
			{
				if (container.TryGetValueWorker(key, out var value))
				{
					return value;
				}
				CreateEntry(key, val);
				return val;
			}
		}

		public Enumerator GetEnumerator()
		{
			Monitor.Enter(lockObject);
			return new Enumerator(this);
		}

		private void CreateEntry(TKey key, TValue value)
		{
			Container container = this.container;
			if (!container.HasCapacity)
			{
				container = (this.container = container.Resize());
			}
			container.CreateEntryNoResize(key, value);
		}
	}
}
namespace System.Collections.Generic
{
	[DebuggerDisplay("Count = {Count}")]
	internal class Dictionary2<TKey, TValue> : IDictionary2<TKey, TValue>, IDictionary2<TKey>, IDictionary2 where TKey : IEquatable<TKey> where TValue : class?
	{
		public ref struct Enumerator
		{
			private readonly Entry[] entries;

			private int index;

			private readonly int count;

			internal Enumerator(Dictionary2<TKey, TValue> dictionary)
			{
				entries = dictionary.entries;
				index = 0;
				count = dictionary.count;
			}

			public bool MoveNext()
			{
				while ((uint)index < (uint)count)
				{
					if (entries[index++].Next >= -1)
					{
						return true;
					}
				}
				index = count + 1;
				return false;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public TKey GetKey()
			{
				return entries[index - 1].Key;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public TValue GetValue()
			{
				return entries[index - 1].Value;
			}
		}

		private struct Entry
		{
			public uint HashCode;

			public int Next;

			public TKey Key;

			public TValue? Value;
		}

		private const int StartOfFreeList = -3;

		private int[] buckets;

		private Entry[] entries;

		private ulong fastModMultiplier;

		private int count;

		private int freeList;

		private int freeCount;

		public int Count
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return count - freeCount;
			}
		}

		public TValue this[TKey key]
		{
			get
			{
				ref TValue reference = ref FindValue(key);
				if (!Unsafe.IsNullRef(ref reference))
				{
					return reference;
				}
				ThrowArgumentExceptionForKeyNotFound(key);
				return null;
			}
		}

		public Dictionary2()
		{
			Initialize(0);
		}

		public void Clear()
		{
			int num = count;
			if (num > 0)
			{
				Array.Clear(buckets);
				count = 0;
				freeList = -1;
				freeCount = 0;
				Array.Clear(entries, 0, num);
			}
		}

		public bool ContainsKey(TKey key)
		{
			return !Unsafe.IsNullRef(ref FindValue(key));
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			ref TValue reference = ref FindValue(key);
			if (!Unsafe.IsNullRef(ref reference))
			{
				value = reference;
				return true;
			}
			value = null;
			return false;
		}

		public bool TryRemove(TKey key)
		{
			uint hashCode = (uint)key.GetHashCode();
			ref int bucket = ref GetBucket(hashCode);
			Entry[] array = entries;
			int num = -1;
			int num2 = bucket - 1;
			while (num2 >= 0)
			{
				ref Entry reference = ref array[num2];
				if (reference.HashCode == hashCode && reference.Key.Equals(key))
				{
					if (num < 0)
					{
						bucket = reference.Next + 1;
					}
					else
					{
						array[num].Next = reference.Next;
					}
					reference.Next = -3 - freeList;
					if (RuntimeHelpers.IsReferenceOrContainsReferences<TKey>())
					{
						reference.Key = default(TKey);
					}
					if (RuntimeHelpers.IsReferenceOrContainsReferences<TValue>())
					{
						reference.Value = null;
					}
					freeList = num2;
					freeCount++;
					return true;
				}
				num = num2;
				num2 = reference.Next;
			}
			return false;
		}

		public ref TValue? GetOrAddValueRef(TKey key)
		{
			Entry[] array = entries;
			uint hashCode = (uint)key.GetHashCode();
			ref int bucket = ref GetBucket(hashCode);
			int num = bucket - 1;
			while ((uint)num < (uint)array.Length)
			{
				if (array[num].HashCode == hashCode && array[num].Key.Equals(key))
				{
					return ref array[num].Value;
				}
				num = array[num].Next;
			}
			int num2;
			if (freeCount > 0)
			{
				num2 = freeList;
				freeList = -3 - array[freeList].Next;
				freeCount--;
			}
			else
			{
				int num3 = count;
				if (num3 == array.Length)
				{
					Resize();
					bucket = ref GetBucket(hashCode);
				}
				num2 = num3;
				count = num3 + 1;
				array = entries;
			}
			ref Entry reference = ref array[num2];
			reference.HashCode = hashCode;
			reference.Next = bucket - 1;
			reference.Key = key;
			reference.Value = null;
			bucket = num2 + 1;
			return ref reference.Value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		private unsafe ref TValue FindValue(TKey key)
		{
			ref Entry reference = ref *(Entry*)null;
			uint hashCode = (uint)key.GetHashCode();
			int bucket = GetBucket(hashCode);
			Entry[] array = entries;
			bucket--;
			while ((uint)bucket < (uint)array.Length)
			{
				reference = ref array[bucket];
				if (reference.HashCode != hashCode || !reference.Key.Equals(key))
				{
					bucket = reference.Next;
					continue;
				}
				return ref reference.Value;
			}
			return ref *(TValue*)null;
		}

		[MemberNotNull(new string[] { "buckets", "entries" })]
		private void Initialize(int capacity)
		{
			int prime = HashHelpers.GetPrime(capacity);
			int[] array = new int[prime];
			Entry[] array2 = new Entry[prime];
			freeList = -1;
			fastModMultiplier = HashHelpers.GetFastModMultiplier((uint)prime);
			buckets = array;
			entries = array2;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Resize()
		{
			int num = HashHelpers.ExpandPrime(count);
			Entry[] array = new Entry[num];
			int num2 = count;
			Array.Copy(entries, array, num2);
			buckets = new int[num];
			fastModMultiplier = HashHelpers.GetFastModMultiplier((uint)num);
			for (int i = 0; i < num2; i++)
			{
				if (array[i].Next >= -1)
				{
					ref int bucket = ref GetBucket(array[i].HashCode);
					array[i].Next = bucket - 1;
					bucket = i + 1;
				}
			}
			entries = array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ref int GetBucket(uint hashCode)
		{
			int[] array = buckets;
			return ref array[HashHelpers.FastMod(hashCode, (uint)array.Length, fastModMultiplier)];
		}

		private static void ThrowArgumentExceptionForKeyNotFound(TKey key)
		{
			throw new ArgumentException($"The target key {key} was not present in the dictionary");
		}
	}
	internal static class HashHelpers
	{
		private const int MaxPrimeArrayLength = 2147483587;

		private const int HashPrime = 101;

		private static readonly int[] primes = new int[72]
		{
			3, 7, 11, 17, 23, 29, 37, 47, 59, 71,
			89, 107, 131, 163, 197, 239, 293, 353, 431, 521,
			631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371,
			4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591, 17519, 21023,
			25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363,
			156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403,
			968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559,
			5999471, 7199369
		};

		private static bool IsPrime(int candidate)
		{
			if (((uint)candidate & (true ? 1u : 0u)) != 0)
			{
				int num = (int)Math.Sqrt(candidate);
				for (int i = 3; i <= num; i += 2)
				{
					if (candidate % i == 0)
					{
						return false;
					}
				}
				return true;
			}
			return candidate == 2;
		}

		public static int GetPrime(int min)
		{
			int[] array = primes;
			foreach (int num in array)
			{
				if (num >= min)
				{
					return num;
				}
			}
			for (int j = min | 1; j < int.MaxValue; j += 2)
			{
				if (IsPrime(j) && (j - 1) % 101 != 0)
				{
					return j;
				}
			}
			return min;
		}

		public static int ExpandPrime(int oldSize)
		{
			int num = 2 * oldSize;
			if ((uint)num > 2147483587u && 2147483587 > oldSize)
			{
				return 2147483587;
			}
			return GetPrime(num);
		}

		public static ulong GetFastModMultiplier(uint divisor)
		{
			return ulong.MaxValue / (ulong)divisor + 1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint FastMod(uint value, uint divisor, ulong multiplier)
		{
			return (uint)(((multiplier * value >> 32) + 1) * divisor >> 32);
		}
	}
	internal interface IDictionary2
	{
		int Count { get; }

		void Clear();
	}
	internal interface IDictionary2<in TKey, out TValue> : IDictionary2<TKey>, IDictionary2 where TKey : IEquatable<TKey> where TValue : class?
	{
		TValue this[TKey key] { get; }
	}
	internal interface IDictionary2<in TKey> : IDictionary2 where TKey : IEquatable<TKey>
	{
		bool TryRemove(TKey key);
	}
}
namespace CommunityToolkit.Mvvm
{
	internal sealed class ArgumentNullException
	{
		public static class For<T>
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static void ThrowIfNull([NotNull] T? argument, [CallerArgumentExpression("argument")] string? paramName = null)
			{
				if (argument == null)
				{
					Throw(paramName);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpression("argument")] string? paramName = null)
		{
			if (argument == null)
			{
				Throw(paramName);
			}
		}

		[DoesNotReturn]
		private static void Throw(string? paramName)
		{
			throw new System.ArgumentNullException(paramName);
		}
	}
}
namespace CommunityToolkit.Mvvm.Messaging
{
	public interface IMessenger
	{
		bool IsRegistered<TMessage, TToken>(object recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>;

		void Register<TRecipient, TMessage, TToken>(TRecipient recipient, TToken token, MessageHandler<TRecipient, TMessage> handler) where TRecipient : class where TMessage : class where TToken : IEquatable<TToken>;

		void UnregisterAll(object recipient);

		void UnregisterAll<TToken>(object recipient, TToken token) where TToken : IEquatable<TToken>;

		void Unregister<TMessage, TToken>(object recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>;

		TMessage Send<TMessage, TToken>(TMessage message, TToken token) where TMessage : class where TToken : IEquatable<TToken>;

		void Cleanup();

		void Reset();
	}
	public static class IMessengerExtensions
	{
		private static class MethodInfos
		{
			public static readonly MethodInfo RegisterIRecipient = new Action<IMessenger, IRecipient<object>, Unit>(Register).Method.GetGenericMethodDefinition();
		}

		private static class DiscoveredRecipients
		{
			public static readonly ConditionalWeakTable<Type, Action<IMessenger, object>?> RegistrationMethods = new ConditionalWeakTable<Type, Action<IMessenger, object>>();
		}

		private static class DiscoveredRecipients<TToken> where TToken : IEquatable<TToken>
		{
			public static readonly ConditionalWeakTable<Type, Action<IMessenger, object, TToken>> RegistrationMethods = new ConditionalWeakTable<Type, Action<IMessenger, object, TToken>>();
		}

		private sealed class Observable<TMessage> : IObservable<TMessage> where TMessage : class
		{
			private sealed class Recipient : IRecipient<TMessage>, IDisposable
			{
				private readonly IMessenger messenger;

				private readonly IObserver<TMessage> observer;

				public Recipient(IMessenger messenger, IObserver<TMessage> observer)
				{
					this.messenger = messenger;
					this.observer = observer;
					messenger.Register(this);
				}

				public void Receive(TMessage message)
				{
					observer.OnNext(message);
				}

				public void Dispose()
				{
					messenger.Unregister<TMessage>(this);
				}
			}

			private readonly IMessenger messenger;

			public Observable(IMessenger messenger)
			{
				this.messenger = messenger;
			}

			public IDisposable Subscribe(IObserver<TMessage> observer)
			{
				return new Recipient(messenger, observer);
			}
		}

		private sealed class Observable<TMessage, TToken> : IObservable<TMessage> where TMessage : class where TToken : IEquatable<TToken>
		{
			private sealed class Recipient : IRecipient<TMessage>, IDisposable
			{
				private readonly IMessenger messenger;

				private readonly IObserver<TMessage> observer;

				private readonly TToken token;

				public Recipient(IMessenger messenger, IObserver<TMessage> observer, TToken token)
				{
					this.messenger = messenger;
					this.observer = observer;
					this.token = token;
					messenger.Register(this, token);
				}

				public void Receive(TMessage message)
				{
					observer.OnNext(message);
				}

				public void Dispose()
				{
					messenger.Unregister<TMessage, TToken>(this, token);
				}
			}

			private readonly IMessenger messenger;

			private readonly TToken token;

			public Observable(IMessenger messenger, TToken token)
			{
				this.messenger = messenger;
				this.token = token;
			}

			public IDisposable Subscribe(IObserver<TMessage> observer)
			{
				return new Recipient(messenger, observer, token);
			}
		}

		public static bool IsRegistered<TMessage>(this IMessenger messenger, object recipient) where TMessage : class
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			return messenger.IsRegistered<TMessage, Unit>(recipient, default(Unit));
		}

		[RequiresUnreferencedCode("This method requires the generated CommunityToolkit.Mvvm.Messaging.__Internals.__IMessengerExtensions type not to be removed to use the fast path. If this type is removed by the linker, or if the target recipient was created dynamically and was missed by the source generator, a slower fallback path using a compiled LINQ expression will be used. This will have more overhead in the first invocation of this method for any given recipient type.")]
		public static void RegisterAll(this IMessenger messenger, object recipient)
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			Action<IMessenger, object> value = DiscoveredRecipients.RegistrationMethods.GetValue(recipient.GetType(), [RequiresUnreferencedCode("The type of the current instance cannot be statically discovered.")] (Type t) => LoadRegistrationMethodsForType(t));
			if (value != null)
			{
				value(messenger, recipient);
			}
			else
			{
				messenger.RegisterAll(recipient, default(Unit));
			}
			[RequiresUnreferencedCode("The type of the current instance cannot be statically discovered.")]
			static Action<IMessenger, object>? LoadRegistrationMethodsForType(Type recipientType)
			{
				Type type = recipientType.Assembly.GetType("CommunityToolkit.Mvvm.Messaging.__Internals.__IMessengerExtensions");
				if ((object)type != null)
				{
					MethodInfo method = type.GetMethod("CreateAllMessagesRegistrator", new Type[1] { recipientType });
					if ((object)method != null)
					{
						return (Action<IMessenger, object>)method.Invoke(null, new object[1]);
					}
				}
				return null;
			}
		}

		[RequiresUnreferencedCode("This method requires the generated CommunityToolkit.Mvvm.Messaging.__Internals.__IMessengerExtensions type not to be removed to use the fast path. If this type is removed by the linker, or if the target recipient was created dynamically and was missed by the source generator, a slower fallback path using a compiled LINQ expression will be used. This will have more overhead in the first invocation of this method for any given recipient type.")]
		public static void RegisterAll<TToken>(this IMessenger messenger, object recipient, TToken token) where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			DiscoveredRecipients<TToken>.RegistrationMethods.GetValue(recipient.GetType(), [RequiresUnreferencedCode("The type of the current instance cannot be statically discovered.")] (Type t) => LoadRegistrationMethodsForType(t))(messenger, recipient, token);
			[RequiresUnreferencedCode("The type of the current instance cannot be statically discovered.")]
			static Action<IMessenger, object, TToken> LoadRegistrationMethodsForType(Type recipientType)
			{
				Type type = recipientType.Assembly.GetType("CommunityToolkit.Mvvm.Messaging.__Internals.__IMessengerExtensions");
				if ((object)type != null)
				{
					MethodInfo method = type.GetMethod("CreateAllMessagesRegistratorWithToken", new Type[1] { recipientType });
					if ((object)method != null)
					{
						return (Action<IMessenger, object, TToken>)method.MakeGenericMethod(typeof(TToken)).Invoke(null, new object[1]);
					}
				}
				return LoadRegistrationMethodsForTypeFallback(recipientType);
			}
			static Action<IMessenger, object, TToken> LoadRegistrationMethodsForTypeFallback(Type recipientType)
			{
				MethodInfo[] array = (from interfaceType in recipientType.GetInterfaces()
					where interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(IRecipient<>)
					let messageType = interfaceType.GenericTypeArguments[0]
					select MethodInfos.RegisterIRecipient.MakeGenericMethod(messageType, typeof(TToken))).ToArray();
				if (array.Length == 0)
				{
					return delegate
					{
					};
				}
				ParameterExpression arg0 = Expression.Parameter(typeof(IMessenger));
				ParameterExpression parameterExpression = Expression.Parameter(typeof(object));
				ParameterExpression arg = Expression.Parameter(typeof(TToken));
				UnaryExpression inst1 = Expression.Convert(parameterExpression, recipientType);
				return Expression.Lambda<Action<IMessenger, object, TToken>>(Expression.Block(array.Select((MethodInfo registrationMethod) => Expression.Call(registrationMethod, new Expression[3] { arg0, inst1, arg }))), new ParameterExpression[3] { arg0, parameterExpression, arg }).Compile();
			}
		}

		public static void Register<TMessage>(this IMessenger messenger, IRecipient<TMessage> recipient) where TMessage : class
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			if (messenger is WeakReferenceMessenger weakReferenceMessenger)
			{
				weakReferenceMessenger.Register(recipient, default(Unit));
				return;
			}
			if (messenger is StrongReferenceMessenger strongReferenceMessenger)
			{
				strongReferenceMessenger.Register(recipient, default(Unit));
				return;
			}
			messenger.Register(recipient, default(Unit), delegate(IRecipient<TMessage> r, TMessage m)
			{
				r.Receive(m);
			});
		}

		public static void Register<TMessage, TToken>(this IMessenger messenger, IRecipient<TMessage> recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			if (messenger is WeakReferenceMessenger weakReferenceMessenger)
			{
				weakReferenceMessenger.Register(recipient, token);
				return;
			}
			if (messenger is StrongReferenceMessenger strongReferenceMessenger)
			{
				strongReferenceMessenger.Register(recipient, token);
				return;
			}
			messenger.Register(recipient, token, delegate(IRecipient<TMessage> r, TMessage m)
			{
				r.Receive(m);
			});
		}

		public static void Register<TMessage>(this IMessenger messenger, object recipient, MessageHandler<object, TMessage> handler) where TMessage : class
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.ThrowIfNull(handler, "handler");
			messenger.Register(recipient, default(Unit), handler);
		}

		public static void Register<TRecipient, TMessage>(this IMessenger messenger, TRecipient recipient, MessageHandler<TRecipient, TMessage> handler) where TRecipient : class where TMessage : class
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.ThrowIfNull(handler, "handler");
			messenger.Register(recipient, default(Unit), handler);
		}

		public static void Register<TMessage, TToken>(this IMessenger messenger, object recipient, TToken token, MessageHandler<object, TMessage> handler) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			ArgumentNullException.ThrowIfNull(handler, "handler");
			messenger.Register(recipient, token, handler);
		}

		public static void Unregister<TMessage>(this IMessenger messenger, object recipient) where TMessage : class
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			messenger.Unregister<TMessage, Unit>(recipient, default(Unit));
		}

		public static TMessage Send<TMessage>(this IMessenger messenger) where TMessage : class, new()
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			return messenger.Send(new TMessage(), default(Unit));
		}

		public static TMessage Send<TMessage>(this IMessenger messenger, TMessage message) where TMessage : class
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.ThrowIfNull(message, "message");
			return messenger.Send(message, default(Unit));
		}

		public static TMessage Send<TMessage, TToken>(this IMessenger messenger, TToken token) where TMessage : class, new() where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			return messenger.Send(new TMessage(), token);
		}

		public static IObservable<TMessage> CreateObservable<TMessage>(this IMessenger messenger) where TMessage : class
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			return new Observable<TMessage>(messenger);
		}

		public static IObservable<TMessage> CreateObservable<TMessage, TToken>(this IMessenger messenger, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			return new Observable<TMessage, TToken>(messenger, token);
		}
	}
	public interface IRecipient<in TMessage> where TMessage : class
	{
		void Receive(TMessage message);
	}
	public delegate void MessageHandler<in TRecipient, in TMessage>(TRecipient recipient, TMessage message) where TRecipient : class where TMessage : class;
	public sealed class StrongReferenceMessenger : IMessenger
	{
		private sealed class Mapping : Dictionary2<Recipient, object?>, IMapping, IDictionary2<Recipient>, IDictionary2
		{
			public Type2 TypeArguments { get; }

			private Mapping(Type messageType)
			{
				TypeArguments = new Type2(messageType, typeof(Unit));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static Mapping Create<TMessage>() where TMessage : class
			{
				return new Mapping(typeof(TMessage));
			}
		}

		private sealed class Mapping<TToken> : Dictionary2<Recipient, Dictionary2<TToken, object?>>, IMapping, IDictionary2<Recipient>, IDictionary2 where TToken : IEquatable<TToken>
		{
			public Type2 TypeArguments { get; }

			private Mapping(Type messageType)
			{
				TypeArguments = new Type2(messageType, typeof(TToken));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static Mapping<TToken> Create<TMessage>() where TMessage : class
			{
				return new Mapping<TToken>(typeof(TMessage));
			}
		}

		private interface IMapping : IDictionary2<Recipient>, IDictionary2
		{
			Type2 TypeArguments { get; }
		}

		private readonly struct Recipient : IEquatable<Recipient>
		{
			public readonly object Target;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Recipient(object target)
			{
				Target = target;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool Equals(Recipient other)
			{
				return Target == other.Target;
			}

			public override bool Equals(object? obj)
			{
				if (obj is Recipient other)
				{
					return Equals(other);
				}
				return false;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public override int GetHashCode()
			{
				return RuntimeHelpers.GetHashCode(Target);
			}
		}

		private readonly Dictionary2<Recipient, HashSet<IMapping>> recipientsMap = new Dictionary2<Recipient, HashSet<IMapping>>();

		private readonly Dictionary2<Type2, IMapping> typesMap = new Dictionary2<Type2, IMapping>();

		public static StrongReferenceMessenger Default { get; } = new StrongReferenceMessenger();


		public bool IsRegistered<TMessage, TToken>(object recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			lock (recipientsMap)
			{
				if (typeof(TToken) == typeof(Unit))
				{
					if (!TryGetMapping<TMessage>(out Mapping mapping))
					{
						return false;
					}
					Recipient key = new Recipient(recipient);
					return mapping.ContainsKey(key);
				}
				if (!TryGetMapping<TMessage, TToken>(out Mapping<TToken> mapping2))
				{
					return false;
				}
				Recipient key2 = new Recipient(recipient);
				Dictionary2<TToken, object> value;
				return mapping2.TryGetValue(key2, out value) && value.ContainsKey(token);
			}
		}

		public void Register<TRecipient, TMessage, TToken>(TRecipient recipient, TToken token, MessageHandler<TRecipient, TMessage> handler) where TRecipient : class where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			ArgumentNullException.ThrowIfNull(handler, "handler");
			Register<TMessage, TToken>(recipient, token, new MessageHandlerDispatcher.For<TRecipient, TMessage>(handler));
		}

		internal void Register<TMessage, TToken>(IRecipient<TMessage> recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			Register<TMessage, TToken>(recipient, token, null);
		}

		private void Register<TMessage, TToken>(object recipient, TToken token, MessageHandlerDispatcher? dispatcher) where TMessage : class where TToken : IEquatable<TToken>
		{
			lock (recipientsMap)
			{
				Recipient key = new Recipient(recipient);
				IMapping item;
				if (typeof(TToken) == typeof(Unit))
				{
					Mapping orAddMapping = GetOrAddMapping<TMessage>();
					ref object? orAddValueRef = ref orAddMapping.GetOrAddValueRef(key);
					if (orAddValueRef != null)
					{
						ThrowInvalidOperationExceptionForDuplicateRegistration();
					}
					orAddValueRef = dispatcher;
					item = orAddMapping;
				}
				else
				{
					Mapping<TToken> orAddMapping2 = GetOrAddMapping<TMessage, TToken>();
					ref Dictionary2<TToken, object> orAddValueRef2 = ref orAddMapping2.GetOrAddValueRef(key);
					if (orAddValueRef2 == null)
					{
						orAddValueRef2 = new Dictionary2<TToken, object>();
					}
					ref object? orAddValueRef3 = ref orAddValueRef2.GetOrAddValueRef(token);
					if (orAddValueRef3 != null)
					{
						ThrowInvalidOperationExceptionForDuplicateRegistration();
					}
					orAddValueRef3 = dispatcher;
					item = orAddMapping2;
				}
				ref HashSet<IMapping> orAddValueRef4 = ref recipientsMap.GetOrAddValueRef(key);
				if (orAddValueRef4 == null)
				{
					orAddValueRef4 = new HashSet<IMapping>();
				}
				orAddValueRef4.Add(item);
			}
		}

		public void UnregisterAll(object recipient)
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			lock (recipientsMap)
			{
				Recipient key = new Recipient(recipient);
				if (!recipientsMap.TryGetValue(key, out HashSet<IMapping> value))
				{
					return;
				}
				foreach (IMapping item in value)
				{
					if (item.TryRemove(key) && item.Count == 0)
					{
						typesMap.TryRemove(item.TypeArguments);
					}
				}
				recipientsMap.TryRemove(key);
			}
		}

		public void UnregisterAll<TToken>(object recipient, TToken token) where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			if (typeof(TToken) == typeof(Unit))
			{
				throw new NotImplementedException();
			}
			bool lockTaken = false;
			object[] array = null;
			int length = 0;
			try
			{
				Monitor.Enter(recipientsMap, ref lockTaken);
				Recipient key = new Recipient(recipient);
				if (!recipientsMap.TryGetValue(key, out HashSet<IMapping> value))
				{
					return;
				}
				array = ArrayPool<object>.Shared.Rent(value.Count);
				foreach (IMapping item in value)
				{
					if (item is IDictionary2<Recipient, IDictionary2<TToken>> dictionary)
					{
						array[length++] = dictionary;
					}
				}
				Span<object> span = array.AsSpan(0, length);
				for (int i = 0; i < span.Length; i++)
				{
					IDictionary2<Recipient, IDictionary2<TToken>> dictionary2 = Unsafe.As<IDictionary2<Recipient, IDictionary2<TToken>>>(span[i]);
					IDictionary2<TToken> dictionary3 = dictionary2[key];
					if (dictionary3.TryRemove(token) && dictionary3.Count == 0)
					{
						dictionary2.TryRemove(key);
						IMapping mapping = Unsafe.As<IMapping>(dictionary2);
						value.Remove(mapping);
						if (value.Count == 0)
						{
							recipientsMap.TryRemove(key);
						}
						if (dictionary2.Count == 0)
						{
							typesMap.TryRemove(mapping.TypeArguments);
						}
					}
				}
			}
			finally
			{
				if (lockTaken)
				{
					Monitor.Exit(recipientsMap);
				}
				if (array != null)
				{
					array.AsSpan(0, length).Clear();
					ArrayPool<object>.Shared.Return(array);
				}
			}
		}

		public void Unregister<TMessage, TToken>(object recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			lock (recipientsMap)
			{
				if (typeof(TToken) == typeof(Unit))
				{
					if (!TryGetMapping<TMessage>(out Mapping mapping))
					{
						return;
					}
					Recipient key = new Recipient(recipient);
					if (mapping.TryRemove(key))
					{
						mapping.TryRemove(key);
						if (mapping.Count == 0)
						{
							typesMap.TryRemove(mapping.TypeArguments);
						}
						HashSet<IMapping> hashSet = recipientsMap[key];
						hashSet.Remove(mapping);
						if (hashSet.Count == 0)
						{
							recipientsMap.TryRemove(key);
						}
					}
				}
				else
				{
					if (!TryGetMapping<TMessage, TToken>(out Mapping<TToken> mapping2))
					{
						return;
					}
					Recipient key2 = new Recipient(recipient);
					if (mapping2.TryGetValue(key2, out Dictionary2<TToken, object> value) && value.TryRemove(token) && value.Count == 0)
					{
						mapping2.TryRemove(key2);
						if (mapping2.Count == 0)
						{
							typesMap.TryRemove(mapping2.TypeArguments);
						}
						HashSet<IMapping> hashSet2 = recipientsMap[key2];
						hashSet2.Remove(mapping2);
						if (hashSet2.Count == 0)
						{
							recipientsMap.TryRemove(key2);
						}
					}
				}
			}
		}

		public TMessage Send<TMessage, TToken>(TMessage message, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(message, "message");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			int num = 0;
			Span<object> span;
			object[] array;
			lock (recipientsMap)
			{
				Mapping<TToken> mapping2;
				if (typeof(TToken) == typeof(Unit))
				{
					if (TryGetMapping<TMessage>(out Mapping mapping))
					{
						int count = mapping.Count;
						if (count != 0)
						{
							span = (array = ArrayPool<object>.Shared.Rent(2 * count));
							Dictionary2<Recipient, object>.Enumerator enumerator = mapping.GetEnumerator();
							while (enumerator.MoveNext())
							{
								span[2 * num] = enumerator.GetValue();
								span[2 * num + 1] = enumerator.GetKey().Target;
								num++;
							}
							goto IL_015d;
						}
					}
				}
				else if (TryGetMapping<TMessage, TToken>(out mapping2))
				{
					int count2 = mapping2.Count;
					if (count2 != 0)
					{
						span = (array = ArrayPool<object>.Shared.Rent(2 * count2));
						Dictionary2<Recipient, Dictionary2<TToken, object>>.Enumerator enumerator2 = mapping2.GetEnumerator();
						while (enumerator2.MoveNext())
						{
							if (enumerator2.GetValue().TryGetValue(token, out var value))
							{
								span[2 * num] = value;
								span[2 * num + 1] = enumerator2.GetKey().Target;
								num++;
							}
						}
						goto IL_015d;
					}
				}
			}
			goto IL_0183;
			IL_015d:
			try
			{
				WeakReferenceMessenger.SendAll(span, num, message);
			}
			finally
			{
				Array.Clear(array, 0, 2 * num);
				ArrayPool<object>.Shared.Return(array);
			}
			goto IL_0183;
			IL_0183:
			return message;
		}

		void IMessenger.Cleanup()
		{
		}

		public void Reset()
		{
			lock (recipientsMap)
			{
				recipientsMap.Clear();
				typesMap.Clear();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool TryGetMapping<TMessage>([NotNullWhen(true)] out Mapping? mapping) where TMessage : class
		{
			Type2 key = new Type2(typeof(TMessage), typeof(Unit));
			if (typesMap.TryGetValue(key, out IMapping value))
			{
				mapping = Unsafe.As<Mapping>(value);
				return true;
			}
			mapping = null;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool TryGetMapping<TMessage, TToken>([NotNullWhen(true)] out Mapping<TToken>? mapping) where TMessage : class where TToken : IEquatable<TToken>
		{
			Type2 key = new Type2(typeof(TMessage), typeof(TToken));
			if (typesMap.TryGetValue(key, out IMapping value))
			{
				mapping = Unsafe.As<Mapping<TToken>>(value);
				return true;
			}
			mapping = null;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private Mapping GetOrAddMapping<TMessage>() where TMessage : class
		{
			Type2 key = new Type2(typeof(TMessage), typeof(Unit));
			ref IMapping orAddValueRef = ref typesMap.GetOrAddValueRef(key);
			if (orAddValueRef == null)
			{
				orAddValueRef = Mapping.Create<TMessage>();
			}
			return Unsafe.As<Mapping>(orAddValueRef);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private Mapping<TToken> GetOrAddMapping<TMessage, TToken>() where TMessage : class where TToken : IEquatable<TToken>
		{
			Type2 key = new Type2(typeof(TMessage), typeof(TToken));
			ref IMapping orAddValueRef = ref typesMap.GetOrAddValueRef(key);
			if (orAddValueRef == null)
			{
				orAddValueRef = Mapping<TToken>.Create<TMessage>();
			}
			return Unsafe.As<Mapping<TToken>>(orAddValueRef);
		}

		private static void ThrowInvalidOperationExceptionForDuplicateRegistration()
		{
			throw new InvalidOperationException("The target recipient has already subscribed to the target message.");
		}
	}
	public sealed class WeakReferenceMessenger : IMessenger
	{
		private readonly Dictionary2<Type2, ConditionalWeakTable2<object, object?>> recipientsMap = new Dictionary2<Type2, ConditionalWeakTable2<object, object>>();

		public static WeakReferenceMessenger Default { get; } = new WeakReferenceMessenger();


		public WeakReferenceMessenger()
		{
			System.Gen2GcCallback.Register(Gen2GcCallbackProxy, this);
			static void Gen2GcCallbackProxy(object target)
			{
				((WeakReferenceMessenger)target).CleanupWithNonBlockingLock();
			}
		}

		public bool IsRegistered<TMessage, TToken>(object recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			lock (recipientsMap)
			{
				Type2 key = new Type2(typeof(TMessage), typeof(TToken));
				if (!recipientsMap.TryGetValue(key, out ConditionalWeakTable2<object, object> value))
				{
					return false;
				}
				object value2;
				if (typeof(TToken) == typeof(Unit))
				{
					return value.TryGetValue(recipient, out value2);
				}
				object value3;
				return value.TryGetValue(recipient, out value3) && Unsafe.As<Dictionary2<TToken, object>>(value3).ContainsKey(token);
			}
		}

		public void Register<TRecipient, TMessage, TToken>(TRecipient recipient, TToken token, MessageHandler<TRecipient, TMessage> handler) where TRecipient : class where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			ArgumentNullException.ThrowIfNull(handler, "handler");
			Register<TMessage, TToken>(recipient, token, new MessageHandlerDispatcher.For<TRecipient, TMessage>(handler));
		}

		internal void Register<TMessage, TToken>(IRecipient<TMessage> recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			Register<TMessage, TToken>(recipient, token, null);
		}

		private void Register<TMessage, TToken>(object recipient, TToken token, MessageHandlerDispatcher? dispatcher) where TMessage : class where TToken : IEquatable<TToken>
		{
			lock (recipientsMap)
			{
				Type2 key = new Type2(typeof(TMessage), typeof(TToken));
				ref ConditionalWeakTable2<object, object> orAddValueRef = ref recipientsMap.GetOrAddValueRef(key);
				if (orAddValueRef == null)
				{
					orAddValueRef = new ConditionalWeakTable2<object, object>();
				}
				if (typeof(TToken) == typeof(Unit))
				{
					if (!orAddValueRef.TryAdd(recipient, dispatcher))
					{
						ThrowInvalidOperationExceptionForDuplicateRegistration();
					}
					return;
				}
				ref object? orAddValueRef2 = ref Unsafe.As<Dictionary2<TToken, object>>(orAddValueRef.GetValue(recipient, (object _) => new Dictionary2<TToken, object>())).GetOrAddValueRef(token);
				if (orAddValueRef2 != null)
				{
					ThrowInvalidOperationExceptionForDuplicateRegistration();
				}
				orAddValueRef2 = dispatcher;
			}
		}

		public void UnregisterAll(object recipient)
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			lock (recipientsMap)
			{
				Dictionary2<Type2, ConditionalWeakTable2<object, object>>.Enumerator enumerator = recipientsMap.GetEnumerator();
				while (enumerator.MoveNext())
				{
					enumerator.GetValue().Remove(recipient);
				}
			}
		}

		public void UnregisterAll<TToken>(object recipient, TToken token) where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			if (typeof(TToken) == typeof(Unit))
			{
				throw new NotImplementedException();
			}
			lock (recipientsMap)
			{
				Dictionary2<Type2, ConditionalWeakTable2<object, object>>.Enumerator enumerator = recipientsMap.GetEnumerator();
				while (enumerator.MoveNext())
				{
					if (enumerator.GetKey().TToken == typeof(TToken) && enumerator.GetValue().TryGetValue(recipient, out var value))
					{
						Unsafe.As<Dictionary2<TToken, object>>(value).TryRemove(token);
					}
				}
			}
		}

		public void Unregister<TMessage, TToken>(object recipient, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(recipient, "recipient");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			lock (recipientsMap)
			{
				Type2 key = new Type2(typeof(TMessage), typeof(TToken));
				if (recipientsMap.TryGetValue(key, out ConditionalWeakTable2<object, object> value))
				{
					object value2;
					if (typeof(TToken) == typeof(Unit))
					{
						value.Remove(recipient);
					}
					else if (value.TryGetValue(recipient, out value2))
					{
						Unsafe.As<Dictionary2<TToken, object>>(value2).TryRemove(token);
					}
				}
			}
		}

		public TMessage Send<TMessage, TToken>(TMessage message, TToken token) where TMessage : class where TToken : IEquatable<TToken>
		{
			ArgumentNullException.ThrowIfNull(message, "message");
			ArgumentNullException.For<TToken>.ThrowIfNull(token, "token");
			int num = 0;
			ArrayPoolBufferWriter<object> arrayPoolBufferWriter;
			lock (recipientsMap)
			{
				Type2 key = new Type2(typeof(TMessage), typeof(TToken));
				if (!recipientsMap.TryGetValue(key, out ConditionalWeakTable2<object, object> value))
				{
					return message;
				}
				arrayPoolBufferWriter = ArrayPoolBufferWriter<object>.Create();
				ConditionalWeakTable2<object, object>.Enumerator enumerator = value.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						object value2;
						if (typeof(TToken) == typeof(Unit))
						{
							arrayPoolBufferWriter.Add(enumerator.GetValue());
							arrayPoolBufferWriter.Add(enumerator.GetKey());
							num++;
						}
						else if (Unsafe.As<Dictionary2<TToken, object>>(enumerator.GetValue()).TryGetValue(token, out value2))
						{
							arrayPoolBufferWriter.Add(value2);
							arrayPoolBufferWriter.Add(enumerator.GetKey());
							num++;
						}
					}
				}
				finally
				{
					enumerator.Dispose();
				}
			}
			try
			{
				SendAll(arrayPoolBufferWriter.Span, num, message);
				return message;
			}
			finally
			{
				arrayPoolBufferWriter.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void SendAll<TMessage>(ReadOnlySpan<object?> pairs, int i, TMessage message) where TMessage : class
		{
			ReadOnlySpan<object> span = pairs.Slice(0, 2 * i);
			ref object reference = ref MemoryMarshal.GetReference(span);
			ref object right = ref Unsafe.Add(ref reference, span.Length);
			while (Unsafe.IsAddressLessThan(ref reference, ref right))
			{
				object obj = reference;
				object obj2 = Unsafe.Add(ref reference, 1);
				if (obj == null)
				{
					Unsafe.As<IRecipient<TMessage>>(obj2).Receive(message);
				}
				else
				{
					Unsafe.As<MessageHandlerDispatcher>(obj).Invoke(obj2, message);
				}
				reference = ref Unsafe.Add(ref reference, 2);
			}
		}

		public void Cleanup()
		{
			lock (recipientsMap)
			{
				CleanupWithoutLock();
			}
		}

		public void Reset()
		{
			lock (recipientsMap)
			{
				recipientsMap.Clear();
			}
		}

		private void CleanupWithNonBlockingLock()
		{
			object obj = recipientsMap;
			bool lockTaken = false;
			try
			{
				Monitor.TryEnter(obj, ref lockTaken);
				if (lockTaken)
				{
					CleanupWithoutLock();
				}
			}
			finally
			{
				if (lockTaken)
				{
					Monitor.Exit(obj);
				}
			}
		}

		private void CleanupWithoutLock()
		{
			ArrayPoolBufferWriter<Type2> arrayPoolBufferWriter = ArrayPoolBufferWriter<Type2>.Create();
			try
			{
				ArrayPoolBufferWriter<object> arrayPoolBufferWriter2 = ArrayPoolBufferWriter<object>.Create();
				try
				{
					Dictionary2<Type2, ConditionalWeakTable2<object, object>>.Enumerator enumerator = recipientsMap.GetEnumerator();
					while (enumerator.MoveNext())
					{
						arrayPoolBufferWriter2.Reset();
						bool flag = false;
						if (enumerator.GetKey().TToken == typeof(Unit))
						{
							ConditionalWeakTable2<object, object>.Enumerator enumerator2 = enumerator.GetValue().GetEnumerator();
							try
							{
								if (enumerator2.MoveNext())
								{
									flag = true;
								}
							}
							finally
							{
								enumerator2.Dispose();
							}
						}
						else
						{
							ConditionalWeakTable2<object, object>.Enumerator enumerator3 = enumerator.GetValue().GetEnumerator();
							try
							{
								while (enumerator3.MoveNext())
								{
									if (Unsafe.As<IDictionary2>(enumerator3.GetValue()).Count == 0)
									{
										arrayPoolBufferWriter2.Add(enumerator3.GetKey());
									}
									else
									{
										flag = true;
									}
								}
							}
							finally
							{
								enumerator3.Dispose();
							}
							ReadOnlySpan<object> span = arrayPoolBufferWriter2.Span;
							for (int i = 0; i < span.Length; i++)
							{
								object key = span[i];
								enumerator.GetValue().Remove(key);
							}
						}
						if (!flag)
						{
							arrayPoolBufferWriter.Add(enumerator.GetKey());
						}
					}
					ReadOnlySpan<Type2> span2 = arrayPoolBufferWriter.Span;
					for (int i = 0; i < span2.Length; i++)
					{
						Type2 key2 = span2[i];
						recipientsMap.TryRemove(key2);
					}
				}
				finally
				{
					arrayPoolBufferWriter2.Dispose();
				}
			}
			finally
			{
				arrayPoolBufferWriter.Dispose();
			}
		}

		private static void ThrowInvalidOperationExceptionForDuplicateRegistration()
		{
			throw new InvalidOperationException("The target recipient has already subscribed to the target message.");
		}
	}
}
namespace CommunityToolkit.Mvvm.Messaging.Messages
{
	public class AsyncCollectionRequestMessage<T> : IAsyncEnumerable<T>
	{
		private readonly List<(Task<T>?, Func<CancellationToken, Task<T>>?)> responses = new List<(Task<T>, Func<CancellationToken, Task<T>>)>();

		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();

		public CancellationToken CancellationToken => cancellationTokenSource.Token;

		public void Reply(T response)
		{
			Reply(Task.FromResult(response));
		}

		public void Reply(Task<T> response)
		{
			ArgumentNullException.ThrowIfNull(response, "response");
			responses.Add((response, null));
		}

		public void Reply(Func<CancellationToken, Task<T>> response)
		{
			ArgumentNullException.ThrowIfNull(response, "response");
			responses.Add((null, response));
		}

		public async Task<IReadOnlyCollection<T>> GetResponsesAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.CanBeCanceled)
			{
				cancellationToken.Register(cancellationTokenSource.Cancel);
			}
			List<T> results = new List<T>(responses.Count);
			await foreach (T item in this.WithCancellation(cancellationToken).ConfigureAwait(continueOnCapturedContext: false))
			{
				results.Add(item);
			}
			return results;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public async IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.CanBeCanceled)
			{
				cancellationToken.Register(cancellationTokenSource.Cancel);
			}
			foreach (var (task, func) in responses)
			{
				if (cancellationToken.IsCancellationRequested)
				{
					yield break;
				}
				if (task != null)
				{
					yield return await task.ConfigureAwait(continueOnCapturedContext: false);
				}
				else
				{
					yield return await func(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
		}
	}
	public class AsyncRequestMessage<T>
	{
		private Task<T>? response;

		public Task<T> Response
		{
			get
			{
				if (!HasReceivedResponse)
				{
					ThrowInvalidOperationExceptionForNoResponseReceived();
				}
				return response;
			}
		}

		public bool HasReceivedResponse { get; private set; }

		public void Reply(T response)
		{
			Reply(Task.FromResult(response));
		}

		public void Reply(Task<T> response)
		{
			ArgumentNullException.ThrowIfNull(response, "response");
			if (HasReceivedResponse)
			{
				ThrowInvalidOperationExceptionForDuplicateReply();
			}
			HasReceivedResponse = true;
			this.response = response;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public TaskAwaiter<T> GetAwaiter()
		{
			return Response.GetAwaiter();
		}

		[DoesNotReturn]
		private static void ThrowInvalidOperationExceptionForNoResponseReceived()
		{
			throw new InvalidOperationException("No response was received for the given request message.");
		}

		[DoesNotReturn]
		private static void ThrowInvalidOperationExceptionForDuplicateReply()
		{
			throw new InvalidOperationException("A response has already been issued for the current message.");
		}
	}
	public class CollectionRequestMessage<T> : IEnumerable<T>, IEnumerable
	{
		private readonly List<T> responses = new List<T>();

		public IReadOnlyCollection<T> Responses => responses;

		public void Reply(T response)
		{
			responses.Add(response);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public IEnumerator<T> GetEnumerator()
		{
			return responses.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class PropertyChangedMessage<T>
	{
		public object Sender { get; }

		public string? PropertyName { get; }

		public T OldValue { get; }

		public T NewValue { get; }

		public PropertyChangedMessage(object sender, string? propertyName, T oldValue, T newValue)
		{
			ArgumentNullException.ThrowIfNull(sender, "sender");
			Sender = sender;
			PropertyName = propertyName;
			OldValue = oldValue;
			NewValue = newValue;
		}
	}
	public class RequestMessage<T>
	{
		private T response;

		public T Response
		{
			get
			{
				if (!HasReceivedResponse)
				{
					ThrowInvalidOperationExceptionForNoResponseReceived();
				}
				return response;
			}
		}

		public bool HasReceivedResponse { get; private set; }

		public void Reply(T response)
		{
			if (HasReceivedResponse)
			{
				ThrowInvalidOperationExceptionForDuplicateReply();
			}
			HasReceivedResponse = true;
			this.response = response;
		}

		public static implicit operator T(RequestMessage<T> message)
		{
			ArgumentNullException.ThrowIfNull(message, "message");
			return message.Response;
		}

		[DoesNotReturn]
		private static void ThrowInvalidOperationExceptionForNoResponseReceived()
		{
			throw new InvalidOperationException("No response was received for the given request message.");
		}

		[DoesNotReturn]
		private static void ThrowInvalidOperationExceptionForDuplicateReply()
		{
			throw new InvalidOperationException("A response has already been issued for the current message.");
		}
	}
	public class ValueChangedMessage<T>
	{
		public T Value { get; }

		public ValueChangedMessage(T value)
		{
			Value = value;
		}
	}
}
namespace CommunityToolkit.Mvvm.Messaging.Internals
{
	internal ref struct ArrayPoolBufferWriter<T>
	{
		private const int DefaultInitialBufferSize = 128;

		private T[] array;

		private Span<T> span;

		private int index;

		public ReadOnlySpan<T> Span
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return span.Slice(0, index);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ArrayPoolBufferWriter<T> Create()
		{
			Unsafe.SkipInit(out ArrayPoolBufferWriter<T> result);
			result.span = (result.array = ArrayPool<T>.Shared.Rent(128));
			result.index = 0;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Add(T item)
		{
			Span<T> span = this.span;
			int num = index;
			if ((uint)num < (uint)span.Length)
			{
				span[num] = item;
				index = num + 1;
			}
			else
			{
				ResizeBufferAndAdd(item);
			}
		}

		public void Reset()
		{
			Array.Clear(array, 0, index);
			index = 0;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void ResizeBufferAndAdd(T item)
		{
			T[] destinationArray = ArrayPool<T>.Shared.Rent(index << 2);
			Array.Copy(array, 0, destinationArray, 0, index);
			Array.Clear(array, 0, index);
			ArrayPool<T>.Shared.Return(array);
			span = (array = destinationArray);
			span[index++] = item;
		}

		public void Dispose()
		{
			Array.Clear(array, 0, index);
			ArrayPool<T>.Shared.Return(array);
		}
	}
	internal abstract class MessageHandlerDispatcher
	{
		public sealed class For<TRecipient, TMessage> : MessageHandlerDispatcher where TRecipient : class where TMessage : class
		{
			private readonly MessageHandler<TRecipient, TMessage> handler;

			public For(MessageHandler<TRecipient, TMessage> handler)
			{
				this.handler = handler;
			}

			public override void Invoke(object recipient, object message)
			{
				handler(Unsafe.As<TRecipient>(recipient), Unsafe.As<TMessage>(message));
			}
		}

		public abstract void Invoke(object recipient, object message);
	}
	internal readonly struct Type2 : IEquatable<Type2>
	{
		public readonly Type TMessage;

		public readonly Type TToken;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Type2(Type tMessage, Type tToken)
		{
			TMessage = tMessage;
			TToken = tToken;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Equals(Type2 other)
		{
			if (TMessage == other.TMessage)
			{
				return TToken == other.TToken;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj is Type2 other)
			{
				return Equals(other);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode()
		{
			int hashCode = TMessage.GetHashCode();
			hashCode = (hashCode << 5) + hashCode;
			return hashCode + TToken.GetHashCode();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal readonly struct Unit : IEquatable<Unit>
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Equals(Unit other)
		{
			return true;
		}

		public override bool Equals(object? obj)
		{
			return obj is Unit;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override int GetHashCode()
		{
			return 0;
		}
	}
}
namespace CommunityToolkit.Mvvm.Input
{
	public sealed class AsyncRelayCommand : IAsyncRelayCommand, IRelayCommand, ICommand, INotifyPropertyChanged, ICancellationAwareCommand
	{
		internal static readonly PropertyChangedEventArgs ExecutionTaskChangedEventArgs = new PropertyChangedEventArgs("ExecutionTask");

		internal static readonly PropertyChangedEventArgs CanBeCanceledChangedEventArgs = new PropertyChangedEventArgs("CanBeCanceled");

		internal static readonly PropertyChangedEventArgs IsCancellationRequestedChangedEventArgs = new PropertyChangedEventArgs("IsCancellationRequested");

		internal static readonly PropertyChangedEventArgs IsRunningChangedEventArgs = new PropertyChangedEventArgs("IsRunning");

		private readonly Func<Task>? execute;

		private readonly Func<CancellationToken, Task>? cancelableExecute;

		private readonly Func<bool>? canExecute;

		private readonly AsyncRelayCommandOptions options;

		private CancellationTokenSource? cancellationTokenSource;

		private Task? executionTask;

		public Task? ExecutionTask
		{
			get
			{
				return executionTask;
			}
			private set
			{
				if (executionTask != value)
				{
					executionTask = value;
					this.PropertyChanged?.Invoke(this, ExecutionTaskChangedEventArgs);
					this.PropertyChanged?.Invoke(this, IsRunningChangedEventArgs);
					bool num = value?.IsCompleted ?? true;
					if (cancellationTokenSource != null)
					{
						this.PropertyChanged?.Invoke(this, CanBeCanceledChangedEventArgs);
						this.PropertyChanged?.Invoke(this, IsCancellationRequestedChangedEventArgs);
					}
					if (!num)
					{
						MonitorTask(this, value);
					}
				}
				static async void MonitorTask(AsyncRelayCommand @this, Task task)
				{
					await task.GetAwaitableWithoutEndValidation();
					if (@this.executionTask == task)
					{
						@this.PropertyChanged?.Invoke(@this, ExecutionTaskChangedEventArgs);
						@this.PropertyChanged?.Invoke(@this, IsRunningChangedEventArgs);
						if (@this.cancellationTokenSource != null)
						{
							@this.PropertyChanged?.Invoke(@this, CanBeCanceledChangedEventArgs);
						}
						if ((@this.options & AsyncRelayCommandOptions.AllowConcurrentExecutions) == 0)
						{
							@this.CanExecuteChanged?.Invoke(@this, EventArgs.Empty);
						}
					}
				}
			}
		}

		public bool CanBeCanceled
		{
			get
			{
				if (IsRunning)
				{
					CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource;
					if (cancellationTokenSource != null)
					{
						return !cancellationTokenSource.IsCancellationRequested;
					}
					return false;
				}
				return false;
			}
		}

		public bool IsCancellationRequested => cancellationTokenSource?.IsCancellationRequested ?? false;

		public bool IsRunning
		{
			get
			{
				Task task = ExecutionTask;
				if (task != null)
				{
					return !task.IsCompleted;
				}
				return false;
			}
		}

		bool ICancellationAwareCommand.IsCancellationSupported => execute == null;

		public event PropertyChangedEventHandler? PropertyChanged;

		public event EventHandler? CanExecuteChanged;

		public AsyncRelayCommand(Func<Task> execute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			this.execute = execute;
		}

		public AsyncRelayCommand(Func<Task> execute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			this.execute = execute;
			this.options = options;
		}

		public AsyncRelayCommand(Func<CancellationToken, Task> cancelableExecute)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			this.cancelableExecute = cancelableExecute;
		}

		public AsyncRelayCommand(Func<CancellationToken, Task> cancelableExecute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			this.cancelableExecute = cancelableExecute;
			this.options = options;
		}

		public AsyncRelayCommand(Func<Task> execute, Func<bool> canExecute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.execute = execute;
			this.canExecute = canExecute;
		}

		public AsyncRelayCommand(Func<Task> execute, Func<bool> canExecute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.execute = execute;
			this.canExecute = canExecute;
			this.options = options;
		}

		public AsyncRelayCommand(Func<CancellationToken, Task> cancelableExecute, Func<bool> canExecute)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.cancelableExecute = cancelableExecute;
			this.canExecute = canExecute;
		}

		public AsyncRelayCommand(Func<CancellationToken, Task> cancelableExecute, Func<bool> canExecute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.cancelableExecute = cancelableExecute;
			this.canExecute = canExecute;
			this.options = options;
		}

		public void NotifyCanExecuteChanged()
		{
			this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanExecute(object? parameter)
		{
			Func<bool>? func = canExecute;
			if (func == null || func())
			{
				if ((options & AsyncRelayCommandOptions.AllowConcurrentExecutions) == 0)
				{
					Task task = ExecutionTask;
					return task == null || task.IsCompleted;
				}
				return true;
			}
			return false;
		}

		public void Execute(object? parameter)
		{
			Task task = ExecuteAsync(parameter);
			if ((options & AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler) == 0)
			{
				AwaitAndThrowIfFailed(task);
			}
		}

		public Task ExecuteAsync(object? parameter)
		{
			Task result;
			if (execute != null)
			{
				Task task2 = (ExecutionTask = execute());
				result = task2;
			}
			else
			{
				this.cancellationTokenSource?.Cancel();
				CancellationTokenSource cancellationTokenSource = (this.cancellationTokenSource = new CancellationTokenSource());
				Task task2 = (ExecutionTask = cancelableExecute(cancellationTokenSource.Token));
				result = task2;
			}
			if ((options & AsyncRelayCommandOptions.AllowConcurrentExecutions) == 0)
			{
				this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
			}
			return result;
		}

		public void Cancel()
		{
			CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource;
			if (cancellationTokenSource != null && !cancellationTokenSource.IsCancellationRequested)
			{
				cancellationTokenSource.Cancel();
				this.PropertyChanged?.Invoke(this, CanBeCanceledChangedEventArgs);
				this.PropertyChanged?.Invoke(this, IsCancellationRequestedChangedEventArgs);
			}
		}

		internal static async void AwaitAndThrowIfFailed(Task executionTask)
		{
			await executionTask;
		}
	}
	[Flags]
	public enum AsyncRelayCommandOptions
	{
		None = 0,
		AllowConcurrentExecutions = 1,
		FlowExceptionsToTaskScheduler = 2
	}
	public sealed class AsyncRelayCommand<T> : IAsyncRelayCommand<T>, IAsyncRelayCommand, IRelayCommand, ICommand, INotifyPropertyChanged, IRelayCommand<T>, ICancellationAwareCommand
	{
		private readonly Func<T?, Task>? execute;

		private readonly Func<T?, CancellationToken, Task>? cancelableExecute;

		private readonly Predicate<T?>? canExecute;

		private readonly AsyncRelayCommandOptions options;

		private CancellationTokenSource? cancellationTokenSource;

		private Task? executionTask;

		public Task? ExecutionTask
		{
			get
			{
				return executionTask;
			}
			private set
			{
				if (executionTask != value)
				{
					executionTask = value;
					this.PropertyChanged?.Invoke(this, AsyncRelayCommand.ExecutionTaskChangedEventArgs);
					this.PropertyChanged?.Invoke(this, AsyncRelayCommand.IsRunningChangedEventArgs);
					bool num = value?.IsCompleted ?? true;
					if (cancellationTokenSource != null)
					{
						this.PropertyChanged?.Invoke(this, AsyncRelayCommand.CanBeCanceledChangedEventArgs);
						this.PropertyChanged?.Invoke(this, AsyncRelayCommand.IsCancellationRequestedChangedEventArgs);
					}
					if (!num)
					{
						MonitorTask(this, value);
					}
				}
				static async void MonitorTask(AsyncRelayCommand<T> @this, Task task)
				{
					await task.GetAwaitableWithoutEndValidation();
					if (@this.executionTask == task)
					{
						@this.PropertyChanged?.Invoke(@this, AsyncRelayCommand.ExecutionTaskChangedEventArgs);
						@this.PropertyChanged?.Invoke(@this, AsyncRelayCommand.IsRunningChangedEventArgs);
						if (@this.cancellationTokenSource != null)
						{
							@this.PropertyChanged?.Invoke(@this, AsyncRelayCommand.CanBeCanceledChangedEventArgs);
						}
						if ((@this.options & AsyncRelayCommandOptions.AllowConcurrentExecutions) == 0)
						{
							@this.CanExecuteChanged?.Invoke(@this, EventArgs.Empty);
						}
					}
				}
			}
		}

		public bool CanBeCanceled
		{
			get
			{
				if (IsRunning)
				{
					CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource;
					if (cancellationTokenSource != null)
					{
						return !cancellationTokenSource.IsCancellationRequested;
					}
					return false;
				}
				return false;
			}
		}

		public bool IsCancellationRequested => cancellationTokenSource?.IsCancellationRequested ?? false;

		public bool IsRunning
		{
			get
			{
				Task task = ExecutionTask;
				if (task != null)
				{
					return !task.IsCompleted;
				}
				return false;
			}
		}

		bool ICancellationAwareCommand.IsCancellationSupported => execute == null;

		public event PropertyChangedEventHandler? PropertyChanged;

		public event EventHandler? CanExecuteChanged;

		public AsyncRelayCommand(Func<T?, Task> execute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			this.execute = execute;
		}

		public AsyncRelayCommand(Func<T?, Task> execute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			this.execute = execute;
			this.options = options;
		}

		public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			this.cancelableExecute = cancelableExecute;
		}

		public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			this.cancelableExecute = cancelableExecute;
			this.options = options;
		}

		public AsyncRelayCommand(Func<T?, Task> execute, Predicate<T?> canExecute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.execute = execute;
			this.canExecute = canExecute;
		}

		public AsyncRelayCommand(Func<T?, Task> execute, Predicate<T?> canExecute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.execute = execute;
			this.canExecute = canExecute;
			this.options = options;
		}

		public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute, Predicate<T?> canExecute)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.cancelableExecute = cancelableExecute;
			this.canExecute = canExecute;
		}

		public AsyncRelayCommand(Func<T?, CancellationToken, Task> cancelableExecute, Predicate<T?> canExecute, AsyncRelayCommandOptions options)
		{
			ArgumentNullException.ThrowIfNull(cancelableExecute, "cancelableExecute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.cancelableExecute = cancelableExecute;
			this.canExecute = canExecute;
			this.options = options;
		}

		public void NotifyCanExecuteChanged()
		{
			this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanExecute(T? parameter)
		{
			Predicate<T?>? predicate = canExecute;
			if (predicate == null || predicate(parameter))
			{
				if ((options & AsyncRelayCommandOptions.AllowConcurrentExecutions) == 0)
				{
					Task task = ExecutionTask;
					return task == null || task.IsCompleted;
				}
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanExecute(object? parameter)
		{
			if (parameter == null && default(T) != null)
			{
				return false;
			}
			if (!RelayCommand<T>.TryGetCommandArgument(parameter, out T result))
			{
				RelayCommand<T>.ThrowArgumentExceptionForInvalidCommandArgument(parameter);
			}
			return CanExecute(result);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Execute(T? parameter)
		{
			Task task = ExecuteAsync(parameter);
			if ((options & AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler) == 0)
			{
				AsyncRelayCommand.AwaitAndThrowIfFailed(task);
			}
		}

		public void Execute(object? parameter)
		{
			if (!RelayCommand<T>.TryGetCommandArgument(parameter, out T result))
			{
				RelayCommand<T>.ThrowArgumentExceptionForInvalidCommandArgument(parameter);
			}
			Execute(result);
		}

		public Task ExecuteAsync(T? parameter)
		{
			Task result;
			if (execute != null)
			{
				Task task2 = (ExecutionTask = execute(parameter));
				result = task2;
			}
			else
			{
				this.cancellationTokenSource?.Cancel();
				CancellationTokenSource cancellationTokenSource = (this.cancellationTokenSource = new CancellationTokenSource());
				Task task2 = (ExecutionTask = cancelableExecute(parameter, cancellationTokenSource.Token));
				result = task2;
			}
			if ((options & AsyncRelayCommandOptions.AllowConcurrentExecutions) == 0)
			{
				this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
			}
			return result;
		}

		public Task ExecuteAsync(object? parameter)
		{
			if (!RelayCommand<T>.TryGetCommandArgument(parameter, out T result))
			{
				RelayCommand<T>.ThrowArgumentExceptionForInvalidCommandArgument(parameter);
			}
			return ExecuteAsync(result);
		}

		public void Cancel()
		{
			CancellationTokenSource cancellationTokenSource = this.cancellationTokenSource;
			if (cancellationTokenSource != null && !cancellationTokenSource.IsCancellationRequested)
			{
				cancellationTokenSource.Cancel();
				this.PropertyChanged?.Invoke(this, AsyncRelayCommand.CanBeCanceledChangedEventArgs);
				this.PropertyChanged?.Invoke(this, AsyncRelayCommand.IsCancellationRequestedChangedEventArgs);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public sealed class RelayCommandAttribute : Attribute
	{
		public string? CanExecute { get; init; }

		public bool AllowConcurrentExecutions { get; init; }

		public bool FlowExceptionsToTaskScheduler { get; init; }

		public bool IncludeCancelCommand { get; init; }
	}
	public static class IAsyncRelayCommandExtensions
	{
		public static ICommand CreateCancelCommand(this IAsyncRelayCommand command)
		{
			ArgumentNullException.ThrowIfNull(command, "command");
			if (command is ICancellationAwareCommand cancellationAwareCommand && !cancellationAwareCommand.IsCancellationSupported)
			{
				return DisabledCommand.Instance;
			}
			return new CancelCommand(command);
		}
	}
	public interface IAsyncRelayCommand : IRelayCommand, ICommand, INotifyPropertyChanged
	{
		Task? ExecutionTask { get; }

		bool CanBeCanceled { get; }

		bool IsCancellationRequested { get; }

		bool IsRunning { get; }

		Task ExecuteAsync(object? parameter);

		void Cancel();
	}
	public interface IAsyncRelayCommand<in T> : IAsyncRelayCommand, IRelayCommand, ICommand, INotifyPropertyChanged, IRelayCommand<T>
	{
		Task ExecuteAsync(T? parameter);
	}
	public interface IRelayCommand : ICommand
	{
		void NotifyCanExecuteChanged();
	}
	public interface IRelayCommand<in T> : IRelayCommand, ICommand
	{
		bool CanExecute(T? parameter);

		void Execute(T? parameter);
	}
	public sealed class RelayCommand : IRelayCommand, ICommand
	{
		private readonly Action execute;

		private readonly Func<bool>? canExecute;

		public event EventHandler? CanExecuteChanged;

		public RelayCommand(Action execute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			this.execute = execute;
		}

		public RelayCommand(Action execute, Func<bool> canExecute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.execute = execute;
			this.canExecute = canExecute;
		}

		public void NotifyCanExecuteChanged()
		{
			this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanExecute(object? parameter)
		{
			return canExecute?.Invoke() ?? true;
		}

		public void Execute(object? parameter)
		{
			execute();
		}
	}
	public sealed class RelayCommand<T> : IRelayCommand<T>, IRelayCommand, ICommand
	{
		private readonly Action<T?> execute;

		private readonly Predicate<T?>? canExecute;

		public event EventHandler? CanExecuteChanged;

		public RelayCommand(Action<T?> execute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			this.execute = execute;
		}

		public RelayCommand(Action<T?> execute, Predicate<T?> canExecute)
		{
			ArgumentNullException.ThrowIfNull(execute, "execute");
			ArgumentNullException.ThrowIfNull(canExecute, "canExecute");
			this.execute = execute;
			this.canExecute = canExecute;
		}

		public void NotifyCanExecuteChanged()
		{
			this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanExecute(T? parameter)
		{
			return canExecute?.Invoke(parameter) ?? true;
		}

		public bool CanExecute(object? parameter)
		{
			if (parameter == null && default(T) != null)
			{
				return false;
			}
			if (!TryGetCommandArgument(parameter, out T result))
			{
				ThrowArgumentExceptionForInvalidCommandArgument(parameter);
			}
			return CanExecute(result);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Execute(T? parameter)
		{
			execute(parameter);
		}

		public void Execute(object? parameter)
		{
			if (!TryGetCommandArgument(parameter, out T result))
			{
				ThrowArgumentExceptionForInvalidCommandArgument(parameter);
			}
			Execute(result);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryGetCommandArgument(object? parameter, out T? result)
		{
			if (parameter == null && default(T) == null)
			{
				result = default(T);
				return true;
			}
			if (parameter is T val)
			{
				result = val;
				return true;
			}
			result = default(T);
			return false;
		}

		[DoesNotReturn]
		internal static void ThrowArgumentExceptionForInvalidCommandArgument(object? parameter)
		{
			throw GetException(parameter);
			[MethodImpl(MethodImplOptions.NoInlining)]
			static Exception GetException(object? parameter)
			{
				if (parameter == null)
				{
					return new ArgumentException($"Parameter \"{"parameter"}\" (object) must not be null, as the command type requires an argument of type {typeof(T)}.", "parameter");
				}
				return new ArgumentException($"Parameter \"{"parameter"}\" (object) cannot be of type {parameter.GetType()}, as the command type requires an argument of type {typeof(T)}.", "parameter");
			}
		}
	}
}
namespace CommunityToolkit.Mvvm.Input.Internals
{
	internal sealed class CancelCommand : ICommand
	{
		private readonly IAsyncRelayCommand command;

		public event EventHandler? CanExecuteChanged;

		public CancelCommand(IAsyncRelayCommand command)
		{
			this.command = command;
			this.command.PropertyChanged += OnPropertyChanged;
		}

		public bool CanExecute(object? parameter)
		{
			return command.CanBeCanceled;
		}

		public void Execute(object? parameter)
		{
			command.Cancel();
		}

		private void OnPropertyChanged(object? sender, PropertyChangedEventArgs e)
		{
			string propertyName = e.PropertyName;
			if ((propertyName == null || propertyName == "CanBeCanceled") ? true : false)
			{
				this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
			}
		}
	}
	internal sealed class DisabledCommand : ICommand
	{
		public static DisabledCommand Instance { get; } = new DisabledCommand();


		public event EventHandler? CanExecuteChanged
		{
			add
			{
			}
			remove
			{
			}
		}

		public bool CanExecute(object? parameter)
		{
			return false;
		}

		public void Execute(object? parameter)
		{
		}
	}
	internal interface ICancellationAwareCommand
	{
		bool IsCancellationSupported { get; }
	}
}
namespace CommunityToolkit.Mvvm.DependencyInjection
{
	public sealed class Ioc : IServiceProvider
	{
		private volatile IServiceProvider? serviceProvider;

		public static Ioc Default { get; } = new Ioc();


		public object? GetService(Type serviceType)
		{
			ArgumentNullException.ThrowIfNull(serviceType, "serviceType");
			IServiceProvider? obj = serviceProvider;
			if (obj == null)
			{
				ThrowInvalidOperationExceptionForMissingInitialization();
			}
			return obj.GetService(serviceType);
		}

		public T? GetService<T>() where T : class
		{
			IServiceProvider? obj = serviceProvider;
			if (obj == null)
			{
				ThrowInvalidOperationExceptionForMissingInitialization();
			}
			return (T)obj.GetService(typeof(T));
		}

		public T GetRequiredService<T>() where T : class
		{
			IServiceProvider? obj = serviceProvider;
			if (obj == null)
			{
				ThrowInvalidOperationExceptionForMissingInitialization();
			}
			T obj2 = (T)obj.GetService(typeof(T));
			if (obj2 == null)
			{
				ThrowInvalidOperationExceptionForUnregisteredType();
			}
			return obj2;
		}

		public void ConfigureServices(IServiceProvider serviceProvider)
		{
			ArgumentNullException.ThrowIfNull(serviceProvider, "serviceProvider");
			if (Interlocked.CompareExchange(ref this.serviceProvider, serviceProvider, null) != null)
			{
				ThrowInvalidOperationExceptionForRepeatedConfiguration();
			}
		}

		[DoesNotReturn]
		private static void ThrowInvalidOperationExceptionForMissingInitialization()
		{
			throw new InvalidOperationException("The service provider has not been configured yet.");
		}

		[DoesNotReturn]
		private static void ThrowInvalidOperationExceptionForUnregisteredType()
		{
			throw new InvalidOperationException("The requested service type was not registered.");
		}

		[DoesNotReturn]
		private static void ThrowInvalidOperationExceptionForRepeatedConfiguration()
		{
			throw new InvalidOperationException("The default service provider has already been configured.");
		}
	}
}
namespace CommunityToolkit.Mvvm.ComponentModel
{
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class INotifyPropertyChangedAttribute : Attribute
	{
		public bool IncludeAdditionalHelperMethods { get; init; } = true;

	}
	[AttributeUsage(AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	public sealed class NotifyCanExecuteChangedForAttribute : Attribute
	{
		public string[] CommandNames { get; }

		public NotifyCanExecuteChangedForAttribute(string commandName)
		{
			CommandNames = new string[1] { commandName };
		}

		public NotifyCanExecuteChangedForAttribute(string commandName, params string[] otherCommandNames)
		{
			CommandNames = new string[1] { commandName }.Concat(otherCommandNames).ToArray();
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	public sealed class NotifyDataErrorInfoAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	public sealed class NotifyPropertyChangedForAttribute : Attribute
	{
		public string[] PropertyNames { get; }

		public NotifyPropertyChangedForAttribute(string propertyName)
		{
			PropertyNames = new string[1] { propertyName };
		}

		public NotifyPropertyChangedForAttribute(string propertyName, params string[] otherPropertyNames)
		{
			PropertyNames = new string[1] { propertyName }.Concat(otherPropertyNames).ToArray();
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	public sealed class NotifyPropertyChangedRecipientsAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class ObservableObjectAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	public sealed class ObservablePropertyAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class ObservableRecipientAttribute : Attribute
	{
	}
	public abstract class ObservableObject : INotifyPropertyChanged, INotifyPropertyChanging
	{
		private interface ITaskNotifier<TTask> where TTask : Task
		{
			TTask? Task { get; set; }
		}

		protected sealed class TaskNotifier : ITaskNotifier<Task>
		{
			private Task? task;

			Task? ITaskNotifier<Task>.Task
			{
				get
				{
					return task;
				}
				set
				{
					task = value;
				}
			}

			internal TaskNotifier()
			{
			}

			public static implicit operator Task?(TaskNotifier? notifier)
			{
				return notifier?.task;
			}
		}

		protected sealed class TaskNotifier<T> : ITaskNotifier<Task<T>>
		{
			private Task<T>? task;

			Task<T>? ITaskNotifier<Task<T>>.Task
			{
				get
				{
					return task;
				}
				set
				{
					task = value;
				}
			}

			internal TaskNotifier()
			{
			}

			public static implicit operator Task<T>?(TaskNotifier<T>? notifier)
			{
				return notifier?.task;
			}
		}

		public event PropertyChangedEventHandler? PropertyChanged;

		public event PropertyChangingEventHandler? PropertyChanging;

		protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
		{
			ArgumentNullException.ThrowIfNull(e, "e");
			this.PropertyChanged?.Invoke(this, e);
		}

		protected virtual void OnPropertyChanging(PropertyChangingEventArgs e)
		{
			ArgumentNullException.ThrowIfNull(e, "e");
			this.PropertyChanging?.Invoke(this, e);
		}

		protected void OnPropertyChanged([CallerMemberName] string? propertyName = null)
		{
			OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
		}

		protected void OnPropertyChanging([CallerMemberName] string? propertyName = null)
		{
			if (!Configuration.IsINotifyPropertyChangingDisabled)
			{
				OnPropertyChanging(new PropertyChangingEventArgs(propertyName));
			}
		}

		protected bool SetProperty<T>([NotNullIfNotNull("newValue")] ref T field, T newValue, [CallerMemberName] string? propertyName = null)
		{
			if (EqualityComparer<T>.Default.Equals(field, newValue))
			{
				return false;
			}
			OnPropertyChanging(propertyName);
			field = newValue;
			OnPropertyChanged(propertyName);
			return true;
		}

		protected bool SetProperty<T>([NotNullIfNotNull("newValue")] ref T field, T newValue, IEqualityComparer<T> comparer, [CallerMemberName] string? propertyName = null)
		{
			ArgumentNullException.ThrowIfNull(comparer, "comparer");
			if (comparer.Equals(field, newValue))
			{
				return false;
			}
			OnPropertyChanging(propertyName);
			field = newValue;
			OnPropertyChanged(propertyName);
			return true;
		}

		protected bool SetProperty<T>(T oldValue, T newValue, Action<T> callback, [CallerMemberName] string? propertyName = null)
		{
			ArgumentNullException.ThrowIfNull(callback, "callback");
			if (EqualityComparer<T>.Default.Equals(oldValue, newValue))
			{
				return false;
			}
			OnPropertyChanging(propertyName);
			callback(newValue);
			OnPropertyChanged(propertyName);
			return true;
		}

		protected bool SetProperty<T>(T oldValue, T newValue, IEqualityComparer<T> comparer, Action<T> callback, [CallerMemberName] string? propertyName = null)
		{
			ArgumentNullException.ThrowIfNull(comparer, "comparer");
			ArgumentNullException.ThrowIfNull(callback, "callback");
			if (comparer.Equals(oldValue, newValue))
			{
				return false;
			}
			OnPropertyChanging(propertyName);
			callback(newValue);
			OnPropertyChanged(propertyName);
			return true;
		}

		protected bool SetProperty<TModel, T>(T oldValue, T newValue, TModel model, Action<TModel, T> callback, [CallerMemberName] string? propertyName = null) where TModel : class
		{
			ArgumentNullException.ThrowIfNull(model, "model");
			ArgumentNullException.ThrowIfNull(callback, "callback");
			if (EqualityComparer<T>.Default.Equals(oldValue, newValue))
			{
				return false;
			}
			OnPropertyChanging(propertyName);
			callback(model, newValue);
			OnPropertyChanged(propertyName);
			return true;
		}

		protected bool SetProperty<TModel, T>(T oldValue, T newValue, IEqualityComparer<T> comparer, TModel model, Action<TModel, T> callback, [CallerMemberName] string? propertyName = null) where TModel : class
		{
			ArgumentNullException.ThrowIfNull(comparer, "comparer");
			ArgumentNullException.ThrowIfNull(model, "model");
			ArgumentNullException.ThrowIfNull(callback, "callback");
			if (comparer.Equals(oldValue, newValue))
			{
				return false;
			}
			OnPropertyChanging(propertyName);
			callback(model, newValue);
			OnPropertyChanged(propertyName);
			return true;
		}

		protected bool SetPropertyAndNotifyOnCompletion([NotNull] ref TaskNotifier? taskNotifier, Task? newValue, [CallerMemberName] string? propertyName = null)
		{
			return SetPropertyAndNotifyOnCompletion(taskNotifier ?? (taskNotifier = new TaskNotifier()), newValue, null, propertyName);
		}

		protected bool SetPropertyAndNotifyOnCompletion([NotNull] ref TaskNotifier? taskNotifier, Task? newValue, Action<Task?> callback, [CallerMemberName] string? propertyName = null)
		{
			ArgumentNullException.ThrowIfNull(callback, "callback");
			return SetPropertyAndNotifyOnCompletion(taskNotifier ?? (taskNotifier = new TaskNotifier()), newValue, callback, propertyName);
		}

		protected bool SetPropertyAndNotifyOnCompletion<T>([NotNull] ref TaskNotifier<T>? taskNotifier, Task<T>? newValue, [CallerMemberName] string? propertyName = null)
		{
			return SetPropertyAndNotifyOnCompletion(taskNotifier ?? (taskNotifier = new TaskNotifier<T>()), newValue, null, propertyName);
		}

		protected bool SetPropertyAndNotifyOnCompletion<T>([NotNull] ref TaskNotifier<T>? taskNotifier, Task<T>? newValue, Action<Task<T>?> callback, [CallerMemberName] string? propertyName = null)
		{
			ArgumentNullException.ThrowIfNull(callback, "callback");
			return SetPropertyAndNotifyOnCompletion(taskNotifier ?? (taskNotifier = new TaskNotifier<T>()), newValue, callback, propertyName);
		}

		private bool SetPropertyAndNotifyOnCompletion<TTask>(ITaskNotifier<TTask> taskNotifier, TTask? newValue, Action<TTask?>? callback, [CallerMemberName] string? propertyName = null) where TTask : Task
		{
			TTask newValue2 = newValue;
			ITaskNotifier<TTask> taskNotifier2 = taskNotifier;
			string propertyName2 = propertyName;
			Action<TTask?> callback2 = callback;
			if (taskNotifier2.Task == newValue2)
			{
				return false;
			}
			bool num = newValue2?.IsCompleted ?? true;
			OnPropertyChanging(propertyName2);
			taskNotifier2.Task = newValue2;
			OnPropertyChanged(propertyName2);
			if (num)
			{
				if (callback2 != null)
				{
					callback2(newValue2);
				}
				return true;
			}
			MonitorTask();
			return true;
			async void MonitorTask()
			{
				await newValue2.GetAwaitableWithoutEndValidation();
				if (taskNotifier2.Task == newValue2)
				{
					OnPropertyChanged(propertyName2);
				}
				if (callback2 != null)
				{
					callback2(newValue2);
				}
			}
		}
	}
	public abstract class ObservableRecipient : ObservableObject
	{
		private bool isActive;

		protected IMessenger Messenger { get; }

		public bool IsActive
		{
			get
			{
				return isActive;
			}
			[RequiresUnreferencedCode("When this property is set to true, the OnActivated() method will be invoked, which will register all necessary message handlers for this recipient. This method requires the generated CommunityToolkit.Mvvm.Messaging.__Internals.__IMessengerExtensions type not to be removed to use the fast path. If this type is removed by the linker, or if the target recipient was created dynamically and was missed by the source generator, a slower fallback path using a compiled LINQ expression will be used. This will have more overhead in the first invocation of this method for any given recipient type. Alternatively, OnActivated() can be manually overwritten, and registration can be done individually for each required message for this recipient.")]
			set
			{
				if (SetProperty(ref isActive, value, broadcast: true, "IsActive"))
				{
					if (value)
					{
						OnActivated();
					}
					else
					{
						OnDeactivated();
					}
				}
			}
		}

		protected ObservableRecipient()
			: this(WeakReferenceMessenger.Default)
		{
		}

		protected ObservableRecipient(IMessenger messenger)
		{
			ArgumentNullException.ThrowIfNull(messenger, "messenger");
			Messenger = messenger;
		}

		[RequiresUnreferencedCode("This method requires th