using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CursedUI")]
[assembly: AssemblyTitle("CursedUI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
}
namespace Repo.DarkMode
{
	public static class DarkModeConfig
	{
		public static bool Enabled = true;

		public static bool CursedText = true;

		public static Color TextColor = new Color(0.85f, 0.1f, 0.1f, 1f);

		public static Color BackgroundColor = new Color(0f, 0f, 0f, 0.6f);

		public static Vector2 BackgroundMinSize = new Vector2(600f, 300f);

		public static float MaxLengthInflation = 1.15f;

		public static int AutoFitMin = 14;

		public static int AutoFitMax = 36;

		public static ColorBlock ButtonTint;

		public static readonly Dictionary<string, string> CursedMapPreferred;

		public static readonly Dictionary<string, string> CursedMapCompact;

		public static bool HideTextUntilThemed;

		public static int PreRenderSweeps;

		public static int MaxPerSweep;

		static DarkModeConfig()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock buttonTint = default(ColorBlock);
			((ColorBlock)(ref buttonTint)).normalColor = new Color(0.25f, 0f, 0f, 1f);
			((ColorBlock)(ref buttonTint)).highlightedColor = new Color(0.5f, 0.05f, 0.05f, 1f);
			((ColorBlock)(ref buttonTint)).pressedColor = new Color(0.7f, 0.1f, 0.1f, 1f);
			((ColorBlock)(ref buttonTint)).selectedColor = new Color(0.4f, 0.05f, 0.05f, 1f);
			((ColorBlock)(ref buttonTint)).disabledColor = new Color(0.2f, 0.2f, 0.2f, 0.6f);
			((ColorBlock)(ref buttonTint)).colorMultiplier = 1f;
			((ColorBlock)(ref buttonTint)).fadeDuration = 0.05f;
			ButtonTint = buttonTint;
			CursedMapPreferred = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
			{
				{ "play", "SUFFER" },
				{ "start", "AWAKEN THE PAIN" },
				{ "continue", "CONTINUE THE TORMENT" },
				{ "load", "SUMMON RELICS" },
				{ "new", "FRESH SACRIFICE" },
				{ "options", "HEXES" },
				{ "settings", "RITUALS" },
				{ "graphics", "VISIONS" },
				{ "audio", "WHISPERS" },
				{ "sound", "ECHOES" },
				{ "controls", "BINDINGS" },
				{ "keybinds", "BLOOD OATHS" },
				{ "resume", "UNPAUSE THE CURSE" },
				{ "pause", "BREACH" },
				{ "quit", "EMBRACE THE VOID" },
				{ "exit", "EXILE SELF" },
				{ "back", "RETREAT" },
				{ "ok", "SO BE IT" },
				{ "confirm", "SEAL FATE" },
				{ "cancel", "DEFY FATE" },
				{ "apply", "INSCRIBE SIGIL" },
				{ "multiplayer", "COVEN" },
				{ "lobby", "CIRCLE" }
			};
			CursedMapCompact = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
			{
				{ "play", "SLAY" },
				{ "start", "RITES" },
				{ "continue", "ENDURE" },
				{ "load", "RAISE" },
				{ "new", "HEX" },
				{ "options", "OMENS" },
				{ "settings", "RITUALS" },
				{ "graphics", "VISIONS" },
				{ "audio", "ECHOES" },
				{ "sound", "ECHO" },
				{ "controls", "BINDINGS" },
				{ "keybinds", "OATHS" },
				{ "resume", "RETURN" },
				{ "pause", "HUSH" },
				{ "quit", "VOID" },
				{ "exit", "EXILE" },
				{ "back", "FLEE" },
				{ "ok", "AYE" },
				{ "confirm", "SEAL" },
				{ "cancel", "DENY" },
				{ "apply", "BRAND" },
				{ "multiplayer", "COVEN" },
				{ "lobby", "CIRCLE" }
			};
			HideTextUntilThemed = true;
			PreRenderSweeps = 12;
			MaxPerSweep = 4096;
		}
	}
	public static class DarkModePatcher
	{
		private static Harmony _harmony;

		internal static readonly HashSet<int> ThemedTexts = new HashSet<int>(4096);

		private static readonly Dictionary<int, string> OriginalTextCache = new Dictionary<int, string>(4096);

		private static readonly Dictionary<char, char> GlyphMap = new Dictionary<char, char>
		{
			{ 'A', 'Å' },
			{ 'a', 'ᵃ' },
			{ 'E', 'Ė' },
			{ 'e', 'ė' },
			{ 'I', 'Į' },
			{ 'i', 'į' },
			{ 'O', 'Ø' },
			{ 'o', 'ø' },
			{ 'U', 'Ů' },
			{ 'u', 'ů' },
			{ 'Y', 'Ɏ' },
			{ 'y', 'ɏ' },
			{ 'S', 'Ƨ' },
			{ 's', 'ʂ' },
			{ 'T', 'Ŧ' },
			{ 't', 'ŧ' },
			{ 'R', 'Я' },
			{ 'N', 'И' },
			{ 'H', 'Ħ' },
			{ 'h', 'ħ' },
			{ 'C', 'Ɔ' },
			{ 'c', 'ƈ' },
			{ 'D', 'Đ' },
			{ 'd', 'đ' },
			{ 'L', 'Ł' },
			{ 'l', 'ł' },
			{ 'P', 'Ᵽ' },
			{ 'p', 'ᵖ' },
			{ 'V', '∨' },
			{ 'M', 'Ϻ' },
			{ 'B', 'Ƀ' },
			{ 'b', 'Ь' },
			{ 'G', 'Ǥ' },
			{ 'g', 'ɠ' },
			{ 'K', 'Ҝ' },
			{ 'k', 'ʞ' },
			{ 'X', '✕' }
		};

		[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
		private static void EarlyInit()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			try
			{
				if (_harmony == null)
				{
					_harmony = new Harmony("repo.darkmode.patch");
					_harmony.PatchAll(typeof(DarkModePatcher).Assembly);
				}
				CreateRunner();
				RenderCatcher.Subscribe();
				Debug.Log((object)"[Repo.DarkMode] EarlyInit complete (text interception armed)");
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Repo.DarkMode] EarlyInit failed: {arg}");
			}
		}

		[RuntimeInitializeOnLoadMethod(/*Could not decode attribute arguments.*/)]
		public static void Init()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			try
			{
				if (_harmony == null)
				{
					_harmony = new Harmony("repo.darkmode.patch");
					_harmony.PatchAll(typeof(DarkModePatcher).Assembly);
				}
				if (!Object.op_Implicit((Object)(object)GameObject.Find("Repo.DarkMode.Runner")))
				{
					CreateRunner();
				}
				ThemedTexts.Clear();
				OriginalTextCache.Clear();
				RenderCatcher.Subscribe();
				Debug.Log((object)"[Repo.DarkMode] Harmony patches applied & runner active");
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Repo.DarkMode] Failed to initialize: {arg}");
			}
		}

		private static void CreateRunner()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			GameObject val = new GameObject("Repo.DarkMode.Runner");
			Object.DontDestroyOnLoad((Object)(object)val);
			DarkModeRunner runner = val.AddComponent<DarkModeRunner>();
			runner.ApplyNowAndDelayed();
			SceneManager.activeSceneChanged += delegate
			{
				ThemedTexts.Clear();
				OriginalTextCache.Clear();
				runner.ApplyNowAndDelayed();
				RenderCatcher.Subscribe();
			};
			SceneManager.sceneLoaded += delegate
			{
				ThemedTexts.Clear();
				OriginalTextCache.Clear();
				runner.ApplyNowAndDelayed();
				RenderCatcher.Subscribe();
			};
		}

		internal static string InterceptTextAssignment(TMP_Text tmpText, string newText)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!DarkModeConfig.Enabled || (Object)(object)tmpText == (Object)null || string.IsNullOrWhiteSpace(newText))
			{
				return newText;
			}
			int instanceID = ((Object)tmpText).GetInstanceID();
			if (!OriginalTextCache.ContainsKey(instanceID))
			{
				OriginalTextCache[instanceID] = newText;
			}
			try
			{
				ForceTmpColor(tmpText, DarkModeConfig.TextColor);
			}
			catch
			{
			}
			string result = newText;
			if (DarkModeConfig.CursedText)
			{
				result = CurseifySmart(newText);
			}
			ThemedTexts.Add(instanceID);
			return result;
		}

		public static void ApplyTheme(Transform root)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (!DarkModeConfig.Enabled || (Object)(object)root == (Object)null)
			{
				return;
			}
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				try
				{
					RectTransform rectTransform = ((Graphic)val).rectTransform;
					bool flag = rectTransform.anchorMin == Vector2.zero && rectTransform.anchorMax == Vector2.one;
					Rect rect = rectTransform.rect;
					int num;
					if (((Rect)(ref rect)).width >= DarkModeConfig.BackgroundMinSize.x)
					{
						rect = rectTransform.rect;
						num = ((((Rect)(ref rect)).height >= DarkModeConfig.BackgroundMinSize.y) ? 1 : 0);
					}
					else
					{
						num = 0;
					}
					bool flag2 = (byte)num != 0;
					if (flag || flag2)
					{
						float num2 = Mathf.Max(DarkModeConfig.BackgroundColor.a, ((Graphic)val).color.a);
						((Graphic)val).color = new Color(DarkModeConfig.BackgroundColor.r, DarkModeConfig.BackgroundColor.g, DarkModeConfig.BackgroundColor.b, num2);
					}
				}
				catch
				{
				}
			}
			TMP_Text[] componentsInChildren2 = ((Component)root).GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val2 in componentsInChildren2)
			{
				try
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					ForceTmpColor(val2, DarkModeConfig.TextColor);
					if (DarkModeConfig.CursedText && !ThemedTexts.Contains(((Object)val2).GetInstanceID()))
					{
						string text = val2.text;
						if (!string.IsNullOrWhiteSpace(text))
						{
							string text2 = CurseifySmart(text);
							if (!string.Equals(text, text2, StringComparison.Ordinal))
							{
								val2.text = text2;
							}
						}
					}
					FitToRect(val2);
					ThemedTexts.Add(((Object)val2).GetInstanceID());
				}
				catch
				{
				}
			}
			Selectable[] componentsInChildren3 = ((Component)root).GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val3 in componentsInChildren3)
			{
				try
				{
					ColorBlock colors = val3.colors;
					((ColorBlock)(ref colors)).normalColor = ((ColorBlock)(ref DarkModeConfig.ButtonTint)).normalColor;
					((ColorBlock)(ref colors)).highlightedColor = ((ColorBlock)(ref DarkModeConfig.ButtonTint)).highlightedColor;
					((ColorBlock)(ref colors)).pressedColor = ((ColorBlock)(ref DarkModeConfig.ButtonTint)).pressedColor;
					((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref DarkModeConfig.ButtonTint)).selectedColor;
					((ColorBlock)(ref colors)).disabledColor = ((ColorBlock)(ref DarkModeConfig.ButtonTint)).disabledColor;
					((ColorBlock)(ref colors)).colorMultiplier = ((ColorBlock)(ref DarkModeConfig.ButtonTint)).colorMultiplier;
					((ColorBlock)(ref colors)).fadeDuration = ((ColorBlock)(ref DarkModeConfig.ButtonTint)).fadeDuration;
					val3.colors = colors;
				}
				catch
				{
				}
			}
		}

		private static void ForceTmpColor(TMP_Text tmp, Color c)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0021: 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_0064: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			tmp.enableVertexGradient = false;
			((Graphic)tmp).color = new Color(c.r, c.g, c.b, 1f);
			tmp.overrideColorTags = true;
			try
			{
				Material fontMaterial = tmp.fontMaterial;
				if ((Object)(object)fontMaterial != (Object)null && fontMaterial.HasProperty(ShaderUtilities.ID_FaceColor))
				{
					fontMaterial.SetColor(ShaderUtilities.ID_FaceColor, new Color(c.r, c.g, c.b, 1f));
				}
				if ((Object)(object)fontMaterial != (Object)null && fontMaterial.HasProperty(ShaderUtilities.ID_OutlineColor))
				{
					fontMaterial.SetColor(ShaderUtilities.ID_OutlineColor, new Color(0f, 0f, 0f, 0.85f));
					if (fontMaterial.HasProperty(ShaderUtilities.ID_OutlineWidth))
					{
						fontMaterial.SetFloat(ShaderUtilities.ID_OutlineWidth, Mathf.Max(0.1f, fontMaterial.GetFloat(ShaderUtilities.ID_OutlineWidth)));
					}
				}
			}
			catch
			{
			}
		}

		private static void FitToRect(TMP_Text tmp)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			tmp.enableWordWrapping = true;
			tmp.overflowMode = (TextOverflowModes)1;
			RectTransform rectTransform = tmp.rectTransform;
			if (!Object.op_Implicit((Object)(object)rectTransform))
			{
				return;
			}
			tmp.ForceMeshUpdate(false, false);
			float preferredWidth = tmp.preferredWidth;
			Rect rect = rectTransform.rect;
			float num = Mathf.Abs(((Rect)(ref rect)).width);
			if (num > 1f && preferredWidth > num * 1.02f)
			{
				tmp.enableAutoSizing = true;
				if (tmp.fontSizeMax <= 0f)
				{
					tmp.fontSizeMax = DarkModeConfig.AutoFitMax;
				}
				if (tmp.fontSizeMin <= 0f)
				{
					tmp.fontSizeMin = DarkModeConfig.AutoFitMin;
				}
				tmp.ForceMeshUpdate(false, false);
			}
		}

		private static string CurseifySmart(string s)
		{
			string text = s;
			foreach (KeyValuePair<string, string> item in DarkModeConfig.CursedMapPreferred)
			{
				text = ReplaceWordBoundary(text, item.Key, item.Value, allowInflation: true);
			}
			foreach (KeyValuePair<string, string> item2 in DarkModeConfig.CursedMapPreferred)
			{
				text = ReplaceContainsLengthAware(text, item2.Key, item2.Value);
			}
			foreach (KeyValuePair<string, string> item3 in DarkModeConfig.CursedMapCompact)
			{
				text = ReplaceContainsLengthAware(text, item3.Key, item3.Value);
			}
			return CorruptLetters(text);
		}

		private static string ReplaceWordBoundary(string input, string key, string val, bool allowInflation)
		{
			string val2 = val;
			return Regex.Replace(input, "\\b" + Regex.Escape(key) + "\\b", (Match m) => allowInflation ? val2 : ((val2.Length <= (int)((float)m.Value.Length * DarkModeConfig.MaxLengthInflation)) ? val2 : m.Value), RegexOptions.IgnoreCase);
		}

		private static string ReplaceContainsLengthAware(string input, string key, string val)
		{
			int num = 0;
			while (num < input.Length)
			{
				int num2 = input.IndexOf(key, num, StringComparison.OrdinalIgnoreCase);
				if (num2 < 0)
				{
					break;
				}
				int length = key.Length;
				if (val.Length <= Mathf.CeilToInt((float)length * DarkModeConfig.MaxLengthInflation))
				{
					string text = input.Substring(0, num2);
					string text2 = input;
					int num3 = num2 + length;
					input = text + val + text2.Substring(num3, text2.Length - num3);
					num = num2 + val.Length;
				}
				else
				{
					num = num2 + length;
				}
			}
			return input;
		}

		private static string CorruptLetters(string s)
		{
			List<char> list = new List<char>(s.Length);
			bool flag = false;
			foreach (char c in s)
			{
				switch (c)
				{
				case '<':
					flag = true;
					list.Add(c);
					continue;
				case '>':
					flag = false;
					list.Add(c);
					continue;
				}
				if (!flag && GlyphMap.TryGetValue(c, out var value))
				{
					list.Add(value);
				}
				else
				{
					list.Add(c);
				}
			}
			return new string(list.ToArray());
		}
	}
	internal sealed class DarkModeRunner : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayedApply>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			public DarkModeRunner <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedApply>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.ApplyAllCanvases();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public void ApplyNowAndDelayed()
		{
			ApplyAllCanvases();
			((MonoBehaviour)this).StopAllCoroutines();
			((MonoBehaviour)this).StartCoroutine(DelayedApply(0.05f));
			((MonoBehaviour)this).StartCoroutine(DelayedApply(0.1f));
			((MonoBehaviour)this).StartCoroutine(DelayedApply(0.25f));
			((MonoBehaviour)this).StartCoroutine(DelayedApply(0.5f));
			((MonoBehaviour)this).StartCoroutine(DelayedApply(1f));
		}

		[IteratorStateMachine(typeof(<DelayedApply>d__1))]
		private IEnumerator DelayedApply(float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedApply>d__1(0)
			{
				<>4__this = this,
				delay = delay
			};
		}

		private void ApplyAllCanvases()
		{
			if (!DarkModeConfig.Enabled)
			{
				return;
			}
			Canvas[] array = Object.FindObjectsOfType<Canvas>(true);
			foreach (Canvas val in array)
			{
				try
				{
					DarkModePatcher.ApplyTheme(((Component)val).transform);
				}
				catch
				{
				}
			}
		}
	}
	internal static class RenderCatcher
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static WillRenderCanvases <0>__OnWillRenderCanvases;
		}

		private static bool _subscribed;

		private static int _sweepsRemaining;

		public static void Subscribe()
		{
			//IL_002c: 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)
			//IL_0037: Expected O, but got Unknown
			_sweepsRemaining = Mathf.Max(1, DarkModeConfig.PreRenderSweeps);
			if (!_subscribed)
			{
				object obj = <>O.<0>__OnWillRenderCanvases;
				if (obj == null)
				{
					WillRenderCanvases val = OnWillRenderCanvases;
					<>O.<0>__OnWillRenderCanvases = val;
					obj = (object)val;
				}
				Canvas.willRenderCanvases += (WillRenderCanvases)obj;
				_subscribed = true;
			}
		}

		private static void Unsubscribe()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (_subscribed)
			{
				object obj = <>O.<0>__OnWillRenderCanvases;
				if (obj == null)
				{
					WillRenderCanvases val = OnWillRenderCanvases;
					<>O.<0>__OnWillRenderCanvases = val;
					obj = (object)val;
				}
				Canvas.willRenderCanvases -= (WillRenderCanvases)obj;
				_subscribed = false;
			}
		}

		private static void OnWillRenderCanvases()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!DarkModeConfig.Enabled)
				{
					return;
				}
				if (DarkModeConfig.HideTextUntilThemed)
				{
					int maxPerSweep = DarkModeConfig.MaxPerSweep;
					TMP_Text[] array = Object.FindObjectsOfType<TMP_Text>(true);
					for (int i = 0; i < array.Length; i++)
					{
						if (maxPerSweep-- <= 0)
						{
							break;
						}
						TMP_Text val = array[i];
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						int instanceID = ((Object)val).GetInstanceID();
						if (!DarkModePatcher.ThemedTexts.Contains(instanceID))
						{
							Color color = ((Graphic)val).color;
							if (color.a > 0f)
							{
								((Graphic)val).color = new Color(color.r, color.g, color.b, 0f);
							}
						}
					}
				}
				int maxPerSweep2 = DarkModeConfig.MaxPerSweep;
				Canvas[] array2 = Object.FindObjectsOfType<Canvas>(true);
				foreach (Canvas val2 in array2)
				{
					if (maxPerSweep2-- <= 0)
					{
						break;
					}
					try
					{
						DarkModePatcher.ApplyTheme(((Component)val2).transform);
					}
					catch
					{
					}
				}
			}
			finally
			{
				_sweepsRemaining = Mathf.Max(0, _sweepsRemaining - 1);
				if (_sweepsRemaining <= 0)
				{
					Unsubscribe();
				}
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class TMP_Text_TextSetter_Patch
	{
		private static bool Prefix(TMP_Text __instance, ref string value)
		{
			try
			{
				value = DarkModePatcher.InterceptTextAssignment(__instance, value);
				return true;
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Repo.DarkMode] TMP_Text setter patch error: {arg}");
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class MenuPage_PageStateSet_Patch
	{
		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("MenuPage");
			if (type == null)
			{
				return null;
			}
			return AccessTools.Method(type, "PageStateSet", (Type[])null, (Type[])null);
		}

		private static void Postfix(object __instance)
		{
			try
			{
				Type type = __instance.GetType();
				FieldInfo fieldInfo = AccessTools.Field(type, "currentPageState");
				if (fieldInfo == null)
				{
					return;
				}
				string text = fieldInfo.GetValue(__instance)?.ToString() ?? string.Empty;
				if (text == "Active" || text == "Activating")
				{
					Component val = (Component)((__instance is Component) ? __instance : null);
					if (val != null)
					{
						DarkModePatcher.ApplyTheme(val.transform);
					}
				}
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[Repo.DarkMode] MenuPage_PageStateSet Postfix error: {arg}");
			}
		}
	}
	[HarmonyPatch]
	internal static class MenuManager_OpenMenu_Patch
	{
		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("MenuManager");
			if (type == null)
			{
				return null;
			}
			return AccessTools.Method(type, "PageOpen", (Type[])null, (Type[])null) ?? AccessTools.Method(type, "OpenMenu", (Type[])null, (Type[])null) ?? AccessTools.Method(type, "PageReactivatePageUnderThisPage", (Type[])null, (Type[])null) ?? AccessTools.Method(type, "MenuEffectPageIntro", (Type[])null, (Type[])null);
		}

		private static void Postfix(object __instance)
		{
			try
			{
				Component val = (Component)((__instance is Component) ? __instance : null);
				if (val != null)
				{
					DarkModePatcher.ApplyTheme(val.transform);
				}
			}
			catch
			{
			}
		}
	}
}
namespace CursedUI
{
	[BepInPlugin("Omniscye.CursedUI", "CursedUI", "1.0")]
	public class CursedUI : BaseUnityPlugin
	{
		internal static CursedUI Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: 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_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}