using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using On.RoR2;
using On.RoR2.Achievements;
using RoR2;
using RoR2.Achievements;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Gimme")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+8344fe9933605c3c439197aecda52d719d8087eb")]
[assembly: AssemblyProduct("Gimme")]
[assembly: AssemblyTitle("Gimme")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Gimme
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("Risk of Rain 2.exe")]
	[BepInPlugin("com.nulldev.ror2.gimme", "Gimme", "1.0.3")]
	public class Gimme : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_RunCmd <0>__Console_RunCmd;

			public static hook_Grant <1>__AchievementBlocker;
		}

		private const string GUID = "com.nulldev.ror2.gimme";

		private const string NAME = "Gimme";

		private const string VERSION = "1.0.3";

		internal static ManualLogSource log { get; set; }

		public void Awake()
		{
			//IL_001b: 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)
			//IL_0026: Expected O, but got Unknown
			//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_0046: Expected O, but got Unknown
			log = ((BaseUnityPlugin)this).Logger;
			object obj = <>O.<0>__Console_RunCmd;
			if (obj == null)
			{
				hook_RunCmd val = Console_RunCmd;
				<>O.<0>__Console_RunCmd = val;
				obj = (object)val;
			}
			Console.RunCmd += (hook_RunCmd)obj;
			object obj2 = <>O.<1>__AchievementBlocker;
			if (obj2 == null)
			{
				hook_Grant val2 = AchievementBlocker;
				<>O.<1>__AchievementBlocker = val2;
				obj2 = (object)val2;
			}
			BaseAchievement.Grant += (hook_Grant)obj2;
			log.LogInfo((object)"Gimme loaded successfully.");
		}

		private static void AchievementBlocker(orig_Grant orig, BaseAchievement self)
		{
			log.LogDebug((object)("[Gimme::AchievementBlocker] Preventing the following achievement: " + (object)self));
		}

		private static void Console_RunCmd(orig_RunCmd orig, Console self, CmdSender sender, string concommandName, List<string> userArgs)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0111: 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_0126: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			if (!NetworkServer.active || (Object)(object)Run.instance == (Object)null || !concommandName.Equals("say", StringComparison.InvariantCultureIgnoreCase))
			{
				orig.Invoke(self, sender, concommandName, userArgs);
				return;
			}
			string text = userArgs.FirstOrDefault();
			if (string.IsNullOrWhiteSpace(text) || !text.StartsWith("/"))
			{
				orig.Invoke(self, sender, concommandName, userArgs);
				return;
			}
			string[] source = text.Split(' ');
			string text2 = source.FirstOrDefault().Substring(1);
			string[] array = source.Skip(1).ToArray();
			if (text2.ToUpperInvariant() == "GIMME" || text2.ToUpperInvariant() == "GI")
			{
				Chat.SendBroadcastChat((ChatMessageBase)new UserChatMessage
				{
					sender = ((Component)sender.networkUser).gameObject,
					text = text
				});
				if (array.Length < 1 || array[0] == "" || array[0].ToUpperInvariant() == "HELP")
				{
					Chat.SendBroadcastChat((ChatMessageBase)new SimpleChatMessage
					{
						baseToken = "<color=#AAE6F0>/gi itemname playername [amount]\n/gimme itemname playername [amount]\n/gr [itemname] [amount]\n/gimmerandom [itemname] [amount]\nWill give items into playername's inventory"
					});
					return;
				}
				string text3 = GimmeLogic.GiveItem(sender.networkUser, array);
				if (text3 == null)
				{
					Chat.SendBroadcastChat((ChatMessageBase)new SimpleChatMessage
					{
						baseToken = "<color=#ff4646>ERROR: null output</color>"
					});
				}
				else
				{
					Chat.SendBroadcastChat((ChatMessageBase)new SimpleChatMessage
					{
						baseToken = text3
					});
				}
			}
			else if (text2.ToUpperInvariant() == "GR" || text2.ToUpperInvariant() == "GIMMERANDOM")
			{
				Chat.SendBroadcastChat((ChatMessageBase)new UserChatMessage
				{
					sender = ((Component)sender.networkUser).gameObject,
					text = text
				});
				string text4 = GimmeLogic.GiveRandomItem(sender.networkUser, array);
				if (text4 == null)
				{
					Chat.SendBroadcastChat((ChatMessageBase)new SimpleChatMessage
					{
						baseToken = "<color=#ff4646>ERROR: null output</color>"
					});
				}
				else
				{
					Chat.SendBroadcastChat((ChatMessageBase)new SimpleChatMessage
					{
						baseToken = text4
					});
				}
			}
			else if (text2.ToUpperInvariant() == "GIMME_DUMP_ITEMS")
			{
				GimmeLogic.DumpItems();
				Chat.SendBroadcastChat((ChatMessageBase)new SimpleChatMessage
				{
					baseToken = "Gimme wrote a gimme_items.txt into your game's directory."
				});
			}
			else
			{
				orig.Invoke(self, sender, concommandName, userArgs);
			}
		}
	}
	internal class GimmeLogic
	{
		public const string RANDOM_ITEM = "#gimme-random";

		public const string green = "<color=#96EBAA>";

		public const string player = "<color=#AAE6F0>";

		public const string error = "<color=#FF8282>";

		public const string bold = "<color=#ff4646>";

		private static readonly Dictionary<ItemDef, int> RESTRICTED_ITEMS;

		static GimmeLogic()
		{
			RESTRICTED_ITEMS = new Dictionary<ItemDef, int>();
			RESTRICTED_ITEMS.Add(Items.LunarDagger, 64);
			RESTRICTED_ITEMS.Add(Items.RandomEquipmentTrigger, 128);
			RESTRICTED_ITEMS.Add(Items.SprintBonus, 100);
			RESTRICTED_ITEMS.Add(Items.Hoof, 100);
			RESTRICTED_ITEMS.Add(Items.AttackSpeedAndMoveSpeed, 100);
			RESTRICTED_ITEMS.Add(Items.AttackSpeedPerNearbyAllyOrEnemy, 100);
			RESTRICTED_ITEMS.Add(Items.CookedSteak, 100);
			RESTRICTED_ITEMS.Add(Items.JumpBoost, 10);
			RESTRICTED_ITEMS.Add(Items.FallBoots, 10);
			RESTRICTED_ITEMS.Add(Items.AutoCastEquipment, 32);
			RESTRICTED_ITEMS.Add(Items.HalfAttackSpeedHalfCooldowns, 8);
			RESTRICTED_ITEMS.Add(Items.Talisman, 69);
			RESTRICTED_ITEMS.Add(Items.HalfSpeedDoubleHealth, 16);
			RESTRICTED_ITEMS.Add(Items.TransferDebuffOnHit, 16);
			RESTRICTED_ITEMS.Add(Items.EquipmentMagazine, 254);
			RESTRICTED_ITEMS.Add(Items.ShinyPearl, 100);
			RESTRICTED_ITEMS.Add(Items.LunarSun, 100);
			RESTRICTED_ITEMS.Add(Items.LowerPricedChests, 100);
			RESTRICTED_ITEMS.Add(Items.Duplicator, 100);
		}

		public static string GiveRandomItem(NetworkUser user, string[] args)
		{
			Inventory val = (((Object)(object)user != (Object)null) ? user.master.inventory : null);
			NetworkUser randomUser = StringParsers.GetRandomUser();
			Inventory val2 = (((Object)(object)randomUser != (Object)null) ? randomUser.master.inventory : null);
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val2))
			{
				return "<color=#ff4646>ERROR: Unable to get player inventory!</color>";
			}
			if (!ParsePlayerArguments(user, args, out var _, out var _, out var quantity))
			{
				return "<color=#ff4646>ERROR: ParsePlayerArguments() returned FALSE!</color>";
			}
			return ProvideItem(user, val, val2, randomUser, quantity, "#gimme-random");
		}

		public static string GiveItem(NetworkUser user, string[] args)
		{
			Inventory val = (((Object)(object)user != (Object)null) ? user.master.inventory : null);
			if (!ParsePlayerArguments(user, args, out var item, out var netUserFromString, out var quantity))
			{
				if (args.Length != 2)
				{
					return "<color=#FF8282>No player name specified!</color>";
				}
				return "<color=#FF8282>Could not find specified </color>player<color=#FF8282> '<color=#ff4646>" + args[1] + "</color>'</color>";
			}
			Inventory val2 = (((Object)(object)netUserFromString != (Object)null) ? netUserFromString.master.inventory : null);
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val2))
			{
				return "<color=#ff4646>Player not found or invalid player name.</color>";
			}
			return ProvideItem(user, val, val2, netUserFromString, quantity, item);
		}

		internal static string ProvideItem(NetworkUser sender, Inventory inventory1, Inventory inventory2, NetworkUser netUserFromString, int num, string item)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_004c: 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_0060: Invalid comparison between Unknown and I4
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			string text = "<color=#AAE6F0>" + netUserFromString.masterController.GetDisplayName() + "</color>";
			string text2 = "<color=#AAE6F0>" + sender.masterController.GetDisplayName() + "</color>";
			ItemIndex val = (ItemIndex)(-1);
			if (item.Equals("#gimme-random"))
			{
				do
				{
					val = StringParsers.RandomItem();
				}
				while (IsNotSpawnable(val));
			}
			else
			{
				val = StringParsers.FindItem(item);
			}
			if ((int)val == -1)
			{
				return "<color=#FF8282>Could not find specified </color>item<color=#FF8282> '<color=#ff4646>" + item + "</color>'</color>";
			}
			ItemDef itemDef = ItemCatalog.GetItemDef(val);
			PickupIndex val2 = PickupCatalog.FindPickupIndex(val);
			string @string = Language.GetString(itemDef.nameToken);
			string text3 = Util.GenerateColoredString(@string, Color32.op_Implicit(PickupCatalog.GetPickupDef(val2).baseColor));
			if (IsNotSpawnable(val))
			{
				return "<color=#FF8282>Item cannot be spawned in.</color>";
			}
			if (RESTRICTED_ITEMS.ContainsKey(itemDef))
			{
				int itemCountPermanent = inventory2.GetItemCountPermanent(itemDef);
				int num2 = RESTRICTED_ITEMS[itemDef];
				if (num >= num2)
				{
					return "<color=#FF8282>Too much of an item requested, the limit is '" + num2 + "'.</color>";
				}
				if (itemCountPermanent + num > num2)
				{
					return "<color=#FF8282>Player already has too much of item.</color>";
				}
			}
			if (num > 1 && !@string.EndsWith("s"))
			{
				text3 += Util.GenerateColoredString("s", Color32.op_Implicit(PickupCatalog.GetPickupDef(val2).baseColor));
			}
			if (num > 1024)
			{
				num = 1024;
			}
			inventory2.GiveItemPermanent(val, num);
			if (text.Equals(text2))
			{
				return string.Format("{0}{1} gave themselves {2} {3}</color>", "<color=#96EBAA>", text2, num, text3);
			}
			return string.Format("{0}{1} gave {2} {3} to </color>{4}", "<color=#96EBAA>", text2, num, text3, text);
		}

		internal static bool IsNotSpawnable(ItemIndex index)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string @string = Language.GetString(ItemCatalog.GetItemDef(index).nameToken);
			if (@string.StartsWith("ITEM_"))
			{
				return @string.EndsWith("_NAME");
			}
			return false;
		}

		internal static bool ParsePlayerArguments(NetworkUser sender, string[] args, out string item, out NetworkUser netUserFromString, out int quantity)
		{
			item = null;
			netUserFromString = null;
			quantity = -1;
			if (args == null || args.Length == 0)
			{
				return false;
			}
			foreach (string text in args)
			{
				int result;
				bool flag = int.TryParse(text, out result);
				if (item == null)
				{
					item = text;
				}
				else if ((Object)(object)netUserFromString == (Object)null && !flag)
				{
					netUserFromString = StringParsers.GetNetUserFromString(text);
				}
				else if (quantity == -1 && flag)
				{
					int.TryParse(text, out quantity);
				}
			}
			if (NetworkUser.readOnlyInstancesList.Count == 1)
			{
				netUserFromString = sender;
			}
			if (quantity == -1)
			{
				quantity = 1;
			}
			return true;
		}

		internal static NetworkUser GetPlayer(NetworkUser sender, string arg)
		{
			if (NetworkUser.readOnlyInstancesList.Count == 1)
			{
				return sender;
			}
			return StringParsers.GetNetUserFromString(arg);
		}

		internal static void DumpItems()
		{
			//IL_001b: 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)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected I4, but got Unknown
			using StreamWriter streamWriter = new StreamWriter("gimme_items.txt");
			streamWriter.WriteLine("// Gimme FORMAT_ONE");
			AllItemsEnumerator enumerator = ItemCatalog.allItems.GetEnumerator();
			try
			{
				while (((AllItemsEnumerator)(ref enumerator)).MoveNext())
				{
					ItemIndex current = ((AllItemsEnumerator)(ref enumerator)).Current;
					ItemDef itemDef = ItemCatalog.GetItemDef(current);
					string @string = Language.GetString(itemDef.nameToken);
					string text = "";
					text += "{index:";
					text += ((object)(ItemIndex)(ref current)).ToString();
					text += ",tier:";
					text += (int)itemDef.tier;
					text += ",nameToken:\"";
					text += ((Object)itemDef).name;
					text += "\",localizedName:\"";
					text += @string;
					text += "\"}";
					streamWriter.WriteLine(text);
				}
			}
			finally
			{
				((IDisposable)(AllItemsEnumerator)(ref enumerator)).Dispose();
			}
		}
	}
	internal sealed class StringParsers
	{
		private static readonly Random rng = new Random();

		internal static ItemIndex FindItemInInventory(string input, Inventory inventory)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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)
			List<ItemIndex> itemAcquisitionOrder = inventory.itemAcquisitionOrder;
			if (!itemAcquisitionOrder.Any())
			{
				return (ItemIndex)(-1);
			}
			input = ReformatString(input);
			if (int.TryParse(input, out var result))
			{
				if (result > itemAcquisitionOrder.Count || result < 0)
				{
					return (ItemIndex)(-1);
				}
				if (result == 0)
				{
					return itemAcquisitionOrder[itemAcquisitionOrder.Count - 1];
				}
				return itemAcquisitionOrder[itemAcquisitionOrder.Count - result];
			}
			for (int num = itemAcquisitionOrder.Count - 1; num >= 0; num--)
			{
				ItemDef itemDef = ItemCatalog.GetItemDef(itemAcquisitionOrder[num]);
				if (ReformatString(Language.GetString(itemDef.nameToken)).Contains(input))
				{
					return itemDef.itemIndex;
				}
			}
			return (ItemIndex)(-1);
		}

		public static EquipmentIndex GetEquipFromPartial(string name)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			name = ReformatString(name);
			EquipmentDef[] equipmentDefs = EquipmentCatalog.equipmentDefs;
			foreach (EquipmentDef val in equipmentDefs)
			{
				if (ReformatString(Language.GetString(val.nameToken)).Contains(name))
				{
					return val.equipmentIndex;
				}
			}
			return (EquipmentIndex)(-1);
		}

		internal static NetworkUser GetRandomUser()
		{
			return NetworkUser.readOnlyInstancesList[rng.Next(NetworkUser.readOnlyInstancesList.Count)];
		}

		internal static NetworkUser GetNetUserFromString(string name)
		{
			if (int.TryParse(name, out var result))
			{
				if (result < NetworkUser.readOnlyInstancesList.Count && result >= 0)
				{
					return NetworkUser.readOnlyInstancesList[result];
				}
				return null;
			}
			name = ReformatString(name);
			foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
			{
				if (ReformatString(readOnlyInstances.userName).StartsWith(name))
				{
					return readOnlyInstances;
				}
			}
			foreach (NetworkUser readOnlyInstances2 in NetworkUser.readOnlyInstancesList)
			{
				if (ReformatString(readOnlyInstances2.userName).Contains(name))
				{
					return readOnlyInstances2;
				}
			}
			foreach (NetworkUser readOnlyInstances3 in NetworkUser.readOnlyInstancesList)
			{
				if (NormalizeString(readOnlyInstances3.userName).Contains(name))
				{
					return readOnlyInstances3;
				}
			}
			return null;
		}

		internal static string ReformatString(string input)
		{
			return Regex.Replace(input, "[ '_.,-]", string.Empty).ToLower();
		}

		internal static string NormalizeString(string input)
		{
			return input.Normalize(NormalizationForm.FormKD);
		}

		internal static ItemIndex RandomItem()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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)
			int index = rng.Next(((IEnumerable<ItemIndex>)(object)ItemCatalog.allItems).Count());
			return ((IEnumerable<ItemIndex>)(object)ItemCatalog.allItems).AsParallel().DefaultIfEmpty((ItemIndex)(-1)).ElementAtOrDefault(index);
		}

		internal static ItemIndex FindItem(string item)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			return (from candidate in ((IEnumerable<ItemIndex>)(object)ItemCatalog.allItems).AsParallel()
				where Language.GetString(ItemCatalog.GetItemDef(candidate).nameToken).IndexOf(item, StringComparison.OrdinalIgnoreCase) >= 0
				select candidate).DefaultIfEmpty((ItemIndex)(-1)).First();
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
}