using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("WKLoc.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+de287f2d82518f94b32be74ee68529cb9c9f954e")]
[assembly: AssemblyProduct("WKLoc.Core")]
[assembly: AssemblyTitle("WKLoc.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[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]
	[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]
	[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 WKLoc.Core
{
	public static class AnchorExtractor
	{
		private const int MinLength = 4;

		public static string FromTemplateKey(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return string.Empty;
			}
			string text = string.Empty;
			string[] array = Regex.Split(key, "\\{\\d+\\}");
			foreach (string text2 in array)
			{
				if (text2.Length > text.Length)
				{
					text = text2;
				}
			}
			if (text.Length < 4)
			{
				return string.Empty;
			}
			return text;
		}

		public static string FromRegex(string pattern)
		{
			if (string.IsNullOrEmpty(pattern))
			{
				return string.Empty;
			}
			if (Regex.IsMatch(pattern, "\\(\\?[a-zA-Z-]*[iI]"))
			{
				return string.Empty;
			}
			char c = '\\';
			string best = string.Empty;
			StringBuilder run = new StringBuilder();
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < pattern.Length; i++)
			{
				char c2 = pattern[i];
				if (num2 > 0)
				{
					if (c2 == c)
					{
						i++;
					}
					else if (c2 == ']')
					{
						num2--;
					}
					continue;
				}
				if (num > 0)
				{
					if (c2 == c)
					{
						i++;
						continue;
					}
					switch (c2)
					{
					case '[':
						num2++;
						break;
					case '(':
						num++;
						break;
					case ')':
						num--;
						break;
					}
					continue;
				}
				switch (c2)
				{
				case '|':
					return string.Empty;
				case '(':
					EndRun();
					num = 1;
					continue;
				case '[':
					EndRun();
					num2 = 1;
					continue;
				case '{':
					DropLastAndEndRun();
					for (; i + 1 < pattern.Length && pattern[i + 1] != '}'; i++)
					{
					}
					i++;
					continue;
				case '*':
				case '?':
					DropLastAndEndRun();
					continue;
				case '+':
					EndRun();
					continue;
				case '$':
				case '.':
				case '^':
					EndRun();
					continue;
				case ')':
				case ']':
				case '}':
					return string.Empty;
				}
				if (c2 == c)
				{
					if (i + 1 >= pattern.Length)
					{
						return string.Empty;
					}
					char c3 = pattern[i + 1];
					i++;
					if (char.IsLetterOrDigit(c3))
					{
						EndRun();
					}
					else
					{
						run.Append(c3);
					}
				}
				else
				{
					run.Append(c2);
				}
			}
			EndRun();
			if (best.Length < 4)
			{
				return string.Empty;
			}
			return best;
			void DropLastAndEndRun()
			{
				if (run.Length > 0)
				{
					run.Length--;
				}
				EndRun();
			}
			void EndRun()
			{
				if (run.Length > best.Length)
				{
					best = run.ToString();
				}
				run.Length = 0;
			}
		}
	}
	public sealed class AutoGeneratedTextWriter : IDisposable
	{
		private readonly string _langDir;

		private readonly TimeSpan _delay;

		private readonly Func<string, TranslationData?> _deserialize;

		private readonly Func<TranslationData, string> _serialize;

		private readonly Action<Exception>? _onError;

		private readonly Action<int, string>? _onWrote;

		private readonly object _gate = new object();

		private readonly object _flushGate = new object();

		private readonly HashSet<string> _pending = new HashSet<string>(StringComparer.Ordinal);

		private readonly AutoResetEvent _signal = new AutoResetEvent(initialState: false);

		private Thread? _worker;

		private bool _started;

		private volatile bool _disposed;

		public AutoGeneratedTextWriter(string langDir, TimeSpan delay, Func<string, TranslationData?> deserialize, Func<TranslationData, string> serialize, Action<Exception>? onError = null, Action<int, string>? onWrote = null)
		{
			_langDir = langDir;
			_delay = ((delay < TimeSpan.Zero) ? TimeSpan.Zero : delay);
			_deserialize = deserialize;
			_serialize = serialize;
			_onError = onError;
			_onWrote = onWrote;
		}

		public void Enqueue(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return;
			}
			lock (_gate)
			{
				if (_disposed)
				{
					return;
				}
				_pending.Add(key);
				EnsureWorker();
			}
			_signal.Set();
		}

		private void EnsureWorker()
		{
			if (!_started)
			{
				_started = true;
				_worker = new Thread(WorkerLoop)
				{
					IsBackground = true,
					Name = "WKLoc-AutoGenWriter"
				};
				_worker.Start();
			}
		}

		private void WorkerLoop()
		{
			while (true)
			{
				_signal.WaitOne();
				if (_disposed)
				{
					break;
				}
				if (_delay > TimeSpan.Zero)
				{
					Thread.Sleep(_delay);
				}
				Flush();
			}
		}

		public void Flush()
		{
			lock (_flushGate)
			{
				FlushCore();
			}
		}

		private void FlushCore()
		{
			while (true)
			{
				List<string> list;
				lock (_gate)
				{
					if (_pending.Count == 0)
					{
						break;
					}
					list = new List<string>(_pending);
					_pending.Clear();
				}
				try
				{
					WriteBatch(list);
				}
				catch (Exception obj)
				{
					lock (_gate)
					{
						foreach (string item in list)
						{
							_pending.Add(item);
						}
					}
					_onError?.Invoke(obj);
					break;
				}
			}
		}

		private void WriteBatch(List<string> batch)
		{
			if (batch.Count == 0)
			{
				return;
			}
			Directory.CreateDirectory(_langDir);
			string text = Path.Combine(_langDir, "_AutoGenerated.json");
			TranslationData translationData = new TranslationData();
			if (File.Exists(text))
			{
				TranslationData translationData2 = _deserialize(File.ReadAllText(text));
				if (translationData2 != null)
				{
					translationData = translationData2;
				}
			}
			int num = 0;
			foreach (string item in batch)
			{
				if (!translationData.Exact.ContainsKey(item))
				{
					translationData.Exact[item] = "";
					num++;
				}
			}
			if (num != 0)
			{
				File.WriteAllText(text, _serialize(translationData));
				_onWrote?.Invoke(num, text);
			}
		}

		public void Dispose()
		{
			lock (_gate)
			{
				if (_disposed)
				{
					return;
				}
				_disposed = true;
			}
			_signal.Set();
			try
			{
				_worker?.Join(2000);
			}
			catch
			{
			}
			Flush();
			_signal.Dispose();
		}
	}
	public sealed class BatchCursor
	{
		public int Length { get; private set; }

		public int Index { get; private set; }

		public bool HasRemaining => Index < Length;

		public void Reset(int length)
		{
			Length = ((length >= 0) ? length : 0);
			Index = 0;
		}

		public bool Step(int batchSize, out int start, out int end)
		{
			if (Length <= 0)
			{
				start = 0;
				end = 0;
				return true;
			}
			if (Index >= Length)
			{
				start = Length;
				end = Length;
				return true;
			}
			start = Index;
			end = Math.Min(Index + Math.Max(1, batchSize), Length);
			Index = end;
			return Index >= Length;
		}
	}
	public static class BudgetMath
	{
		private const float BootstrapMs = 1f;

		private const int MinSamples = 5;

		private const double AbsFloorMs = 0.5;

		private const double FloorFraction = 0.05;

		private const double CeilingFraction = 0.5;

		public static float ComputeBudgetMs(float[] frameMs, int count)
		{
			if (count < 5)
			{
				return 1f;
			}
			double num = 0.0;
			double num2 = 0.0;
			for (int i = 0; i < count; i++)
			{
				float num3 = frameMs[i];
				num += (double)num3;
				num2 += (double)num3 * (double)num3;
			}
			double num4 = num / (double)count;
			double num5 = num2 / (double)count - num4 * num4;
			double num6 = ((num5 > 0.0) ? Math.Sqrt(num5) : 0.0);
			double num7 = num4 * 0.05;
			double num8 = ((num6 > num7) ? num6 : num7);
			double num9 = num4 * 0.5;
			return (float)((num8 < 0.5) ? 0.5 : ((num8 > num9) ? num9 : num8));
		}
	}
	public static class CollectFilter
	{
		private static readonly Regex Garbage = new Regex("^[.\\-_~=\\s\\/\\\\|:;()\\[\\]{}*+?!@#$%^&<>,\"']*$", RegexOptions.Compiled);

		private static readonly Regex Cyrillic = new Regex("[а-яА-ЯёЁ]", RegexOptions.Compiled);

		private static readonly Regex PureNumber = new Regex("^[+-]?\\d+(?:[.,]\\d+)?$", RegexOptions.Compiled);

		private static readonly Regex Timing = new Regex("^\\d{1,2}(?::\\d{1,2}){1,3}$", RegexOptions.Compiled);

		public static bool ShouldCollect(string? key)
		{
			if (string.IsNullOrWhiteSpace(key))
			{
				return false;
			}
			string text = key.Trim();
			if (text.Length <= 1)
			{
				return false;
			}
			if (Cyrillic.IsMatch(text))
			{
				return false;
			}
			if (Garbage.IsMatch(text))
			{
				return false;
			}
			if (PureNumber.IsMatch(text))
			{
				return false;
			}
			if (Timing.IsMatch(text))
			{
				return false;
			}
			if (text.StartsWith("<") && text.EndsWith(">") && !text.Contains(" "))
			{
				return false;
			}
			return true;
		}
	}
	public sealed class DeferredRefreshQueue<T> where T : class
	{
		private struct Entry
		{
			public readonly T Item;

			public int Frames;

			public Entry(T item, int frames)
			{
				Item = item;
				Frames = frames;
			}
		}

		private readonly List<Entry> _entries = new List<Entry>();

		public void Enqueue(T item, int frames)
		{
			if (item == null)
			{
				return;
			}
			frames = Math.Max(1, frames);
			for (int i = 0; i < _entries.Count; i++)
			{
				if (_entries[i].Item == item)
				{
					_entries[i] = new Entry(item, frames);
					return;
				}
			}
			_entries.Add(new Entry(item, frames));
		}

		public void Tick(Action<T> action)
		{
			if (action == null)
			{
				return;
			}
			for (int num = _entries.Count - 1; num >= 0; num--)
			{
				Entry value = _entries[num];
				value.Frames--;
				if (value.Frames > 0)
				{
					_entries[num] = value;
				}
				else
				{
					_entries.RemoveAt(num);
					action(value.Item);
				}
			}
		}
	}
	public static class FontBundleLocator
	{
		private static readonly HashSet<string> NonBundleExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
		{
			".cfg", ".config", ".cs", ".dll", ".exe", ".json", ".md", ".pdb", ".png", ".txt",
			".xml"
		};

		public static string[] GetCandidatePaths(IEnumerable<string> files)
		{
			List<string> list = new List<string>();
			foreach (string file in files)
			{
				if (!string.IsNullOrWhiteSpace(file))
				{
					string extension = Path.GetExtension(file);
					if (extension.Length <= 0 || !NonBundleExtensions.Contains(extension))
					{
						list.Add(file);
					}
				}
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			return list.ToArray();
		}
	}
	public static class HotkeyDefaults
	{
		public const bool EnableHotkeys = false;

		public const string ToggleTranslationKey = "F6";

		public const string ReloadKey = "F7";
	}
	public static class LegacyTxtParser
	{
		private const char Backslash = '\\';

		private const char Quote = '"';

		private static readonly string RegexPrefix = "r:\"";

		private static readonly string SplitPrefix = "sr:\"";

		private static readonly string QuoteEq = "\"=";

		private static readonly string EscapedEq = "\\=";

		public static TranslationData Parse(IEnumerable<string> lines)
		{
			TranslationData translationData = new TranslationData();
			HashSet<int> levels = new HashSet<int>();
			bool captured = false;
			foreach (string line in lines)
			{
				if (string.IsNullOrEmpty(line))
				{
					continue;
				}
				string text = line.TrimEnd('\r', '\n');
				if (text.Length == 0)
				{
					continue;
				}
				if (text[0] == '#')
				{
					ApplyDirective(text, levels);
					continue;
				}
				if (text.StartsWith(SplitPrefix))
				{
					ParseRegex(text, SplitPrefix, translationData.SplitterRegex);
					CaptureLevels(levels, translationData, ref captured);
					continue;
				}
				if (text.StartsWith(RegexPrefix))
				{
					ParseRegex(text, RegexPrefix, translationData.Regex);
					CaptureLevels(levels, translationData, ref captured);
					continue;
				}
				int num = IndexOfUnescapedEquals(text);
				if (num >= 0)
				{
					string text2 = Unescape(text.Substring(0, num));
					string value = Unescape(text.Substring(num + 1));
					if (text2.Length != 0)
					{
						translationData.Exact[text2] = value;
						CaptureLevels(levels, translationData, ref captured);
					}
				}
			}
			return translationData;
		}

		private static void ApplyDirective(string line, HashSet<int> levels)
		{
			string[] array = line.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < 3)
			{
				return;
			}
			string text = array[0].ToLowerInvariant();
			if (array[1].ToLowerInvariant() != "level")
			{
				return;
			}
			for (int i = 2; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { ',' });
				for (int j = 0; j < array2.Length; j++)
				{
					if (int.TryParse(array2[j], out var result))
					{
						if (text == "#set")
						{
							levels.Add(result);
						}
						else if (text == "#unset")
						{
							levels.Remove(result);
						}
					}
				}
			}
		}

		private static void CaptureLevels(HashSet<int> levels, TranslationData data, ref bool captured)
		{
			if (!captured)
			{
				captured = true;
				if (levels.Count > 0)
				{
					data.Levels = new List<int>(levels).ToArray();
				}
			}
		}

		private static void ParseRegex(string line, string prefix, Dictionary<string, string> target)
		{
			int num = line.IndexOf(QuoteEq, prefix.Length);
			if (num >= 0)
			{
				string text = Unescape(line.Substring(prefix.Length, num - prefix.Length));
				string text2 = line.Substring(num + QuoteEq.Length);
				if (text2.Length >= 2 && text2[0] == '"' && text2[text2.Length - 1] == '"')
				{
					text2 = text2.Substring(1, text2.Length - 2);
				}
				text2 = Unescape(text2);
				if (text.Length != 0)
				{
					target[text] = text2;
				}
			}
		}

		private static int IndexOfUnescapedEquals(string s)
		{
			for (int i = 0; i < s.Length; i++)
			{
				if (s[i] == '=' && (i == 0 || s[i - 1] != '\\'))
				{
					return i;
				}
			}
			return -1;
		}

		private static string Unescape(string s)
		{
			return s.Replace(EscapedEq, "=");
		}
	}
	public static class PngWriter
	{
		private static readonly byte[] Signature = new byte[8] { 137, 80, 78, 71, 13, 10, 26, 10 };

		private static readonly uint[] CrcTable = BuildCrcTable();

		public static byte[] EncodeRgba32(byte[] rgba, int width, int height, bool bottomUp)
		{
			if (rgba == null)
			{
				throw new ArgumentNullException("rgba");
			}
			if (width <= 0 || height <= 0)
			{
				throw new ArgumentException("invalid dimensions");
			}
			if (rgba.Length != width * height * 4)
			{
				throw new ArgumentException($"pixel buffer {rgba.Length} != {width}x{height}x4");
			}
			int num = width * 4;
			byte[] array = new byte[height * (1 + num)];
			for (int i = 0; i < height; i++)
			{
				int num2 = (bottomUp ? (height - 1 - i) : i);
				int num3 = i * (1 + num);
				array[num3] = 0;
				Buffer.BlockCopy(rgba, num2 * num, array, num3 + 1, num);
			}
			using MemoryStream memoryStream = new MemoryStream();
			memoryStream.Write(Signature, 0, Signature.Length);
			byte[] array2 = new byte[13];
			WriteBE32(array2, 0, width);
			WriteBE32(array2, 4, height);
			array2[8] = 8;
			array2[9] = 6;
			array2[10] = 0;
			array2[11] = 0;
			array2[12] = 0;
			WriteChunk(memoryStream, "IHDR", array2);
			WriteChunk(memoryStream, "IDAT", ZlibDeflate(array));
			WriteChunk(memoryStream, "IEND", Array.Empty<byte>());
			return memoryStream.ToArray();
		}

		private static byte[] ZlibDeflate(byte[] data)
		{
			using MemoryStream memoryStream = new MemoryStream();
			memoryStream.WriteByte(120);
			memoryStream.WriteByte(1);
			using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Fastest, leaveOpen: true))
			{
				deflateStream.Write(data, 0, data.Length);
			}
			uint num = Adler32(data);
			memoryStream.WriteByte((byte)((num >> 24) & 0xFF));
			memoryStream.WriteByte((byte)((num >> 16) & 0xFF));
			memoryStream.WriteByte((byte)((num >> 8) & 0xFF));
			memoryStream.WriteByte((byte)(num & 0xFF));
			return memoryStream.ToArray();
		}

		private static void WriteChunk(Stream s, string type, byte[] data)
		{
			byte[] array = new byte[4];
			WriteBE32(array, 0, data.Length);
			s.Write(array, 0, 4);
			byte[] bytes = Encoding.ASCII.GetBytes(type);
			s.Write(bytes, 0, 4);
			if (data.Length != 0)
			{
				s.Write(data, 0, data.Length);
			}
			uint value = Crc32(bytes, data);
			byte[] array2 = new byte[4];
			WriteBE32(array2, 0, (int)value);
			s.Write(array2, 0, 4);
		}

		private static void WriteBE32(byte[] buf, int offset, int value)
		{
			buf[offset] = (byte)((value >> 24) & 0xFF);
			buf[offset + 1] = (byte)((value >> 16) & 0xFF);
			buf[offset + 2] = (byte)((value >> 8) & 0xFF);
			buf[offset + 3] = (byte)(value & 0xFF);
		}

		private static uint Adler32(byte[] data)
		{
			uint num = 1u;
			uint num2 = 0u;
			foreach (byte b in data)
			{
				num = (num + b) % 65521;
				num2 = (num2 + num) % 65521;
			}
			return (num2 << 16) | num;
		}

		private static uint[] BuildCrcTable()
		{
			uint[] array = new uint[256];
			for (uint num = 0u; num < 256; num++)
			{
				uint num2 = num;
				for (int i = 0; i < 8; i++)
				{
					num2 = (((num2 & 1) != 0) ? (0xEDB88320u ^ (num2 >> 1)) : (num2 >> 1));
				}
				array[num] = num2;
			}
			return array;
		}

		private static uint Crc32(byte[] type, byte[] data)
		{
			uint num = uint.MaxValue;
			byte[] array = type;
			foreach (byte b in array)
			{
				num = CrcTable[(num ^ b) & 0xFF] ^ (num >> 8);
			}
			array = data;
			foreach (byte b2 in array)
			{
				num = CrcTable[(num ^ b2) & 0xFF] ^ (num >> 8);
			}
			return num ^ 0xFFFFFFFFu;
		}
	}
	public sealed class ReloadableScaleState
	{
		private const float Epsilon = 0.001f;

		private float _baseSize;

		private float _lastApplied;

		private int _generation = -1;

		private bool _initialized;

		public bool NeedsApply(int generation)
		{
			if (_initialized)
			{
				return _generation != generation;
			}
			return true;
		}

		public float BeginApply(int generation, float current)
		{
			if (!_initialized || Math.Abs(current - _lastApplied) > 0.001f)
			{
				_baseSize = current;
			}
			_generation = generation;
			_initialized = true;
			return _baseSize;
		}

		public void CompleteApply(float applied)
		{
			_lastApplied = applied;
		}
	}
	public sealed class ReloadDebounce
	{
		private readonly object _gate = new object();

		private volatile bool _pending;

		private double _lastEventSeconds;

		public void NotifyChange(double nowSeconds)
		{
			lock (_gate)
			{
				_lastEventSeconds = nowSeconds;
				_pending = true;
			}
		}

		public bool TryConsume(double nowSeconds, double quietSeconds)
		{
			if (!_pending)
			{
				return false;
			}
			lock (_gate)
			{
				if (!_pending)
				{
					return false;
				}
				if (nowSeconds - _lastEventSeconds < quietSeconds)
				{
					return false;
				}
				_pending = false;
				return true;
			}
		}
	}
	public static class ResizerTxtParser
	{
		public static Dictionary<string, string> Parse(IEnumerable<string> lines)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			foreach (string line in lines)
			{
				if (string.IsNullOrEmpty(line))
				{
					continue;
				}
				string text = line.TrimEnd('\r', '\n');
				int num = text.IndexOf('=');
				if (num > 0)
				{
					string text2 = text.Substring(0, num).Trim();
					string text3 = text.Substring(num + 1).Trim();
					if (text2.Length != 0 && text3.Length != 0)
					{
						dictionary[text2] = text3;
					}
				}
			}
			return dictionary;
		}
	}
	public sealed class RetirementQueue<T>
	{
		private readonly Queue<T> _items = new Queue<T>();

		public int Count => _items.Count;

		public void Enqueue(T item)
		{
			_items.Enqueue(item);
		}

		public int Drain(int maxItems, Action<T> retire)
		{
			if (maxItems <= 0 || retire == null)
			{
				return 0;
			}
			int num = Math.Min(maxItems, _items.Count);
			for (int i = 0; i < num; i++)
			{
				retire(_items.Dequeue());
			}
			return num;
		}
	}
	public static class ScanInterval
	{
		public static bool ShouldRefresh(float now, float lastRefresh, float intervalSeconds)
		{
			if (intervalSeconds <= 0f)
			{
				return false;
			}
			return now - lastRefresh > intervalSeconds;
		}
	}
	public static class SceneLogFormatter
	{
		public static IEnumerable<string> FormatBuildScenes(IEnumerable<(int Index, string Path)> scenes)
		{
			yield return "Build scenes:";
			foreach (var scene in scenes)
			{
				string text = Path.GetFileNameWithoutExtension(scene.Path);
				if (string.IsNullOrWhiteSpace(text))
				{
					text = "<unknown>";
				}
				yield return $"  {scene.Index}: {text}";
			}
		}
	}
	public static class SpriteGeometry
	{
		public static (float X, float Y) NormalizedPivot(float pivotPxX, float pivotPxY, float rectW, float rectH)
		{
			if (rectW <= 0f || rectH <= 0f)
			{
				return (X: 0.5f, Y: 0.5f);
			}
			return (X: pivotPxX / rectW, Y: pivotPxY / rectH);
		}

		public static float MatchedPpu(float origPpu, float origW, float newW)
		{
			if (!(origPpu <= 0f) && !(origW <= 0f))
			{
				return origPpu * (newW / origW);
			}
			return 100f;
		}

		public static (float L, float B, float R, float T) ScaleBorder(float l, float b, float r, float t, float origW, float origH, float newW, float newH)
		{
			if (origW <= 0f || origH <= 0f)
			{
				return (L: 0f, B: 0f, R: 0f, T: 0f);
			}
			float num = newW / origW;
			float num2 = newH / origH;
			float num3 = l * num;
			float num4 = r * num;
			float num5 = b * num2;
			float num6 = t * num2;
			if (num3 + num4 > newW && num3 + num4 > 0f)
			{
				float num7 = newW / (num3 + num4);
				num3 *= num7;
				num4 *= num7;
			}
			if (num5 + num6 > newH && num5 + num6 > 0f)
			{
				float num8 = newH / (num5 + num6);
				num5 *= num8;
				num6 *= num8;
			}
			return (L: num3, B: num5, R: num4, T: num6);
		}
	}
	public static class TextNormalizer
	{
		private const char Cr = '\r';

		private const char Lf = '\n';

		private const char Backslash = '\\';

		private const char Nul = '\0';

		private const char ZeroWidth = '\u200b';

		private const char Nbsp = '\u00a0';

		public static string CanonicalKey(string? str)
		{
			if (string.IsNullOrEmpty(str))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(str.Length);
			for (int i = 0; i < str.Length; i++)
			{
				char c = str[i];
				switch (c)
				{
				case '\r':
					if (i + 1 < str.Length && str[i + 1] == '\n')
					{
						i++;
					}
					stringBuilder.Append('\\');
					stringBuilder.Append('n');
					break;
				case '\n':
					stringBuilder.Append('\\');
					stringBuilder.Append('n');
					break;
				default:
					stringBuilder.Append(c);
					break;
				case '\0':
				case '\u00a0':
				case '\u200b':
					break;
				}
			}
			return stringBuilder.ToString().Replace("<noparse></noparse>", "").Trim();
		}
	}
	public static class TextureNameNormalizer
	{
		private static readonly Regex HashSuffix = new Regex("\\s*-?\\[[0-9A-Fa-f]+-[0-9A-Fa-f]+\\]$", RegexOptions.Compiled);

		public static string GetOriginalName(string fileNameNoExt)
		{
			if (string.IsNullOrEmpty(fileNameNoExt))
			{
				return fileNameNoExt;
			}
			return HashSuffix.Replace(fileNameNoExt, "").TrimEnd(Array.Empty<char>());
		}
	}
	public static class TextureSlots
	{
		public static IReadOnlyList<string> Allowed { get; } = new string[3] { "_MainTex", "_BaseMap", "_BaseColorMap" };

		public static bool ShouldDump(int width, int height, int maxSize)
		{
			if (maxSize > 0)
			{
				if (width <= maxSize)
				{
					return height <= maxSize;
				}
				return false;
			}
			return true;
		}

		public static IEnumerable<string> FilterSlots(IEnumerable<string> materialPropertyNames)
		{
			HashSet<string> hashSet = new HashSet<string>(materialPropertyNames);
			return Allowed.Where(hashSet.Contains);
		}
	}
	public static class ThirdPartyTextTranslator
	{
		private static readonly Regex Cyrillic = new Regex("[\\u0400-\\u04FF]", RegexOptions.Compiled);

		public static string TranslateOrCapture(string s, Func<string, string?> resolve, Action<string> capture)
		{
			if (string.IsNullOrWhiteSpace(s) || Cyrillic.IsMatch(s))
			{
				return s;
			}
			string text = resolve(s);
			if (text == null)
			{
				string text2 = s.ToLowerInvariant();
				if (text2 != s)
				{
					text = resolve(text2);
				}
			}
			if (text != null)
			{
				return text;
			}
			capture(s);
			return s;
		}
	}
	public sealed class TranslationData
	{
		public int[] Levels { get; set; } = new int[0];

		public string? FileFontOverride { get; set; }

		public Dictionary<string, string> Exact { get; set; } = new Dictionary<string, string>();

		public Dictionary<string, string> Regex { get; set; } = new Dictionary<string, string>();

		public Dictionary<string, string> SplitterRegex { get; set; } = new Dictionary<string, string>();

		public Dictionary<string, string> StringFontOverride { get; set; } = new Dictionary<string, string>();
	}
	public sealed class TranslationStore
	{
		private sealed class Bucket
		{
			public readonly Dictionary<string, string> Exact = new Dictionary<string, string>(StringComparer.Ordinal);

			public readonly List<(Regex Rx, string Repl, string Anchor)> Regex = new List<(Regex, string, string)>();

			public readonly List<(Regex Rx, string Repl, string Anchor)> Splitters = new List<(Regex, string, string)>();

			public readonly List<(Regex Rx, string Repl, List<string> Ph, string Anchor)> Templates = new List<(Regex, string, List<string>, string)>();

			public readonly List<(Regex Rx, string Font)> FontRegex = new List<(Regex, string)>();

			public readonly List<(Regex Rx, string Font)> FontSplitters = new List<(Regex, string)>();

			public readonly Dictionary<string, string> FontExactByKey = new Dictionary<string, string>(StringComparer.Ordinal);

			public readonly Dictionary<string, string> FontExactByValue = new Dictionary<string, string>(StringComparer.Ordinal);

			public readonly HashSet<string> AutoSize = new HashSet<string>(StringComparer.Ordinal);

			public readonly List<Regex> AutoSizePatterns = new List<Regex>();

			public readonly Dictionary<string, float> TextSize = new Dictionary<string, float>(StringComparer.Ordinal);

			public readonly List<(Regex Rx, float Size)> TextSizePatterns = new List<(Regex, float)>();
		}

		private readonly struct PrefixMeta
		{
			public string Val { get; }

			public bool AutoSize { get; }

			public float? TextSize { get; }

			public PrefixMeta(string val, bool autoSize, float? textSize)
			{
				Val = val;
				AutoSize = autoSize;
				TextSize = textSize;
			}
		}

		private static readonly TimeSpan DefaultRegexTimeout = TimeSpan.FromMilliseconds(50.0);

		private static readonly string LiteralNl = "\\n";

		private static readonly string RealNl = '\n'.ToString();

		private const string AutoSizePrefix = "autosize:";

		private const string SetSizePrefix = "setsize:";

		private static readonly Regex SetSizePrefixRegex = new Regex("^setsize:([0-9]+(?:[.,][0-9]+)?):", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant);

		public const int Global = int.MinValue;

		private readonly Dictionary<int, Bucket> _buckets = new Dictionary<int, Bucket>();

		private readonly HashSet<string> _knownSourceKeys = new HashSet<string>(StringComparer.Ordinal);

		private readonly HashSet<string> _knownResultKeys = new HashSet<string>(StringComparer.Ordinal);

		private readonly Dictionary<string, Regex> _rxCache = new Dictionary<string, Regex>(StringComparer.Ordinal);

		private readonly HashSet<Regex> _disabledRegex = new HashSet<Regex>();

		private readonly HashSet<string> _warnedPatterns = new HashSet<string>(StringComparer.Ordinal);

		private readonly TimeSpan _regexTimeout;

		private readonly Action<string>? _warning;

		private const int ResolveCacheCap = 10000;

		private readonly Dictionary<string, string?> _resolveCache = new Dictionary<string, string>(StringComparer.Ordinal);

		private readonly Dictionary<string, string?> _fontCache = new Dictionary<string, string>(StringComparer.Ordinal);

		private readonly Dictionary<string, (float? Size, bool AutoSize)> _directiveCache = new Dictionary<string, (float?, bool)>(StringComparer.Ordinal);

		private int _currentLevel = int.MinValue;

		public int CurrentLevel
		{
			get
			{
				return _currentLevel;
			}
			set
			{
				if (_currentLevel != value)
				{
					_currentLevel = value;
					InvalidateCaches();
				}
			}
		}

		public int ExactCount
		{
			get
			{
				int num = 0;
				foreach (Bucket value in _buckets.Values)
				{
					num += value.Exact.Count + value.Templates.Count;
				}
				return num;
			}
		}

		public int RegexCount
		{
			get
			{
				int num = 0;
				foreach (Bucket value in _buckets.Values)
				{
					num += value.Regex.Count;
				}
				return num;
			}
		}

		public int CompiledPatternCount => _rxCache.Count;

		public TranslationStore(TimeSpan? regexTimeout = null, Action<string>? warning = null)
		{
			_regexTimeout = regexTimeout ?? DefaultRegexTimeout;
			_warning = warning;
		}

		private static string ToRealNl(string s)
		{
			if (s.IndexOf(LiteralNl, StringComparison.Ordinal) >= 0)
			{
				return s.Replace(LiteralNl, RealNl);
			}
			return s;
		}

		private Bucket B(int level)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				value = new Bucket();
				_buckets[level] = value;
			}
			return value;
		}

		private Regex GetCompiled(string pattern)
		{
			if (!_rxCache.TryGetValue(pattern, out Regex value))
			{
				value = new Regex(pattern, RegexOptions.Compiled | RegexOptions.CultureInvariant, _regexTimeout);
				_rxCache[pattern] = value;
			}
			return value;
		}

		public void Add(TranslationData data, bool scoping = true)
		{
			if (data == null)
			{
				return;
			}
			InvalidateCaches();
			int[] array = ((scoping && data.Levels != null && data.Levels.Length != 0) ? data.Levels : new int[1] { -2147483648 });
			int[] array2 = array;
			foreach (int level in array2)
			{
				Bucket bucket = B(level);
				foreach (KeyValuePair<string, string> item in data.Exact)
				{
					string text = TextNormalizer.CanonicalKey(item.Key);
					if (text.Length == 0 || string.IsNullOrEmpty(item.Value))
					{
						continue;
					}
					PrefixMeta prefixMeta = StripCommandPrefixes(item.Value);
					if (Regex.IsMatch(text, "\\{\\d+\\}"))
					{
						AddTemplateRule(bucket, text, prefixMeta.Val, prefixMeta.AutoSize, prefixMeta.TextSize);
						_knownSourceKeys.Add(text);
						continue;
					}
					bucket.Exact[text] = prefixMeta.Val;
					_knownSourceKeys.Add(text);
					_knownResultKeys.Add(TextNormalizer.CanonicalKey(prefixMeta.Val));
					if (prefixMeta.AutoSize)
					{
						bucket.AutoSize.Add(text);
					}
					if (prefixMeta.TextSize.HasValue)
					{
						bucket.TextSize[text] = prefixMeta.TextSize.Value;
					}
				}
				foreach (KeyValuePair<string, string> item2 in data.Regex)
				{
					if (string.IsNullOrEmpty(item2.Key))
					{
						continue;
					}
					try
					{
						PrefixMeta prefixMeta2 = StripCommandPrefixes(item2.Value ?? string.Empty);
						Regex compiled = GetCompiled(item2.Key);
						bucket.Regex.Add((compiled, prefixMeta2.Val, AnchorExtractor.FromRegex(item2.Key)));
						_knownSourceKeys.Add(TextNormalizer.CanonicalKey(item2.Key));
						if (prefixMeta2.AutoSize)
						{
							bucket.AutoSizePatterns.Add(compiled);
						}
						if (prefixMeta2.TextSize.HasValue)
						{
							bucket.TextSizePatterns.Add((compiled, prefixMeta2.TextSize.Value));
						}
					}
					catch (Exception e)
					{
						WarnInvalidPattern(item2.Key, e);
					}
				}
				if (data.SplitterRegex == null)
				{
					continue;
				}
				foreach (KeyValuePair<string, string> item3 in data.SplitterRegex)
				{
					if (string.IsNullOrEmpty(item3.Key))
					{
						continue;
					}
					try
					{
						PrefixMeta prefixMeta3 = StripCommandPrefixes(item3.Value ?? string.Empty);
						Regex compiled2 = GetCompiled(AnchorSplitterPattern(item3.Key));
						bucket.Splitters.Add((compiled2, prefixMeta3.Val, AnchorExtractor.FromRegex(item3.Key)));
						_knownSourceKeys.Add(TextNormalizer.CanonicalKey(item3.Key));
						if (prefixMeta3.AutoSize)
						{
							bucket.AutoSizePatterns.Add(compiled2);
						}
						if (prefixMeta3.TextSize.HasValue)
						{
							bucket.TextSizePatterns.Add((compiled2, prefixMeta3.TextSize.Value));
						}
					}
					catch (Exception e2)
					{
						WarnInvalidPattern(item3.Key, e2);
					}
				}
			}
			string fileFontOverride = data.FileFontOverride;
			if (!string.IsNullOrEmpty(fileFontOverride))
			{
				foreach (KeyValuePair<string, string> item4 in data.Exact)
				{
					RegisterExactFontOverride(array, item4.Key, item4.Value, fileFontOverride);
				}
				RegisterRegexFontOverrides(array, data.Regex, fileFontOverride, splitter: false);
				RegisterRegexFontOverrides(array, data.SplitterRegex, fileFontOverride, splitter: true);
			}
			if (data.StringFontOverride == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> item5 in data.StringFontOverride)
			{
				if (TextNormalizer.CanonicalKey(item5.Key).Length != 0 && !string.IsNullOrEmpty(item5.Value))
				{
					data.Exact.TryGetValue(item5.Key, out string value);
					RegisterExactFontOverride(array, item5.Key, value ?? string.Empty, item5.Value);
					if (data.Regex != null && data.Regex.ContainsKey(item5.Key))
					{
						RegisterRegexFontOverride(array, item5.Key, item5.Value, splitter: false);
					}
					if (data.SplitterRegex != null && data.SplitterRegex.ContainsKey(item5.Key))
					{
						RegisterRegexFontOverride(array, item5.Key, item5.Value, splitter: true);
					}
				}
			}
		}

		private void InvalidateCaches()
		{
			_resolveCache.Clear();
			_fontCache.Clear();
			_directiveCache.Clear();
		}

		private void RegisterExactFontOverride(int[] levels, string sourceKey, string translatedValue, string fontName)
		{
			string text = TextNormalizer.CanonicalKey(sourceKey);
			if (text.Length == 0 || string.IsNullOrEmpty(fontName))
			{
				return;
			}
			string text2 = (string.IsNullOrEmpty(translatedValue) ? string.Empty : TextNormalizer.CanonicalKey(StripCommandPrefixes(translatedValue).Val));
			foreach (int level in levels)
			{
				Bucket bucket = B(level);
				bucket.FontExactByKey[text] = fontName;
				string text3 = text2;
				if (text3.Length == 0 && bucket.Exact.TryGetValue(text, out string value))
				{
					text3 = TextNormalizer.CanonicalKey(value);
				}
				if (text3.Length > 0)
				{
					bucket.FontExactByValue[text3] = fontName;
				}
			}
		}

		private void RegisterRegexFontOverrides(int[] levels, Dictionary<string, string>? patterns, string fontName, bool splitter)
		{
			if (patterns == null)
			{
				return;
			}
			foreach (KeyValuePair<string, string> pattern in patterns)
			{
				RegisterRegexFontOverride(levels, pattern.Key, fontName, splitter);
			}
		}

		private void RegisterRegexFontOverride(int[] levels, string pattern, string fontName, bool splitter)
		{
			if (string.IsNullOrEmpty(pattern) || string.IsNullOrEmpty(fontName))
			{
				return;
			}
			try
			{
				string pattern2 = (splitter ? AnchorSplitterPattern(pattern) : pattern);
				Regex compiled = GetCompiled(pattern2);
				foreach (int level in levels)
				{
					Bucket bucket = B(level);
					if (splitter)
					{
						bucket.FontSplitters.Add((compiled, fontName));
					}
					else
					{
						bucket.FontRegex.Add((compiled, fontName));
					}
				}
			}
			catch (Exception e)
			{
				WarnInvalidPattern(pattern, e);
			}
		}

		private static string AnchorSplitterPattern(string pattern)
		{
			string text = pattern;
			if (!text.StartsWith("^"))
			{
				text = "^" + text;
			}
			if (!text.EndsWith("$"))
			{
				text += "$";
			}
			return text;
		}

		private void AddTemplateRule(Bucket bucket, string key, string val, bool autoSize, float? textSize)
		{
			List<string> list = new List<string>();
			foreach (Match item in Regex.Matches(key, "\\{(\\d+)\\}"))
			{
				list.Add(item.Groups[1].Value);
			}
			string input = Regex.Escape(key);
			input = Regex.Replace(input, "\\\\\\{\\d+\\}", "([+-]?\\d+(?:[.,]\\d+)?)");
			input = "^" + input + "$";
			try
			{
				Regex compiled = GetCompiled(input);
				bucket.Templates.Add((compiled, val, list, AnchorExtractor.FromTemplateKey(key)));
				if (autoSize)
				{
					bucket.AutoSizePatterns.Add(compiled);
				}
				if (textSize.HasValue)
				{
					bucket.TextSizePatterns.Add((compiled, textSize.Value));
				}
			}
			catch (Exception e)
			{
				WarnInvalidPattern(input, e);
			}
		}

		private static PrefixMeta StripCommandPrefixes(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return new PrefixMeta(value, autoSize: false, null);
			}
			bool autoSize = false;
			float? textSize = null;
			string text = value;
			while (!string.IsNullOrEmpty(text))
			{
				if (text.StartsWith("autosize:", StringComparison.OrdinalIgnoreCase))
				{
					autoSize = true;
					text = text.Substring("autosize:".Length);
					continue;
				}
				if (!text.StartsWith("setsize:", StringComparison.OrdinalIgnoreCase))
				{
					break;
				}
				Match match = SetSizePrefixRegex.Match(text);
				if (!match.Success || !float.TryParse(match.Groups[1].Value.Replace(',', '.'), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || result <= 0f)
				{
					break;
				}
				textSize = result;
				text = text.Substring(match.Length);
			}
			return new PrefixMeta(text, autoSize, textSize);
		}

		public string? Resolve(string? current)
		{
			if (string.IsNullOrEmpty(current))
			{
				return null;
			}
			string key = TextNormalizer.CanonicalKey(current);
			if (_resolveCache.TryGetValue(key, out string value))
			{
				return value;
			}
			string text = ResolveByKey(key, useSplitter: true);
			if (_resolveCache.Count >= 10000)
			{
				_resolveCache.Clear();
			}
			_resolveCache[key] = text;
			return text;
		}

		private string? Resolve(string? current, bool useSplitter)
		{
			if (string.IsNullOrEmpty(current))
			{
				return null;
			}
			return ResolveByKey(TextNormalizer.CanonicalKey(current), useSplitter);
		}

		private string? ResolveByKey(string key, bool useSplitter)
		{
			string rxText = ToRealNl(key);
			string text = ExactStage(CurrentLevel, key);
			if (text == null && CurrentLevel != int.MinValue)
			{
				text = ExactStage(int.MinValue, key);
			}
			if (text != null)
			{
				return text;
			}
			text = RegexStage(CurrentLevel, rxText);
			if (text == null && CurrentLevel != int.MinValue)
			{
				text = RegexStage(int.MinValue, rxText);
			}
			if (text != null)
			{
				return text;
			}
			if (useSplitter)
			{
				text = SplitterStage(CurrentLevel, rxText);
				if (text == null && CurrentLevel != int.MinValue)
				{
					text = SplitterStage(int.MinValue, rxText);
				}
			}
			return text;
		}

		private string? ExactStage(int level, string key)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				return null;
			}
			if (value.Exact.TryGetValue(key, out string value2))
			{
				return ToRealNl(value2);
			}
			foreach (var (rx, text, list, text2) in value.Templates)
			{
				if ((text2.Length <= 0 || key.IndexOf(text2, StringComparison.Ordinal) >= 0) && TryMatch(rx, key, out Match match))
				{
					string text3 = text;
					for (int i = 1; i < match.Groups.Count; i++)
					{
						text3 = text3.Replace("{" + list[i - 1] + "}", match.Groups[i].Value);
					}
					return ToRealNl(text3);
				}
			}
			return null;
		}

		private string? RegexStage(int level, string rxText)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				return null;
			}
			foreach (var (rx, replacement, text) in value.Regex)
			{
				if ((text.Length <= 0 || rxText.IndexOf(text, StringComparison.Ordinal) >= 0) && TryMatch(rx, rxText, out Match match))
				{
					return ToRealNl(match.Result(replacement));
				}
			}
			return null;
		}

		private string? SplitterStage(int level, string rxText)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				return null;
			}
			foreach (var (rx, template, text) in value.Splitters)
			{
				if ((text.Length <= 0 || rxText.IndexOf(text, StringComparison.Ordinal) >= 0) && TryMatch(rx, rxText, out Match match))
				{
					return ToRealNl(ApplySplitter(match, template));
				}
			}
			return null;
		}

		private string ApplySplitter(Match m, string template)
		{
			StringBuilder stringBuilder = new StringBuilder(template);
			for (int num = m.Groups.Count - 1; num >= 1; num--)
			{
				Group obj = m.Groups[num];
				string oldValue = "$" + num;
				if (!obj.Success)
				{
					stringBuilder.Replace(oldValue, string.Empty);
				}
				else
				{
					string value = obj.Value;
					string newValue = Resolve(value, useSplitter: false) ?? value;
					stringBuilder.Replace(oldValue, newValue);
				}
			}
			return stringBuilder.ToString();
		}

		public string? GetFont(string? key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return null;
			}
			string text = TextNormalizer.CanonicalKey(key);
			if (_fontCache.TryGetValue(text, out string value))
			{
				return value;
			}
			string fontByKey = GetFontByKey(text);
			if (_fontCache.Count >= 10000)
			{
				_fontCache.Clear();
			}
			_fontCache[text] = fontByKey;
			return fontByKey;
		}

		private string? GetFontByKey(string normalized)
		{
			string text = FontExactStage(CurrentLevel, normalized);
			if (text == null && CurrentLevel != int.MinValue)
			{
				text = FontExactStage(int.MinValue, normalized);
			}
			if (text != null)
			{
				return text;
			}
			string rxText = ToRealNl(normalized);
			text = FontRegexStage(CurrentLevel, rxText);
			if (text == null && CurrentLevel != int.MinValue)
			{
				text = FontRegexStage(int.MinValue, rxText);
			}
			return text;
		}

		private string? FontExactStage(int level, string normalized)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				return null;
			}
			if (value.FontExactByKey.TryGetValue(normalized, out string value2))
			{
				return value2;
			}
			if (!value.FontExactByValue.TryGetValue(normalized, out value2))
			{
				return null;
			}
			return value2;
		}

		private string? FontRegexStage(int level, string rxText)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				return null;
			}
			for (int num = value.FontRegex.Count - 1; num >= 0; num--)
			{
				if (IsMatchSafe(value.FontRegex[num].Rx, rxText))
				{
					return value.FontRegex[num].Font;
				}
			}
			for (int num2 = value.FontSplitters.Count - 1; num2 >= 0; num2--)
			{
				if (IsMatchSafe(value.FontSplitters[num2].Rx, rxText))
				{
					return value.FontSplitters[num2].Font;
				}
			}
			return null;
		}

		public bool KnowsText(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			return KnowsCanonical(TextNormalizer.CanonicalKey(text));
		}

		public bool KnowsCanonical(string? canonicalKey)
		{
			if (!string.IsNullOrEmpty(canonicalKey))
			{
				if (!_knownSourceKeys.Contains(canonicalKey))
				{
					return _knownResultKeys.Contains(canonicalKey);
				}
				return true;
			}
			return false;
		}

		public bool RequiresAutoSize(string? original)
		{
			if (string.IsNullOrEmpty(original))
			{
				return false;
			}
			return GetDirectives(TextNormalizer.CanonicalKey(original)).AutoSize;
		}

		private bool AutoSizeIn(int level, string key)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				return false;
			}
			if (value.AutoSize.Contains(key))
			{
				return true;
			}
			string input = ToRealNl(key);
			foreach (Regex autoSizePattern in value.AutoSizePatterns)
			{
				if (IsMatchSafe(autoSizePattern, key) || IsMatchSafe(autoSizePattern, input))
				{
					return true;
				}
			}
			return false;
		}

		public float? GetTextSize(string? original)
		{
			if (string.IsNullOrEmpty(original))
			{
				return null;
			}
			return GetDirectives(TextNormalizer.CanonicalKey(original)).Size;
		}

		private (float? Size, bool AutoSize) GetDirectives(string key)
		{
			if (_directiveCache.TryGetValue(key, out (float?, bool) value))
			{
				return value;
			}
			float? item = TextSizeIn(CurrentLevel, key);
			if (!item.HasValue && CurrentLevel != int.MinValue)
			{
				item = TextSizeIn(int.MinValue, key);
			}
			bool item2 = AutoSizeIn(CurrentLevel, key) || (CurrentLevel != int.MinValue && AutoSizeIn(int.MinValue, key));
			value = (item, item2);
			if (_directiveCache.Count >= 10000)
			{
				_directiveCache.Clear();
			}
			_directiveCache[key] = value;
			return value;
		}

		private float? TextSizeIn(int level, string key)
		{
			if (!_buckets.TryGetValue(level, out Bucket value))
			{
				return null;
			}
			if (value.TextSize.TryGetValue(key, out var value2))
			{
				return value2;
			}
			string input = ToRealNl(key);
			foreach (var (rx, value3) in value.TextSizePatterns)
			{
				if (IsMatchSafe(rx, key) || IsMatchSafe(rx, input))
				{
					return value3;
				}
			}
			return null;
		}

		private bool TryMatch(Regex rx, string input, out Match match)
		{
			match = Match.Empty;
			if (_disabledRegex.Count > 0 && _disabledRegex.Contains(rx))
			{
				return false;
			}
			try
			{
				match = rx.Match(input);
				return match.Success;
			}
			catch (RegexMatchTimeoutException)
			{
				_disabledRegex.Add(rx);
				WarnOnce("timeout:" + rx, $"Regex timed out and was disabled: {rx}");
				return false;
			}
		}

		private bool IsMatchSafe(Regex rx, string input)
		{
			Match match;
			return TryMatch(rx, input, out match);
		}

		private void WarnInvalidPattern(string pattern, Exception e)
		{
			WarnOnce("invalid:" + pattern, "Invalid regex skipped: " + pattern + " (" + e.Message + ")");
		}

		private void WarnOnce(string key, string message)
		{
			if (_warning != null && _warnedPatterns.Add(key))
			{
				_warning(message);
			}
		}
	}
	public static class TranslationWatchFilter
	{
		private const char Backslash = '\\';

		public static bool ShouldTrigger(string? fullPath)
		{
			if (string.IsNullOrEmpty(fullPath))
			{
				return false;
			}
			string extension = Path.GetExtension(fullPath);
			if (!extension.Equals(".json", StringComparison.OrdinalIgnoreCase) && !extension.Equals(".png", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (Path.GetFileName(fullPath).Equals("_AutoGenerated.json", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (fullPath.Replace('\\', '/').IndexOf("/Texture_Dump/", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			return true;
		}
	}
	public sealed class VersionedTextValue
	{
		private string _text = string.Empty;

		private string _canonical = string.Empty;

		private int _generation = -1;

		public void Set(string text, string canonical, int generation)
		{
			_text = text;
			_canonical = canonical;
			_generation = generation;
		}

		public bool Matches(string text, int generation)
		{
			if (generation == _generation)
			{
				if (!(_text == text))
				{
					return _canonical == TextNormalizer.CanonicalKey(text);
				}
				return true;
			}
			return false;
		}
	}
}