using System;
using System.Collections;
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.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Timers;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn.Managers;
using Localization.DevTools;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("Localization")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+3b3b4aed6420cc2f72f6bdae0dea94042e81068d")]
[assembly: AssemblyProduct("Localization")]
[assembly: AssemblyTitle("Localization")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 Localization
{
	internal sealed class BoundedStringDictionary<TValue>
	{
		private readonly int capacity;

		private readonly Dictionary<string, TValue> values;

		private readonly Queue<string> insertionOrder;

		public int Count => values.Count;

		public BoundedStringDictionary(int capacity, IEqualityComparer<string> comparer)
		{
			this.capacity = ((capacity <= 0) ? 1 : capacity);
			values = new Dictionary<string, TValue>(this.capacity, comparer ?? StringComparer.Ordinal);
			insertionOrder = new Queue<string>(this.capacity);
		}

		public bool TryGetValue(string key, out TValue value)
		{
			return values.TryGetValue(key, out value);
		}

		public bool Set(string key, TValue value, out KeyValuePair<string, TValue> evictedEntry)
		{
			evictedEntry = default(KeyValuePair<string, TValue>);
			if (values.ContainsKey(key))
			{
				values[key] = value;
				return false;
			}
			EvictIfNeeded(out evictedEntry);
			values.Add(key, value);
			insertionOrder.Enqueue(key);
			return evictedEntry.Key != null;
		}

		public void Clear()
		{
			values.Clear();
			insertionOrder.Clear();
		}

		private void EvictIfNeeded(out KeyValuePair<string, TValue> evictedEntry)
		{
			evictedEntry = default(KeyValuePair<string, TValue>);
			while (values.Count >= capacity && insertionOrder.Count > 0)
			{
				string key = insertionOrder.Dequeue();
				if (values.TryGetValue(key, out var value))
				{
					values.Remove(key);
					evictedEntry = new KeyValuePair<string, TValue>(key, value);
					break;
				}
			}
		}
	}
	internal sealed class BoundedStringSet
	{
		private readonly int capacity;

		private readonly HashSet<string> values;

		private readonly Queue<string> insertionOrder;

		public int Count => values.Count;

		public BoundedStringSet(int capacity, IEqualityComparer<string> comparer)
		{
			this.capacity = ((capacity <= 0) ? 1 : capacity);
			values = new HashSet<string>(comparer ?? StringComparer.Ordinal);
			insertionOrder = new Queue<string>(this.capacity);
		}

		public bool Contains(string key)
		{
			return values.Contains(key);
		}

		public bool Add(string key, out string evictedKey)
		{
			evictedKey = null;
			if (values.Contains(key))
			{
				return false;
			}
			EvictIfNeeded(out evictedKey);
			values.Add(key);
			insertionOrder.Enqueue(key);
			return true;
		}

		public void Clear()
		{
			values.Clear();
			insertionOrder.Clear();
		}

		private void EvictIfNeeded(out string evictedKey)
		{
			evictedKey = null;
			while (values.Count >= capacity && insertionOrder.Count > 0)
			{
				string text = insertionOrder.Dequeue();
				if (values.Remove(text))
				{
					evictedKey = text;
					break;
				}
			}
		}
	}
	internal sealed class CompiledTemplateRule
	{
		private readonly struct TemplateToken
		{
			public bool IsPlaceholder { get; }

			public string Value { get; }

			public bool IsFunctionCall { get; }

			public PlaceholderConstraint Constraint { get; }

			public TemplateToken(bool isPlaceholder, string value, bool isFunctionCall = false, PlaceholderConstraint constraint = null)
			{
				IsPlaceholder = isPlaceholder;
				Value = value;
				IsFunctionCall = isFunctionCall;
				Constraint = constraint;
			}
		}

		private sealed class PlaceholderConstraint
		{
			public PlaceholderConstraintKind Kind { get; }

			public string Signature { get; }

			private IntegerRange WordCountRange { get; }

			private IntegerRange IntegerDigitRange { get; }

			private IntegerRange FractionDigitRange { get; }

			private NumericPredicate[] NumericPredicates { get; }

			private string[] OneOfValues { get; }

			private PlaceholderConstraint(PlaceholderConstraintKind kind, string signature, IntegerRange wordCountRange, IntegerRange integerDigitRange, IntegerRange fractionDigitRange, NumericPredicate[] numericPredicates, string[] oneOfValues)
			{
				Kind = kind;
				Signature = signature;
				WordCountRange = wordCountRange;
				IntegerDigitRange = integerDigitRange;
				FractionDigitRange = fractionDigitRange;
				NumericPredicates = numericPredicates ?? Array.Empty<NumericPredicate>();
				OneOfValues = oneOfValues ?? Array.Empty<string>();
			}

			public static PlaceholderConstraint CreateWord()
			{
				return new PlaceholderConstraint(PlaceholderConstraintKind.Word, "word", IntegerRange.Exact(1), default(IntegerRange), default(IntegerRange), Array.Empty<NumericPredicate>(), Array.Empty<string>());
			}

			public static PlaceholderConstraint CreateWords(IntegerRange countRange)
			{
				return new PlaceholderConstraint(PlaceholderConstraintKind.Words, "words(count=" + countRange.ToSignature() + ")", countRange, default(IntegerRange), default(IntegerRange), Array.Empty<NumericPredicate>(), Array.Empty<string>());
			}

			public static PlaceholderConstraint CreateInteger(IntegerRange digitRange, NumericPredicate[] predicates)
			{
				return new PlaceholderConstraint(PlaceholderConstraintKind.Integer, BuildIntegerSignature(digitRange, predicates), default(IntegerRange), digitRange, default(IntegerRange), predicates, Array.Empty<string>());
			}

			public static PlaceholderConstraint CreateFloat(IntegerRange integerDigitRange, IntegerRange fractionDigitRange, NumericPredicate[] predicates)
			{
				return new PlaceholderConstraint(PlaceholderConstraintKind.Float, BuildFloatSignature(integerDigitRange, fractionDigitRange, predicates), default(IntegerRange), integerDigitRange, fractionDigitRange, predicates, Array.Empty<string>());
			}

			public static PlaceholderConstraint CreateOneOf(string[] values)
			{
				return new PlaceholderConstraint(PlaceholderConstraintKind.OneOf, "oneof(" + string.Join("|", values) + ")", default(IntegerRange), default(IntegerRange), default(IntegerRange), Array.Empty<NumericPredicate>(), values);
			}

			public bool IsMatch(string value)
			{
				if (value == null)
				{
					return false;
				}
				return IsMatch(value, 0, value.Length);
			}

			public bool IsMatch(string value, int startIndex, int length)
			{
				switch (Kind)
				{
				case PlaceholderConstraintKind.Word:
				case PlaceholderConstraintKind.Words:
					return MatchesWords(value, startIndex, length, WordCountRange);
				case PlaceholderConstraintKind.Integer:
					return MatchesInteger(value, startIndex, length, IntegerDigitRange, NumericPredicates);
				case PlaceholderConstraintKind.Float:
					return MatchesFloat(value, startIndex, length, IntegerDigitRange, FractionDigitRange, NumericPredicates);
				case PlaceholderConstraintKind.OneOf:
					return MatchesOneOf(value, startIndex, length, OneOfValues);
				default:
					return false;
				}
			}

			private static string BuildIntegerSignature(IntegerRange digitRange, NumericPredicate[] predicates)
			{
				if (predicates == null || predicates.Length == 0)
				{
					if (digitRange.IsAtLeastOne())
					{
						return "int";
					}
					return "int(digits=" + digitRange.ToSignature() + ")";
				}
				if (digitRange.IsAtLeastOne())
				{
					return "int(where=" + JoinPredicates(predicates) + ")";
				}
				return "int(digits=" + digitRange.ToSignature() + ",where=" + JoinPredicates(predicates) + ")";
			}

			private static string BuildFloatSignature(IntegerRange integerDigitRange, IntegerRange fractionDigitRange, NumericPredicate[] predicates)
			{
				List<string> list = new List<string>(3);
				if (!integerDigitRange.IsAtLeastOne())
				{
					list.Add("int=" + integerDigitRange.ToSignature());
				}
				if (!fractionDigitRange.IsAtLeastZero())
				{
					list.Add("frac=" + fractionDigitRange.ToSignature());
				}
				if (predicates != null && predicates.Length != 0)
				{
					list.Add("where=" + JoinPredicates(predicates));
				}
				if (list.Count == 0)
				{
					return "float";
				}
				return "float(" + string.Join(",", list) + ")";
			}

			private static string JoinPredicates(NumericPredicate[] predicates)
			{
				if (predicates == null || predicates.Length == 0)
				{
					return string.Empty;
				}
				string[] array = new string[predicates.Length];
				for (int i = 0; i < predicates.Length; i++)
				{
					array[i] = predicates[i].ToSignature();
				}
				return string.Join("&&", array);
			}

			private static bool MatchesWords(string value, int startIndex, int length, IntegerRange countRange)
			{
				if (string.IsNullOrEmpty(value) || length <= 0)
				{
					return false;
				}
				int num = startIndex + length;
				if (char.IsWhiteSpace(value[startIndex]) || char.IsWhiteSpace(value[num - 1]))
				{
					return false;
				}
				int num2 = 0;
				bool flag = false;
				for (int i = startIndex; i < num; i++)
				{
					char c = value[i];
					if (char.IsWhiteSpace(c))
					{
						flag = false;
						continue;
					}
					if (!IsWordCharacter(c))
					{
						return false;
					}
					if (!flag)
					{
						num2++;
						flag = true;
					}
				}
				return countRange.Contains(num2);
			}

			private static bool MatchesInteger(string value, int startIndex, int length, IntegerRange digitRange, NumericPredicate[] predicates)
			{
				bool flag = predicates != null && predicates.Length != 0;
				if (!TryParseInteger(value, startIndex, length, flag, out var digitCount, out var numericValue))
				{
					return false;
				}
				if (!digitRange.Contains(digitCount))
				{
					return false;
				}
				if (flag)
				{
					return MatchesNumericPredicates(numericValue, predicates);
				}
				return true;
			}

			private static bool MatchesFloat(string value, int startIndex, int length, IntegerRange integerDigitRange, IntegerRange fractionDigitRange, NumericPredicate[] predicates)
			{
				bool flag = predicates != null && predicates.Length != 0;
				if (!TryParseFloat(value, startIndex, length, flag, out var integerDigitCount, out var fractionDigitCount, out var numericValue))
				{
					return false;
				}
				if (!integerDigitRange.Contains(integerDigitCount) || !fractionDigitRange.Contains(fractionDigitCount))
				{
					return false;
				}
				if (flag)
				{
					return MatchesNumericPredicates(numericValue, predicates);
				}
				return true;
			}

			private static bool MatchesOneOf(string value, int startIndex, int length, string[] oneOfValues)
			{
				if (string.IsNullOrEmpty(value) || length <= 0)
				{
					return false;
				}
				foreach (string text in oneOfValues)
				{
					if (text.Length == length && string.Compare(value, startIndex, text, 0, length, StringComparison.OrdinalIgnoreCase) == 0)
					{
						return true;
					}
				}
				return false;
			}

			private static bool MatchesNumericPredicates(decimal numericValue, NumericPredicate[] predicates)
			{
				if (predicates == null || predicates.Length == 0)
				{
					return true;
				}
				for (int i = 0; i < predicates.Length; i++)
				{
					if (!predicates[i].Matches(numericValue))
					{
						return false;
					}
				}
				return true;
			}

			private static bool TryParseInteger(string value, int startIndex, int length, bool requireNumericValue, out int digitCount, out decimal numericValue)
			{
				digitCount = 0;
				numericValue = default(decimal);
				if (string.IsNullOrEmpty(value) || length <= 0)
				{
					return false;
				}
				int num = ((value[startIndex] == '+' || value[startIndex] == '-') ? 1 : 0);
				if (num >= length)
				{
					return false;
				}
				for (int i = startIndex + num; i < startIndex + length; i++)
				{
					if (!char.IsDigit(value[i]))
					{
						return false;
					}
				}
				digitCount = length - num;
				if (!requireNumericValue)
				{
					return true;
				}
				return decimal.TryParse(value.Substring(startIndex, length), NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out numericValue);
			}

			private static bool TryParseFloat(string value, int startIndex, int length, bool requireNumericValue, out int integerDigitCount, out int fractionDigitCount, out decimal numericValue)
			{
				integerDigitCount = 0;
				fractionDigitCount = 0;
				numericValue = default(decimal);
				if (string.IsNullOrEmpty(value) || length <= 0)
				{
					return false;
				}
				int num = ((value[startIndex] == '+' || value[startIndex] == '-') ? 1 : 0);
				if (num >= length)
				{
					return false;
				}
				int num2 = -1;
				int num3 = startIndex + length;
				for (int i = startIndex + num; i < num3; i++)
				{
					char c = value[i];
					if (c == '.')
					{
						if (num2 >= 0)
						{
							return false;
						}
						num2 = i;
					}
					else if (!char.IsDigit(c))
					{
						return false;
					}
				}
				if (num2 < 0)
				{
					integerDigitCount = length - num;
					if (integerDigitCount <= 0)
					{
						return false;
					}
					if (!requireNumericValue)
					{
						return true;
					}
					return decimal.TryParse(value.Substring(startIndex, length), NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out numericValue);
				}
				integerDigitCount = num2 - startIndex - num;
				fractionDigitCount = num3 - num2 - 1;
				if (integerDigitCount <= 0 || fractionDigitCount <= 0)
				{
					return false;
				}
				if (!requireNumericValue)
				{
					return true;
				}
				return decimal.TryParse(value.Substring(startIndex, length), NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out numericValue);
			}
		}

		private enum PlaceholderConstraintKind
		{
			Word,
			Words,
			Integer,
			Float,
			OneOf
		}

		private enum NumericComparisonOperator
		{
			LessThan,
			LessThanOrEqual,
			GreaterThan,
			GreaterThanOrEqual,
			Equal,
			NotEqual
		}

		private readonly struct IntegerRange
		{
			public bool HasMinimum { get; }

			public int Minimum { get; }

			public bool HasMaximum { get; }

			public int Maximum { get; }

			public IntegerRange(bool hasMinimum, int minimum, bool hasMaximum, int maximum)
			{
				HasMinimum = hasMinimum;
				Minimum = minimum;
				HasMaximum = hasMaximum;
				Maximum = maximum;
			}

			public static IntegerRange Exact(int value)
			{
				return new IntegerRange(hasMinimum: true, value, hasMaximum: true, value);
			}

			public static IntegerRange AtLeast(int minimum)
			{
				return new IntegerRange(hasMinimum: true, minimum, hasMaximum: false, 0);
			}

			public bool Contains(int value)
			{
				if (HasMinimum && value < Minimum)
				{
					return false;
				}
				if (HasMaximum && value > Maximum)
				{
					return false;
				}
				return true;
			}

			public bool IsAtLeastOne()
			{
				if (HasMinimum && Minimum == 1)
				{
					return !HasMaximum;
				}
				return false;
			}

			public bool IsAtLeastZero()
			{
				if (HasMinimum && Minimum == 0)
				{
					return !HasMaximum;
				}
				return false;
			}

			public string ToSignature()
			{
				if (HasMinimum && HasMaximum && Minimum == Maximum)
				{
					return Minimum.ToString(CultureInfo.InvariantCulture);
				}
				if (HasMinimum && HasMaximum)
				{
					return Minimum.ToString(CultureInfo.InvariantCulture) + ".." + Maximum.ToString(CultureInfo.InvariantCulture);
				}
				if (HasMinimum)
				{
					return Minimum.ToString(CultureInfo.InvariantCulture) + "..";
				}
				if (HasMaximum)
				{
					return ".." + Maximum.ToString(CultureInfo.InvariantCulture);
				}
				return "..";
			}
		}

		private readonly struct NumericPredicate
		{
			public NumericComparisonOperator ComparisonOperator { get; }

			public decimal ComparisonValue { get; }

			public NumericPredicate(NumericComparisonOperator comparisonOperator, decimal comparisonValue)
			{
				ComparisonOperator = comparisonOperator;
				ComparisonValue = comparisonValue;
			}

			public bool Matches(decimal value)
			{
				return ComparisonOperator switch
				{
					NumericComparisonOperator.LessThan => value < ComparisonValue, 
					NumericComparisonOperator.LessThanOrEqual => value <= ComparisonValue, 
					NumericComparisonOperator.GreaterThan => value > ComparisonValue, 
					NumericComparisonOperator.GreaterThanOrEqual => value >= ComparisonValue, 
					NumericComparisonOperator.Equal => value == ComparisonValue, 
					_ => value != ComparisonValue, 
				};
			}

			public string ToSignature()
			{
				return ComparisonOperator switch
				{
					NumericComparisonOperator.LessThan => "<", 
					NumericComparisonOperator.LessThanOrEqual => "<=", 
					NumericComparisonOperator.GreaterThan => ">", 
					NumericComparisonOperator.GreaterThanOrEqual => ">=", 
					NumericComparisonOperator.Equal => "==", 
					_ => "!=", 
				} + ComparisonValue.ToString(CultureInfo.InvariantCulture);
			}
		}

		private const string FunctionStartToken = "{{";

		private const string FunctionEndToken = "}}";

		private const string LocalizeFunctionName = "localize";

		private const string ConstraintOptionCount = "count";

		private const string ConstraintOptionDigits = "digits";

		private const string ConstraintOptionFractionDigits = "frac";

		private const string ConstraintOptionIntegerDigits = "int";

		private const string ConstraintOptionWhere = "where";

		private readonly TemplateToken[] matchTokens;

		private readonly TemplateToken[] replaceTokens;

		private readonly string[] nextLiteralValues;

		private readonly string leadingLiteralPrefix;

		private readonly string trailingLiteralSuffix;

		private readonly string longestLiteralAnchor;

		private readonly int minimumInputLength;

		private readonly int placeholderCount;

		private readonly int uniquePlaceholderCount;

		private readonly int literalSegmentCount;

		private readonly bool startsWithPlaceholder;

		private readonly bool endsWithPlaceholder;

		private readonly bool hasRepeatedPlaceholderNames;

		private readonly bool hasConstrainedPlaceholders;

		private readonly int[] matchPlaceholderSlots;

		private readonly int[] replacePlaceholderSlots;

		public string Signature { get; }

		public string ReplaceTemplate { get; }

		public string SourcePath { get; }

		public string LeadingLiteralPrefix => leadingLiteralPrefix;

		public string TrailingLiteralSuffix => trailingLiteralSuffix;

		public string LongestLiteralAnchor => longestLiteralAnchor;

		public int MinimumInputLength => minimumInputLength;

		public int PlaceholderCount => placeholderCount;

		public int LiteralSegmentCount => literalSegmentCount;

		public bool StartsWithPlaceholder => startsWithPlaceholder;

		public bool EndsWithPlaceholder => endsWithPlaceholder;

		public bool HasRepeatedPlaceholderNames => hasRepeatedPlaceholderNames;

		internal bool UsesConstrainedPlaceholders => hasConstrainedPlaceholders;

		internal int DispatchOrder { get; private set; }

		private CompiledTemplateRule(string signature, string replaceTemplate, string sourcePath, TemplateToken[] matchTokens, TemplateToken[] replaceTokens)
		{
			Signature = signature;
			ReplaceTemplate = replaceTemplate ?? string.Empty;
			SourcePath = sourcePath ?? string.Empty;
			this.matchTokens = matchTokens;
			this.replaceTokens = replaceTokens;
			nextLiteralValues = BuildNextLiteralValues(matchTokens);
			InitializeMatchMetadata(matchTokens, out leadingLiteralPrefix, out trailingLiteralSuffix, out longestLiteralAnchor, out minimumInputLength, out placeholderCount, out literalSegmentCount, out startsWithPlaceholder, out endsWithPlaceholder, out hasRepeatedPlaceholderNames);
			hasConstrainedPlaceholders = HasConstrainedPlaceholders(matchTokens);
			BuildPlaceholderSlots(matchTokens, replaceTokens, out matchPlaceholderSlots, out replacePlaceholderSlots, out uniquePlaceholderCount);
		}

		public static bool TryCreate(string matchTemplate, string replaceTemplate, out CompiledTemplateRule rule, out string error)
		{
			return TryCreate(matchTemplate, replaceTemplate, null, out rule, out error);
		}

		public static bool TryCreate(string matchTemplate, string replaceTemplate, string sourcePath, out CompiledTemplateRule rule, out string error)
		{
			rule = null;
			error = null;
			if (!TryTokenize(matchTemplate, requirePlaceholder: true, allowFunctions: false, allowConstraints: true, allowAdjacentPlaceholders: false, out var tokens, out error))
			{
				return false;
			}
			if (!TryNormalizeMatchTokens(matchTemplate, tokens, out var normalizedTokens, out error))
			{
				return false;
			}
			if (!TryValidateRepeatedPlaceholderConstraints(matchTemplate, normalizedTokens, out error))
			{
				return false;
			}
			if (!TryTokenize(replaceTemplate, requirePlaceholder: false, allowFunctions: true, allowConstraints: false, allowAdjacentPlaceholders: true, out var tokens2, out error))
			{
				return false;
			}
			rule = new CompiledTemplateRule(matchTemplate, replaceTemplate, sourcePath, normalizedTokens, tokens2);
			return true;
		}

		public bool TryTranslate(TextMatchNormalizer.NormalizedText normalizedInput, out string translated)
		{
			translated = null;
			string value = normalizedInput.Value;
			if (value == null || value.Length < minimumInputLength)
			{
				return false;
			}
			if (leadingLiteralPrefix != null && !StartsWith(value, 0, leadingLiteralPrefix))
			{
				return false;
			}
			if (trailingLiteralSuffix != null && !EndsWith(value, trailingLiteralSuffix))
			{
				return false;
			}
			int[] array = ((uniquePlaceholderCount == 0) ? Array.Empty<int>() : new int[uniquePlaceholderCount]);
			int[] captureLengths = ((uniquePlaceholderCount == 0) ? Array.Empty<int>() : new int[uniquePlaceholderCount]);
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = -1;
			}
			if (!(hasConstrainedPlaceholders ? TryTranslateConstrained(value, 0, 0, array, captureLengths) : TryTranslateFast(value, array, captureLengths)))
			{
				return false;
			}
			translated = normalizedInput.WrapWholeMatch(BuildTranslatedOutput(value, array, captureLengths));
			return true;
		}

		private bool TryTranslateFast(string normalizedValue, int[] captureStarts, int[] captureLengths)
		{
			int num = 0;
			for (int i = 0; i < matchTokens.Length; i++)
			{
				TemplateToken token = matchTokens[i];
				if (!token.IsPlaceholder)
				{
					if (!StartsWith(normalizedValue, num, token.Value))
					{
						return false;
					}
					num += token.Value.Length;
					continue;
				}
				string text = nextLiteralValues[i];
				int captureStartIndex = num;
				int captureLength;
				if (text == null)
				{
					captureLength = normalizedValue.Length - num;
					num = normalizedValue.Length;
				}
				else
				{
					int num2 = normalizedValue.IndexOf(text, num, StringComparison.OrdinalIgnoreCase);
					if (num2 < 0)
					{
						return false;
					}
					captureLength = num2 - num;
					num = num2;
				}
				if (!TryStoreCapture(token, matchPlaceholderSlots[i], normalizedValue, captureStartIndex, captureLength, captureStarts, captureLengths, out var _, out var _, out var _))
				{
					return false;
				}
			}
			return num == normalizedValue.Length;
		}

		private bool TryTranslateConstrained(string normalizedValue, int tokenIndex, int position, int[] captureStarts, int[] captureLengths)
		{
			if (tokenIndex >= matchTokens.Length)
			{
				return position == normalizedValue.Length;
			}
			TemplateToken templateToken = matchTokens[tokenIndex];
			if (!templateToken.IsPlaceholder)
			{
				if (!StartsWith(normalizedValue, position, templateToken.Value))
				{
					return false;
				}
				return TryTranslateConstrained(normalizedValue, tokenIndex + 1, position + templateToken.Value.Length, captureStarts, captureLengths);
			}
			string text = nextLiteralValues[tokenIndex];
			if (text == null)
			{
				return TryMatchPlaceholderCandidate(normalizedValue, tokenIndex, position, normalizedValue.Length, captureStarts, captureLengths);
			}
			int num = position;
			while (num <= normalizedValue.Length)
			{
				int num2 = normalizedValue.IndexOf(text, num, StringComparison.OrdinalIgnoreCase);
				if (num2 < 0)
				{
					return false;
				}
				if (TryMatchPlaceholderCandidate(normalizedValue, tokenIndex, position, num2, captureStarts, captureLengths))
				{
					return true;
				}
				num = num2 + 1;
			}
			return false;
		}

		private bool TryMatchPlaceholderCandidate(string normalizedValue, int tokenIndex, int captureStartIndex, int nextPosition, int[] captureStarts, int[] captureLengths)
		{
			int num = matchPlaceholderSlots[tokenIndex];
			int captureLength = nextPosition - captureStartIndex;
			if (!TryStoreCapture(matchTokens[tokenIndex], num, normalizedValue, captureStartIndex, captureLength, captureStarts, captureLengths, out var previousStart, out var previousLength, out var assignedNew))
			{
				return false;
			}
			bool num2 = TryTranslateConstrained(normalizedValue, tokenIndex + 1, nextPosition, captureStarts, captureLengths);
			if (!num2 && assignedNew)
			{
				captureStarts[num] = previousStart;
				captureLengths[num] = previousLength;
			}
			return num2;
		}

		private bool TryStoreCapture(TemplateToken token, int captureSlot, string normalizedValue, int captureStartIndex, int captureLength, int[] captureStarts, int[] captureLengths, out int previousStart, out int previousLength, out bool assignedNew)
		{
			previousStart = captureStarts[captureSlot];
			previousLength = captureLengths[captureSlot];
			assignedNew = false;
			if (previousStart >= 0 && !SegmentsEqual(normalizedValue, previousStart, previousLength, captureStartIndex, captureLength))
			{
				return false;
			}
			if (token.Constraint != null && !token.Constraint.IsMatch(normalizedValue, captureStartIndex, captureLength))
			{
				return false;
			}
			if (previousStart < 0)
			{
				captureStarts[captureSlot] = captureStartIndex;
				captureLengths[captureSlot] = captureLength;
				assignedNew = true;
			}
			return true;
		}

		private string BuildTranslatedOutput(string normalizedValue, int[] captureStarts, int[] captureLengths)
		{
			StringBuilder stringBuilder = new StringBuilder(normalizedValue.Length + 16);
			for (int i = 0; i < replaceTokens.Length; i++)
			{
				TemplateToken templateToken = replaceTokens[i];
				if (!templateToken.IsPlaceholder)
				{
					stringBuilder.Append(templateToken.Value);
					continue;
				}
				int num = replacePlaceholderSlots[i];
				if (num < 0 || num >= captureStarts.Length)
				{
					continue;
				}
				int num2 = captureStarts[num];
				if (num2 >= 0)
				{
					int num3 = captureLengths[num];
					if (templateToken.IsFunctionCall)
					{
						stringBuilder.Append(TranslationRuntime.ResolveTemplatePlaceholder(normalizedValue.Substring(num2, num3)));
					}
					else
					{
						stringBuilder.Append(normalizedValue, num2, num3);
					}
				}
			}
			return stringBuilder.ToString();
		}

		private static bool SegmentsEqual(string value, int leftStart, int leftLength, int rightStart, int rightLength)
		{
			if (leftLength != rightLength)
			{
				return false;
			}
			if (leftLength == 0)
			{
				return true;
			}
			return string.Compare(value, leftStart, value, rightStart, leftLength, StringComparison.Ordinal) == 0;
		}

		private static bool HasConstrainedPlaceholders(TemplateToken[] tokens)
		{
			for (int i = 0; i < tokens.Length; i++)
			{
				if (tokens[i].Constraint != null)
				{
					return true;
				}
			}
			return false;
		}

		private static bool TryValidateRepeatedPlaceholderConstraints(string template, TemplateToken[] matchTokens, out string error)
		{
			error = null;
			Dictionary<string, string> dictionary = null;
			for (int i = 0; i < matchTokens.Length; i++)
			{
				TemplateToken templateToken = matchTokens[i];
				if (!templateToken.IsPlaceholder)
				{
					continue;
				}
				if (dictionary == null)
				{
					dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
				}
				string text = ((templateToken.Constraint == null) ? string.Empty : templateToken.Constraint.Signature);
				if (dictionary.TryGetValue(templateToken.Value, out var value))
				{
					if (!string.Equals(value, text, StringComparison.Ordinal))
					{
						error = "Template '" + template + "' uses placeholder '" + templateToken.Value + "' with conflicting constraints.";
						return false;
					}
				}
				else
				{
					dictionary[templateToken.Value] = text;
				}
			}
			return true;
		}

		private static void BuildPlaceholderSlots(TemplateToken[] matchTokens, TemplateToken[] replaceTokens, out int[] matchPlaceholderSlots, out int[] replacePlaceholderSlots, out int uniquePlaceholderCount)
		{
			matchPlaceholderSlots = new int[matchTokens.Length];
			replacePlaceholderSlots = new int[replaceTokens.Length];
			uniquePlaceholderCount = 0;
			Dictionary<string, int> dictionary = null;
			for (int i = 0; i < matchTokens.Length; i++)
			{
				if (matchTokens[i].IsPlaceholder)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
					}
					if (!dictionary.TryGetValue(matchTokens[i].Value, out var value))
					{
						value = uniquePlaceholderCount;
						uniquePlaceholderCount++;
						dictionary[matchTokens[i].Value] = value;
					}
					matchPlaceholderSlots[i] = value;
				}
			}
			for (int j = 0; j < replaceTokens.Length; j++)
			{
				if (replaceTokens[j].IsPlaceholder)
				{
					replacePlaceholderSlots[j] = -1;
					if (dictionary != null && dictionary.TryGetValue(replaceTokens[j].Value, out var value2))
					{
						replacePlaceholderSlots[j] = value2;
					}
				}
			}
		}

		private static bool TryNormalizeMatchTokens(string template, TemplateToken[] sourceTokens, out TemplateToken[] normalizedTokens, out string error)
		{
			List<TemplateToken> list = new List<TemplateToken>(sourceTokens.Length);
			for (int i = 0; i < sourceTokens.Length; i++)
			{
				TemplateToken item = sourceTokens[i];
				if (item.IsPlaceholder)
				{
					if (list.Count > 0 && list[list.Count - 1].IsPlaceholder)
					{
						normalizedTokens = Array.Empty<TemplateToken>();
						error = "Template '" + template + "' becomes ambiguous after stripping rich-text tags.";
						return false;
					}
					list.Add(item);
				}
				else
				{
					string value = TextMatchNormalizer.Normalize(item.Value);
					if (!string.IsNullOrEmpty(value))
					{
						list.Add(new TemplateToken(isPlaceholder: false, value));
					}
				}
			}
			if (list.Count == 0)
			{
				normalizedTokens = Array.Empty<TemplateToken>();
				error = "Template '" + template + "' becomes empty after stripping rich-text tags.";
				return false;
			}
			normalizedTokens = list.ToArray();
			error = null;
			return true;
		}

		internal void SetDispatchOrder(int dispatchOrder)
		{
			DispatchOrder = dispatchOrder;
		}

		private static string[] BuildNextLiteralValues(TemplateToken[] tokens)
		{
			string[] array = new string[tokens.Length];
			string text = null;
			for (int num = tokens.Length - 1; num >= 0; num--)
			{
				array[num] = text;
				if (!tokens[num].IsPlaceholder)
				{
					text = tokens[num].Value;
				}
			}
			return array;
		}

		private static bool StartsWith(string text, int startIndex, string value)
		{
			if (startIndex + value.Length > text.Length)
			{
				return false;
			}
			return string.Compare(text, startIndex, value, 0, value.Length, StringComparison.OrdinalIgnoreCase) == 0;
		}

		private static bool EndsWith(string text, string value)
		{
			if (value.Length > text.Length)
			{
				return false;
			}
			return string.Compare(text, text.Length - value.Length, value, 0, value.Length, StringComparison.OrdinalIgnoreCase) == 0;
		}

		private static void InitializeMatchMetadata(TemplateToken[] tokens, out string leadingLiteralPrefix, out string trailingLiteralSuffix, out string longestLiteralAnchor, out int minimumInputLength, out int placeholderCount, out int literalSegmentCount, out bool startsWithPlaceholder, out bool endsWithPlaceholder, out bool hasRepeatedPlaceholderNames)
		{
			leadingLiteralPrefix = null;
			trailingLiteralSuffix = null;
			longestLiteralAnchor = null;
			minimumInputLength = 0;
			placeholderCount = 0;
			literalSegmentCount = 0;
			startsWithPlaceholder = tokens.Length != 0 && tokens[0].IsPlaceholder;
			endsWithPlaceholder = tokens.Length != 0 && tokens[^1].IsPlaceholder;
			hasRepeatedPlaceholderNames = false;
			HashSet<string> hashSet = null;
			for (int i = 0; i < tokens.Length; i++)
			{
				TemplateToken templateToken = tokens[i];
				if (templateToken.IsPlaceholder)
				{
					placeholderCount++;
					if (hashSet == null)
					{
						hashSet = new HashSet<string>(StringComparer.Ordinal);
					}
					if (!hashSet.Add(templateToken.Value))
					{
						hasRepeatedPlaceholderNames = true;
					}
					continue;
				}
				literalSegmentCount++;
				minimumInputLength += templateToken.Value.Length;
				if (i == 0)
				{
					leadingLiteralPrefix = templateToken.Value;
				}
				if (i == tokens.Length - 1)
				{
					trailingLiteralSuffix = templateToken.Value;
				}
				if (longestLiteralAnchor == null || templateToken.Value.Length > longestLiteralAnchor.Length)
				{
					longestLiteralAnchor = templateToken.Value;
				}
			}
		}

		private static bool TryTokenize(string template, bool requirePlaceholder, bool allowFunctions, bool allowConstraints, bool allowAdjacentPlaceholders, out TemplateToken[] tokens, out string error)
		{
			tokens = Array.Empty<TemplateToken>();
			error = null;
			if (string.IsNullOrWhiteSpace(template))
			{
				error = "Template cannot be empty.";
				return false;
			}
			List<TemplateToken> list = new List<TemplateToken>();
			int num = 0;
			bool flag = false;
			while (num < template.Length)
			{
				int num2 = template.IndexOf("{{", num, StringComparison.Ordinal);
				if (num2 < 0)
				{
					list.Add(new TemplateToken(isPlaceholder: false, template.Substring(num)));
					num = template.Length;
					break;
				}
				if (num2 > num)
				{
					list.Add(new TemplateToken(isPlaceholder: false, template.Substring(num, num2 - num)));
				}
				if (!TryParseToken(template, num2, allowFunctions, allowConstraints, out var token, out var nextCursor, out error))
				{
					return false;
				}
				num = nextCursor;
				if (!allowAdjacentPlaceholders && list.Count > 0 && list[list.Count - 1].IsPlaceholder)
				{
					error = "Template '" + template + "' cannot contain adjacent placeholders.";
					return false;
				}
				list.Add(token);
				flag = true;
			}
			if (requirePlaceholder && !flag)
			{
				error = "Template '" + template + "' must contain at least one placeholder.";
				return false;
			}
			if (list.Count == 0)
			{
				list.Add(new TemplateToken(isPlaceholder: false, template));
			}
			tokens = list.ToArray();
			return true;
		}

		private static bool IsValidPlaceholderName(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			if (!IsValidPlaceholderStartCharacter(value[0]))
			{
				return false;
			}
			for (int i = 1; i < value.Length; i++)
			{
				if (!IsValidPlaceholderCharacter(value[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryParseToken(string template, int tokenStart, bool allowFunctions, bool allowConstraints, out TemplateToken token, out int nextCursor, out string error)
		{
			token = default(TemplateToken);
			nextCursor = tokenStart;
			error = null;
			int num = template.IndexOf("}}", tokenStart + "{{".Length, StringComparison.Ordinal);
			if (num < 0)
			{
				error = "Template '" + template + "' has an unclosed function token.";
				return false;
			}
			string text = template.Substring(tokenStart + "{{".Length, num - tokenStart - "{{".Length).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				error = "Template '" + template + "' contains an empty function token.";
				return false;
			}
			if (text[0] == '$')
			{
				if (!TryParsePlaceholderToken(template, text, allowConstraints, out token, out error))
				{
					return false;
				}
				nextCursor = num + "}}".Length;
				return true;
			}
			if (!allowFunctions)
			{
				error = "Template '" + template + "' cannot use function tokens in the match template.";
				return false;
			}
			int num2 = text.IndexOf('(');
			int num3 = text.LastIndexOf(')');
			if (num2 <= 0 || num3 != text.Length - 1)
			{
				error = "Template '" + template + "' has an invalid function token '" + text + "'.";
				return false;
			}
			string text2 = text.Substring(0, num2).Trim();
			if (!string.Equals(text2, "localize", StringComparison.Ordinal))
			{
				error = "Template '" + template + "' uses an unsupported function '" + text2 + "'.";
				return false;
			}
			string text3 = text.Substring(num2 + 1, num3 - num2 - 1).Trim();
			if (string.IsNullOrWhiteSpace(text3))
			{
				error = "Template '" + template + "' function '" + text2 + "' requires one placeholder argument.";
				return false;
			}
			string[] array = text3.Split(new char[1] { ',' });
			if (array.Length != 1)
			{
				error = "Template '" + template + "' function '" + text2 + "' currently supports exactly one placeholder argument.";
				return false;
			}
			string text4 = array[0].Trim();
			if (text4.Length < 2 || text4[0] != '$')
			{
				error = "Template '" + template + "' function '" + text2 + "' must reference a placeholder like $name.";
				return false;
			}
			string text5 = text4.Substring(1).Trim();
			if (!IsValidPlaceholderName(text5))
			{
				error = "Template '" + template + "' has an invalid placeholder name '" + text5 + "'.";
				return false;
			}
			token = new TemplateToken(isPlaceholder: true, text5, isFunctionCall: true);
			nextCursor = num + "}}".Length;
			return true;
		}

		private static bool TryParsePlaceholderToken(string template, string tokenContent, bool allowConstraints, out TemplateToken token, out string error)
		{
			token = default(TemplateToken);
			error = null;
			string text = tokenContent.Substring(1).Trim();
			int num = text.IndexOf(':');
			string text2 = ((num < 0) ? text : text.Substring(0, num).Trim());
			if (!IsValidPlaceholderName(text2))
			{
				error = "Template '" + template + "' has an invalid placeholder name '" + text2 + "'.";
				return false;
			}
			PlaceholderConstraint constraint = null;
			if (num >= 0)
			{
				if (!allowConstraints)
				{
					error = "Template '" + template + "' cannot use constrained placeholders in the replacement template.";
					return false;
				}
				string text3 = text.Substring(num + 1).Trim();
				if (string.IsNullOrWhiteSpace(text3))
				{
					error = "Template '" + template + "' placeholder '" + text2 + "' has an empty constraint.";
					return false;
				}
				if (!TryParsePlaceholderConstraint(template, text2, text3, out constraint, out error))
				{
					return false;
				}
			}
			token = new TemplateToken(isPlaceholder: true, text2, isFunctionCall: false, constraint);
			return true;
		}

		private static bool TryParsePlaceholderConstraint(string template, string placeholderName, string constraintText, out PlaceholderConstraint constraint, out string error)
		{
			constraint = null;
			error = null;
			int num = constraintText.IndexOf('(');
			string text = constraintText;
			string text2 = null;
			if (num >= 0)
			{
				int num2 = constraintText.LastIndexOf(')');
				if (num == 0 || num2 != constraintText.Length - 1)
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' has an invalid constraint '" + constraintText + "'.";
					return false;
				}
				text = constraintText.Substring(0, num).Trim();
				text2 = constraintText.Substring(num + 1, num2 - num - 1).Trim();
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				error = "Template '" + template + "' placeholder '" + placeholderName + "' has an empty constraint type.";
				return false;
			}
			if (string.Equals(text, "word", StringComparison.OrdinalIgnoreCase))
			{
				if (!string.IsNullOrWhiteSpace(text2))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint 'word' does not accept options.";
					return false;
				}
				constraint = PlaceholderConstraint.CreateWord();
				return true;
			}
			if (string.Equals(text, "words", StringComparison.OrdinalIgnoreCase))
			{
				if (!TryParseConstraintOptions(template, placeholderName, text, text2, out var options, out error))
				{
					return false;
				}
				IntegerRange range = IntegerRange.AtLeast(1);
				if (options.TryGetValue("count", out var value) && !TryParseIntegerRangeOption(template, placeholderName, text, "count", value, allowZeroMinimum: false, out range, out error))
				{
					return false;
				}
				if (!EnsureOnlySupportedOptions(template, placeholderName, text, options, "count", out error))
				{
					return false;
				}
				constraint = PlaceholderConstraint.CreateWords(range);
				return true;
			}
			if (string.Equals(text, "int", StringComparison.OrdinalIgnoreCase))
			{
				if (!TryParseConstraintOptions(template, placeholderName, text, text2, out var options2, out error))
				{
					return false;
				}
				IntegerRange range2 = IntegerRange.AtLeast(1);
				if (options2.TryGetValue("digits", out var value2) && !TryParseIntegerRangeOption(template, placeholderName, text, "digits", value2, allowZeroMinimum: false, out range2, out error))
				{
					return false;
				}
				NumericPredicate[] predicates = Array.Empty<NumericPredicate>();
				if (options2.TryGetValue("where", out var value3) && !TryParseNumericPredicates(template, placeholderName, text, value3, out predicates, out error))
				{
					return false;
				}
				if (!EnsureOnlySupportedOptions(template, placeholderName, text, options2, "digits", "where", out error))
				{
					return false;
				}
				constraint = PlaceholderConstraint.CreateInteger(range2, predicates);
				return true;
			}
			if (string.Equals(text, "float", StringComparison.OrdinalIgnoreCase))
			{
				if (!TryParseConstraintOptions(template, placeholderName, text, text2, out var options3, out error))
				{
					return false;
				}
				IntegerRange range3 = IntegerRange.AtLeast(1);
				if (options3.TryGetValue("int", out var value4) && !TryParseIntegerRangeOption(template, placeholderName, text, "int", value4, allowZeroMinimum: false, out range3, out error))
				{
					return false;
				}
				IntegerRange range4 = IntegerRange.AtLeast(0);
				if (options3.TryGetValue("frac", out var value5) && !TryParseIntegerRangeOption(template, placeholderName, text, "frac", value5, allowZeroMinimum: true, out range4, out error))
				{
					return false;
				}
				NumericPredicate[] predicates2 = Array.Empty<NumericPredicate>();
				if (options3.TryGetValue("where", out var value6) && !TryParseNumericPredicates(template, placeholderName, text, value6, out predicates2, out error))
				{
					return false;
				}
				if (!EnsureOnlySupportedOptions(template, placeholderName, text, options3, "int", "frac", "where", out error))
				{
					return false;
				}
				constraint = PlaceholderConstraint.CreateFloat(range3, range4, predicates2);
				return true;
			}
			if (string.Equals(text, "oneof", StringComparison.OrdinalIgnoreCase))
			{
				if (string.IsNullOrWhiteSpace(text2))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint 'oneof' requires at least one value.";
					return false;
				}
				string[] array = text2.Split(new char[1] { '|' });
				List<string> list = new List<string>(array.Length);
				for (int i = 0; i < array.Length; i++)
				{
					string text3 = array[i].Trim();
					if (string.IsNullOrEmpty(text3))
					{
						error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint 'oneof' contains an empty option.";
						return false;
					}
					list.Add(text3);
				}
				constraint = PlaceholderConstraint.CreateOneOf(list.ToArray());
				return true;
			}
			error = "Template '" + template + "' placeholder '" + placeholderName + "' uses an unsupported constraint type '" + text + "'.";
			return false;
		}

		private static bool TryParseConstraintOptions(string template, string placeholderName, string constraintType, string argumentText, out Dictionary<string, string> options, out string error)
		{
			options = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			error = null;
			if (string.IsNullOrWhiteSpace(argumentText))
			{
				return true;
			}
			string[] array = argumentText.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (string.IsNullOrEmpty(text))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' contains an empty option.";
					return false;
				}
				int num = text.IndexOf('=');
				if (num <= 0 || num == text.Length - 1)
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' has an invalid option '" + text + "'.";
					return false;
				}
				string text2 = text.Substring(0, num).Trim();
				string value = text.Substring(num + 1).Trim();
				if (string.IsNullOrEmpty(text2) || string.IsNullOrEmpty(value))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' has an invalid option '" + text + "'.";
					return false;
				}
				if (options.ContainsKey(text2))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' repeats option '" + text2 + "'.";
					return false;
				}
				options[text2] = value;
			}
			return true;
		}

		private static bool EnsureOnlySupportedOptions(string template, string placeholderName, string constraintType, Dictionary<string, string> options, string supportedOption, out string error)
		{
			return EnsureOnlySupportedOptions(template, placeholderName, constraintType, options, new string[1] { supportedOption }, out error);
		}

		private static bool EnsureOnlySupportedOptions(string template, string placeholderName, string constraintType, Dictionary<string, string> options, string supportedOptionOne, string supportedOptionTwo, out string error)
		{
			return EnsureOnlySupportedOptions(template, placeholderName, constraintType, options, new string[2] { supportedOptionOne, supportedOptionTwo }, out error);
		}

		private static bool EnsureOnlySupportedOptions(string template, string placeholderName, string constraintType, Dictionary<string, string> options, string supportedOptionOne, string supportedOptionTwo, string supportedOptionThree, out string error)
		{
			return EnsureOnlySupportedOptions(template, placeholderName, constraintType, options, new string[3] { supportedOptionOne, supportedOptionTwo, supportedOptionThree }, out error);
		}

		private static bool EnsureOnlySupportedOptions(string template, string placeholderName, string constraintType, Dictionary<string, string> options, string[] supportedOptions, out string error)
		{
			error = null;
			HashSet<string> hashSet = new HashSet<string>(supportedOptions, StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, string> option in options)
			{
				if (!hashSet.Contains(option.Key))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' does not support option '" + option.Key + "'.";
					return false;
				}
			}
			return true;
		}

		private static bool TryParseIntegerRangeOption(string template, string placeholderName, string constraintType, string optionName, string valueText, bool allowZeroMinimum, out IntegerRange range, out string error)
		{
			if (!TryParseIntegerRange(valueText, allowZeroMinimum, out range, out error))
			{
				error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' has an invalid '" + optionName + "' range: " + error;
				return false;
			}
			return true;
		}

		private static bool TryParseIntegerRange(string valueText, bool allowZeroMinimum, out IntegerRange range, out string error)
		{
			range = default(IntegerRange);
			error = null;
			if (string.IsNullOrWhiteSpace(valueText))
			{
				error = "range cannot be empty.";
				return false;
			}
			string text = valueText.Trim();
			int num = text.IndexOf("..", StringComparison.Ordinal);
			if (num < 0)
			{
				if (!TryParseBoundValue(text, allowZeroMinimum, out var value, out error))
				{
					return false;
				}
				range = IntegerRange.Exact(value);
				return true;
			}
			string text2 = text.Substring(0, num).Trim();
			string text3 = text.Substring(num + 2).Trim();
			bool flag = !string.IsNullOrEmpty(text2);
			bool flag2 = !string.IsNullOrEmpty(text3);
			if (!flag && !flag2)
			{
				error = "range must specify at least one bound.";
				return false;
			}
			int value2 = 0;
			if (flag && !TryParseBoundValue(text2, allowZeroMinimum, out value2, out error))
			{
				return false;
			}
			int value3 = 0;
			if (flag2 && !TryParseBoundValue(text3, allowZeroMinimum: true, out value3, out error))
			{
				return false;
			}
			if (flag && flag2 && value2 > value3)
			{
				error = "range minimum cannot be greater than maximum.";
				return false;
			}
			range = new IntegerRange(flag, value2, flag2, value3);
			return true;
		}

		private static bool TryParseBoundValue(string valueText, bool allowZeroMinimum, out int value, out string error)
		{
			value = 0;
			error = null;
			if (!int.TryParse(valueText, NumberStyles.None, CultureInfo.InvariantCulture, out value))
			{
				error = "'" + valueText + "' is not a valid integer.";
				return false;
			}
			if (value < 0)
			{
				error = "range values must be non-negative.";
				return false;
			}
			if (!allowZeroMinimum && value == 0)
			{
				error = "range values must be greater than zero.";
				return false;
			}
			return true;
		}

		private static bool TryParseNumericPredicates(string template, string placeholderName, string constraintType, string whereText, out NumericPredicate[] predicates, out string error)
		{
			predicates = Array.Empty<NumericPredicate>();
			error = null;
			if (string.IsNullOrWhiteSpace(whereText))
			{
				error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' has an empty 'where' clause.";
				return false;
			}
			string[] array = whereText.Split(new string[1] { "&&" }, StringSplitOptions.None);
			List<NumericPredicate> list = new List<NumericPredicate>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (string.IsNullOrEmpty(text))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' contains an empty numeric predicate.";
					return false;
				}
				if (!TryParseNumericPredicate(text, out var predicate, out var error2))
				{
					error = "Template '" + template + "' placeholder '" + placeholderName + "' constraint '" + constraintType + "' has an invalid numeric predicate '" + text + "': " + error2;
					return false;
				}
				list.Add(predicate);
			}
			predicates = list.ToArray();
			return true;
		}

		private static bool TryParseNumericPredicate(string clause, out NumericPredicate predicate, out string error)
		{
			predicate = default(NumericPredicate);
			error = null;
			NumericComparisonOperator comparisonOperator;
			string text;
			if (clause.StartsWith(">=", StringComparison.Ordinal))
			{
				comparisonOperator = NumericComparisonOperator.GreaterThanOrEqual;
				text = clause.Substring(2).Trim();
			}
			else if (clause.StartsWith("<=", StringComparison.Ordinal))
			{
				comparisonOperator = NumericComparisonOperator.LessThanOrEqual;
				text = clause.Substring(2).Trim();
			}
			else if (clause.StartsWith("!=", StringComparison.Ordinal))
			{
				comparisonOperator = NumericComparisonOperator.NotEqual;
				text = clause.Substring(2).Trim();
			}
			else if (clause.StartsWith("==", StringComparison.Ordinal))
			{
				comparisonOperator = NumericComparisonOperator.Equal;
				text = clause.Substring(2).Trim();
			}
			else if (clause.StartsWith(">", StringComparison.Ordinal))
			{
				comparisonOperator = NumericComparisonOperator.GreaterThan;
				text = clause.Substring(1).Trim();
			}
			else
			{
				if (!clause.StartsWith("<", StringComparison.Ordinal))
				{
					error = "predicate must start with one of <, <=, >, >=, ==, or !=.";
					return false;
				}
				comparisonOperator = NumericComparisonOperator.LessThan;
				text = clause.Substring(1).Trim();
			}
			if (!decimal.TryParse(text, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var result))
			{
				error = "'" + text + "' is not a valid numeric value.";
				return false;
			}
			predicate = new NumericPredicate(comparisonOperator, result);
			return true;
		}

		private static bool IsValidPlaceholderStartCharacter(char character)
		{
			if (!char.IsLetter(character))
			{
				return character == '_';
			}
			return true;
		}

		private static bool IsValidPlaceholderCharacter(char character)
		{
			if (!char.IsLetterOrDigit(character))
			{
				return character == '_';
			}
			return true;
		}

		private static bool IsWordCharacter(char character)
		{
			if (!char.IsLetterOrDigit(character) && character != '_' && character != '-')
			{
				return character == '\'';
			}
			return true;
		}
	}
	internal static class GameTranslationResolver
	{
		private enum CacheEvictionKind
		{
			Resolve,
			ResolveMiss,
			Localize,
			LocalizeMiss,
			ItemNameToken,
			ItemNameTokenMiss
		}

		private const int MaxResolveCacheEntries = 4096;

		private const int MaxResolveMissCacheEntries = 2048;

		private const int MaxLocalizeCacheEntries = 4096;

		private const int MaxLocalizeMissCacheEntries = 2048;

		private const int MaxItemNameTokenCacheEntries = 4096;

		private const int MaxItemNameTokenMissCacheEntries = 2048;

		private static readonly Type ObjectDbType = AccessTools.TypeByName("ObjectDB");

		private static readonly Type ZNetSceneType = AccessTools.TypeByName("ZNetScene");

		private static readonly Type ItemDropType = AccessTools.TypeByName("ItemDrop");

		private static readonly Type LocalizationType = AccessTools.TypeByName("Localization");

		private static readonly FieldInfo ObjectDbInstanceField = AccessTools.Field(ObjectDbType, "instance");

		private static readonly PropertyInfo ObjectDbInstanceProperty = AccessTools.Property(ObjectDbType, "instance");

		private static readonly MethodInfo GetItemPrefabMethod = AccessTools.Method(ObjectDbType, "GetItemPrefab", new Type[1] { typeof(string) }, (Type[])null);

		private static readonly FieldInfo ZNetSceneInstanceField = AccessTools.Field(ZNetSceneType, "instance");

		private static readonly PropertyInfo ZNetSceneInstanceProperty = AccessTools.Property(ZNetSceneType, "instance");

		private static readonly MethodInfo GetPrefabMethod = AccessTools.Method(ZNetSceneType, "GetPrefab", new Type[1] { typeof(string) }, (Type[])null);

		private static readonly FieldInfo ItemDataField = AccessTools.Field(ItemDropType, "m_itemData");

		private static readonly FieldInfo SharedDataField = AccessTools.Field(AccessTools.Inner(ItemDropType, "ItemData") ?? AccessTools.TypeByName("ItemDrop+ItemData"), "m_shared");

		private static readonly FieldInfo SharedNameField = AccessTools.Field(AccessTools.Inner(ItemDropType, "ItemData+SharedData") ?? AccessTools.TypeByName("ItemDrop+ItemData+SharedData"), "m_name");

		private static readonly FieldInfo LocalizationInstanceField = AccessTools.Field(LocalizationType, "instance");

		private static readonly PropertyInfo LocalizationInstanceProperty = AccessTools.Property(LocalizationType, "instance");

		private static readonly MethodInfo LocalizeMethod = AccessTools.Method(LocalizationType, "Localize", new Type[1] { typeof(string) }, (Type[])null);

		private static readonly BoundedStringDictionary<string> resolveCache = new BoundedStringDictionary<string>(4096, StringComparer.Ordinal);

		private static readonly BoundedStringSet resolveMissCache = new BoundedStringSet(2048, StringComparer.Ordinal);

		private static readonly BoundedStringDictionary<string> localizeCache = new BoundedStringDictionary<string>(4096, StringComparer.Ordinal);

		private static readonly BoundedStringSet localizeMissCache = new BoundedStringSet(2048, StringComparer.Ordinal);

		private static readonly BoundedStringDictionary<string> itemNameTokenCache = new BoundedStringDictionary<string>(4096, StringComparer.Ordinal);

		private static readonly BoundedStringSet itemNameTokenMissCache = new BoundedStringSet(2048, StringComparer.Ordinal);

		public static bool TryResolve(string input, out string resolved)
		{
			resolved = null;
			if (string.IsNullOrWhiteSpace(input))
			{
				return false;
			}
			if (resolveCache.TryGetValue(input, out resolved))
			{
				return true;
			}
			if (resolveMissCache.Contains(input))
			{
				return false;
			}
			if (!TryResolveCore(input, out resolved))
			{
				AddMiss(resolveMissCache, CacheEvictionKind.ResolveMiss, input);
				return false;
			}
			AddValue(resolveCache, CacheEvictionKind.Resolve, input, resolved);
			return true;
		}

		internal static void ClearCaches()
		{
			resolveCache.Clear();
			resolveMissCache.Clear();
			localizeCache.Clear();
			localizeMissCache.Clear();
			itemNameTokenCache.Clear();
			itemNameTokenMissCache.Clear();
		}

		private static bool TryResolveCore(string input, out string resolved)
		{
			resolved = null;
			if (TryLocalize(input, out resolved))
			{
				return true;
			}
			if (!TryResolveItemNameToken(input, out var itemNameToken))
			{
				return false;
			}
			if (TryLocalize(itemNameToken, out resolved))
			{
				return true;
			}
			if (!string.Equals(itemNameToken, input, StringComparison.Ordinal))
			{
				resolved = itemNameToken;
				return true;
			}
			return false;
		}

		private static bool TryResolveItemNameToken(string prefabName, out string itemNameToken)
		{
			itemNameToken = null;
			if (itemNameTokenCache.TryGetValue(prefabName, out itemNameToken))
			{
				return true;
			}
			if (itemNameTokenMissCache.Contains(prefabName))
			{
				return false;
			}
			GameObject val = TryGetItemPrefab(prefabName) ?? TryGetScenePrefab(prefabName);
			if ((Object)(object)val == (Object)null || ItemDropType == null)
			{
				AddMiss(itemNameTokenMissCache, CacheEvictionKind.ItemNameTokenMiss, prefabName);
				return false;
			}
			Component component = val.GetComponent(ItemDropType);
			if ((Object)(object)component == (Object)null || ItemDataField == null || SharedDataField == null || SharedNameField == null)
			{
				AddMiss(itemNameTokenMissCache, CacheEvictionKind.ItemNameTokenMiss, prefabName);
				return false;
			}
			object value = ItemDataField.GetValue(component);
			if (value == null)
			{
				AddMiss(itemNameTokenMissCache, CacheEvictionKind.ItemNameTokenMiss, prefabName);
				return false;
			}
			object value2 = SharedDataField.GetValue(value);
			if (value2 == null)
			{
				AddMiss(itemNameTokenMissCache, CacheEvictionKind.ItemNameTokenMiss, prefabName);
				return false;
			}
			itemNameToken = SharedNameField.GetValue(value2) as string;
			if (string.IsNullOrWhiteSpace(itemNameToken))
			{
				AddMiss(itemNameTokenMissCache, CacheEvictionKind.ItemNameTokenMiss, prefabName);
				return false;
			}
			AddValue(itemNameTokenCache, CacheEvictionKind.ItemNameToken, prefabName, itemNameToken);
			return true;
		}

		private static GameObject TryGetItemPrefab(string prefabName)
		{
			object obj = ObjectDbInstanceField?.GetValue(null) ?? ObjectDbInstanceProperty?.GetValue(null, null);
			if (obj == null || GetItemPrefabMethod == null)
			{
				return null;
			}
			object? obj2 = GetItemPrefabMethod.Invoke(obj, new object[1] { prefabName });
			return (GameObject)((obj2 is GameObject) ? obj2 : null);
		}

		private static GameObject TryGetScenePrefab(string prefabName)
		{
			object obj = ZNetSceneInstanceField?.GetValue(null) ?? ZNetSceneInstanceProperty?.GetValue(null, null);
			if (obj == null || GetPrefabMethod == null)
			{
				return null;
			}
			object? obj2 = GetPrefabMethod.Invoke(obj, new object[1] { prefabName });
			return (GameObject)((obj2 is GameObject) ? obj2 : null);
		}

		private static bool TryLocalize(string input, out string localized)
		{
			localized = null;
			if (localizeCache.TryGetValue(input, out localized))
			{
				return true;
			}
			if (localizeMissCache.Contains(input))
			{
				return false;
			}
			object obj = LocalizationInstanceField?.GetValue(null) ?? LocalizationInstanceProperty?.GetValue(null, null);
			if (obj == null || LocalizeMethod == null)
			{
				return false;
			}
			try
			{
				localized = LocalizeMethod.Invoke(obj, new object[1] { input }) as string;
			}
			catch (Exception ex)
			{
				Exception exception = ex;
				PluginMain.DebugLog(() => "Game localization lookup failed for '" + PluginMain.FormatTextForDebug(input) + "': " + exception.Message);
				return false;
			}
			if (string.IsNullOrWhiteSpace(localized) || string.Equals(localized, input, StringComparison.Ordinal))
			{
				AddMiss(localizeMissCache, CacheEvictionKind.LocalizeMiss, input);
				localized = null;
				return false;
			}
			AddValue(localizeCache, CacheEvictionKind.Localize, input, localized);
			return true;
		}

		private static void AddValue(BoundedStringDictionary<string> cache, CacheEvictionKind evictionKind, string key, string value)
		{
			if (cache.Set(key, value, out var _))
			{
				RecordEviction(evictionKind);
			}
		}

		private static void AddMiss(BoundedStringSet cache, CacheEvictionKind evictionKind, string key)
		{
			if (cache.Add(key, out var evictedKey) && evictedKey != null)
			{
				RecordEviction(evictionKind);
			}
		}

		private static void RecordEviction(CacheEvictionKind evictionKind)
		{
			switch (evictionKind)
			{
			case CacheEvictionKind.Resolve:
				TranslationPerformanceMetrics.RecordGameResolveCacheEviction();
				break;
			case CacheEvictionKind.ResolveMiss:
				TranslationPerformanceMetrics.RecordGameResolveMissCacheEviction();
				break;
			case CacheEvictionKind.Localize:
				TranslationPerformanceMetrics.RecordGameLocalizeCacheEviction();
				break;
			case CacheEvictionKind.LocalizeMiss:
				TranslationPerformanceMetrics.RecordGameLocalizeMissCacheEviction();
				break;
			case CacheEvictionKind.ItemNameToken:
				TranslationPerformanceMetrics.RecordGameItemNameTokenCacheEviction();
				break;
			case CacheEvictionKind.ItemNameTokenMiss:
				TranslationPerformanceMetrics.RecordGameItemNameTokenMissCacheEviction();
				break;
			}
		}
	}
	internal static class PluginLocalization
	{
		private const string EnglishLanguage = "English";

		private const string TraditionalChineseLanguage = "Chinese_Trad";

		private const string FileNamePrefix = "Localization-";

		private const string FileExtension = ".json";

		private const double ReloadDebounceMilliseconds = 250.0;

		private static readonly IReadOnlyList<KeyValuePair<string, string>> DefaultEntries = BuildDefaultEntries();

		private static readonly Dictionary<string, string> DefaultValuesByKey = BuildDefaultValuesByKey();

		private static readonly Dictionary<string, string> DefaultLegacyValuesByKey = BuildDefaultLegacyValuesByKey();

		private static readonly Dictionary<string, string> TraditionalChineseValuesByKey = BuildTraditionalChineseValuesByKey();

		private static readonly Dictionary<string, string> TraditionalChineseLegacyValuesByKey = BuildTraditionalChineseLegacyValuesByKey();

		private static readonly Dictionary<string, string> DefaultKeysByFallback = BuildDefaultKeysByFallback();

		private static Dictionary<string, string> localizedValues = new Dictionary<string, string>(StringComparer.Ordinal);

		private static FileSystemWatcher watcher;

		private static System.Timers.Timer reloadDebounceTimer;

		private static bool initialized;

		private static string currentLanguage = "English";

		internal static event Action Reloaded;

		internal static void Initialize()
		{
			if (!initialized)
			{
				initialized = true;
				currentLanguage = ResolveLanguage(null);
				Directory.CreateDirectory(TranslationRuleLoader.ConfigRootPath);
				ReloadCurrentLanguage();
				SetupWatcher();
			}
		}

		internal static void Shutdown()
		{
			if (initialized)
			{
				if (watcher != null)
				{
					watcher.EnableRaisingEvents = false;
					watcher.Changed -= OnLocalizationFileChanged;
					watcher.Created -= OnLocalizationFileChanged;
					watcher.Deleted -= OnLocalizationFileChanged;
					watcher.Renamed -= OnLocalizationFileRenamed;
					watcher.Dispose();
					watcher = null;
				}
				if (reloadDebounceTimer != null)
				{
					reloadDebounceTimer.Stop();
					reloadDebounceTimer.Elapsed -= OnReloadDebounceElapsed;
					reloadDebounceTimer.Dispose();
					reloadDebounceTimer = null;
				}
				localizedValues = new Dictionary<string, string>(StringComparer.Ordinal);
				initialized = false;
				currentLanguage = "English";
			}
		}

		internal static void NotifyLanguageChanged(string languageName)
		{
			currentLanguage = ResolveLanguage(languageName);
			ReloadCurrentLanguage();
		}

		internal static void NotifyLanguageReset()
		{
			NotifyLanguageChanged("English");
		}

		internal static string Get(string key, string fallback)
		{
			if (!string.IsNullOrWhiteSpace(key) && localizedValues.TryGetValue(key, out var value) && !string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			if (!string.IsNullOrWhiteSpace(fallback))
			{
				return fallback;
			}
			return key ?? string.Empty;
		}

		internal static string Format(string key, string fallback, params object[] args)
		{
			string text = Get(key, fallback);
			if (args != null && args.Length != 0)
			{
				return string.Format(CultureInfo.InvariantCulture, text, args);
			}
			return text;
		}

		internal static string TranslateFallback(string fallback)
		{
			if (string.IsNullOrEmpty(fallback))
			{
				return fallback ?? string.Empty;
			}
			if (!DefaultKeysByFallback.TryGetValue(fallback, out var value))
			{
				return fallback;
			}
			return Get(value, fallback);
		}

		private static void SetupWatcher()
		{
			watcher = new FileSystemWatcher(TranslationRuleLoader.ConfigRootPath, "Localization-*.json")
			{
				IncludeSubdirectories = false,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime),
				SynchronizingObject = ThreadingHelper.SynchronizingObject
			};
			watcher.Changed += OnLocalizationFileChanged;
			watcher.Created += OnLocalizationFileChanged;
			watcher.Deleted += OnLocalizationFileChanged;
			watcher.Renamed += OnLocalizationFileRenamed;
			watcher.EnableRaisingEvents = true;
			reloadDebounceTimer = new System.Timers.Timer(250.0)
			{
				AutoReset = false,
				SynchronizingObject = ThreadingHelper.SynchronizingObject
			};
			reloadDebounceTimer.Elapsed += OnReloadDebounceElapsed;
		}

		private static void OnLocalizationFileChanged(object sender, FileSystemEventArgs e)
		{
			ScheduleReload();
		}

		private static void OnLocalizationFileRenamed(object sender, RenamedEventArgs e)
		{
			ScheduleReload();
		}

		private static void ScheduleReload()
		{
			if (reloadDebounceTimer == null)
			{
				ReloadCurrentLanguage();
				return;
			}
			reloadDebounceTimer.Stop();
			reloadDebounceTimer.Start();
		}

		private static void OnReloadDebounceElapsed(object sender, ElapsedEventArgs e)
		{
			ReloadCurrentLanguage();
		}

		private static void ReloadCurrentLanguage()
		{
			string text = (currentLanguage = ResolveLanguage(currentLanguage));
			try
			{
				Directory.CreateDirectory(TranslationRuleLoader.ConfigRootPath);
				Dictionary<string, string> dictionary = EnsureFileAndLoad("English", GetFilePath("English"), DefaultValuesByKey);
				EnsureFileAndLoad("Chinese_Trad", GetFilePath("Chinese_Trad"), TraditionalChineseValuesByKey);
				Dictionary<string, string> dictionary2 = new Dictionary<string, string>(dictionary, StringComparer.Ordinal);
				if (!string.Equals(text, "English", StringComparison.Ordinal))
				{
					foreach (KeyValuePair<string, string> item in EnsureFileAndLoad(text, GetFilePath(text), GetSeedValuesForLanguage(text)))
					{
						if (!string.IsNullOrWhiteSpace(item.Value))
						{
							dictionary2[item.Key] = item.Value;
						}
					}
				}
				localizedValues = dictionary2;
			}
			catch (Exception ex)
			{
				localizedValues = new Dictionary<string, string>(DefaultValuesByKey, StringComparer.Ordinal);
				ManualLogSource log = PluginMain.Log;
				if (log != null)
				{
					log.LogError((object)("Failed to reload plugin localization files: " + ex.Message));
				}
			}
			PluginLocalization.Reloaded?.Invoke();
		}

		private static Dictionary<string, string> EnsureFileAndLoad(string languageName, string filePath, IReadOnlyDictionary<string, string> seedValues)
		{
			bool exists;
			Dictionary<string, string> dictionary = TryLoadFile(filePath, out exists) ?? new Dictionary<string, string>(StringComparer.Ordinal);
			IReadOnlyDictionary<string, string> legacyValuesForLanguage = GetLegacyValuesForLanguage(languageName);
			bool flag = !exists;
			foreach (KeyValuePair<string, string> defaultEntry in DefaultEntries)
			{
				string value;
				string text = ((seedValues != null && seedValues.TryGetValue(defaultEntry.Key, out value)) ? value : defaultEntry.Value);
				if (!dictionary.ContainsKey(defaultEntry.Key))
				{
					dictionary[defaultEntry.Key] = text;
					flag = true;
				}
				else if (ShouldUpdateSeedValue(defaultEntry.Key, dictionary[defaultEntry.Key], defaultEntry.Value, text, legacyValuesForLanguage))
				{
					dictionary[defaultEntry.Key] = text;
					flag = true;
				}
			}
			if (flag)
			{
				File.WriteAllText(filePath, JsonConvert.SerializeObject((object)dictionary, (Formatting)1));
			}
			return dictionary;
		}

		private static Dictionary<string, string> TryLoadFile(string filePath, out bool exists)
		{
			exists = File.Exists(filePath);
			if (!exists)
			{
				return null;
			}
			try
			{
				Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(File.ReadAllText(filePath));
				return (dictionary != null) ? new Dictionary<string, string>(dictionary, StringComparer.Ordinal) : new Dictionary<string, string>(StringComparer.Ordinal);
			}
			catch (Exception ex)
			{
				ManualLogSource log = PluginMain.Log;
				if (log != null)
				{
					log.LogError((object)("Failed to read plugin localization file '" + filePath + "': " + ex.Message));
				}
				return new Dictionary<string, string>(StringComparer.Ordinal);
			}
		}

		private static IReadOnlyDictionary<string, string> GetSeedValuesForLanguage(string languageName)
		{
			if (!string.Equals(languageName, "Chinese_Trad", StringComparison.Ordinal))
			{
				return DefaultValuesByKey;
			}
			return TraditionalChineseValuesByKey;
		}

		private static IReadOnlyDictionary<string, string> GetLegacyValuesForLanguage(string languageName)
		{
			if (!string.Equals(languageName, "Chinese_Trad", StringComparison.Ordinal))
			{
				return DefaultLegacyValuesByKey;
			}
			return TraditionalChineseLegacyValuesByKey;
		}

		private static bool ShouldUpdateSeedValue(string key, string currentValue, string defaultValue, string seedValue, IReadOnlyDictionary<string, string> legacyValues)
		{
			if (currentValue == null)
			{
				return true;
			}
			if (string.Equals(currentValue, seedValue, StringComparison.Ordinal))
			{
				return false;
			}
			if (!string.Equals(seedValue, defaultValue, StringComparison.Ordinal) && string.Equals(currentValue, defaultValue, StringComparison.Ordinal))
			{
				return true;
			}
			if (legacyValues != null && legacyValues.TryGetValue(key, out var value))
			{
				return string.Equals(currentValue, value, StringComparison.Ordinal);
			}
			return false;
		}

		private static string ResolveLanguage(string languageName)
		{
			if (!string.IsNullOrWhiteSpace(languageName))
			{
				return languageName;
			}
			string @string = PlayerPrefs.GetString("language", "English");
			if (!string.IsNullOrWhiteSpace(@string))
			{
				return @string;
			}
			return "English";
		}

		private static string GetFilePath(string languageName)
		{
			return Path.Combine(TranslationRuleLoader.ConfigRootPath, "Localization-" + ResolveLanguage(languageName) + ".json");
		}

		private static IReadOnlyList<KeyValuePair<string, string>> BuildDefaultEntries()
		{
			return new KeyValuePair<string, string>[252]
			{
				new KeyValuePair<string, string>("common.no", "No"),
				new KeyValuePair<string, string>("common.off", "Off"),
				new KeyValuePair<string, string>("common.on", "On"),
				new KeyValuePair<string, string>("common.yes", "Yes"),
				new KeyValuePair<string, string>("common.clear", "Clear"),
				new KeyValuePair<string, string>("common.search", "Search"),
				new KeyValuePair<string, string>("common.debug.null", "<null>"),
				new KeyValuePair<string, string>("common.debug.truncated_suffix", "... [truncated]"),
				new KeyValuePair<string, string>("common.unknown", "<unknown>"),
				new KeyValuePair<string, string>("plugin.loaded", "{0} loaded."),
				new KeyValuePair<string, string>("plugin.loaded_dedicated", "{0} loaded in dedicated server mode. ServerSync remains active; translation runtime and UI patches are skipped."),
				new KeyValuePair<string, string>("plugin.log.devtools_not_ready", "Localization devtools UI is not ready yet."),
				new KeyValuePair<string, string>("plugin.log.devtools_update_failed", "Failed to update {0} from the devtools UI: {1}"),
				new KeyValuePair<string, string>("runtime.analysis.final_output", "Final output: '{0}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_result_loop", "Pass 2 result: a translation loop back to the original input was detected, so the pass 1 output was kept."),
				new KeyValuePair<string, string>("runtime.analysis.pass_result_no_change", "Pass 1 result: no translation rule changed the input."),
				new KeyValuePair<string, string>("runtime.analysis.pass_result_no_further_change", "Pass 2 result: no further translation rule changed the first pass output."),
				new KeyValuePair<string, string>("runtime.analysis.pass_result_updated", "Pass 2 result: output updated to '{0}'."),
				new KeyValuePair<string, string>("runtime.analysis.runtime_disabled", "Translation is currently disabled; analysis is using the current in-memory rule state."),
				new KeyValuePair<string, string>("runtime.analysis.runtime_empty", "Analysis stopped because the selected string is empty."),
				new KeyValuePair<string, string>("runtime.analysis.runtime_not_initialized", "Analysis stopped because the translation runtime is not initialized."),
				new KeyValuePair<string, string>("runtime.analysis.runtime_pass_chain", "Top-level pass chain: fixed 2 passes. Additional whole string longest match rewrites are shown as step N inside a pass."),
				new KeyValuePair<string, string>("runtime.analysis.runtime_state", "Runtime State"),
				new KeyValuePair<string, string>("runtime.analysis.runtime_initialized", "Runtime initialized: {0}"),
				new KeyValuePair<string, string>("runtime.analysis.translation_enabled", "Translation enabled: {0}"),
				new KeyValuePair<string, string>("runtime.analysis.pass_title_one", "Pass 1"),
				new KeyValuePair<string, string>("runtime.analysis.pass_title_two", "Pass 2"),
				new KeyValuePair<string, string>("runtime.analysis.final_title", "Final"),
				new KeyValuePair<string, string>("runtime.analysis.stage.exact", "Exact"),
				new KeyValuePair<string, string>("runtime.analysis.stage.normalized_exact", "Normalized Exact"),
				new KeyValuePair<string, string>("runtime.analysis.stage.template", "Template"),
				new KeyValuePair<string, string>("runtime.analysis.stage.whole_string_longest_match", "Whole String Longest Match"),
				new KeyValuePair<string, string>("runtime.analysis.pass_stage_not_executed", "{0} {1}: not executed ({2} already produced output)"),
				new KeyValuePair<string, string>("runtime.analysis.stage_summary_output", "Output: '{0}'"),
				new KeyValuePair<string, string>("runtime.analysis.stage_summary_miss", "No rule matched."),
				new KeyValuePair<string, string>("runtime.analysis.stage_summary_not_executed", "Skipped because {0} already produced output."),
				new KeyValuePair<string, string>("runtime.analysis.pass_input", "{0} input: '{1}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_exact_hit", "{0} exact: hit target='{1}', match='{2}', replace='{3}', file='{4}' -> '{5}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_exact_miss", "{0} exact: miss"),
				new KeyValuePair<string, string>("runtime.analysis.pass_normalized_input", "{0} normalized input: '{1}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_normalized_exact_hit", "{0} normalized exact: hit target='{1}', match='{2}', replace='{3}', file='{4}' -> '{5}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_normalized_exact_miss", "{0} normalized exact: miss"),
				new KeyValuePair<string, string>("runtime.analysis.pass_template_hit", "{0} template: hit target='{1}', match='{2}', replace='{3}', file='{4}' -> '{5}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_template_miss", "{0} template: miss"),
				new KeyValuePair<string, string>("runtime.analysis.pass_whole_string_longest_match_step_input", "{0} whole string longest match step {1} input: '{2}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_whole_string_longest_match_step_hit", "{0} whole string longest match step {1} hit [{2}..{3}): target='{4}', match='{5}', replace='{6}', file='{7}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_whole_string_longest_match_step_output", "{0} whole string longest match step {1} output: '{2}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_whole_string_longest_match_loop", "{0} whole string longest match: detected a loop and kept the last non-loop output."),
				new KeyValuePair<string, string>("runtime.analysis.pass_whole_string_longest_match_final", "{0} whole string longest match: final -> '{1}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_whole_string_longest_match_matched", "{0} whole string longest match: matched -> '{1}'"),
				new KeyValuePair<string, string>("runtime.analysis.pass_whole_string_longest_match_miss", "{0} whole string longest match: miss"),
				new KeyValuePair<string, string>("runtime.log.config_root", "Translation config root: {0}"),
				new KeyValuePair<string, string>("runtime.log.disabled_after_reason", "Translation runtime disabled; skipped rule loading after {0}."),
				new KeyValuePair<string, string>("runtime.log.load_result", "{0} translation rules for '{1}'. English='{2}' (local={3}, synced={4}), Active='{5}' (local={6}, synced={7}), exact={8}, templates={9}."),
				new KeyValuePair<string, string>("runtime.settings.read_failed", "Failed to read runtime settings from '{0}': {1}"),
				new KeyValuePair<string, string>("runtime.settings.backfill_failed", "Failed to backfill missing runtime settings in '{0}': {1}"),
				new KeyValuePair<string, string>("runtime.settings.summary", "Runtime settings via '{0}' ({1}): translation_enabled={2}, debug={3}, whole_string_longest_match_mode={4}, whole_string_longest_match_min_length={5}, trace_feed_max_entries={6}."),
				new KeyValuePair<string, string>("serversync.log.source_of_truth", "ServerSync source-of-truth enabled; local config hot reload is active."),
				new KeyValuePair<string, string>("serversync.log.snapshot_published", "Published local translation snapshot after {0}: {1} language folder(s), {2} file(s)."),
				new KeyValuePair<string, string>("devtools.app.title", "Localization Devtools"),
				new KeyValuePair<string, string>("devtools.page.browser", "Browser"),
				new KeyValuePair<string, string>("devtools.page.performance", "Performance"),
				new KeyValuePair<string, string>("devtools.page.playground", "Playground"),
				new KeyValuePair<string, string>("devtools.page.plugin", "Plugin"),
				new KeyValuePair<string, string>("devtools.page.trace", "Trace"),
				new KeyValuePair<string, string>("devtools.plugin.section.overview", "Overview"),
				new KeyValuePair<string, string>("devtools.plugin.section.devtools", "Devtools"),
				new KeyValuePair<string, string>("devtools.plugin.section.runtime", "Runtime"),
				new KeyValuePair<string, string>("devtools.plugin.section.status", "Status"),
				new KeyValuePair<string, string>("devtools.plugin.row.plugin_version", "Plugin Version"),
				new KeyValuePair<string, string>("devtools.plugin.row.current_language", "Current Language"),
				new KeyValuePair<string, string>("devtools.plugin.row.remote_snapshot", "Remote Snapshot"),
				new KeyValuePair<string, string>("devtools.plugin.row.overlay_enabled", "Overlay Enabled"),
				new KeyValuePair<string, string>("devtools.plugin.row.toggle_shortcut", "Toggle Shortcut"),
				new KeyValuePair<string, string>("devtools.plugin.row.close_actions", "Close Actions"),
				new KeyValuePair<string, string>("devtools.plugin.row.translation_enabled", "Translation Enabled"),
				new KeyValuePair<string, string>("devtools.plugin.row.debug_enabled", "Debug Enabled"),
				new KeyValuePair<string, string>("devtools.plugin.row.whole_string_longest_match_mode", "Whole String Longest Match Mode"),
				new KeyValuePair<string, string>("devtools.plugin.row.minimum_match_length", "Minimum Match Length"),
				new KeyValuePair<string, string>("devtools.plugin.row.trace_feed_capacity", "Trace Feed Capacity"),
				new KeyValuePair<string, string>("devtools.plugin.row.hot_update", "Hot Update"),
				new KeyValuePair<string, string>("devtools.plugin.row.shortcut_capture", "Shortcut Capture"),
				new KeyValuePair<string, string>("devtools.plugin.row.last_config_action", "Last Config Action"),
				new KeyValuePair<string, string>("devtools.plugin.action.capture", "Capture"),
				new KeyValuePair<string, string>("devtools.plugin.action.next", "Next"),
				new KeyValuePair<string, string>("devtools.plugin.action.prev", "Prev"),
				new KeyValuePair<string, string>("devtools.plugin.action.reset", "Reset"),
				new KeyValuePair<string, string>("devtools.plugin.action.toggle", "Toggle"),
				new KeyValuePair<string, string>("devtools.plugin.close_actions_value", "ESC"),
				new KeyValuePair<string, string>("devtools.plugin.hot_update_value", "Immediate"),
				new KeyValuePair<string, string>("devtools.plugin.shortcut.capture_prompt", "Press a new shortcut..."),
				new KeyValuePair<string, string>("devtools.plugin.shortcut.listening", "Listening (ESC cancels)"),
				new KeyValuePair<string, string>("devtools.plugin.shortcut.idle", "Idle"),
				new KeyValuePair<string, string>("devtools.plugin.status.ready", "Ready"),
				new KeyValuePair<string, string>("devtools.plugin.status.capture_cancelled", "Shortcut capture cancelled."),
				new KeyValuePair<string, string>("devtools.plugin.status.capture_started", "Press the new toggle shortcut. ESC cancels."),
				new KeyValuePair<string, string>("devtools.plugin.status.toggle_shortcut_updated", "Toggle Shortcut -> {0}"),
				new KeyValuePair<string, string>("devtools.plugin.status.overlay_enabled_updated", "Overlay Enabled -> {0}"),
				new KeyValuePair<string, string>("devtools.plugin.status.translation_enabled_updated", "Translation Enabled -> {0}"),
				new KeyValuePair<string, string>("devtools.plugin.status.debug_enabled_updated", "Debug Enabled -> {0}"),
				new KeyValuePair<string, string>("devtools.plugin.status.whole_string_longest_match_mode_updated", "Whole String Longest Match Mode -> {0}"),
				new KeyValuePair<string, string>("devtools.plugin.status.min_length_updated", "Minimum Match Length -> {0}"),
				new KeyValuePair<string, string>("devtools.plugin.status.trace_feed_capacity_updated", "Trace Feed Capacity -> {0}"),
				new KeyValuePair<string, string>("devtools.plugin.status.setting_failed", "{0} update failed: {1}"),
				new KeyValuePair<string, string>("devtools.plugin.mode.off", "Off"),
				new KeyValuePair<string, string>("devtools.plugin.mode.min_length", "Min Length"),
				new KeyValuePair<string, string>("devtools.plugin.mode.per_word", "Per Word"),
				new KeyValuePair<string, string>("devtools.performance.section.loaded_content", "Loaded Content"),
				new KeyValuePair<string, string>("devtools.performance.section.hot_path", "Hot Path"),
				new KeyValuePair<string, string>("devtools.performance.section.caches", "Caches"),
				new KeyValuePair<string, string>("devtools.performance.section.timings", "Timings"),
				new KeyValuePair<string, string>("devtools.performance.row.exact_rules", "Exact Rules"),
				new KeyValuePair<string, string>("devtools.performance.row.template_rules", "Template Rules"),
				new KeyValuePair<string, string>("devtools.performance.row.local_english_files", "Local English Files"),
				new KeyValuePair<string, string>("devtools.performance.row.synced_english_files", "Synced English Files"),
				new KeyValuePair<string, string>("devtools.performance.row.local_active_files", "Local Active Files"),
				new KeyValuePair<string, string>("devtools.performance.row.synced_active_files", "Synced Active Files"),
				new KeyValuePair<string, string>("devtools.performance.row.intercepts", "Intercepts"),
				new KeyValuePair<string, string>("devtools.performance.row.reuse_hits", "Reuse Hits"),
				new KeyValuePair<string, string>("devtools.performance.row.reuse_hit_rate", "Reuse Hit Rate"),
				new KeyValuePair<string, string>("devtools.performance.row.known_output_skips", "Known Output Skips"),
				new KeyValuePair<string, string>("devtools.performance.row.known_output_skip_rate", "Known Output Skip Rate"),
				new KeyValuePair<string, string>("devtools.performance.row.translation_cache_hits", "Translation Cache Hits"),
				new KeyValuePair<string, string>("devtools.performance.row.translation_cache_calls", "Translation Cache Calls"),
				new KeyValuePair<string, string>("devtools.performance.row.translation_cache_hit_rate", "Translation Cache Rate"),
				new KeyValuePair<string, string>("devtools.performance.row.translation_miss_cache_hits", "Miss Cache Hits"),
				new KeyValuePair<string, string>("devtools.performance.row.translation_miss_cache_calls", "Miss Cache Calls"),
				new KeyValuePair<string, string>("devtools.performance.row.miss_cache_hit_rate", "Miss Cache Rate"),
				new KeyValuePair<string, string>("devtools.performance.row.normalizer_cache_hits", "Normalizer Cache Hits"),
				new KeyValuePair<string, string>("devtools.performance.row.normalizer_cache_calls", "Normalizer Cache Calls"),
				new KeyValuePair<string, string>("devtools.performance.row.normalizer_cache_hit_rate", "Normalizer Cache Rate"),
				new KeyValuePair<string, string>("devtools.performance.row.avg_template_candidates", "Avg Template Candidates"),
				new KeyValuePair<string, string>("devtools.performance.row.translation_cache", "Translation Cache"),
				new KeyValuePair<string, string>("devtools.performance.row.translation_miss_cache", "Translation Miss Cache"),
				new KeyValuePair<string, string>("devtools.performance.row.placeholder_cache", "Placeholder Cache"),
				new KeyValuePair<string, string>("devtools.performance.row.placeholder_miss_cache", "Placeholder Miss Cache"),
				new KeyValuePair<string, string>("devtools.performance.row.runtime_evictions", "Runtime Evictions"),
				new KeyValuePair<string, string>("devtools.performance.row.resolver_evictions", "Resolver Evictions"),
				new KeyValuePair<string, string>("devtools.performance.row.avg_intercept", "Avg Intercept"),
				new KeyValuePair<string, string>("devtools.performance.row.avg_translate", "Avg Translate"),
				new KeyValuePair<string, string>("devtools.performance.row.avg_normalize", "Avg Normalize"),
				new KeyValuePair<string, string>("devtools.performance.row.avg_template", "Avg Template"),
				new KeyValuePair<string, string>("devtools.performance.row.avg_whole_string_longest_match", "Avg Whole String Longest Match"),
				new KeyValuePair<string, string>("devtools.performance.row.template_attempts", "Template Attempts"),
				new KeyValuePair<string, string>("devtools.performance.row.template_matches", "Template Hits"),
				new KeyValuePair<string, string>("devtools.performance.row.template_constrained", "Template Constrained"),
				new KeyValuePair<string, string>("devtools.performance.row.whole_string_longest_match_attempts", "Whole String Longest Match Attempts"),
				new KeyValuePair<string, string>("devtools.performance.row.whole_string_longest_match_matches", "Whole String Longest Match Hits"),
				new KeyValuePair<string, string>("devtools.performance.row.metrics", "Metrics"),
				new KeyValuePair<string, string>("devtools.performance.status.cumulative", "Cumulative since startup"),
				new KeyValuePair<string, string>("devtools.performance.status.reset_now", "Reset just now"),
				new KeyValuePair<string, string>("devtools.performance.value.count", "Count"),
				new KeyValuePair<string, string>("devtools.performance.value.hit", "Hit"),
				new KeyValuePair<string, string>("devtools.performance.value.total", "Total"),
				new KeyValuePair<string, string>("devtools.performance.value.rate", "Rate"),
				new KeyValuePair<string, string>("devtools.performance.value.attempts", "Attempts"),
				new KeyValuePair<string, string>("devtools.performance.value.matches", "Matches"),
				new KeyValuePair<string, string>("devtools.performance.value.constrained", "Constrained"),
				new KeyValuePair<string, string>("devtools.trace.section.how_to_use", "How To Use"),
				new KeyValuePair<string, string>("devtools.trace.section.overview", "Overview"),
				new KeyValuePair<string, string>("devtools.trace.header.feed", "Trace Feed"),
				new KeyValuePair<string, string>("devtools.trace.header.analysis", "Translation Analysis"),
				new KeyValuePair<string, string>("devtools.trace.header.selected_source", "Selected Source"),
				new KeyValuePair<string, string>("devtools.trace.analysis.status.hit", "Hit"),
				new KeyValuePair<string, string>("devtools.trace.analysis.status.miss", "Miss"),
				new KeyValuePair<string, string>("devtools.trace.analysis.status.not_executed", "Not Executed"),
				new KeyValuePair<string, string>("devtools.trace.button.start_feed", "Start Feed"),
				new KeyValuePair<string, string>("devtools.trace.button.stop_feed", "Stop Feed"),
				new KeyValuePair<string, string>("devtools.trace.button.copy_input", "Copy Input"),
				new KeyValuePair<string, string>("devtools.trace.button.copy_report", "Copy Report"),
				new KeyValuePair<string, string>("devtools.trace.report.title", "Translation Analysis Report"),
				new KeyValuePair<string, string>("devtools.trace.feed.status", "Feed: {0}  |  Unique: {1} / {2}"),
				new KeyValuePair<string, string>("devtools.trace.feed.unique_count", "Unique Strings: {0} / {1}"),
				new KeyValuePair<string, string>("devtools.trace.search.placeholder", "Search captured strings or sources..."),
				new KeyValuePair<string, string>("devtools.trace.overview.input", "Input: {0}"),
				new KeyValuePair<string, string>("devtools.trace.overview.source", "Source: {0}"),
				new KeyValuePair<string, string>("devtools.trace.overview.output", "Current Output: {0}"),
				new KeyValuePair<string, string>("devtools.trace.usage.select", "Click a captured string on the left to run a fresh translation analysis."),
				new KeyValuePair<string, string>("devtools.trace.usage.replay", "The analysis always replays the translation flow live for the selected input."),
				new KeyValuePair<string, string>("devtools.trace.usage.capacity", "Feed only stores unique strings and stops at {0} entries."),
				new KeyValuePair<string, string>("devtools.trace.source.empty", "Select a captured string to inspect its source."),
				new KeyValuePair<string, string>("devtools.trace.ui.truncated_suffix", "... [truncated in UI]"),
				new KeyValuePair<string, string>("devtools.browser.header.navigator", "Translation Browser"),
				new KeyValuePair<string, string>("devtools.browser.header.details", "File Details"),
				new KeyValuePair<string, string>("devtools.browser.search.placeholder", "Search file path, match, or replace..."),
				new KeyValuePair<string, string>("devtools.browser.status.results", "Showing {0} / {1} files"),
				new KeyValuePair<string, string>("devtools.browser.status.selection", "{0}  |  {1} exact / {2} template"),
				new KeyValuePair<string, string>("devtools.browser.source.local", "Local"),
				new KeyValuePair<string, string>("devtools.browser.source.server", "Server"),
				new KeyValuePair<string, string>("devtools.browser.empty.no_results", "No translation files matched the current search."),
				new KeyValuePair<string, string>("devtools.browser.empty.no_selection", "Select a translation file on the left to inspect its rules."),
				new KeyValuePair<string, string>("devtools.browser.empty.no_rules", "This file does not contain any rules."),
				new KeyValuePair<string, string>("devtools.browser.file.summary", "{0} exact / {1} template"),
				new KeyValuePair<string, string>("devtools.browser.rule.title", "Rule #{0}"),
				new KeyValuePair<string, string>("devtools.playground.section.scenario", "Scenario"),
				new KeyValuePair<string, string>("devtools.playground.section.rule_editor", "Rule Editor"),
				new KeyValuePair<string, string>("devtools.playground.section.enabled_rules", "Enabled Rules"),
				new KeyValuePair<string, string>("devtools.playground.section.preview", "Preview"),
				new KeyValuePair<string, string>("devtools.playground.section.generated_test_set", "Generated Test Set"),
				new KeyValuePair<string, string>("devtools.playground.label.include_external_rules", "Include translation files loaded outside the Playground in the preview."),
				new KeyValuePair<string, string>("devtools.playground.label.copy_json_help", "Copy only the saved playground rules as a bare Localization rule file."),
				new KeyValuePair<string, string>("devtools.playground.field.test_input", "Test Input"),
				new KeyValuePair<string, string>("devtools.playground.field.match", "Match"),
				new KeyValuePair<string, string>("devtools.playground.field.replace", "Replace"),
				new KeyValuePair<string, string>("devtools.playground.field.summary", "Summary"),
				new KeyValuePair<string, string>("devtools.playground.field.matched_input", "Matched Input"),
				new KeyValuePair<string, string>("devtools.playground.field.rule_editor_match_preview", "Rule Editor Match Preview"),
				new KeyValuePair<string, string>("devtools.playground.field.output", "Output"),
				new KeyValuePair<string, string>("devtools.playground.field.json_preview", "JSON Preview"),
				new KeyValuePair<string, string>("devtools.playground.placeholder.test_input", "Enter text to evaluate against the active playground rule set."),
				new KeyValuePair<string, string>("devtools.playground.placeholder.match", "Exact text or template match."),
				new KeyValuePair<string, string>("devtools.playground.placeholder.replace", "Translated output for the match above."),
				new KeyValuePair<string, string>("devtools.playground.button.add_rule", "Add Rule"),
				new KeyValuePair<string, string>("devtools.playground.button.clear_rules", "Clear Rules"),
				new KeyValuePair<string, string>("devtools.playground.button.copy_json", "Copy JSON"),
				new KeyValuePair<string, string>("devtools.playground.button.remove", "Remove"),
				new KeyValuePair<string, string>("devtools.playground.button.external_rules_on", "External Rules: On"),
				new KeyValuePair<string, string>("devtools.playground.button.external_rules_off", "External Rules: Off"),
				new KeyValuePair<string, string>("devtools.playground.button.rule_type", "Rule Type: {0}"),
				new KeyValuePair<string, string>("devtools.playground.empty_rules", "No saved playground rules yet."),
				new KeyValuePair<string, string>("devtools.playground.status.ready", "Ready."),
				new KeyValuePair<string, string>("devtools.playground.status.include_external_rules_enabled", "Translation files loaded outside the Playground are now included in preview evaluation."),
				new KeyValuePair<string, string>("devtools.playground.status.include_external_rules_disabled", "Preview evaluation now uses only Playground rules."),
				new KeyValuePair<string, string>("devtools.playground.status.draft_mode_switched", "Draft mode switched to {0}."),
				new KeyValuePair<string, string>("devtools.playground.status.rule_saved", "Saved {0} rule #{1}."),
				new KeyValuePair<string, string>("devtools.playground.status.rules_cleared", "Cleared all saved playground rules."),
				new KeyValuePair<string, string>("devtools.playground.status.rule_removed", "Removed {0} rule #{1}."),
				new KeyValuePair<string, string>("devtools.playground.status.json_copied", "Copied playground JSON to clipboard."),
				new KeyValuePair<string, string>("devtools.playground.status.output_empty", "Enter input to see the translated output."),
				new KeyValuePair<string, string>("devtools.playground.status.draft_empty", "Draft empty."),
				new KeyValuePair<string, string>("devtools.playground.status.draft_incomplete", "Draft incomplete. Both match and replace are required."),
				new KeyValuePair<string, string>("devtools.playground.status.draft_invalid", "Template invalid: {0}"),
				new KeyValuePair<string, string>("devtools.playground.status.draft_ready", "Draft ready as {0}."),
				new KeyValuePair<string, string>("devtools.playground.status.no_input", "No input"),
				new KeyValuePair<string, string>("devtools.playground.status.no_match", "No Match"),
				new KeyValuePair<string, string>("devtools.playground.status.normalized_exact", "Normalized Exact"),
				new KeyValuePair<string, string>("devtools.playground.status.whole_string_longest_match", "Whole String Longest Match"),
				new KeyValuePair<string, string>("devtools.playground.status.highlight_prompt", "Enter input to see highlighted matches."),
				new KeyValuePair<string, string>("devtools.playground.summary.saved_rules", "Saved rules: {0} ({1} exact / {2} template)"),
				new KeyValuePair<string, string>("devtools.playground.summary.preview_rules_with_external", "Preview rule set: {0} exact / {1} template + external rules {2}"),
				new KeyValuePair<string, string>("devtools.playground.summary.winning_stage", "Winning stage: {0}"),
				new KeyValuePair<string, string>("devtools.playground.summary.stacked_result_winning_stage", "Stacked result winning stage: {0}"),
				new KeyValuePair<string, string>("devtools.playground.summary.match_preview_scope", "Rule editor match preview uses only the current Match field. Output remains the full stacked rule result."),
				new KeyValuePair<string, string>("devtools.playground.summary.draft", "Draft: {0}"),
				new KeyValuePair<string, string>("devtools.playground.preview.no_input", "Enter test input to preview the current rule editor match."),
				new KeyValuePair<string, string>("devtools.playground.preview.no_draft", "Fill Match and Replace to preview the current rule editor match."),
				new KeyValuePair<string, string>("devtools.playground.preview.current_match", "Current Match field: {0}"),
				new KeyValuePair<string, string>("devtools.playground.preview.applies", "Applies to current test input: {0}"),
				new KeyValuePair<string, string>("devtools.playground.preview.stage", "Draft preview stage: {0}"),
				new KeyValuePair<string, string>("devtools.playground.rule_row", "#{0} [{1}] {2} => {3}"),
				new KeyValuePair<string, string>("devtools.playground.kind.exact", "Exact"),
				new KeyValuePair<string, string>("devtools.playground.kind.template", "Template")
			};
		}

		private static Dictionary<string, string> BuildDefaultValuesByKey()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			for (int i = 0; i < DefaultEntries.Count; i++)
			{
				KeyValuePair<string, string> keyValuePair = DefaultEntries[i];
				dictionary[keyValuePair.Key] = keyValuePair.Value;
			}
			return dictionary;
		}

		private static Dictionary<string, string> BuildDefaultLegacyValuesByKey()
		{
			return new Dictionary<string, string>(StringComparer.Ordinal)
			{
				["runtime.settings.summary"] = "Runtime settings via '{0}' ({1}): translation_enabled={2}, debug={3}, whole_string_longest_match_mode={4}, whole_string_longest_match_min_length={5}.",
				["devtools.trace.usage.capacity"] = "Feed only stores unique strings and stops at 1024 entries.",
				["devtools.browser.status.selection"] = "{0} / {1} / {2}  |  {3} exact / {4} template"
			};
		}

		private static Dictionary<string, string> BuildDefaultKeysByFallback()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			for (int i = 0; i < DefaultEntries.Count; i++)
			{
				KeyValuePair<string, string> keyValuePair = DefaultEntries[i];
				if (!string.IsNullOrWhiteSpace(keyValuePair.Value) && !dictionary.ContainsKey(keyValuePair.Value))
				{
					dictionary.Add(keyValuePair.Value, keyValuePair.Key);
				}
			}
			return dictionary;
		}

		private static Dictionary<string, string> BuildTraditionalChineseValuesByKey()
		{
			return new Dictionary<string, string>(DefaultValuesByKey, StringComparer.Ordinal)
			{
				["common.no"] = "否",
				["common.off"] = "關",
				["common.on"] = "開",
				["common.yes"] = "是",
				["common.clear"] = "清除",
				["common.search"] = "搜尋",
				["common.debug.truncated_suffix"] = "... [已截斷]",
				["common.unknown"] = "<未知>",
				["plugin.loaded"] = "{0} 已載入。",
				["plugin.loaded_dedicated"] = "{0} 以專用伺服器模式載入。伺服器同步仍保持啟用；已略過翻譯執行階段與介面更新。",
				["plugin.log.devtools_not_ready"] = "本地化開發工具介面尚未就緒。",
				["plugin.log.devtools_update_failed"] = "無法從開發工具介面更新 {0}：{1}",
				["runtime.analysis.final_output"] = "最終輸出：'{0}'",
				["runtime.analysis.pass_result_loop"] = "第二輪結果：偵測到回到原始輸入的翻譯迴圈，因此保留第一輪輸出。",
				["runtime.analysis.pass_result_no_change"] = "第一輪結果：沒有任何翻譯規則改變輸入。",
				["runtime.analysis.pass_result_no_further_change"] = "第二輪結果：第一輪輸出未再被任何翻譯規則改變。",
				["runtime.analysis.pass_result_updated"] = "第二輪結果：輸出更新為 '{0}'。",
				["runtime.analysis.runtime_disabled"] = "翻譯目前已停用；分析仍會使用目前記憶體中的規則狀態。",
				["runtime.analysis.runtime_empty"] = "分析已停止，因為選取的字串是空的。",
				["runtime.analysis.runtime_not_initialized"] = "分析已停止，因為翻譯執行階段尚未初始化。",
				["runtime.analysis.runtime_pass_chain"] = "最上層流程固定跑 2 輪。額外的整句最長匹配重寫會在每輪內顯示為步驟 N。",
				["runtime.analysis.runtime_state"] = "執行階段狀態",
				["runtime.analysis.runtime_initialized"] = "執行階段已初始化：{0}",
				["runtime.analysis.translation_enabled"] = "翻譯已啟用：{0}",
				["runtime.analysis.pass_title_one"] = "第一輪",
				["runtime.analysis.pass_title_two"] = "第二輪",
				["runtime.analysis.final_title"] = "最終結果",
				["runtime.analysis.stage.exact"] = "精確匹配",
				["runtime.analysis.stage.normalized_exact"] = "正規化精確匹配",
				["runtime.analysis.stage.template"] = "樣板匹配",
				["runtime.analysis.stage.whole_string_longest_match"] = "整句最長匹配",
				["runtime.analysis.pass_stage_not_executed"] = "{0} {1}：未執行（{2} 已先產生輸出）",
				["runtime.analysis.stage_summary_output"] = "輸出：'{0}'",
				["runtime.analysis.stage_summary_miss"] = "沒有規則命中。",
				["runtime.analysis.stage_summary_not_executed"] = "已略過，因為 {0} 已先產生輸出。",
				["runtime.analysis.pass_input"] = "{0} 輸入：'{1}'",
				["runtime.analysis.pass_exact_hit"] = "{0} 精確匹配：命中 目標='{1}', 匹配='{2}', 替換='{3}', 檔案='{4}' -> '{5}'",
				["runtime.analysis.pass_exact_miss"] = "{0} 精確匹配：未命中",
				["runtime.analysis.pass_normalized_input"] = "{0} 正規化輸入：'{1}'",
				["runtime.analysis.pass_normalized_exact_hit"] = "{0} 正規化精確匹配：命中 目標='{1}', 匹配='{2}', 替換='{3}', 檔案='{4}' -> '{5}'",
				["runtime.analysis.pass_normalized_exact_miss"] = "{0} 正規化精確匹配：未命中",
				["runtime.analysis.pass_template_hit"] = "{0} 樣板匹配：命中 目標='{1}', 匹配='{2}', 替換='{3}', 檔案='{4}' -> '{5}'",
				["runtime.analysis.pass_template_miss"] = "{0} 樣板匹配：未命中",
				["runtime.analysis.pass_whole_string_longest_match_step_input"] = "{0} 整句最長匹配 step {1} 輸入：'{2}'",
				["runtime.analysis.pass_whole_string_longest_match_step_hit"] = "{0} 整句最長匹配 step {1} 命中 [{2}..{3})：目標='{4}', 匹配='{5}', 替換='{6}', 檔案='{7}'",
				["runtime.analysis.pass_whole_string_longest_match_step_output"] = "{0} 整句最長匹配 step {1} 輸出：'{2}'",
				["runtime.analysis.pass_whole_string_longest_match_loop"] = "{0} 整句最長匹配：偵測到迴圈，已保留最後一個非迴圈輸出。",
				["runtime.analysis.pass_whole_string_longest_match_final"] = "{0} 整句最長匹配：最終 -> '{1}'",
				["runtime.analysis.pass_whole_string_longest_match_matched"] = "{0} 整句最長匹配：命中 -> '{1}'",
				["runtime.analysis.pass_whole_string_longest_match_miss"] = "{0} 整句最長匹配：未命中",
				["runtime.log.config_root"] = "翻譯設定根目錄：{0}",
				["runtime.log.disabled_after_reason"] = "翻譯執行階段已停用；在 {0} 後略過規則載入。",
				["runtime.log.load_result"] = "{0} '{1}' 的翻譯規則。英文='{2}'（本地={3}, 已同步={4}），啟用='{5}'（本地={6}, 已同步={7}），精確={8}，樣板={9}。",
				["runtime.settings.read_failed"] = "無法讀取 '{0}' 的執行階段設定：{1}",
				["runtime.settings.backfill_failed"] = "無法補齊 '{0}' 中缺少的執行階段設定：{1}",
				["runtime.settings.summary"] = "'{0}' 的執行階段設定（{1}）：翻譯啟用={2}, 除錯啟用={3}, 整句最長匹配模式={4}, 最小匹配長度={5}, 追蹤資料流容量={6}。",
				["serversync.log.source_of_truth"] = "伺服器同步唯一資料來源已啟用；本機設定的熱更新目前生效。",
				["serversync.log.snapshot_published"] = "已在 {0} 後發佈本機翻譯快照：{1} 個語言資料夾、{2} 個檔案。",
				["devtools.app.title"] = "本地化開發工具",
				["devtools.page.browser"] = "翻譯瀏覽",
				["devtools.page.performance"] = "效能",
				["devtools.page.playground"] = "沙盒",
				["devtools.page.plugin"] = "插件",
				["devtools.page.trace"] = "追蹤",
				["devtools.plugin.section.overview"] = "總覽",
				["devtools.plugin.section.devtools"] = "開發工具",
				["devtools.plugin.section.runtime"] = "執行階段",
				["devtools.plugin.section.status"] = "狀態",
				["devtools.plugin.row.plugin_version"] = "插件版本",
				["devtools.plugin.row.current_language"] = "目前語言",
				["devtools.plugin.row.remote_snapshot"] = "遠端快照",
				["devtools.plugin.row.overlay_enabled"] = "覆蓋層啟用",
				["devtools.plugin.row.toggle_shortcut"] = "切換快捷鍵",
				["devtools.plugin.row.close_actions"] = "關閉方式",
				["devtools.plugin.row.translation_enabled"] = "啟用翻譯",
				["devtools.plugin.row.debug_enabled"] = "啟用除錯",
				["devtools.plugin.row.whole_string_longest_match_mode"] = "整句最長匹配模式",
				["devtools.plugin.row.minimum_match_length"] = "最小匹配長度",
				["devtools.plugin.row.trace_feed_capacity"] = "追蹤資料流容量",
				["devtools.plugin.row.hot_update"] = "熱更新",
				["devtools.plugin.row.shortcut_capture"] = "快捷鍵擷取",
				["devtools.plugin.row.last_config_action"] = "最近設定動作",
				["devtools.plugin.action.capture"] = "擷取",
				["devtools.plugin.action.next"] = "下一個",
				["devtools.plugin.action.prev"] = "上一個",
				["devtools.plugin.action.reset"] = "重設",
				["devtools.plugin.action.toggle"] = "切換",
				["devtools.plugin.hot_update_value"] = "即時",
				["devtools.plugin.shortcut.capture_prompt"] = "請按下新的快捷鍵...",
				["devtools.plugin.shortcut.listening"] = "監聽中（ESC 取消）",
				["devtools.plugin.shortcut.idle"] = "閒置",
				["devtools.plugin.status.ready"] = "就緒",
				["devtools.plugin.status.capture_cancelled"] = "快捷鍵擷取已取消。",
				["devtools.plugin.status.capture_started"] = "請按下新的切換快捷鍵。ESC 可取消。",
				["devtools.plugin.status.toggle_shortcut_updated"] = "切換快捷鍵 -> {0}",
				["devtools.plugin.status.overlay_enabled_updated"] = "覆蓋層啟用 -> {0}",
				["devtools.plugin.status.translation_enabled_updated"] = "翻譯啟用 -> {0}",
				["devtools.plugin.status.debug_enabled_updated"] = "除錯啟用 -> {0}",
				["devtools.plugin.status.whole_string_longest_match_mode_updated"] = "整句最長匹配模式 -> {0}",
				["devtools.plugin.status.min_length_updated"] = "最小匹配長度 -> {0}",
				["devtools.plugin.status.trace_feed_capacity_updated"] = "追蹤資料流容量 -> {0}",
				["devtools.plugin.status.setting_failed"] = "{0} 更新失敗：{1}",
				["devtools.plugin.mode.off"] = "關閉",
				["devtools.plugin.mode.min_length"] = "最小長度",
				["devtools.plugin.mode.per_word"] = "逐詞",
				["devtools.performance.section.loaded_content"] = "已載入內容",
				["devtools.performance.section.hot_path"] = "熱路徑",
				["devtools.performance.section.caches"] = "快取",
				["devtools.performance.section.timings"] = "耗時",
				["devtools.performance.row.exact_rules"] = "精確規則",
				["devtools.performance.row.template_rules"] = "樣板規則",
				["devtools.performance.row.local_english_files"] = "本機英文翻譯檔案",
				["devtools.performance.row.synced_english_files"] = "同步英文翻譯檔案",
				["devtools.performance.row.local_active_files"] = "本機目前翻譯語言檔案",
				["devtools.performance.row.synced_active_files"] = "同步目前翻譯語言檔案",
				["devtools.performance.row.intercepts"] = "攔截次數",
				["devtools.performance.row.reuse_hits"] = "重用命中",
				["devtools.performance.row.reuse_hit_rate"] = "重用命中比率",
				["devtools.performance.row.known_output_skips"] = "已知輸出略過",
				["devtools.performance.row.known_output_skip_rate"] = "已知輸出略過比率",
				["devtools.performance.row.translation_cache_hits"] = "翻譯快取命中",
				["devtools.performance.row.translation_cache_calls"] = "翻譯快取查詢",
				["devtools.performance.row.translation_cache_hit_rate"] = "翻譯快取比率",
				["devtools.performance.row.translation_miss_cache_hits"] = "未命中快取命中",
				["devtools.performance.row.translation_miss_cache_calls"] = "未命中快取查詢",
				["devtools.performance.row.miss_cache_hit_rate"] = "未命中快取比率",
				["devtools.performance.row.normalizer_cache_hits"] = "正規化快取命中",
				["devtools.performance.row.normalizer_cache_calls"] = "正規化快取查詢",
				["devtools.performance.row.normalizer_cache_hit_rate"] = "正規化快取比率",
				["devtools.performance.row.avg_template_candidates"] = "平均樣板候選數",
				["devtools.performance.row.translation_cache"] = "翻譯快取",
				["devtools.performance.row.translation_miss_cache"] = "翻譯為命中的快取",
				["devtools.performance.row.placeholder_cache"] = "佔位符快取",
				["devtools.performance.row.placeholder_miss_cache"] = "佔位符未命中的快取",
				["devtools.performance.row.runtime_evictions"] = "執行階段捨棄次數",
				["devtools.performance.row.resolver_evictions"] = "解析器捨棄次數",
				["devtools.performance.row.avg_intercept"] = "平均攔截耗時",
				["devtools.performance.row.avg_translate"] = "平均翻譯耗時",
				["devtools.performance.row.avg_normalize"] = "平均正規化耗時",
				["devtools.performance.row.avg_template"] = "平均樣板耗時",
				["devtools.performance.row.avg_whole_string_longest_match"] = "平均整句最長匹配耗時",
				["devtools.performance.row.template_attempts"] = "樣板嘗試次數",
				["devtools.performance.row.template_matches"] = "樣板命中次數",
				["devtools.performance.row.template_constrained"] = "樣板受限次數",
				["devtools.performance.row.whole_string_longest_match_attempts"] = "整句最長匹配嘗試次數",
				["devtools.performance.row.whole_string_longest_match_matches"] = "整句最長匹配命中次數",
				["devtools.performance.row.metrics"] = "指標",
				["devtools.performance.status.cumulative"] = "自啟動後累積",
				["devtools.performance.status.reset_now"] = "剛剛已重設",
				["devtools.performance.value.count"] = "次數",
				["devtools.performance.value.hit"] = "命中",
				["devtools.performance.value.total"] = "總數",
				["devtools.performance.value.rate"] = "比率",
				["devtools.performance.value.attempts"] = "嘗試",
				["devtools.performance.value.matches"] = "命中",
				["devtools.performance.value.constrained"] = "受限",
				["devtools.trace.section.how_to_use"] = "使用方式",
				["devtools.trace.section.overview"] = "概覽",
				["devtools.trace.header.feed"] = "追蹤紀錄",
				["devtools.trace.header.analysis"] = "翻譯分析",
				["devtools.trace.header.selected_source"] = "已選來源",
				["devtools.trace.analysis.status.hit"] = "命中",
				["devtools.trace.analysis.status.miss"] = "未命中",
				["devtools.trace.analysis.status.not_executed"] = "未執行",
				["devtools.trace.button.start_feed"] = "開始串流",
				["devtools.trace.button.stop_feed"] = "停止串流",
				["devtools.trace.button.copy_input"] = "複製輸入",
				["devtools.trace.button.copy_report"] = "複製報告",
				["devtools.trace.report.title"] = "翻譯分析報告",
				["devtools.trace.feed.status"] = "資料流：{0}  |  唯一字串：{1} / {2}",
				["devtools.trace.feed.unique_count"] = "唯一字串：{0} / {1}",
				["devtools.trace.search.placeholder"] = "搜尋已擷取字串或來源...",
				["devtools.trace.overview.input"] = "輸入：{0}",
				["devtools.trace.overview.source"] = "來源：{0}",
				["devtools.trace.overview.output"] = "目前輸出：{0}",
				["devtools.trace.usage.select"] = "點擊左側已擷取的字串，可重新執行該字串的翻譯分析。",
				["devtools.trace.usage.replay"] = "分析會即時重播所選輸入的翻譯流程。",
				["devtools.trace.usage.capacity"] = "資料流只會儲存唯一字串，最多 {0} 筆。",
				["devtools.trace.source.empty"] = "請先選取一筆已擷取字串，以檢視其來源。",
				["devtools.trace.ui.truncated_suffix"] = "... [UI 已截斷]",
				["devtools.browser.header.navigator"] = "翻譯瀏覽",
				["devtools.browser.header.details"] = "檔案內容",
				["devtools.browser.search.placeholder"] = "搜尋檔案路徑、匹配或替換...",
				["devtools.browser.status.results"] = "顯示 {0} / {1} 個檔案",
				["devtools.browser.status.selection"] = "{0}  |  {1} 筆精確 / {2} 筆樣板",
				["devtools.browser.source.local"] = "本機",
				["devtools.browser.source.server"] = "伺服器",
				["devtools.browser.empty.no_results"] = "目前搜尋條件沒有命中的翻譯檔。",
				["devtools.browser.empty.no_selection"] = "請在左側選擇翻譯檔以檢視規則內容。",
				["devtools.browser.empty.no_rules"] = "這個檔案目前沒有任何規則。",
				["devtools.browser.file.summary"] = "{0} 筆精確 / {1} 筆樣板",
				["devtools.browser.rule.title"] = "規則 #{0}",
				["devtools.playground.section.scenario"] = "情境",
				["devtools.playground.section.rule_editor"] = "規則編輯器",
				["devtools.playground.section.enabled_rules"] = "啟用規則",
				["devtools.playground.section.preview"] = "預覽",
				["devtools.playground.section.generated_test_set"] = "產生的測試集",
				["devtools.playground.label.include_external_rules"] = "在預覽中包含沙盒以外已載入的翻譯檔。",
				["devtools.playground.label.copy_json_help"] = "只複製已儲存的沙盒規則，作為純粹的本地化規則檔。",
				["devtools.playground.field.test_input"] = "測試輸入",
				["devtools.playground.field.match"] = "匹配",
				["devtools.playground.field.replace"] = "替換",
				["devtools.playground.field.summary"] = "摘要",
				["devtools.playground.field.matched_input"] = "命中的輸入",
				["devtools.playground.field.rule_editor_match_preview"] = "規則編輯器匹配預覽",
				["devtools.playground.field.output"] = "輸出",
				["devtools.playground.field.json_preview"] = "JSON 預覽",
				["devtools.playground.placeholder.test_input"] = "輸入要用目前沙盒規則集評估的文字。",
				["devtools.playground.placeholder.match"] = "精確文字或樣板匹配。",
				["devtools.playground.placeholder.replace"] = "上方匹配對應的翻譯輸出。",
				["devtools.playground.button.add_rule"] = "新增規則",
				["devtools.playground.button.clear_rules"] = "清空規則",
				["devtools.playground.button.copy_json"] = "複製 JSON",
				["devtools.playground.button.remove"] = "移除",
				["devtools.playground.button.external_rules_on"] = "外部規則：開",
				["devtools.playground.button.external_rules_off"] = "外部規則：關",
				["devtools.playground.button.rule_type"] = "規則類型：{0}",
				["devtools.playground.empty_rules"] = "目前還沒有已儲存的沙盒規則。",
				["devtools.playground.status.ready"] = "就緒。",
				["devtools.playground.status.include_external_rules_enabled"] = "預覽評估現在會包含沙盒以外已載入的翻譯檔。",
				["devtools.playground.status.include_external_rules_disabled"] = "預覽評估現在只使用沙盒規則。",
				["devtools.playground.status.draft_mode_switched"] = "草稿模式已切換為 {0}。",
				["devtools.playground.status.rule_saved"] = "已儲存第 #{1} 條 {0} 規則。",
				["devtools.playground.status.rules_cleared"] = "已清空所有已儲存的沙盒規則。",
				["devtools.playground.status.rule_removed"] = "已移除第 #{1} 條 {0} 規則。",
				["devtools.playground.status.json_copied"] = "已將沙盒 JSON 複製到剪貼簿。",
				["devtools.playground.status.output_empty"] = "輸入文字後即可查看翻譯輸出。",
				["devtools.playground.status.draft_empty"] = "草稿為空。",
				["devtools.playground.status.draft_incomplete"] = "草稿不完整。匹配與替換都必須填寫。",
				["devtools.playground.status.draft_invalid"] = "樣板無效：{0}",
				["devtools.playground.status.draft_ready"] = "草稿已就緒，類型為 {0}。",
				["devtools.playground.status.no_input"] = "沒有輸入",
				["devtools.playground.status.no_match"] = "未命中",
				["devtools.playground.status.normalized_exact"] = "正規化精確匹配",
				["devtools.playground.status.whole_string_longest_match"] = "整句最長匹配",
				["devtools.playground.status.highlight_prompt"] = "輸入文字後即可查看高亮命中結果。",
				["devtools.playground.summary.saved_rules"] = "已儲存規則：{0}（{1} 筆精確 / {2} 筆樣板）",
				["devtools.playground.summary.preview_rules_with_external"] = "預覽規則集：{0} 筆精確 / {1} 筆樣板 + 外部規則 {2}",
				["devtools.playground.summary.winning_stage"] = "命中階段：{0}",
				["devtools.playground.summary.stacked_result_winning_stage"] = "疊加結果命中階段：{0}",
				["devtools.playground.summary.match_preview_scope"] = "規則編輯器匹配預覽只會使用目前的 Match 欄位；Output 仍然是完整疊加規則後的結果。",
				["devtools.playground.summary.draft"] = "草稿：{0}",
				["devtools.playground.preview.no_input"] = "輸入測試文字後，即可預覽目前規則編輯器的匹配結果。",
				["devtools.playground.preview.no_draft"] = "填寫 Match 與 Replace 後，即可預覽目前規則編輯器的匹配結果。",
				["devtools.playground.preview.current_match"] = "目前 Match 欄位：{0}",
				["devtools.playground.preview.applies"] = "是否套用到目前測試輸入：{0}",
				["devtools.playground.preview.stage"] = "草稿預覽階段：{0}",
				["devtools.playground.rule_row"] = "#{0} [{1}] {2} => {3}",
				["devtools.playground.kind.exact"] = "精確",
				["devtools.playground.kind.template"] = "樣板"
			};
		}

		private static Dictionary<string, string> BuildTraditionalChineseLegacyValuesByKey()
		{
			return new Dictionary<string, string>(StringComparer.Ordinal)
			{
				["plugin.log.devtools_not_ready"] = "本地化開發工具介面尚未就緒。",
				["devtools.app.title"] = "本地化開發工具",
				["devtools.playground.label.include_external_rules"] = "在預覽中包含沙盒以外已載入的翻譯檔。",
				["devtools.playground.label.copy_json_help"] = "只複製已儲存的沙盒規則，作為純粹的本地化規則檔。",
				["devtools.playground.placeholder.match"] = "精確文字或樣板匹配。",
				["devtools.playground.placeholder.replace"] = "上方匹配對應的翻譯輸出。",
				["devtools.playground.empty_rules"] = "目前還沒有已儲存的沙盒規則。",
				["devtools.playground.status.include_external_rules_enabled"] = "預覽評估現在會包含沙盒以外已載入的翻譯檔。",
				["devtools.playground.status.include_external_rules_disabled"] = "預覽評估現在只使用沙盒規則。",
				["devtools.playground.summary.saved_rules"] = "已儲存規則：{0}（{1} 條精確 / {2} 條樣板",
				["devtools.playground.summary.preview_rules_with_external"] = "預覽規則集：{0} 條精確 / {1} 條樣板ˋ + 外部規則 {2}",
				["runtime.settings.summary"] = "'{0}' 的執行階段設定（{1}）：翻譯啟用={2}, 除錯啟用={3}, 整句最長匹配模式={4}, 最小匹配長度={5}。",
				["devtools.trace.usage.capacity"] = "資料流只會儲存唯一字串，最多 1024 筆。",
				["devtools.browser.status.selection"] = "{0} / {1} / {2}  |  {3} 筆精確 / {4} 筆樣板"
			};
		}
	}
	[BepInPlugin("com.paxton0505.localization", "Localization", "2.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class PluginMain : BaseUnityPlugin
	{
		private const int MaxDebugTextLength = 4096;

		public const string PluginGuid = "com.paxton0505.localization";

		public const string PluginName = "Localization";

		public const string PluginVersion = "2.0.1";

		private Harmony harmony;

		internal static ManualLogSource Log { get; private set; }

		internal static bool IsDedicatedServer { get; private set; }

		internal static bool DebugModeEnabled => RuntimeDebugConfig.Enabled;

		internal static void DebugLog(string message)
		{
			if (DebugModeEnabled && Log != null)
			{
				Log.LogInfo((object)("[Debug] " + LocalizeFallback(message)));
			}
		}

		internal static void DebugLog(Func<string> messageFactory)
		{
			if (DebugModeEnabled && Log != null && messageFactory != null)
			{
				Log.LogInfo((object)("[Debug] " + LocalizeFallback(messageFactory())));
			}
		}

		internal static string Localize(string key, string fallback)
		{
			return PluginLocalization.Get(key, fallback);
		}

		internal static string LocalizeFallback(string fallback)
		{
			return PluginLocalization.TranslateFallback(fallback);
		}

		internal static string LocalizeFormat(string key, string fallback, params object[] args)
		{
			return PluginLocalization.Format(key, fallback, args);
		}

		internal static string FormatTextForDebug(string value)
		{
			if (value == null)
			{
				return Localize("common.debug.null", "<null>");
			}
			string text = value.Replace("\\", "\\\\").Replace("\r", "\\r").Replace("\n", "\\n");
			if (text.Length <= 4096)
			{
				return text;
			}
			return text.Substring(0, 4096) + Localize("common.debug.truncated_suffix", "... [truncated]");
		}

		private void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			IsDedicatedServer = Application.isBatchMode || (int)SystemInfo.graphicsDeviceType == 4;
			PluginLocalization.Initialize();
			RuntimeDebugConfig.Initialize();
			TranslationServerSyncBridge.Initialize();
			if (IsDedicatedServer)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)LocalizeFormat("plugin.loaded_dedicated", "{0} loaded in dedicated server mode. ServerSync remains active; translation runtime and UI patches are skipped.", "Localization"));
				return;
			}
			TranslationRuntime.Initialize();
			harmony = new Harmony("com.paxton0505.localization");
			harmony.PatchAll();
			DevToolsBootstrap.Initialize(this);
			((BaseUnityPlugin)this).Logger.LogInfo((object)LocalizeFormat("plugin.loaded", "{0} loaded.", "Localization"));
		}

		private void OnDestroy()
		{
			DevToolsBootstrap.Shutdown();
			TranslationServerSyncBridge.Shutdown();
			RuntimeDebugConfig.Shutdown();
			PluginLocalization.Shutdown();
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
	}
	[Serializable]
	internal sealed class RuleFileModel
	{
		public ExactRuleDefinition[] exact = Array.Empty<ExactRuleDefinition>();

		public TemplateRuleDefinition[] templates = Array.Empty<TemplateRuleDefinition>();
	}
	[Serializable]
	internal sealed class ExactRuleDefinition
	{
		public string match = string.Empty;

		public string replace = string.Empty;
	}
	[Serializable]
	internal sealed class TemplateRuleDefinition
	{
		public string match = string.Empty;

		public string replace = string.Empty;
	}
	internal sealed class CompiledRuleSet
	{
		private readonly struct GreedyExactRule
		{
			public string Match { get; }

			public string OriginalMatch { get; }

			public string Replace { get; }

			public string SourcePath { get; }

			public int WordCharacterCount { get; }

			public GreedyExactRule(string match, string originalMatch, string replace, string sourcePath)
			{
				Match = match;
				OriginalMatch = (string.IsNullOrEmpty(originalMatch) ? match : originalMatch);
				Replace = replace;
				SourcePath = sourcePath ?? string.Empty;
				WordCharacterCount = CountWordCharacters(match);
			}
		}

		private readonly struct GreedyExactMatch
		{
			public int StartIndex { get; }

			public int EndIndex => StartIndex + Rule.Match.Length;

			public GreedyExactRule Rule { get; }

			public GreedyExactMatch(int startIndex, GreedyExactRule rule)
			{
				StartIndex = startIndex;
				Rule = rule;
			}
		}

		private const int MinimumDispatchLiteralLength = 2;

		[ThreadStatic]
		private static HashSet<char> anchorVisitedCharactersScratch;

		[ThreadStatic]
		private static List<GreedyExactMatch> greedyAllMatchesScratch;

		[ThreadStatic]
		private static List<GreedyExactMatch> greedySelectedMatchesScratch;

		[ThreadStatic]
		private static bool[] greedyOccupiedScratch;

		[ThreadStatic]
		private static List<CompiledTemplateRule> templateCandidateScratch;

		[ThreadStatic]
		private static HashSet<CompiledTemplateRule> templateCandidateSeenScratch;

		private readonly Dictionary<char, List<string>> prefixKeysByFirstCharacter = new Dictionary<char, List<string>>();

		private readonly Dictionary<char, List<string>> anchorKeysByFirstCharacter = new Dictionary<char, List<string>>();

		private readonly Dictionary<char, List<GreedyExactRule>> greedyExactRulesByFirstCharacter = new Dictionary<char, List<GreedyExactRule>>();

		public static readonly CompiledRuleSet Empty = new CompiledRuleSet(new Dictionary<string, string>(0, StringComparer.Ordinal), new Dictionary<string, string>(0, StringComparer.OrdinalIgnoreCase), new List<CompiledTemplateRule>(0));

		public Dictionary<string, string> ExactRules { get; }

		public Dictionary<string, string> MatchNormalizedExactRules { get; }

		public Dictionary<string, string> MatchNormalizedExactOriginalMatches { get; }

		public Dictionary<string, RuleTraceMetadata> ExactRuleMetadata { get; }

		public Dictionary<string, RuleTraceMetadata> NormalizedExactRuleMetadata { get; }

		public List<CompiledTemplateRule> TemplateRules { get; }

		public Dictionary<string, List<CompiledTemplateRule>> TemplateRulesByPrefix { get; }

		public Dictionary<string, List<CompiledTemplateRule>> TemplateRulesByAnchor { get; }

		public List<CompiledTemplateRule> FallbackTemplateRules { get; }

		public CompiledRuleSet(Dictionary<string, string> exactRules, Dictionary<string, string> englishExactRulesIgnoreCase, List<CompiledTemplateRule> templateRules)
			: this(exactRules, englishExactRulesIgnoreCase, BuildOriginalNormalizedExactMatches(englishExactRulesIgnoreCase), BuildExactRuleMetadata(exactRules), BuildNormalizedExactRuleMetadata(englishExactRulesIgnoreCase, null), templateRules)
		{
		}

		public CompiledRuleSet(Dictionary<string, string> exactRules, Dictionary<string, string> englishExactRulesIgnoreCase, Dictionary<string, string> originalNormalizedExactMatches, List<CompiledTemplateRule> templateRules)
			: this(exactRules, englishExactRulesIgnoreCase, originalNormalizedExactMatches, BuildExactRuleMetadata(exactRules), BuildNormalizedExactRuleMetadata(englishExactRulesIgnoreCase, originalNormalizedExactMatches), templateRules)
		{
		}

		public CompiledRuleSet(Dictionary<string, string> exactRules, Dictionary<string, string> englishExactRulesIgnoreCase, Dictionary<string, string> originalNormalizedExactMatches, Dictionary<string, RuleTraceMetadata> exactRuleMetadata, Dictionary<string, RuleTraceMetadata> normalizedExactRuleMetadata, List<CompiledTemplateRule> templateRules)
		{
			ExactRules = exactRules;
			MatchNormalizedExactRules = englishExactRulesIgnoreCase;
			MatchNormalizedExactOriginalMatches = originalNormalizedExactMatches ?? BuildOriginalNormalizedExactMatches(englishExactRulesIgnoreCase);
			ExactRuleMetadata = exactRuleMetadata ?? BuildExactRuleMetadata(exactRules);
			NormalizedExactRuleMetadata = normalizedExactRuleMetadata ?? BuildNormalizedExactRuleMetadata(englishExactRulesIgnoreCase, MatchNormalizedExactOriginalMatches);
			TemplateRules = templateRules;
			TemplateRulesByPrefix = new Dictionary<string, List<CompiledTemplateRule>>(StringComparer.OrdinalIgnoreCase);
			TemplateRulesByAnchor = new Dictionary<string, List<CompiledTemplateRule>>(StringComparer.OrdinalIgnoreCase);
			FallbackTemplateRules = new List<CompiledTemplateRule>();
			BuildGreedyExactIndexes();
			BuildDispatchIndexes();
		}

		public static CompiledRuleSet CreateAdHoc(IEnumerable<RuleTraceMetadata> exactRules, IEnumerable<CompiledTemplateRule> templateRules)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			Dictionary<string, string> dictionary2 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, string> dictionary3 = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, RuleTraceMetadata> dictionary4 = new Dictionary<string, RuleTraceMetadata>(StringComparer.Ordinal);
			Dictionary<string, RuleTraceMetadata> dictionary5 = new Dictionary<string, RuleTraceMetadata>(StringComparer.OrdinalIgnoreCase);
			if (exactRules != null)
			{
				foreach (RuleTraceMetadata exactRule in exactRules)
				{
					if (exactRule != null && !string.IsNullOrWhiteSpace(exactRule.MatchText))
					{
						dictionary[exactRule.MatchText] = exactRule.ReplaceText;
						dictionary4[exactRule.MatchText] = exactRule;
						string text = TextMatchNormalizer.Normalize(exactRule.MatchText);
						if (!string.IsNullOrWhiteSpace(text))
						{
							dictionary2[text] = exactRule.ReplaceText;
							dictionary3[text] = exactRule.MatchText;
							dictionary5[text] = exactRule;
						}
					}
				}
			}
			List<CompiledTemplateRule> templateRules2 = ((templateRules != null) ? new List<CompiledTemplateRule>(templateRules) : new List<CompiledTemplateRule>());
			return new CompiledRuleSet(dictionary, dictionary2, dictionary3, dictionary4, dictionary5, templateRules2);
		}

		public bool TryGetOriginalNormalizedExactMatch(string normalizedMatch, out string originalMatch)
		{
			originalMatch = null;
			if (string.IsNullOrWhiteSpace(normalizedMatch) || MatchNormalizedExactOriginalMatches == null)
			{
				return false;
			}
			return MatchNormalizedExactOriginalMatches.TryGetValue(normalizedMatch, out originalMatch);
		}

		public bool TryGetExactRuleMetadata(string match, out RuleTraceMetadata metadata)
		{
			metadata = null;
			if (!string.IsNullOrWhiteSpace(match) && ExactRuleMetadata != null)
			{
				return ExactRuleMetadata.TryGetValue(match, out metadata);
			}
			return false;
		}

		public bool TryGetNormalizedExactRuleMetadata(string normalizedMatch, out RuleTraceMetadata metadata)
		{
			metadata = null;
			if (!string.IsNullOrWhiteSpace(normalizedMatch) && NormalizedExactRuleMetadata != null)
			{
				return NormalizedExactRuleMetadata.TryGetValue(normalizedMatch, out metadata);
			}
			return false;
		}

		public bool TryTranslateGreedyExact(string input, out string translated)
		{
			return TryTranslateGreedyExact(TextMatchNormalizer.Analyze(input), out translated);
		}

		public bool TryTranslateGreedyExact(TextMatchNormalizer.NormalizedText normalizedInput, out string translated)
		{
			List<GreedyExactAnalysisStep> analysisSteps;
			bool loopDetected;
			return TryTranslateGreedyExactCore(normalizedInput, captureAnalysis: false, out translated, out analysisSteps, out loopDetected);
		}

		public bool TryAnalyzeGreedyExact(TextMatchNormalizer.NormalizedText normalizedInput, out GreedyExactAnalysisResult analysis)
		{
			string translated;
			List<GreedyExactAnalysisStep> analysisSteps;
			bool loopDetected;
			bool result = TryTranslateGreedyExactCore(normalizedInput, captureAnalysis: true, out translated, out analysisSteps, out loopDetected);
			analysis = new GreedyExactAnalysisResult(translated, loopDetected, (analysisSteps != null) ? analysisSteps.ToArray() : Array.Empty<GreedyExactAnalysisStep>());
			return result;
		}

		private bool TryTranslateGreedyExactCore(TextMatchNormalizer.NormalizedText normalizedInput, bool captureAnalysis, out string translated, out List<GreedyExactAnalysisStep> analysisSteps, out bool loopDetected)
		{
			string current = normalizedInput.RawText;
			translated = current;
			loopDetected = false;
			analysisSteps = (captureAnalysis ? new List<GreedyExactAnalysisStep>() : null);
			if (greedyExactRulesByFirstCharacter.Count == 0)
			{
				return false;
			}
			bool flag = false;
			string initialState = current;
			HashSet<string> hashSet = null;
			TextMatchNormalizer.NormalizedText normalizedInput2 = normalizedInput;
			List<GreedyExactMatch> selectedMatches;
			while (!string.IsNullOrEmpty(normalizedInput2.Value) && TrySelectGreedyExactMatches(normalizedInput2.Value, out selectedMatches))
			{
				string text = ApplyGreedyExactMatches(normalizedInput2, selectedMatches);
				if (string.Equals(text, current, StringComparison.Ordinal))
				{
					break;
				}
				if (captureAnalysis && analysisSteps != null)
				{
					analysisSteps.Add(CreateGreedyExactAnalysisStep(normalizedInput2, current, text, selectedMatches));
				}
				if (string.Equals(text, initialState, StringComparison.Ordinal))
				{
					loopDetected = true;
					PluginMain.DebugLog(() => "Detected whole string longest match translation loop while translating '" + PluginMain.FormatTextForDebug(initialState) + "'. Returning '" + PluginMain.FormatTextForDebug(current) + "'.");
					break;
				}
				if (hashSet != null)
				{
					if (!hashSet.Add(text))
					{
						loopDetected = true;
						PluginMain.DebugLog(() => "Detected whole string longest match translation loop while translating '" + PluginMain.FormatTextForDebug(initialState) + "'. Returning '" + PluginMain.FormatTextForDebug(current) + "'.");
						break;
					}
				}
				else if (flag)
				{
					hashSet = new HashSet<string>(StringComparer.Ordinal) { initialState, current };
					if (!hashSet.Add(text))
					{
						loopDetected = true;
						PluginMain.DebugLog(() => "Detected whole string longest match translation loop while translating '" + PluginMain.FormatTextForDebug(initialState) + "'. Returning '" + PluginMain.FormatTextForDebug(current) + "'.");
						break;
					}
				}
				current = text;
				normalizedInput2 = TextMatchNormalizer.Analyze(current);
				flag = true;
			}
			if (!flag)
			{
				if (analysisSteps != null)
				{
					analysisSteps.Clear();
				}
				return false;
			}
			translated = current;
			return true;
		}

		public IReadOnlyList<CompiledTemplateRule> GetTemplateCandidates(string normalizedInput)
		{
			if (TemplateRules.Count == 0)
			{
				return TemplateRules;
			}
			if (TemplateRulesByPrefix.Count == 0 && TemplateRulesByAnchor.Count == 0)
			{
				return TemplateRules;
			}
			List<CompiledTemplateRule> singleCandidateSource = null;
			List<CompiledTemplateRule> mergedCandidates = null;
			HashSet<CompiledTemplateRule> seenCandidates = null;
			AddPrefixCandidates(normalizedInput, ref singleCandidateSource, ref mergedCandidates, ref seenCandidates);
			AddAnchorCandidates(normalizedInput, ref singleCandidateSource, ref mergedCandidates, ref seenCandidates);
			if (FallbackTemplateRules.Count > 0)
			{
				AppendCandidateSource(FallbackTemplateRules, ref singleCandidateSource, ref mergedCandidates, ref seenCandidates);
			}
			if (mergedCandidates != null)
			{
				if (mergedCandidates.Count > 1)
				{
					mergedCandidates.Sort(CompareByDispatchOrder);
				}
				return mergedCandidates;
			}
			IReadOnlyList<CompiledTemplateRule> readOnlyList = singleCandidateSource;
			return readOnlyList ?? Array.Empty<CompiledTemplateRule>();
		}

		private void BuildDispatchIndexes()
		{
			for (int i = 0; i < TemplateRules.Count; i++)
			{
				CompiledTemplateRule compiledTemplateRule = TemplateRules[i];
				compiledTemplateRule.SetDispatchOrder(i);
				if (!TryAddPrefixRule(compiledTemplateRule) && !TryAddAnchorRule(compiledTemplateRule))
				{
					FallbackTemplateRules.Add(compiledTemplateRule);
				}
			}
		}

		private void BuildGreedyExactIndexes()
		{
			foreach (KeyValuePair<string, string> matchNormalizedExactRule in MatchNormalizedExactRules)
			{
				if (!string.IsNullOrEmpty(matchNormalizedExactRule.Key))
				{
					char key = char.ToUpperInvariant(matchNormalizedExactRule.Key[0]);
					if (!greedyExactRulesByFirstCharacter.TryGetValue(key, out var value))
					{
						value = new List<GreedyExactRule>();
						greedyExactRulesByFirstCharacter[key] = value;
					}
					RuleTraceMetadata metadata;
					RuleTraceMetadata ruleTraceMetadata = (TryGetNormalizedExactRuleMetadata(matchNormalizedExactRule.Key, out metadata) ? metadata : new RuleTraceMetadata(matchNormalizedExactRule.Key, matchNormalizedExactRule.Value, null));
					value.Add(new GreedyExactRule(matchNormalizedExactRule.Key, ruleTraceMetadata.MatchText, ruleTraceMetadata.ReplaceText, ruleTraceMetadata.SourcePath));
				}
			}
			foreach (List<GreedyExactRule> value2 in greedyExactRulesByFirstCharacter.Values)
			{
				value2.Sort(CompareGreedyExactRules);
			}
		}

		private bool TrySelectGreedyExactMatches(string input, out List<GreedyExactMatch> selectedMatches)
		{
			selectedMatches = null;
			List<GreedyExactMatch> list = GetGreedyAllMatchesScratch();
			CollectGreedyExactMatches(input, list);
			if (list.Count == 0)
			{
				return false;
			}
			list.Sort(CompareGreedyExactMatches);
			bool[] occupied = GetGreedyOccupiedScratch(input.Length);
			List<GreedyExactMatch> selected = GetGreedySelectedMatchesScratch(list.Count);
			foreach (GreedyExactMatch item in list)
			{
				if (!OverlapsOccupiedRange(occupied, item.StartIndex, item.EndIndex))
				{
					selected.Add(item);
					MarkOccupiedRange(occupied, item.StartIndex, item.EndIndex);
				}
			}
			if (selected.Count == 0)
			{
				return false;
			}
			selected.Sort(CompareGreedyExactMatchesByStartIndex);
			if (PluginMain.DebugModeEnabled)
			{
				PluginMain.DebugLog(delegate
				{
					StringBuilder stringBuilder = new StringBuilder();
					stringBuilder.Append("Whole string longest match selected ");
					stringBuilder.Append(selected.Count);
					stringBuilder.Append(" match(es) for normalized input '");
					stringBuilder.Append(PluginMain.FormatTextForDebug(input));
					stringBuilder.Append("': ");
					for (int i = 0; i < selected.Count; i++)
					{
						if (i > 0)
						{
							stringBuilder.Append(" | ");
						}
						GreedyExactMatch greedyExactMatch = selected[i];
						stringBuilder.Append('[');
						stringBuilder.Append(greedyExactMatch.StartIndex);
						stringBuilder.Append("..");
						stringBuilder.Append(greedyExactMatch.EndIndex);
						stringBuilder.Append("] '");
						stringBuilder.Append(PluginMain.FormatTextForDebug(input.Substring(greedyExactMatch.StartIndex, greedyExactMatch.Rule.Match.Length)));
						stringBuilder.Append("' -> '");
						stringBuilder.Append(PluginMain.FormatTextForDebug(greedyExactMatch.Rule.Replace));
						stringBuilder.Append('\'');
					}
					return stringBuilder.ToString();
				});
			}
			selectedMatches = selected;
			return true;
		}

		private void CollectGreedyExactMatches(string input, List<GreedyExactMatch> matches)
		{
			for (int i = 0; i < input.Length; i++)
			{
				char key = char.ToUpperInvariant(input[i]);
				if (!greedyExactRulesByFirstCharacter.TryGetValue(key, out var value))
				{
					continue;
				}
				foreach (GreedyExactRule item in value)
				{
					if (i + item.Match.Length <= input.Length && string.Compare(input, i, item.Match, 0, item.Match.Length, StringComparison.OrdinalIgnoreCase) == 0 && IsGreedyExactMatchAllowed(input, i, item))
					{
						matches.Add(new GreedyExactMatch(i, item));
					}
				}
			}
		}

		private static bool IsGreedyExactMatchAllowed(string input, int startIndex, GreedyExactRule rule)
		{
			return RuntimeDebugConfig.GreedyExactMatchMode switch
			{
				WholeStringGreedyExactMatchMode.Off => true, 
				WholeStringGreedyExactMatchMode.MinLength => rule.WordCharacterCount >= RuntimeDebugConfig.GreedyExactMinimumMatchLength, 
				_ => IsWholeWordMatch(input, startIndex, rule), 
			};
		}

		private static bool IsWholeWordMatch(string input, int startIndex, GreedyExactRule rule)
		{
			if (rule.WordCharacterCount <= 0)
			{
				return false;
			}
			int num = startIndex + rule.Match.Length;
			if (startIndex > 0 && IsWordCharacter(input[startIndex - 1]) && IsWordCharacter(input[startIndex]))
			{
				return false;
			}
			if (num < input.Length && IsWordCharacter(input[num - 1]) && IsWordCharacter(input[num]))
			{
				return false;
			}
			return true;
		}

		private static int CountWordCharacters(string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < input.Length; i++)
			{
				if (IsWordCharacter(input[i]))
				{
					num++;
				}
			}
			return num;
		}

		private static bool IsWordCharacter(char character)
		{
			return char.IsLetterOrDigit(character);
		}

		private static bool OverlapsOccupiedRange(bool[] occupied, int startIndex, int endIndex)
		{
			for (int i = startIndex; i < endIndex; i++)
			{
				if (occupied[i])
				{
					return true;
				}
			}
			return false;
		}

		private static void MarkOccupiedRange(bool[] occupied, int startIndex, int endIndex)
		{
			for (int i = startIndex; i < endIndex; i++)
			{
				occupied[i] = true;
			}
		}

		private static string ApplyGreedyExactMatches(TextMatchNormalizer.NormalizedText normalizedInput, List<GreedyExactMatch> selectedMatches)
		{
			TextMatchNormalizer.ReplacementSegment[] array = new TextMatchNormalizer.ReplacementSegment[selectedMatches.Count];
			for (int i = 0; i < selectedMatches.Count; i++)
			{
				GreedyExactMatch greedyExactMatch = selectedMatches[i];
				array[i] = new TextMatchNormalizer.ReplacementSegment(greedyExactMatch.StartIndex, greedyExactMatch.Rule.Match.Length, greedyExactMatch.Rule.Replace);
			}
			return normalizedInput.ReplaceNormalizedRanges(array);
		}

		private static GreedyExactAnalysisStep CreateGreedyExactAnalysisStep(TextMatchNormalizer.NormalizedText normalizedInput, string input, string output, List<GreedyExactMatch> selectedMatches)
		{
			GreedyExactAnalysisMatch[] array = new GreedyExactAnalysisMatch[selectedMatches.Count];
			for (int i = 0; i < selectedMatches.Count; i++)
			{
				GreedyExactMatch greedyExactMatch = selectedMatches[i];
				string inputSegment = normalizedInput.Value.Substring(greedyExactMatch.StartIndex, greedyExactMatch.Rule.Match.Length);
				array[i] = new GreedyExactAnalysisMatch(greedyExactMatch.StartIndex, greedyExactMatch.EndIndex, inputSegment, greedyExactMatch.Rule.OriginalMatch, greedyExactMatch.Rule.Replace, greedyExactMatch.Rule.SourcePath);
			}
			return new GreedyExactAnalysisStep(input, output, array);
		}

		private bool TryAddPrefixRule(CompiledTemplateRule rule)
		{
			string leadingLiteralPrefix = rule.LeadingLiteralPrefix;
			if (string.IsNullOrEmpty(leadingLiteralPrefix) || leadingLiteralPrefix.Length < 2)
			{
				return false;
			}
			AddBucketRule(TemplateRulesByPrefix, prefixKeysByFirstCharacter, leadingLiteralPrefix, rule);
			return true;
		}

		private bool TryAddAnchorRule(CompiledTemplateRule rule)
		{
			string longestLiteralAnchor = rule.LongestLiteralAnchor;
			if (string.IsNullOrEmpty(longestLiteralAnchor) || longestLiteralAnchor.Length < 2)
			{
				return false;
			}
			AddBucketRule(TemplateRulesByAnchor, anchorKeysByFirstCharacter, longestLiteralAnchor, rule);
			return true;
		}

		private void AddPrefixCandidates(string input, ref List<CompiledTemplateRule> singleCandidateSource, ref List<CompiledTemplateRule> mergedCandidates, ref HashSet<CompiledTemplateRule> seenCandidates)
		{
			if (string.IsNullOrEmpty(input) || !prefixKeysByFirstCharacter.TryGetValue(char.ToUpperInvariant(input[0]), out var value))
			{
				return;
			}
			foreach (string item in value)
			{
				if (input.StartsWith(item, StringComparison.OrdinalIgnoreCase))
				{
					AppendCandidateSource(TemplateRulesByPrefix[item], ref singleCandidateSource, ref mergedCandidates, ref seenCandidates);
				}
			}
		}

		private void AddAnchorCandidates(string input, ref List<CompiledTemplateRule> singleCandidateSource, ref List<CompiledTemplateRule> mergedCandidates, ref HashSet<CompiledTemplateRule> seenCandidates)
		{
			if (string.IsNullOrEmpty(input) || TemplateRulesByAnchor.Count == 0)
			{
				return;
			}
			HashSet<char> hashSet = GetAnchorVisitedCharactersScratch();
			for (int i = 0; i < input.Length; i++)
			{
				char c = char.ToUpperInvariant(input[i]);
				if (!hashSet.Add(c) || !anchorKeysByFirstCharacter.TryGetValue(c, out var value))
				{
					continue;
				}
				foreach (string item in value)
				{
					if (input.IndexOf(item, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						AppendCandidateSource(TemplateRulesByAnchor[item], ref singleCandidateSource, ref mergedCandidates, ref seenCandidates);
					}
				}
			}
		}

		private static void AppendCandidateSource(List<CompiledTemplateRule> source, ref List<CompiledTemplateRule> singleCandidateSource, ref List<CompiledTemplateRule> mergedCandidates, ref HashSet<CompiledTemplateRule> seenCandidates)
		{
			if (source != null && source.Count != 0)
			{
				if (mergedCandidates != null)
				{
					AddUniqueCandidates(source, mergedCandidates, seenCandidates);
				}
				else if (singleCandidateSource == null)
				{
					singleCandidateSource = source;
				}
				else if (singleCandidateSource != source)
				{
					mergedCandidates = GetTemplateCandidateScratch(singleCandidateSource.Count + source.Count);
					seenCandidates = GetTemplateCandidateSeenScratch();
					AddUniqueCandidates(singleCandidateSource, mergedCandidates, seenCandidates);
					AddUniqueCandidates(source, mergedCandidates, seenCandidates);
					singleCandidateSource = null;
				}
			}
		}

		private static void AddUniqueCandidates(List<CompiledTemplateRule> source, List<CompiledTemplateRule> destination, HashSet<CompiledTemplateRule> seenCandidates)
		{
			for (int i = 0; i < source.Count; i++)
			{
				CompiledTemplateRule item = source[i];
				if (seenCandidates.Add(item))
				{
					destination.Add(item);
				}
			}
		}

		private static HashSet<char> GetAnchorVisitedCharactersScratch()
		{
			HashSet<char> hashSet = anchorVisitedCharactersScratch;
			if (hashSet == null)
			{
				return anchorVisitedCharactersScratch = new HashSet<char>();
			}
			hashSet.Clear();
			return hashSet;
		}

		private static List<GreedyExactMatch> GetGreedyAllMatchesScratch()
		{
			List<GreedyExactMatch> list = greedyAllMatchesScratch;
			if (list == null)
			{
				return greedyAllMatchesScratch = new List<GreedyExactMatch>();
			}
			list.Clear();
			return list;
		}

		private static List<CompiledTemplateRule> GetTemplateCandidateScratch(int capacity)
		{
			List<CompiledTemplateRule> list = templateCandidateScratch;
			if (list == null)
			{
				return templateCandidateScratch = new List<CompiledTemplateRule>(capacity);
			}
			list.Clear();
			if (list.Capacity < capacity)
			{
				list.Capacity = capacity;
			}
			return list;
		}

		private static HashSet<CompiledTemplateRule> GetTemplateCandidateSeenScratch()
		{
			HashSet<CompiledTemplateRule> hashSet = templateCandidateSeenScratch;
			if (hashSet == null)
			{
				return templateCandidateSeenScratch = new HashSet<CompiledTemplateRule>();
			}
			hashSet.Clear();
			return hashSet;
		}

		private static List<GreedyExactMatch> GetGreedySelectedMatchesScratch(int capacity)
		{
			List<GreedyExactMatch> list = greedySelectedMatchesScratch;
			if (list == null)
			{
				return greedySelectedMatchesScratch = new List<GreedyExactMatch>(capacity);
			}
			list.Clear();
			if (list.Capacity < capacity)
			{
				list.Capacity = capacity;
			}
			return list;
		}

		private static Dictionary<string, string> BuildOriginalNormalizedExactMatches(Dictionary<string, string> normalizedExactRules)
		{
			if (normalizedExactRules == null || normalizedExactRules.Count == 0)
			{
				return new Dictionary<string, string>(0, StringComparer.OrdinalIgnoreCase);
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>(normalizedExactRules.Count, StringComparer.OrdinalIgnoreCase);
			foreach (KeyValuePair<string, string> normalizedExactRule in normalizedExactRules)
			{
				if (!dictionary.ContainsKey(normalizedExactRule.Key))
				{
					dictionary.Add(normalizedExactRule.Key, normalizedExactRule.Key);
				}
			}
			return dictionary;
		}

		private static Dictionary<string, RuleTraceMetadata> BuildExactRuleMetadata(Dictionary<string, string> exactRules)
		{
			Dictionary<string, RuleTraceMetadata> dictionary = new Dictionary<string, RuleTraceMetadata>(exactRules?.Count ?? 0, StringComparer.Ordinal);
			if (exactRules == null)
			{
				return dictionary;
			}
			foreach (KeyValuePair<string, string> exactRule in exactRules)
			{
				dictionary[exactRule.Key] = new RuleTraceMetadata(exactRule.Key, exactRule.Value, null);
			}
			return dictionary;
		}

		private static Dictionary<string, RuleTraceMetadata> BuildNormalizedExactRuleMetadata(Dictionary<string, string> normalizedExactRules, Dictionary<string, string> originalMatches)
		{
			Dictionary<string, RuleTraceMetadata> dictionary = new Dictionary<string, RuleTraceMetadata>(normalizedExactRules?.Count ?? 0, StringComparer.OrdinalIgnoreCase);
			if (normalizedExactRules == null)
			{
				return dictionary;
			}
			foreach (KeyValuePair<string, string> normalizedExactRule in normalizedExactRules)
			{
				string value;
				string matchText = ((originalMatches != null && originalMatches.TryGetValue(normalizedExactRule.Key, out value)) ? value : normalizedExactRule.Key);
				dictionary[normalizedExactRule.Key] = new RuleTraceMetadata(matchText, normalizedExactRule.Value, null);
			}
			return dictionary;
		}

		private static bool[] GetGreedyOccupiedScratch(int length)
		{
			bool[] array = greedyOccupiedScratch;
			if (array == null || array.Length < length)
			{
				return greedyOccupiedScratch = new bool[length];
			}
			Array.Clear(array, 0, length);
			return array;
		}

		private static void AddBucketRule(Dictionary<string, List<CompiledTemplateRule>> buckets, Dictionary<char, List<string>> keysByFirstCharacter, string key, CompiledTemplateRule rule)
		{
			if (!buckets.TryGetValue(key, out var value))
			{
				value = (buckets[key] = new List<CompiledTemplateRule>());
				char key2 = char.ToUpperInvariant(key[0]);
				if (!keysByFirstCharacter.TryGetValue(key2, out var value2))
				{
					value2 = (keysByFirstCharacter[key2] = new List<string>());
				}
				value2.Add(key);
			}
			value.Add(rule);
		}

		private static int CompareByDispatchOrder(CompiledTemplateRule left, CompiledTemplateRule right)
		{
			return left.DispatchOrder.CompareTo(right.DispatchOrder);
		}

		private static int CompareGreedyExactRules(GreedyExactRule left, GreedyExactRule right)
		{
			int num = right.Match.Length.CompareTo(left.Match.Length);
			if (num != 0)
			{
				return num;
			}
			return string.Compare(left.Match, right.Match, StringComparison.OrdinalIgnoreCase);
		}

		private static int CompareGreedyExactMatches(GreedyExactMatch left, GreedyExactMatch right)
		{
			int num = right.Rule.Match.Length.CompareTo(left.Rule.Match.Length);
			if (num != 0)
			{
				return num;
			}
			int num2 = left.StartIndex.CompareTo(right.StartIndex);
			if (num2 != 0)
			{
				return num2;
			}
			int num3 = string.Compare(left.Rule.Match, right.Rule.Match, StringComparison.OrdinalIgnoreCase);
			if (num3 != 0)
			{
				return num3;
			}
			return string.Compare(left.Rule.Replace, right.Rule.Replace, StringComparison.Ordinal);
		}

		private static int CompareGreedyExactMatchesByStartIndex(GreedyExactMatch left, GreedyExactMatch right)
		{
			return left.StartIndex.CompareTo(right.StartIndex);
		}
	}
	internal sealed class TranslationLoadResult
	{
		public string LanguageName { get; }

		public string EnglishFolderPath { get; }

		public int LocalEnglishFileCount { get; }

		public int SyncedEnglishFileCount { get; }

		public string ActiveFolderPath { get; }

		public int LocalActiveFileCount { get; }

		public int SyncedActiveFileCount { get; }

		public int ExactRuleCount { get; }

		public int TemplateRuleCount { get; }

		public CompiledRuleSet RuleSet { get; }

		public TranslationLoadResult(string languageName, string englishFolderPath, int localEnglishFileCount, int syncedEnglishFileCount, string activeFolderPath, int localActiveFileCount, int syncedActiveFileCount, int exactRuleCount, int templateRuleCount, CompiledRuleSet ruleSet)
		{
			LanguageName = languageName;
			EnglishFolderPath = englishFolderPath;
			LocalEnglishFileCount = localEnglishFileCount;
			SyncedEnglishFileCount = syncedEnglishFileCount;
			ActiveFolderPath = activeFolderPath;
			LocalActiveFileCount = localActiveFileCount;
			SyncedActiveFileCount = syncedActiveFileCount;
			ExactRuleCount = exactRuleCount;
			TemplateRuleCount = templateRuleCount;
			RuleSet = ruleSet;
		}
	}
	internal sealed class TranslationRuntimeDiagnostics
	{
		public bool Initialized { get; }

		public string LanguageName { get; }

		public bool TranslationEnabled { get; }

		public bool DebugEnabled { get; }

		public string ConfigRootPath { get; }

		public int ExactRuleCount { get; }

		public int TemplateRuleCount { get; }

		public int LocalEnglishFileCount { get; }

		public int SyncedEnglishFileCount { get; }

		public int LocalActiveFileCount { get; }

		public int SyncedActiveFileCount { get; }

		public int TranslationCacheCount { get; }

		public int TranslationMissCacheCount { get; }

		public int PlaceholderCacheCount { get; }

		public int PlaceholderMissCacheCount { get; }

		public bool HasRemoteSnapshot { get; }

		public TranslationPerformanceSnapshot Performance { get; }

		public TranslationRuntimeDiagnostics(bool initialized, string languageName, bool translationEnabled, bool debugEnabled, string configRootPath, int exactRuleCount, int templateRuleCount, int localEnglishFileCount, int syncedEnglishFileCount, int localActiveFileCount, int syncedActiveFileCount, int translationCacheCount, int translationMissCacheCount, int placeholderCacheCount, int placeholderMissCacheCount, bool hasRemoteSnapshot, TranslationPerformanceSnapshot performance)
		{
			Initialized = initialized;
			LanguageName = languageName;
			TranslationEnabled = translationEnabled;
			DebugEnabled = debugEnabled;
			ConfigRootPath = configRootPath;
			ExactRuleCount = exactRuleCount;
			TemplateRuleCount = templateRuleCount;
			LocalEnglishFileCount = localEnglishFileCount;
			SyncedEnglishFileCount = syncedEnglishFileCount;
			LocalActiveFileCount = localActiveFileCount;
			SyncedActiveFileCount = syncedActiveFileCount;
			TranslationCacheCount = translationCacheCount;
			TranslationMissCacheCount = translationMissCacheCount;
			PlaceholderCacheCount = placeholderCacheCount;
			PlaceholderMissCacheCount = placeholderMissCacheCount;
			HasRemoteSnapshot = hasRemoteSnapshot;
			Performance = performance;
		}
	}
	internal sealed class TranslationAnalysisSection
	{
		public string Title { get; }

		public string[] Lines { get; }

		public TranslationAnalysisPassView PassView { get; }

		public TranslationAnalysisSection(string title, string[] lines, TranslationAnalysisPassView passView = null)
		{
			Title = title ?? string.Empty;
			Lines = lines ?? Array.Empty<string>();
			PassView = passView;
		}
	}
	internal enum TranslationAnalysisStageStatus
	{
		Hit,
		Miss,
		NotExecuted
	}
	internal sealed class TranslationAnalysisPassStage
	{
		public string Title { get; }

		public TranslationAnalysisStageStatus Status { get; }

		public string Summary { get; }

		public string[] Details { get; }

		public TranslationAnalysisPassStage(string title, TranslationAnalysisStageStatus status, string summary, string[] details)
		{
			Title = title ?? string.Empty;
			Status = status;
			Summary = summary ?? string.Empty;
			Details = details ?? Array.Empty<string>();
		}
	}
	internal sealed class TranslationAnalysisPassView
	{
		public string Input { get; }

		public string Output { get; }

		public TranslationAnalysisPassStage[] Stages { get; }

		public TranslationAnalysisPassView(string input, string output, TranslationAnalysisPassStage[] stages)
		{
			Input = input ?? string.Empty;
			Output = output ?? string.Empty;
			Stages = stages ?? Array.Empty<TranslationAnalysisPassStage>();
		}
	}
	internal sealed class TranslationAnalysisResult
	{
		public string Input { get; }

		public string Output { get; }

		public TranslationAnalysisSection[] Sections { get; }

		public TranslationAnalysisResult(string input, string output, TranslationAnalysisSection[] sections)
		{
			Input = input ?? string.Empty;
			Output = output ?? string.Empty;
			Sections = sections ?? Array.Empty<TranslationAnalysisSection>();
		}
	}
	internal sealed class GreedyExactAnalysisResult
	{
		public string Output { get; }

		public bool LoopDetected { get; }

		public GreedyExactAnalysisStep[] Steps { get; }

		public GreedyExactAnalysisResult(string output, bool loopDetected, GreedyExactAnalysisStep[] steps)
		{
			Output = output ?? string.Empty;
			LoopDetected = loopDetected;
			Steps = steps ?? Array.Empty<GreedyExactAnalysisStep>();
		}
	}
	internal sealed class GreedyExactAnalysisStep
	{
		public string Input { get; }

		public string Output { get; }

		public GreedyExactAnalysisMatch[] Matches { get; }

		public GreedyExactAnalysisStep(string input, string output, GreedyExactAnalysisMatch[] matches)
		{
			Input = input ?? string.Empty;
			Output = output ?? string.Empty;
			Matches = matches ?? Array.Empty<GreedyExactAnalysisMatch>();
		}
	}
	internal sealed class GreedyExactAnalysisMatch
	{
		public int StartIndex { get; }

		public int EndIndex { get; }

		public string InputSegment { get; }

		public string Match { get; }

		public string Replace { get; }

		public string SourcePath { get; }

		public GreedyExactAnalysisMatch(int startIndex, int endIndex, string inputSegment, string match, string replace, string sourcePath)
		{
			StartIndex = startIndex;
			EndIndex = endIndex;
			InputSegment = inputSegment ?? string.Empty;
			Match = match ?? string.Empty;
			Replace = replace ?? string.Empty;
			SourcePath = sourcePath ?? string.Empty;
		}
	}
	internal sealed class RuleTraceMetadata
	{
		public string MatchText { get; }

		public string ReplaceText { get; }

		public string SourcePath { get; }

		public RuleTraceMetadata(string matchText, string replaceText, string sourcePath)
		{
			MatchText = matchText ?? string.Empty;
			ReplaceText = replaceText ?? string.Empty;
			SourcePath = sourcePath ?? string.Empty;
		}
	}
	internal enum WholeStringGreedyExactMatchMode
	{
		Off,
		PerWord,
		MinLength
	}
	internal static class RuntimeDebugConfig
	{
		private const string ConfigFileName = "config.yaml";

		private const double ReloadDebounceMilliseconds = 250.0;

		private const bool DefaultTranslationEnabled = true;

		private const bool DefaultDevToolsEnabled = true;

		private const WholeStringGreedyExactMatchMode DefaultGreedyExactMatchMode = WholeStringGreedyExactMatchMode.PerWord;

		private const int DefaultGreedyExactMinimumMatchLength = 5;

		internal const int DefaultTraceFeedMaxEntries = 1024;

		private static readonly KeyboardShortcut DefaultDevToolsToggleShortcut = new KeyboardShortcut((KeyCode)282, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 });

		private static FileSystemWatcher configWatcher;

		private static System.Timers.Timer reloadDebounceTimer;

		private static bool initialized;

		private static bool localTranslationEnabled = true;

		public static bool Enabled { get; private set; }

		public static bool TranslationEnabled => localTranslationEnabled;

		public static WholeStringGreedyExactMatchMode GreedyExactMatchMode { get; private set; } = WholeStringGreedyExactMatchMode.PerWord;


		public static int GreedyExactMinimumMatchLength { get; private set; } = 5;


		public static int TraceFeedMaxEntries { get; private set; } = 1024;


		public static bool DevToolsEnabled { get; private set; } = true;


		public static KeyboardShortcut DevToolsToggleShortcut { get; private set; } = DefaultDevToolsToggleShortcut;


		public static string ConfigFilePath => Path.Combine(TranslationRuleLoader.ConfigRootPath, "config.yaml");

		internal static KeyboardShortcut DefaultDevToolsShortcut => DefaultDevToolsToggleShortcut;

		public static bool TrySetTranslationEnabled(bool value, out string error)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return TryWriteSettings(value, Enabled, GreedyExactMatchMode, GreedyExactMinimumMatchLength, TraceFeedMaxEntries, DevToolsEnabled, DevToolsToggleShortcut, "translation_enabled updated from devtools", out error);
		}

		public static bool TrySetDebugEnabled(bool value, out string error)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return TryWriteSettings(TranslationEnabled, value, GreedyExactMatchMode, GreedyExactMinimumMatchLength, TraceFeedMaxEntries, DevToolsEnabled, DevToolsToggleShortcut, "debug updated from devtools", out error);
		}

		public static bool TrySetGreedyExactMatchMode(WholeStringGreedyExactMatchMode value, out string error)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return TryWriteSettings(TranslationEnabled, Enabled, value, GreedyExactMinimumMatchLength, TraceFeedMaxEntries, DevToolsEnabled, DevToolsToggleShortcut, "whole_string_longest_match_mode updated from devtools", out error);
		}

		public static bool TrySetGreedyExactMinimumMatchLength(int value, out string error)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			int greedyExactMinimumMatchLength = ((value <= 0) ? 1 : value);
			return TryWriteSettings(TranslationEnabled, Enabled, GreedyExactMatchMode, greedyExactMinimumMatchLength, TraceFeedMaxEntries, DevToolsEnabled, DevToolsToggleShortcut, "whole_string_longest_match_min_length updated from devtools", out error);
		}

		public static bool TrySetTraceFeedMaxEntries(int value, out string error)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			int traceFeedMaxEntries = ((value <= 0) ? 1 : value);
			return TryWriteSettings(TranslationEnabled, Enabled, GreedyExactMatchMode, GreedyExactMinimumMatchLength, traceFeedMaxEntries, DevToolsEnabled, DevToolsToggleShortcut, "trace_feed_max_entries updated from devtools", out error);
		}

		public static bool TrySetDevToolsEnabled(bool value, out string error)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return TryWriteSettings(TranslationEnabled, Enabled, GreedyExactMatchMode, GreedyExactMinimumMatchLength, TraceFeedMaxEntries, value, DevToolsToggleShortcut, "devtools_enabled updated from devtools", out error);
		}

		public static bool TrySetDevToolsToggleShortcut(KeyboardShortcut shortcut, out string error)
		{
			//IL_0002: 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)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				error = "Shortcut must include a main key.";
				return false;
			}
			return TryWriteSettings(TranslationEnabled, Enabled, GreedyExactMatchMode, GreedyExactMinimumMatchLength, TraceFeedMaxEntries, DevToolsEnabled, shortcut, "devtools_toggle_shortcut updated from devtools", out error);
		}

		public static bool ResetDevToolsToggleShortcut(out string error)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return TrySetDevToolsToggleShortcut(DefaultDevToolsToggleShortcut, out error);
		}

		public static void Initialize()
		{
			if (!initialized)
			{
				initialized = true;
				Directory.CreateDirectory(TranslationRuleLoader.ConfigRootPath);
				EnsureConfigFileExists();
				Reload("startup", logWhenUnchanged: true);
				SetupWatcher();
			}
		}

		public static void Shutdown()
		{
			if (initialized)
			{
				if (configWatcher != null)
				{
					configWatcher.EnableRaisingEvents = false;
					configWatcher.Changed -= OnConfigChanged;
					configWatcher.Created -= OnConfigChanged;
					configWatcher.Deleted -= OnConfigChanged;
					configWatcher.Renamed -= OnConfigRenamed;
					configWatcher.Dispose();
					configWatcher = null;
				}
				if (reloadDebounceTimer != null)
				{
					reloadDebounceTimer.Stop();
					reloadDebounceTimer.Elapsed -= OnReloadDebounceElapsed;
					reloadDebounceTimer.Dispose();
					reloadDebounceTimer = null;
				}
				initialized = false;
			}
		}

		private static void SetupWatcher()
		{
			configWatcher = new FileSystemWatcher(TranslationRuleLoader.ConfigRootPath, "config.yaml")
			{
				IncludeSubdirectories = false,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.CreationTime),
				SynchronizingObject = ThreadingHelper.SynchronizingObject
			};
			configWatcher.Changed += OnConfigChanged;
			configWatcher.Created += OnConfigChanged;
			configWatcher.Deleted += OnConfigChanged;
			configWatcher.Renamed += OnConfigRenamed;
			configWatcher.EnableRaisingEvents = true;
			reloadDebounceTimer = new System.Timers.Timer(250.0)
			{
				AutoReset = false,
				SynchronizingObject = ThreadingHelper.SynchronizingObject
			};
			reloadDebounceTimer.Elapsed += OnReloadDebounceElapsed;
		}

		private static void EnsureConfigFileExists()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(ConfigFilePath))
			{
				File.WriteAllText(ConfigFilePath, BuildConfigContents(translationEnabled: true, debugEnabled: false, WholeStringGreedyExactMatchMode.PerWord, 5, 1024, devToolsEnabled: true, DefaultDevToolsToggleShortcut));
			}
		}

		private static void OnConfigChanged(object sender, FileSystemEventArgs e)
		{
			ScheduleReload();
		}

		private static void OnConfigRenamed(object sender, RenamedEventArgs e)
		{
			ScheduleReload();
		}

		private static void ScheduleReload()
		{
			if (reloadDebounceTimer == null)
			{
				Reload("config.yaml change");
				return;
			}
			reloadDebounceTimer.Stop();
			reloadDebounceTimer.Start();
		}

		private static void OnReloadDebounceElapsed(object sender, ElapsedEventArgs e)
		{
			Reload("config.yaml change");
		}

		private static void Reload(string reason, bool logWhenUnchanged = false)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			if (!TryReadSettings(out var translationEnabled, out var enabled, out var greedyExactMatchMode, out var greedyExactMinimumMatchLength, out var traceFeedMaxEntries, out var devToolsEnabled, out var devToolsToggleShortcut, out var error))
			{
				ManualLogSource log = PluginMain.Log;
				if (log != null)
				{
					log.LogError((object)PluginMain.LocalizeFormat("runtime.settings.read_failed", "Failed to read runtime settings from '{0}': {1}", ConfigFilePath, error));
				}
				return;
			}
			BackfillMissingSettingsIfNeeded(translationEnabled, enabled, greedyExactMatchMode, greedyExactMinimumMatchLength, traceFeedMaxEntries, devToolsEnabled, devToolsToggleShortcut);
			bool num = translationEnabled != localTranslationEnabled;
			bool flag = enabled != Enabled;
			bool flag2 = greedyExactMatchMode != GreedyExactMatchMode || greedyExactMinimumMatchLength != GreedyExactMinimumMatchLength;
			bool flag3 = traceFeedMaxEntries != TraceFeedMaxEntries;
			bool flag4 = devToolsEnabled != DevToolsEnabled || !KeyboardShortcutsEqual(devToolsToggleShortcut, DevToolsToggleShortcut);
			localTranslationEnabled = translationEnabled;
			Enabled = enabled;
			GreedyExactMatchMode = greedyExactMatchMode;
			GreedyExactMinimumMatchLength = greedyExactMinimumMatchLength;
			TraceFeedMaxEntries = traceFeedMaxEntries;
			DevToolsEnabled = devToolsEnabled;
			DevToolsToggleShortcut = devToolsToggleShortcut;
			TranslationRuntime.NotifyRuntimeSettingsChanged(num);
			if (num || flag || flag2 || flag3 || flag4 || logWhenUnchanged)
			{
				ManualLogSource log2 = PluginMain.Log;
				if (log2 != null)
				{
					log2.LogInfo((object)PluginMain.LocalizeFormat("runtime.settings.summary", "Runtime settings via '{0}' ({1}): translation_enabled={2}, debug={3}, whole_string_longest_match_mode={4}, whole_string_longest_match_min_length={5}, trace_feed_max_entries={6}, devtools_enabled={7}, devtools_toggle_shortcut={8}.", ConfigFilePath, reason, TranslationEnabled ? "true" : "false", Enabled ? "enabled" : "disabled", FormatGreedyExactMatchMode(GreedyExactMatchMode), GreedyExactMinimumMatchLength, TraceFeedMaxEntries, DevToolsEnabled ? "true" : "false", FormatKeyboardShortcutValue(DevToolsToggleShortcut)));
				}
			}
		}

		private static void BackfillMissingSettingsIfNeeded(bool translationEnabled, bool debugEnabled, WholeStringGreedyExactMatchMode greedyExactMatchMode, int greedyExactMinimumMatchLength, int traceFeedMaxEntries, bool devToolsEnabled, KeyboardShortcut devToolsToggleShortcut)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!ConfigHasAllKnownSettings())
				{
					Directory.CreateDirectory(TranslationRuleLoader.ConfigRootPath);
					File.WriteAllText(ConfigFilePath, BuildConfigContents(translationEnabled, debugEnabled, greedyExactMatchMode, greedyExactMinimumMatchLength, traceFeedMaxEntries, devToolsEnabled, devToolsToggleShortcut));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = PluginMain.Log;
				if (log != null)
				{
					log.LogWarning((object)PluginMain.LocalizeFormat("runtime.settings.backfill_failed", "Failed to backfill missing runtime settings in '{0}': {1}", ConfigFilePath, ex.Message));
				}
			}
		}

		private static bool TryWriteSettings(bool translationEnabled, bool debugEnabled, WholeStringGreedyExactMatchMode greedyExactMatchMode, int greedyExactMinimumMatchLength, int traceFeedMaxEntries, bool devToolsEnabled, KeyboardShortcut devToolsToggleShortcut, string reason, out string error)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			error = null;
			try
			{
				Directory.CreateDirectory(TranslationRuleLoader.ConfigRootPath);
				File.WriteAllText(ConfigFilePath, BuildConfigContents(translationEnabled, debugEnabled, greedyExactMatchMode, greedyExactMinimumMatchLength, traceFeedMaxEntries, devToolsEnabled, devToolsToggleShortcut));
				Reload(reason, logWhenUnchanged: true);
				return true;
			}
			catch (Exception ex)
			{
				error = ex.Message;
				return false;
			}
		}

		private static bool TryReadSettings(out bool translationEnabled, out bool enabled, out WholeStringGreedyExactMatchMode greedyExactMatchMode, out int greedyExactMinimumMatchLength, out int traceFeedMaxEntries, out bool devToolsEnabled, out KeyboardShortcut devToolsToggleShortcut, out string error)
		{
			//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)
			translationEnabled = true;
			enabled = false;
			greedyExactMatchMode = WholeStringGreedyExactMatchMode.PerWord;
			greedyExactMinimumMatchLength = 5;
			traceFeedMaxEntries = 1024;
			devToolsEnabled = true;
			devToolsToggleShortcut = DefaultDevToolsToggleShortcut;
			error = null;
			try
			{
				EnsureConfigFileExists();
				string[] array = File.ReadAllLines(ConfigFilePath);
				for (int i = 0; i < array.Length; i++)
				{
					string text = StripComment(array[i]).Trim();
					if (text.Length == 0)
					{
						continue;
					}
					int num = text.IndexOf(':');
					if (num < 0)
					{
						continue;
					}
					string a = text.Substring(0, num).Trim();
					string text2 = text.Substring(num + 1).Trim();
					if (string.Equals(a, "translation_enabled", StringComparison.OrdinalIgnoreCase))
					{
						if (!TryParseBoolean(text2, out translationEnabled))
						{
							error = "Unsupported boolean value '" + text2 + "' for 'translation_enabled'.";
							return false;
						}
					}
					else if (string.Equals(a, "debug", StringComparison.OrdinalIgnoreCase))
					{
						if (!TryParseBoolean(text2, out enabled))
						{
							error = "Unsupported boolean value '" + text2 + "' for 'debug'.";
							return false;
						}
					}
					else if (string.Equals(a, "whole_string_longest_match_mode", StringComparison.OrdinalIgnoreCase))
					{
						if (!TryParseGreedyExactMatchMode(text2, out greedyExactMatchMode))
						{
							error = "Unsupported value '" + text2 + "' for 'whole_string_longest_match_mode'. Expected off, per_word, or min_length.";
							return false;
						}
					}
					else if (string.Equals(a, "whole_string_longest_match_min_length", StringComparison.OrdinalIgnoreCase))
					{
						if (!TryParsePositiveInteger(text2, out greedyExactMinimumMatchLength))
						{
							error = "Unsupported positive integer value '" + text2 + "' for 'whole_string_longest_match_min_length'.";
							return false;
						}
					}
					else if (string.Equals(a, "trace_feed_max_entries", StringComparison.OrdinalIgnoreCase))
					{
						if (!TryParsePositiveInteger(text2, out traceFeedMaxEntries))
						{
							error = "Unsupported positive integer value '" + text2 + "' for 'trace_feed_max_entries'.";
							return false;
						}
					}
					else if (string.Equals(a, "devtools_enabled", StringComparison.OrdinalIgnoreCase))
					{
						if (!TryParseBoolean(text2, out devToolsEnabled))
						{
							error = "Unsupported boolean value '" + text2 + "' for 'devtools_enabled'.";
							return false;
						}
					}
					else if (string.Equals(a, "devtools_toggle_shortcut", StringComparison.OrdinalIgnoreCase) && !TryParseKeyboardShortcut(text2, out devToolsToggleShortcut))
					{
						error = "Unsupported value '" + text2 + "' for 'devtools_toggle_shortcut'.";
						return false;
					}
				}
				return true;
			}
			catch (Exception ex)
			{
				error = ex.Message;
				return false;
			}
		}

		private static string StripComment(string value)
		{
			int num = value.IndexOf('#');
			if (num < 0)
			{
				return value;
			}
			return value.Substring(0, num);
		}

		private static bool ConfigHasAllKnownSettings()
		{
			if (ConfigContainsKey("translation_enabled") && ConfigContainsKey("debug") && ConfigContainsKey("whole_string_longest_match_mode") && ConfigContainsKey("whole_string_longest_match_min_length") && ConfigContainsKey("trace_feed_max_entries") && ConfigContainsKey("devtools_enabled"))
			{
				return ConfigContainsKey("devtools_toggle_shortcut");
			}
			return false;
		}

		private static bool ConfigContainsKey(string expectedKey)
		{
			if (string.IsNullOrWhiteSpace(expectedKey) || !File.Exists(ConfigFilePath))
			{
				return false;
			}
			string[] array = File.ReadAllLines(ConfigFilePath);
			for (int i = 0; i < array.Length; i++)
			{
				string text = StripComment(array[i]).Trim();
				if (text.Length != 0)
				{
					int num = text.IndexOf(':');
					if (num >= 0 && string.Equals(text.Substring(0, num).Trim(), expectedKey, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static string BuildConfigContents(bool translationEnabled, bool debugEnabled, WholeStringGreedyExactMatchMode greedyExactMatchMode, int greedyExactMinimumMatchLength, int traceFeedMaxEntries, bool devToolsEnabled, KeyboardShortcut devToolsToggleShortcut)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			return "# Localization runtime settings\n# Set to false to bypass the entire translation pipeline.\ntranslation_enabled: " + FormatBooleanValue(translationEnabled) + "\n\n# Set to true to log intercepted UI text and translation decisions.\ndebug: " + FormatBooleanValue(debugEnabled) + "\n\n# Controls whole-string longest-match exact replacement.\n# Values: off, per_word, min_length\nwhole_string_longest_match_mode: " + FormatGreedyExactMatchMode(greedyExactMatchMode) + "\n\n# Minimum letter/digit count for a whole string longest match when mode is min_length.\n" + $"whole_string_longest_match_min_length: {greedyExactMinimumMatchLength}\n" + "\n# Maximum unique entries kept in the Trace feed before the oldest entries are evicted.\n" + $"trace_feed_max_entries: {traceFeedMaxEntries}\n" + "\n# Set to false to disable the in-game Localization devtools overlay.\ndevtools_enabled: " + FormatBooleanValue(devToolsEnabled) + "\n\n# Shortcut used to open or close the in-game Localization devtools overlay.\n# Default: Ctrl + F1 in the UI (LeftControl + F1 in this file).\n# Format example: LeftControl + F1\ndevtools_toggle_shortcut: " + FormatKeyboardShortcutValue(devToolsToggleShortcut) + "\n";
		}

		private static bool TryParseBoolean(string value, out bool result)
		{
			switch ((value ?? string.Empty).Trim().ToLowerInvariant())
			{
			case "1":
			case "on":
			case "yes":
			case "true":
				result = true;
				return true;
			case "0":
			case "no":
			case "off":
			case "false":
				result = false;
				return true;
			default:
				result = false;
				return false;
			}
		}

		private static string FormatBooleanValue(bool value)
		{
			if (!value)
			{
				return "false";
			}
			return "true";
		}

		private static bool TryParseKeyboardShortcut(string value, out KeyboardShortcut shortcut)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			shortcut = DefaultDevToolsToggleShortcut;
			string text = NormalizeScalarValue(value);
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			if (string.Equals(text, "none", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "unset", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "<unset>", StringComparison.OrdinalIgnoreCase))
			{
				shortcut = new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>());
				return true;
			}
			string[] array = text.Split(new char[1] { '+' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0)
			{
				return false;
			}
			List<KeyCode> list = new List<KeyCode>();
			KeyCode val = (KeyCode)0;
			for (int i = 0; i < array.Length; i++)
			{
				if (!TryParseShortcutKey(array[i], out var key))
				{
					return false;
				}
				key = NormalizeModifierKey(key);
				if (IsModifierKey(key))
				{
					AddUniqueModifier(list, key);
					continue;
				}
				if ((int)val != 0)
				{
					return false;
				}
				val = key;
			}
			if ((int)val == 0)
			{
				return false;
			}
			shortcut = ((list.Count == 0) ? new KeyboardShortcut(val, Array.Empty<KeyCode>()) : new KeyboardShortcut(val, list.ToArray()));
			return true;
		}

		private static string FormatKeyboardShortcutValue(KeyboardShortcut shortcut)
		{
			//IL_0002: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				return "None";
			}
			HashSet<KeyCode> hashSet = new HashSet<KeyCode>();
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				hashSet.Add(NormalizeModifierKey(modifier));
			}
			List<string> list = new List<string>();
			AppendModifierIfPresent(list, hashSet, (KeyCode)306);
			AppendModifierIfPresent(list, hashSet, (KeyCode)304);
			AppendModifierIfPresent(list, hashSet, (KeyCode)308);
			AppendModifierIfPresent(list, hashSet, (KeyCode)310);
			KeyCode mainKey = ((KeyboardShortcut)(ref shortcut)).MainKey;
			list.Add(((object)(KeyCode)(ref mainKey)).ToString());
			return string.Join(" + ", list.ToArray());
		}

		private static bool KeyboardShortcutsEqual(KeyboardShortcut left, KeyboardShortcut right)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return string.Equals(FormatKeyboardShortcutValue(left), FormatKeyboardShortcutValue(right), StringComparison.OrdinalIgnoreCase);
		}

		private static string NormalizeScalarValue(string value)
		{
			string text = (value ?? string.Empty).Trim();
			if (text.Length >= 2)
			{
				char c = text[0];
				char c2 = text[text.Length - 1];
				if ((c == '"' && c2 == '"') || (c == '\'' && c2 == '\''))
				{
					return text.Substring(1, text.Length - 2).Trim();
				}
			}
			return text;
		}

		private static bool TryParseShortcutKey(string value, out KeyCode key)
		{
			string text = NormalizeScalarValue(value).Replace(" ", string.Empty);
			switch (text.ToLowerInvariant())
			{
			case "ctrl":
			case "control":
				key = (KeyCode)306;
				return true;
			case "shift":
				key = (KeyCode)304;
				return true;
			case "alt":
				key = (KeyCode)308;
				return true;
			case "cmd":
			case "command":
				key = (KeyCode)310;
				return true;
			default:
				return Enum.TryParse<KeyCode>(text, ignoreCase: true, out key);
			}
		}

		private static bool IsModifierKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if (key - 303 <= 7)
			{
				return true;
			}
			return false;
		}

		private static KeyCode NormalizeModifierKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			return (KeyCode)((key - 303) switch
			{
				2 => 306, 
				0 => 304, 
				4 => 308, 
				6 => 310, 
				_ => key, 
			});
		}

		private static void AddUniqueModifier(List<KeyCode> modifiers, KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			KeyCode val = NormalizeModifierKey(key);
			for (int i = 0; i < modifiers.Count; i++)
			{
				if (modifiers[i] == val)
				{
					return;
				}
			}
			modifiers.Add(val);
		}

		private static void AppendModifierIfPresent(List<string> parts, HashSet<KeyCode> modifierSet, KeyCode modifier)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (modifierSet.Contains(modifier))
			{
				parts.Add(((object)(KeyCode)(ref modifier)).ToString());
			}
		}

		private static bool TryParseGreedyExactMatchMode(string value, out WholeStringGreedyExactMatchMode result)
		{
			switch ((value ?? string.Empty).Trim().ToLowerInvariant())
			{
			case "none":
			case "disabled":
			case "off":
			case "unrestricted":
				result = WholeStringGreedyExactMatchMode.Off;
				return true;
			case "word":
			case "per_word":
			case "word_boundary":
				result = WholeStringGreedyExactMatchMode.PerWord;
				return true;
			case "min_length":
			case "minimum_length":
			case "minimum_match_length":
				result = WholeStringGreedyExactMatchMode.MinLength;
				return true;
			default:
				result = WholeStringGreedyExactMatchMode.PerWord;
				return false;
			}
		}

		private static bool TryParsePositiveInteger(string value, out int result)
		{
			if (int.TryParse((value ?? string.Empty).Trim(), out result) && result > 0)
			{
				return true;
			}
			result = 0;
			return false;
		}

		private static string FormatGreedyExactMatchMode(WholeStringGreedyExactMatchMode mode)
		{
			return mode switch
			{
				WholeStringGreedyExactMatchMode.Off => "off", 
				WholeStringGreedyExactMatchMode.MinLength => "min_length", 
				_ => "per_word", 
			};
		}
	}
	[HarmonyPatch]
	internal static class TextInterceptionPatches
	{
		private sealed class InterceptedTextState
		{
			public bool IsDevToolsComponent;

			public int Version;

			public string Input;

			public string Output;
		}

		private static readonly ConditionalWeakTable<Component, InterceptedTextState> interceptedTextStates = new ConditionalWeakTable<Component, InterceptedTextState>();

		private static IEnumerable<MethodBase> TargetMethods()
		{
			List<MethodBase> list = new List<MethodBase>();
			MethodInfo methodInfo = AccessTools.PropertySetter(typeof(TMP_Text), "text");
			if (methodInfo != null)
			{
				list.Add(methodInfo);
			}
			MethodInfo methodInfo2 = AccessTools.PropertySetter(typeof(Text), "text");
			if (methodInfo2 != null)
			{
				list.Add(methodInfo2);
			}
			MethodInfo methodInfo3 = AccessTools.Method(typeof(TMP_Text), "SetText", new Type[2]
			{
				typeof(string),
				typeof(bool)
			}, (Type[])null);
			if (methodInfo3 != null)
			{
				list.Add(methodInfo3);
			}
			return list;
		}

		private static void Prefix(Component __instance, ref string __0, MethodBase __originalMethod)
		{
			long startTimestamp = TranslationPerformanceMetrics.StartTiming();
			TranslationPerformanceMetrics.RecordInterceptionCall();
			try
			{
				if (ShouldBypassDevToolsComponent(__instance))
				{
					return;
				}
				int interceptionStateVersion = TranslationRuntime.InterceptionStateVersion;
				string text = __0;
				if (TryReuseInterceptedText(__instance, text, interceptionStateVersion, out var output))
				{
					TranslationPerformanceMetrics.RecordInterceptionStateReuse();
					__0 = output;
					return;
				}
				if (TranslationRuntime.IsKnownTranslatedOutput(text))
				{
					TranslationPerformanceMetrics.RecordInterceptionKnownTranslatedOutput();
					RememberInterceptedText(__instance, text, text, interceptionStateVersion);
					return;
				}
				bool num = !string.IsNullOrEmpty(__0);
				bool flag = num && TranslationTraceFeed.IsEnabled;
				bool flag2 = num && PluginMain.DebugModeEnabled;
				string sourceName = null;
				if (flag || flag2)
				{
					sourceName = ((__originalMethod == null) ? "<unknown>" : (__originalMethod.DeclaringType?.FullName + "." + __originalMethod.Name));
				}
				if (flag && TranslationTraceFeed.Capture(__0, sourceName))
				{
					TranslationPerformanceMetrics.RecordTraceCapture();
				}
				if (!RuntimeDebugConfig.TranslationEnabled)
				{
					RememberInterceptedText(__instance, text, text, interceptionStateVersion);
					return;
				}
				if (flag2)
				{
					string interceptedText = PluginMain.FormatTextForDebug(__0);
					PluginMain.DebugLog(() => "Captured UI text via " + sourceName + ": '" + interceptedText + "'");
				}
				__0 = TranslationRuntime.Translate(__0);
				RememberInterceptedText(__instance, text, __0, interceptionStateVersion);
			}
			finally
			{
				TranslationPerformanceMetrics.AddInterceptionDuration(startTimestamp);
			}
		}

		private static bool ShouldBypassDevToolsComponent(Component instance)
		{
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			InterceptedTextState orCreateValue = interceptedTextStates.GetOrCreateValue(instance);
			if (!orCreateValue.IsDevToolsComponent)
			{
				orCreateValue.IsDevToolsComponent = (Object)(object)instance.GetComponentInParent<DevToolsUiMarker>() != (Object)null;
			}
			return orCreateValue.IsDevToolsComponent;
		}

		private static bool TryReuseInterceptedText(Component instance, string input, int version, out string output)
		{
			output = null;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if (!interceptedTextStates.TryGetValue(instance, out var value))
			{
				return false;
			}
			if (value.Version != version || !string.Equals(value.Input, input, StringComparison.Ordinal))
			{
				return false;
			}
			output = value.Output;
			return true;
		}

		private static void RememberInterceptedText(Component instance, string input, string output, int version)
		{
			if (!((Object)(object)instance == (Object)null))
			{
				InterceptedTextState orCreateValue = interceptedTextStates.GetOrCreateValue(instance);
				orCreateValue.Version = version;
				orCreateValue.Input = input;
				orCreateValue.Output = output;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerPrefs), "SetString", new Type[]
	{
		typeof(string),
		typeof(string)
	})]
	internal static class LanguagePreferencePatches
	{
		private static void Postfix(string key, string value)
		{
			if (string.Equals(key, "language", StringComparison.Ordinal))
			{
				PluginLocalization.NotifyLanguageChanged(value);
				TranslationRuntime.NotifyLanguageChanged(value);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerPrefs), "DeleteKey", new Type[] { typeof(string) })]
	internal static class LanguagePreferenceResetPatch
	{
		private static void Postfix(string key)
		{
			if (string.Equals(key, "language", StringComparison.Ordinal))
			{
				PluginLocalization.NotifyLanguageReset();
				TranslationRuntime.NotifyLanguageReset();
			}
		}
	}
	internal static class TextMatchNormalizer
	{
		internal readonly struct ReplacementSegment
		{
			public int NormalizedStartIndex { get; }

			public int NormalizedLength { get; }

			public string ReplacementText { get; }

			public ReplacementSegment(int normalizedStartIndex, int normalizedLength, string replacementText)
			{
				NormalizedStartIndex = normalizedStartIndex;
				NormalizedLength = normalizedLength;
				ReplacementText = replacementText ?? string.Empty;
			}
		}

		internal readonly struct NormalizedText
		{
			private readonly int[] rawStartsByNormalizedIndex;

			private readonly int[] rawEndsByNormalizedIndex;

			private readonly TagToken[] tags;

			public string RawText { get; }

			public string Value { get; }

			internal NormalizedText(string rawText, string value, int[] rawStartsByNormalizedIndex, int[] rawEndsByNormalizedIndex, TagToken[] tags)
			{
				RawText = rawText;
				Value = value;
				this.rawStartsByNormalizedIndex = rawStartsByNormalizedIndex;
				this.rawEndsByNormalizedIndex = rawEndsByNormalizedIndex;
				this.tags = tags;
			}

			public string WrapWholeMatch(string replacement)
			{
				if (string.IsNullOrEmpty(Value))
				{
					return replacement;
				}
				if (tags.Length == 0)
				{
					return replacement;
				}
				return CreateWrappedMatch(0, Value.Length, replacement).ReplacementText;
			}

			public string ReplaceNormalizedRanges(IReadOnlyList<ReplacementSegment> replacements)
			{
				if (replacements == null || replacements.Count == 0)
				{
					return RawText;
				}
				StringBuilder stringBuilder = new StringBuilder((RawText?.Length ?? 0) + 16);
				int num = 0;
				for (int i = 0; i < replacements.Count; i++)
				{
					ReplacementSegment replacementSegment = replacements[i];
					if (replacementSegment.NormalizedLength > 0 && replacementSegment.NormalizedStartIndex >= 0 && replacementSegment.NormalizedStartIndex + replacementSegment.NormalizedLength <= Value.Length)
					{
						int num2;
						int num3;
						if (rawStartsByNormalizedIndex == null || rawEndsByNormalizedIndex == null)
						{
							num2 = replacementSegment.NormalizedStartIndex;
							num3 = replacementSegment.NormalizedStartIndex + replacementSegment.NormalizedLength;
						}
						else
						{
							num2 = rawStartsByNormalizedIndex[replacementSegment.NormalizedStartIndex];
							num3 = rawEndsByNormalizedIndex[replacementSegment.NormalizedStartIndex + replacementSegment.NormalizedLength - 1];
						}
						if (num2 > num)
						{
							stringBuilder.Append(RawText, num, num2 - num);
						}
						stringBuilder.Append(replacementSegment.ReplacementText);
						num = num3;
					}
				}
				if (num < RawText.Length)
				{
					stringBuilder.Append(RawText, num, RawText.Length - num);
				}
				return stringBuilder.ToString();
			}

			public WrappedMatch CreateWrappedMatch(int normalizedStartIndex, int normalizedLength, string replacement)
			{
				if (normalizedLength <= 0 || normalizedStartIndex < 0 || normalizedStartIndex + normalizedLength > Value.Length)
				{
					return new WrappedMatch(0, 0, replacement);
				}
				int rawInnerStart;
				int rawInnerEnd;
				if (rawStartsByNormalizedIndex == null || rawEndsByNormalizedIndex == null)
				{
					rawInnerStart = normalizedStartIndex;
					rawInnerEnd = normalizedStartIndex + normalizedLength;
				}
				else
				{
					rawInnerStart = rawStartsByNormalizedIndex[normalizedStartIndex];
					rawInnerEnd = rawEndsByNormalizedIndex[normalizedStartIndex + normalizedLength - 1];
				}
				int rawStart;
				List<TagToken> prefixTags = CollectAdjacentOpeningTags(rawInnerStart, out rawStart);
				int rawEnd;
				List<TagToken> suffixTags = CollectAdjacentClosingTags(rawInnerEnd, out rawEnd);
				return new WrappedMatch(rawStart, rawEnd, BuildBalancedReplacement(prefixTags, replacement, suffixTags));
			}

			private List<TagToken> CollectAdjacentOpeningTags(int rawInnerStart, out int rawStart)
			{
				List<TagToken> list = new List<TagToken>();
				int num = rawInnerStart;
				TagToken matchedTag;
				while (TryFindOpeningTagEndingAt(num, out matchedTag))
				{
					list.Insert(0, matchedTag);
					num = matchedTag.RawStart;
				}
				rawStart = num;
				return list;
			}

			private List<TagToken> CollectAdjacentClosingTags(int rawInnerEnd, out int rawEnd)
			{
				List<TagToken> list = new List<TagToken>();
				int num = rawInnerEnd;
				TagToken matchedTag;
				while (TryFindClosingTagStartingAt(num, out matchedTag))
				{
					list.Add(matchedTag);
					num = matchedTag.RawEnd;
				}
				rawEnd = num;
				return list;
			}

			private string BuildBalancedReplacement(List<TagToken> prefixTags, string replacement, List<TagToken> suffixTags)
			{
				if ((prefixTags == null || prefixTags.Count == 0) && (suffixTags == null || suffixTags.Count == 0))
				{
					return replacement;
				}
				StringBuilder stringBuilder = new StringBuilder((replacement?.Length ?? 0) + 32);
				List<TagToken> list = new List<TagToken>(prefixTags?.Count ?? 0);
				if (prefixTags != null)
				{
					for (int i = 0; i < prefixTags.Count; i++)
					{
						TagToken tagToken = prefixTags[i];
						AppendRawTag(stringBuilder, tagToken);
						if (!tagToken.IsSelfClosing)
						{
							list.Add(tagToken);
						}
					}
				}
				stringBuilder.Append(replacement);
				if (suffixTags != null)
				{
					for (int j = 0; j < suffixTags.Count; j++)
					{
						TagToken tag = suffixTags[j];
						int num = FindLastMatchingOpenTagIndex(list, tag.Name);
						if (num >= 0)
						{
							for (int num2 = list.Count - 1; num2 > num; num2--)
							{
								stringBuilder.Append(CreateClosingTagText(list[num2]));
								list.RemoveAt(num2);
							}
							AppendRawTag(stringBuilder, tag);
							list.RemoveAt(list.Count - 1);
						}
					}
				}
				for (int num3 = list.Count - 1; num3 >= 0; num3--)
				{
					stringBuilder.Append(CreateClosingTagText(list[num3]));
				}
				return stringBuilder.ToString();
			}

			private void AppendRawTag(StringBuilder builder, TagToken tag)
			{
				builder.Append(RawText, tag.RawStart, tag.RawEnd - tag.RawStart);
			}

			private static int FindLastMatchingOpenTagIndex(List<TagToken> openStack, string closingTagName)
			{
				for (int num = openStack.Count - 1; num >= 0; num--)
				{
					if (string.Equals(openStack[num].Name, closingTagName, StringComparison.OrdinalIgnoreCase))
					{
						return num;
					}
				}
				return -1;
			}

			private static string CreateClosingTagText(TagToken openingTag)
			{
				if (!string.IsNullOrEmpty(openingTag.Name))
				{
					return "</" + openingTag.Name + ">";
				}
				return string.Empty;
			}

			private bool TryFindOpeningTagEndingAt(int rawEnd, out TagToken matchedTag)
			{
				for (int i = 0; i < tags.Length; i++)
				{
					TagToken tagToken = tags[i];
					if (!tagToken.IsClosing && !tagToken.IsSelfClosing && tagToken.RawEnd == rawEnd)
					{
						matchedTag = tagToken;
						return true;
					}
				}
				matchedTag = default(TagToken);
				return false;
			}

			private bool TryFindClosingTagStartingAt(int rawStart, out TagToken matchedTag)
			{
				for (int i = 0; i < tags.Length; i++)
				{
					TagToken tagToken = tags[i];
					if (tagToken.IsClosing && tagToken.RawStart == rawStart)
					{
						matchedTag = tagToken;
						return true;
					}
				}
				matchedTag = default(TagToken);
				return false;
			}
		}

		internal readonly struct WrappedMatch
		{
			public int RawStart { get; }

			public int RawEnd { get; }

			public string ReplacementText { get; }

			public WrappedMatch(int rawStart, int rawEnd, string replacementText)
			{
				RawStart = rawStart;
				RawEnd = rawEnd;
				ReplacementText = replacementText;
			}
		}

		internal readonly struct TagToken
		{
			public int RawStart { get; }

			public int RawEnd { get; }

			public bool IsClosing { get; }

			public bool IsSelfClosing { get; }

			public string Name { get; }

			public TagToken(int rawStart, int rawEnd, bool isClosing, bool isSelfClosing, string name)
			{
				RawStart = rawStart;
				RawEnd = rawEnd;
				IsClosing = isClosing;
				IsSelfClosing = isSelfClosing;
				Name = name;
			}
		}

		private const int MaxAnalysisCacheEntries = 4096;

		private static readonly BoundedStringDictionary<NormalizedText> analysisCache = new BoundedStringDictionary<NormalizedText>(4096, StringComparer.Ordinal);

		private static readonly string[] SupportedTagNames = new string[39]
		{
			"align", "allcaps", "alpha", "b", "br", "color", "cspace", "font", "font-weight", "gradient",
			"i", "indent", "line-height", "line-indent", "link", "lowercase", "margin", "mark", "material", "mspace",
			"nobr", "noparse", "page", "pos", "quad", "rotate", "s", "size", "smallcaps", "space",
			"sprite", "strikethrough", "style", "sub", "sup", "u", "uppercase", "voffset", "width"
		};

		public static string Normalize(string input)
		{
			return Analyze(input).Value;
		}

		public static NormalizedText Analyze(string input)
		{
			string text = input ?? string.Empty;
			long startTimestamp = TranslationPerformanceMetrics.StartTiming();
			TranslationPerformanceMetrics.RecordNormalizationCall();
			try
			{
				if (analysisCache.TryGetValue(text, out var value))
				{
					TranslationPerformanceMetrics.RecordNormalizationCacheHit();
					return value;
				}
				NormalizedText normalizedText = AnalyzeCore(text);
				if (analysisCache.Set(text, normalizedText, out var _))
				{
					TranslationPerformanceMetrics.RecordNormalizationCacheEviction();
				}
				return normalizedText;
			}
			finally
			{
				TranslationPerformanceMetrics.AddNormalizationDuration(startTimestamp);
			}
		}

		private static NormalizedText AnalyzeCore(string rawText)
		{
			if (rawText.Length == 0)
			{
				return new NormalizedText(rawText, string.Empty, Array.Empty<int>(), Array.Empty<int>(), Array.Empty<TagToken>());
			}
			if (rawText.IndexOf('<') < 0)
			{
				return new NormalizedText(rawText, rawText, null, null, Array.Empty<TagToken>());
			}
			StringBuilder stringBuilder = new StringBuilder(rawText.Length);
			List<int> list = new List<int>(rawText.Length);
			List<int> list2 = new List<int>(rawText.Length);
			List<TagToken> list3 = new List<TagToken>();
			int num = 0;
			while (num < rawText.Length)
			{
				if (rawText[num] == '<' && TryParseSupportedTag(rawText, num, out var tag))
				{
					list3.Add(tag);
					num = tag.RawEnd;
					continue;
				}
				list.Add(num);
				stringBuilder.Append(rawText[num]);
				num++;
				list2.Add(num);
			}
			return new NormalizedText(rawText, stringBuilder.ToString(), list.ToArray(), list2.ToArray(), list3.ToArray());
		}

		private static bool TryParseSupportedTag(string input, int startIndex, out TagToken tag)
		{
			tag = default(TagToken);
			int num = input.IndexOf('>', startIndex + 1);
			if (num < 0)
			{
				return false;
			}
			int num2 = num - startIndex - 1;
			if (num2 <= 0)
			{
				return false;
			}
			if (!LooksLikeSupportedRichTextTag(input.Substring(startIndex + 1, num2), out var isClosing, out var isSelfClosing, out var tagName))
			{
				return false;
			}
			tag = new TagToken(startIndex, num + 1, isClosing, isSelfClosing, tagName);
			return true;
		}

		private static bool LooksLikeSupportedRichTextTag(string content, out bool isClosing, out bool isSelfClosing, out string tagName)
		{
			isClosing = false;
			isSelfClosing = false;
			tagName = null;
			if (string.IsNullOrEmpty(content) || char.IsWhiteSpace(content[0]))
			{
				return false;
			}
			int i = 0;
			if (content[i] == '/')
			{
				isClosing = true;
				i++;
				if (i >= content.Length || char.IsWhiteSpace(content[i]))
				{
					return false;
				}
			}
			if (content[i] == '#')
			{
				if (isClosing || !IsSupportedHexColorTag(content, i))
				{
					return false;
				}
				tagName = "color";
				return true;
			}
			int num = i;
			for (; i < content.Length && IsTagNameCharacter(content[i]); i++)
			{
			}
			if (i == num)
			{
				return false;
			}
			string text = content.Substring(num, i - num);
			if (!IsSupportedTagName(text))
			{
				return false;
			}
			tagName = text.ToLowerInvariant();
			if (isClosing)
			{
				return HasOnlyTrailingWhitespace(content, i);
			}
			if (SupportsParameterlessTag(tagName))
			{
				if (!HasOnlyOptionalSelfClosingSuffix(content, i, out var hasSelfClosingSlash))
				{
					return false;
				}
				isSelfClosing = IsSelfClosingTag(tagName) || hasSelfClosingSlash;
				return true;
			}
			if (!HasAttributeAssignment(content, i))
			{
				return false;
			}
			isSelfClosing = IsSelfClosingTag(tagName);
			return true;
		}

		private static bool IsSupportedHexColorTag(string content, int startIndex)
		{
			int num = content.Length - startIndex - 1;
			if (num != 3 && num != 4 && num != 6 && num != 8)
			{
				return false;
			}
			for (int i = startIndex + 1; i < content.Length; i++)
			{
				if (!IsHexDigit(content[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsHexDigit(char character)
		{
			if ((character < '0' || character > '9') && (character < 'a' || character > 'f'))
			{
				if (character >= 'A')
				{
					return character <= 'F';
				}
				return false;
			}
			return true;
		}

		private static bool IsTagNameCharacter(char character)
		{
			if (!char.IsLetter(character))
			{
				return character == '-';
			}
			return true;
		}

		private static bool IsSupportedTagName(string tagName)
		{
			for (int i = 0; i < SupportedTagNames.Length; i++)
			{
				if (string.Equals(SupportedTagNames[i], tagName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool SupportsParameterlessTag(string tagName)
		{
			string text = tagName.ToLowerInvariant();
			if (text != null)
			{
				switch (text.Length)
				{
				case 7:
				{
					char c = text[0];
					if (c != 'a')
					{
						if (c != 'n' || !(text == "noparse"))
						{
							break;
						}
					}
					else if (!(text == "allcaps"))
					{
						break;
					}
					goto IL_0179;
				}
				case 1:
				{
					char c = text[0];
					if ((uint)c <= 105u)
					{
						if (c != 'b' && c != 'i')
						{
							break;
						}
					}
					else if (c != 's' && c != 'u')
					{
						break;
					}
					goto IL_0179;
				}
				case 9:
				{
					char c = text[0];
					if (c != 'l')
					{
						if (c != 's')
						{
							if (c != 'u' || !(text == "uppercase"))
							{
								break;
							}
						}
						else if (!(text == "smallcaps"))
						{
							break;
						}
					}
					else if (!(text == "lowercase"))
					{
						break;
					}
					goto IL_0179;
				}
				case 3:
				{
					char c = text[2];
					if (c != 'b')
					{
						if (c != 'p' || !(text == "sup"))
						{
							break;
						}
					}
					else if (!(text == "sub"))
					{
						break;
					}
					goto IL_0179;
				}
				case 2:
					if (!(text == "br"))
					{
						break;
					}
					goto IL_0179;
				case 4:
					if (!(text == "nobr"))
					{
						break;
					}
					goto IL_0179;
				case 13:
					{
						if (!(text == "strikethrough"))
						{
							break;
						}
						goto IL_0179;
					}
					IL_0179:
					return true;
				}
			}
			return false;
		}

		private static bool IsSelfClosingTag(string tagName)
		{
			switch (tagName.ToLowerInvariant())
			{
			case "br":
			case "page":
			case "quad":
			case "space":
			case "sprite":
				return true;
			default:
				return false;
			}
		}

		private static bool HasOnlyTrailingWhitespace(string content, int startIndex)
		{
			for (int i = startIndex; i < content.Length; i++)
			{
				if (!char.IsWhiteSpace(content[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool HasOnlyOptionalSelfClosingSuffix(string content, int startIndex, out bool hasSelfClosingSlash)
		{
			hasSelfClosingSlash = false;
			int i;
			for (i = startIndex; i < content.Length && char.IsWhiteSpace(content[i]); i++)
			{
			}
			if (i == content.Length)
			{
				return true;
			}
			if (content[i] != '/')
			{
				return false;
			}
			hasSelfClosingSlash = true;
			i++;
			return HasOnlyTrailingWhitespace(content, i);
		}

		private static bool HasAttributeAssignment(string content, int startIndex)
		{
			int i;
			for (i = startIndex; i < content.Length && char.IsWhiteSpace(content[i]); i++)
			{
			}
			if (i >= content.Length)
			{
				return false;
			}
			if (content[i] == '=')
			{
				return true;
			}
			int num = i;
			for (; i < content.Length && IsAttributeNameCharacter(content[i]); i++)
			{
			}
			if (i == num)
			{
				return false;
			}
			for (; i < content.Length && char.IsWhiteSpace(content[i]); i++)
			{
			}
			if (i < content.Length)
			{
				return content[i] == '=';
			}
			return false;
		}

		private static bool IsAttributeNameCharacter(char character)
		{
			if (!char.IsLetterOrDigit(character) && character != '-')
			{
				return character == '_';
			}
			return true;
		}
	}
	internal sealed class TranslationPerformanceSnapshot
	{
		public long InterceptionCallCount { get; }

		public long InterceptionStateReuseCount { get; }

		public long InterceptionKnownTranslatedOutputCount { get; }

		public long InterceptionTraceCaptureCount { get; }

		public long TranslationCallCount { get; }

		public long TranslationCacheHitCount { get; }

		public long TranslationMissCacheHitCount { get; }

		public long PlaceholderCacheHitCount { get; }

		public long PlaceholderMissCacheHitCount { get; }

		public long NormalizationCallCount { get; }

		public long NormalizationCacheHitCount { get; }

		public long TemplateDispatchCallCount { get; }

		public long TemplateCandidateCount { get; }

		public long TemplateRuleAttemptCount { get; }

		public long TemplateConstrainedAttemptCount { get; }

		public long TemplateMatchCount { get; }

		public long GreedyAttemptCount { get; }

		public long GreedyMatchCount { get; }

		public long TranslationCacheEvictionCount { get; }

		public long TranslationMissCacheEvictionCount { get; }

		public long PlaceholderCacheEvictionCount { get; }

		public long PlaceholderMissCacheEvictionCount { get; }

		public long NormalizationCacheEvictionCount { get; }

		public long GameResolveCacheEvictionCount { get; }

		public long GameResolveMissCacheEvictionCount { get; }

		public long GameLocalizeCacheEvictionCount { get; }

		public long GameLocalizeMissCacheEvictionCount { get; }

		public long GameItemNameTokenCacheEvictionCount { get; }

		public long GameItemNameTokenMissCacheEvictionCount { get; }

		public double InterceptionTotalMilliseconds { get; }

		public double TranslationTotalMilliseconds { get; }

		public double NormalizationTotalMilliseconds { get; }

		public double TemplateTotalMilliseconds { get; }

		public double GreedyTotalMilliseconds { get; }

		public double InterceptionAverageMilliseconds => CalculateAverage(InterceptionTotalMilliseconds, InterceptionCallCount);

		public double TranslationAverageMilliseconds => CalculateAverage(TranslationTotalMilliseconds, TranslationCallCount);

		public double NormalizationAverageMilliseconds => CalculateAverage(NormalizationTotalMilliseconds, NormalizationCallCount);

		public double TemplateAverageMilliseconds => CalculateAverage(TemplateTotalMilliseconds, TemplateDispatchCallCount);

		public double GreedyAverageMilliseconds => CalculateAverage(GreedyTotalMilliseconds, GreedyAttemptCount);

		public double TranslationCacheHitRate => CalculateRate(TranslationCacheHitCount, TranslationCallCount);

		public double TranslationMissCacheHitRate => CalculateRate(TranslationMissCacheHitCount, TranslationCallCount);

		public double NormalizationCacheHitRate => CalculateRate(NormalizationCacheHitCount, NormalizationCallCount);

		public double AverageTemplateCandidateCount => CalculateAverage(TemplateCandidateCount, TemplateDispatchCallCount);

		public long TotalRuntimeCacheEvictions => TranslationCacheEvictionCount + TranslationMissCacheEvictionCount + PlaceholderCacheEvictionCount + PlaceholderMissCacheEvictionCount + NormalizationCacheEvictionCount;

		public long TotalResolverCacheEvictions => GameResolveCacheEvictionCount + GameResolveMissCacheEvictionCount + GameLocalizeCacheEvictionCount + GameLocalizeMissCacheEvictionCount + GameItemNameTokenCacheEvictionCount + GameItemNameTokenMissCacheEvictionCount;

		public TranslationPerformanceSnapshot(long interceptionCallCount, long interceptionStateReuseCount, long interceptionKnownTranslatedOutputCount, long interceptionTraceCaptureCount, long translationCallCount, long translationCacheHitCount, long translationMissCacheHitCount, long placeholderCacheHitCount, long placeholderMissCacheHitCount, long normalizationCallCount, long normalizationCacheHitCount, long templateDispatchCallCount, long templateCandidateCount, long templateRuleAttemptCount, long templateConstrainedAttemptCount, long templateMatchCount, long greedyAttemptCount, long greedyMatchCount, long translationCacheEvictionCount, long translationMissCacheEvictionCount, long placeholderCacheEvictionCount, long placeholderMissCacheEvictionCount, long normalizationCacheEvictionCount, long gameResolveCacheEvictionCount, long gameResolveMissCacheEvictionCount, long gameLocalizeCacheEvictionCount, long gameLocalizeMissCacheEvictionCount, long gameItemNameTokenCacheEvictionCount, long gameItemNameTokenMissCacheEvictionCount, long interceptionTicks, long translationTicks, long normalizationTicks, long templateTicks, long greedyTicks)
		{
			InterceptionCallCount = interceptionCallCount;
			InterceptionStateReuseCount = interceptionStateReuseCount;
			InterceptionKnownTranslatedOutputCount = interceptionKnownTranslatedOutputCount;
			InterceptionTraceCaptureCount = interceptionTraceCaptureCount;
			TranslationCallCount = translationCallCount;
			TranslationCacheHitCount = translationCacheHitCount;
			TranslationMissCacheHitCount = translationMissCacheHitCount;
			PlaceholderCacheHitCount = placeholderCacheHitCount;
			PlaceholderMissCacheHitCount = placeholderMissCacheHitCount;
			NormalizationCallCount = normalizationCallCount;
			NormalizationCacheHitCount = normalizationCacheHitCount;
			TemplateDispatchCallCount = templateDispatchCallCount;
			TemplateCandidateCount = templateCandidateCount;
			TemplateRuleAttemptCount = templateRuleAttemptCount;
			TemplateConstrainedAttemptCount = templateConstrainedAttemptCount;
			TemplateMatchCount = templateMatchCount;
			GreedyAttemptCount = greedyAttemptCount;
			GreedyMatchCount = greedyMatchCount;
			TranslationCacheEvictionCount = translationCacheEvictionCount;
			TranslationMissCacheEvictionCount = translationMissCacheEvictionCount;
			PlaceholderCacheEvictionCount = placeholderCacheEvictionCount;
			PlaceholderMissCacheEvictionCount = placeholderMissCacheEvictionCount;
			NormalizationCacheEvictionCount = normalizationCacheEvictionCount;
			GameResolveCacheEvictionCount = gameResolveCacheEvictionCount;
			GameResolveMissCacheEvictionCount = gameResolveMissCacheEvictionCount;
			GameLocalizeCacheEvictionCount = gameLocalizeCacheEvictionCount;
			GameLocalizeMissCacheEvictionCount = gameLocalizeMissCacheEvictionCount;
			GameItemNameTokenCacheEvictionCount = gameItemNameTokenCacheEvictionCount;
			GameItemNameTokenMissCacheEvictionCount = gameItemNameTokenMissCacheEvictionCount;
			InterceptionTotalMilliseconds = TicksToMilliseconds(interceptionTicks);
			TranslationTotalMilliseconds = TicksToMilliseconds(translationTicks);
			NormalizationTotalMilliseconds = TicksToMilliseconds(normalizationTicks);
			TemplateTotalMilliseconds = TicksToMilliseconds(templateTicks);
			GreedyTotalMilliseconds = TicksToMilliseconds(greedyTicks);
		}

		private static double TicksToMilliseconds(long ticks)
		{
			if (ticks > 0)
			{
				return (double)ticks * 1000.0 / (double)Stopwatch.Frequency;
			}
			return 0.0;
		}

		private static double CalculateAverage(double total, long count)
		{
			if (count > 0)
			{
				return total / (double)count;
			}
			return 0.0;
		}

		private static double CalculateAverage(long total, long count)
		{
			if (count > 0)
			{
				return (double)total / (double)count;
			}
			return 0.0;
		}

		private static double CalculateRate(long hits, long total)
		{
			if (total > 0)
			{
				return (double)hits / (double)total;
			}
			return 0.0;
		}
	}
	internal static class TranslationPerformanceMetrics
	{
		private static long interceptionCallCount;

		private static long interceptionStateReuseCount;

		private static long interceptionKnownTranslatedOutputCount;

		private static long interceptionTraceCaptureCount;

		private static long translationCallCount;

		private static long translationCacheHitCount;

		private static long translationMissCacheHitCount;

		private static long placeholderCacheHitCount;

		private static long placeholderMissCacheHitCount;

		private static long normalizationCallCount;

		private static long normalizationCacheHitCount;

		private static long templateDispatchCallCount;

		private static long templateCandidateCount;

		private static long templateRuleAttemptCount;

		private static long templateConstrainedAttemptCount;

		private static long templateMatchCount;

		private static long greedyAttemptCount;

		private static long greedyMatchCount;

		private static long translationCacheEvictionCount;

		private static long translationMissCacheEvictionCount;

		private static long placeholderCacheEvictionCount;

		private static long placeholderMissCacheEvictionCount;

		private static long normalizationCacheEvictionCount;

		private static long gameResolveCacheEvictionCount;

		private static long gameResolveMissCacheEvictionCount;

		private static long gameLocalizeCacheEvictionCount;

		private static long gameLocalizeMissCacheEvictionCount;

		private static long gameItemNameTokenCacheEvictionCount;

		private static long gameItemNameTokenMissCacheEvictionCount;

		private static long interceptionTicks;

		private static long translationTicks;

		private static long normalizationTicks;

		private static long templateTicks;

		private static long greedyTicks;

		private static bool CollectionEnabled => RuntimeDebugConfig.TranslationEnabled;

		internal static long StartTiming()
		{
			if (!CollectionEnabled)
			{
				return 0L;
			}
			return Stopwatch.GetTimestamp();
		}

		internal static TranslationPerformanceSnapshot GetSnapshot()
		{
			return new TranslationPerformanceSnapshot(Interlocked.Read(ref interceptionCallCount), Interlocked.Read(ref interceptionStateReuseCount), Interlocked.Read(ref interceptionKnownTranslatedOutputCount), Interlocked.Read(ref interceptionTraceCaptureCount), Interlocked.Read(ref translationCallCount), Interlocked.Read(ref translationCacheHitCount), Interlocked.Read(ref translationMissCacheHitCount), Interlocked.Read(ref placeholderCacheHitCount), Interlocked.Read(ref placeholderMissCacheHitCount), Interlocked.Read(ref normalizationCallCount), Interlocked.Read(ref normalizationCacheHitCount), Interlocked.Read(ref templateDispatchCallCount), Interlocked.Read(ref templateCandidateCount), Interlocked.Read(ref templateRuleAttemptCount), Interlocked.Read(ref templateConstrainedAttemptCount), Interlocked.Read(ref templateMatchCount), Interlocked.Read(ref greedyAttemptCount), Interlocked.Read(ref greedyMatchCount), Interlocked.Read(ref translationCacheEvictionCount), Interlocked.Read(ref translationMissCacheEvictionCount), Interlocked.Read(ref placeholderCacheEvictionCount), Interlocked.Read(ref placeholderMissCacheEvictionCount), Interlocked.Read(ref normalizationCacheEvictionCount), Interlocked.Read(ref gameResolveCacheEvictionCount), Interlocked.Read(ref gameResolveMissCacheEvictionCount), Interlocked.Read(ref gameLocalizeCacheEvictionCount), Interlocked.Read(ref gameLocalizeMissCacheEvictionCount), Interlocked.Read(ref gameItemNameTokenCacheEvictionCount), Interlocked.Read(ref gameItemNameTokenMissCacheEvictionCount), Interlocked.Read(ref interceptionTicks), Interlocked.Read(ref translationTicks), Interlocked.Read(ref normalizationTicks), Interlocked.Read(ref templateTicks), Interlocked.Read(ref greedyTicks));
		}

		internal static void Reset()
		{
			Interlocked.Exchange(ref interceptionCallCount, 0L);
			Interlocked.Exchange(ref interceptionStateReuseCount, 0L);
			Interlocked.Exchange(ref interceptionKnownTranslatedOutputCount, 0L);
			Interlocked.Exchange(ref interceptionTraceCaptureCount, 0L);
			Interlocked.Exchange(ref translationCallCount, 0L);
			Interlocked.Exchange(ref translationCacheHitCount, 0L);
			Interlocked.Exchange(ref translationMissCacheHitCount, 0L);
			Interlocked.Exchange(ref placeholderCacheHitCount, 0L);
			Interlocked.Exchange(ref placeholderMissCacheHitCount, 0L);
			Interlocked.Exchange(ref normalizationCallCount, 0L);
			Interlocked.Exchange(ref normalizationCacheHitCount, 0L);
			Interlocked.Exchange(ref templateDispatchCallCount, 0L);
			Interlocked.Exchange(ref templateCandidateCount, 0L);
			Interlocked.Exchange(ref templateRuleAttemptCount, 0L);
			Interlocked.Exchange(ref templateConstrainedAttemptCount, 0L);
			Interlocked.Exchange(ref templateMatchCount, 0L);
			Interlocked.Exchange(ref greedyAttemptCount, 0L);
			Interlocked.Exchange(ref greedyMatchCount, 0L);
			Interlocked.Exchange(ref translationCacheEvictionCount, 0L);
			Interlocked.Exchange(ref translationMissCacheEvictionCount, 0L);
			Interlocked.Exchange(ref placeholderCacheEvictionCount, 0L);
			Interlocked.Exchange(ref placeholderMissCacheEvictionCount, 0L);
			Interlocked.Exchange(ref normalizationCacheEvictionCount, 0L);
			Interlocked.Exchange(ref gameResolveCacheEvictionCount, 0L);
			Interlocked.Exchange(ref gameResolveMissCacheEvictionCount, 0L);
			Interlocked.Exchange(ref gameLocalizeCacheEvictionCount, 0L);
			Interlocked.Exchange(ref gameLocalizeMissCacheEvictionCount, 0L);
			Interlocked.Exchange(ref gameItemNameTokenCacheEvictionCount, 0L);
			Interlocked.Exchange(ref gameItemNameTokenMissCacheEvictionCount, 0L);
			Interlocked.Exchange(ref interceptionTicks, 0L);
			Interlocked.Exchange(ref translationTicks, 0L);
			Interlocked.Exchange(ref normalizationTicks, 0L);
			Interlocked.Exchange(ref templateTicks, 0L);
			Interlocked.Exchange(ref greedyTicks, 0L);
		}

		internal static void RecordInterceptionCall()
		{
			IncrementIfEnabled(ref interceptionCallCount);
		}

		internal static void RecordInterceptionStateReuse()
		{
			IncrementIfEnabled(ref interceptionStateReuseCount);
		}

		internal static void RecordInterceptionKnownTranslatedOutput()
		{
			IncrementIfEnabled(ref interceptionKnownTranslatedOutputCount);
		}

		internal static void RecordTraceCapture()
		{
			IncrementIfEnabled(ref interceptionTraceCaptureCount);
		}

		internal static void RecordTranslationCall()
		{
			IncrementIfEnabled(ref translationCallCount);
		}

		internal static void RecordTranslationCacheHit()
		{
			IncrementIfEnabled(ref translationCacheHitCount);
		}

		internal static void RecordTranslationMissCacheHit()
		{
			IncrementIfEnabled(ref translationMissCacheHitCount);
		}

		internal static void RecordPlaceholderCacheHit()
		{
			IncrementIfEnabled(ref placeholderCacheHitCount);
		}

		internal static void RecordPlaceholderMissCacheHit()
		{
			IncrementIfEnabled(ref placeholderMissCacheHitCount);
		}

		internal static void RecordNormalizationCall()
		{
			IncrementIfEnabled(ref normalizationCallCount);
		}

		internal static void RecordNormalizationCacheHit()
		{
			IncrementIfEnabled(ref normalizationCacheHitCount);
		}

		internal static void RecordTemplateDispatch(int candidateCount)
		{
			if (CollectionEnabled)
			{
				Interlocked.Increment(ref templateDispatchCallCount);
				Interlocked.Add(ref templateCandidateCount, candidateCount);
			}
		}

		internal static void RecordTemplateRuleAttempt(bool constrained)
		{
			if (CollectionEnabled)
			{
				Interlocked.Increment(ref templateRuleAttemptCount);
				if (constrained)
				{
					Interlocked.Increment(ref templateConstrainedAttemptCount);
				}
			}
		}

		internal static void RecordTemplateMatch()
		{
			IncrementIfEnabled(ref templateMatchCount);
		}

		internal static void RecordGreedyAttempt()
		{
			IncrementIfEnabled(ref greedyAttemptCount);
		}

		internal static void RecordGreedyMatch()
		{
			IncrementIfEnabled(ref greedyMatchCount);
		}

		internal static void RecordTranslationCacheEviction()
		{
			IncrementIfEnabled(ref translationCacheEvictionCount);
		}

		internal static void RecordTranslationMissCacheEviction()
		{
			IncrementIfEnabled(ref translationMissCacheEvictionCount);
		}

		internal static void RecordPlaceholderCacheEviction()
		{
			IncrementIfEnabled(ref placeholderCacheEvictionCount);
		}

		internal static void RecordPlaceholderMissCacheEviction()
		{
			IncrementIfEnabled(ref placeholderMissCacheEvictionCount);
		}

		internal static void RecordNormalizationCacheEviction()
		{
			IncrementIfEnabled(ref normalizationCacheEvictionCount);
		}

		internal static void RecordGameResolveCacheEviction()
		{
			IncrementIfEnabled(ref gameResolveCacheEvictionCount);
		}

		internal static void RecordGameResolveMissCacheEviction()
		{
			IncrementIfEnabled(ref gameResolveMissCacheEvictionCount);
		}

		internal static void RecordGameLocalizeCacheEviction()
		{
			IncrementIfEnabled(ref gameLocalizeCacheEvictionCount);
		}

		internal static void RecordGameLocalizeMissCacheEviction()
		{
			IncrementIfEnabled(ref gameLocalizeMissCacheEvictionCount);
		}

		internal static void RecordGameItemNameTokenCacheEviction()
		{
			IncrementIfEnabled(ref gameItemNameTokenCacheEvictionCount);
		}

		internal static void RecordGameItemNameTokenMissCacheEviction()
		{
			IncrementIfEnabled(ref gameItemNameTokenMissCacheEvictionCount);
		}

		internal static void AddInterceptionDuration(long startTimestamp)
		{
			AddDuration(ref interceptionTicks, startTimestamp);
		}

		internal static void AddTranslationDuration(long startTimestamp)
		{
			AddDuration(ref translationTicks, startTimestamp);
		}

		internal static void AddNormalizationDuration(long startTimestamp)
		{
			AddDuration(ref normalizationTicks, startTimestamp);
		}

		internal static void AddTemplateDuration(long startTimestamp)
		{
			AddDuration(ref templateTicks, startTimestamp);
		}

		internal static void AddGreedyDuration(long startTimestamp)
		{
			AddDuration(ref greedyTicks, startTimestamp);
		}

		private static void AddDuration(ref long destinationTicks, long startTimestamp)
		{
			if (CollectionEnabled && startTimestamp > 0)
			{
				long num = Stopwatch.GetTimestamp() - startTimestamp;
				if (num > 0)
				{
					Interlocked.Add(ref destinationTicks, num);
				}
			}
		}

		private static void IncrementIfEnabled(ref long counter)
		{
			if (CollectionEnabled)
			{
				Interlocked.Increment(ref counter);
			}
		}
	}
	internal static class TranslationRuleBrowserSnapshotProvider
	{
		private static readonly object Sync = new object();

		private static int nextVersion = 1;

		private static TranslationRuleBrowserSnapshot snapshot;

		internal static TranslationRuleBrowserSnapshot GetSnapshot()
		{
			lock (Sync)
			{
				if (snapshot != null)
				{
					return snapshot;
				}
				snapshot = new TranslationRuleBrowserSnapshot(nextVersion++, new TranslationRuleBrowserSourceSnapshot[2]
				{
					BuildSource("local", TranslationServerSyncBridge.GetLocalSnapshotForBrowsing()),
					BuildSource("server", TranslationServerSyncBridge.GetServerSnapshotForBrowsing())
				});
				return snapshot;
			}
		}

		internal static void Invalidate()
		{
			lock (Sync)
			{
				snapshot = null;
			}
		}

		private static TranslationRuleBrowserSourceSnapshot BuildSource(string sourceKey, TranslationSyncSnapshot sourceSnapshot)
		{
			List<TranslationRuleBrowserLanguageSnapshot> list = new List<TranslationRuleBrowserLanguageSnapshot>();
			foreach (SyncedLanguageRules item in (sourceSnapshot?.languages ?? Array.Empty<SyncedLanguageRules>()).Where((SyncedLanguageRules candidate) => candidate != null && !string.IsNullOrWhiteSpace(candidate.name)).OrderBy<SyncedLanguageRules, string>((SyncedLanguageRules candidate) => candidate.name, StringComparer.OrdinalIgnoreCase))
			{
				List<TranslationRuleBrowserFileSnapshot> list2 = new List<TranslationRuleBrowserFileSnapshot>();
				foreach (SyncedRuleFile item2 in (item.files ?? Array.Empty<SyncedRuleFile>()).Where((SyncedRuleFile candidate) => candidate != null && !string.IsNullOrWhiteSpace(candidate.fileName)).OrderBy<SyncedRuleFile, string>((SyncedRuleFile candidate) => candidate.fileName, StringComparer.OrdinalIgnoreCase))
				{
					RuleFileModel ruleFileModel = item2.rules ?? new RuleFileModel();
					TranslationRuleBrowserRuleSnapshot[] exactRules = BuildRules(TranslationRuleBrowserRuleKind.Exact, ruleFileModel.exact);
					TranslationRuleBrowserRuleSnapshot[] templateRules = BuildRules(TranslationRuleBrowserRuleKind.Template, ruleFileModel.templates);
					list2.Add(new TranslationRuleBrowserFileSnapshot(sourceKey, item.name, item2.fileName, exactRules, templateRules));
				}
				list.Add(new TranslationRuleBrowserLanguageSnapshot(item.name, list2.ToArray()));
			}
			return new TranslationRuleBrowserSourceSnapshot(sourceKey, list.ToArray());
		}

		private static TranslationRuleBrowserRuleSnapshot[] BuildRules(TranslationRuleBrowserRuleKind kind, ExactRuleDefinition[] rules)
		{
			if (rules == null || rules.Length == 0)
			{
				return Array.Empty<TranslationRuleBrowserRuleSnapshot>();
			}
			List<TranslationRuleBrowserRuleSnapshot> list = new List<TranslationRuleBrowserRuleSnapshot>(rules.Length);
			foreach (ExactRuleDefinition exactRuleDefinition in rules)
			{
				if (exactRuleDefinition != null)
				{
					list.Add(new TranslationRuleBrowserRuleSnapshot(kind, exactRuleDefinition.match, exactRuleDefinition.replace));
				}
			}
			return list.ToArray();
		}

		private static TranslationRuleBrowserRuleSnapshot[] BuildRules(TranslationRuleBrowserRuleKind kind, TemplateRuleDefinition[] rules)
		{
			if (rules == null || rules.Length == 0)
			{
				return Array.Empty<TranslationRuleBrowserRuleSnapshot>();
			}
			List<TranslationRuleBrowserRuleSnapshot> list = new List<TranslationRuleBrowserRuleSnapshot>(rules.Length);
			foreach (TemplateRuleDefinition templateRuleDefinition in rules)
			{
				if (templateRuleDefinition != null)
				{
					list.Add(new TranslationRuleBrowserRuleSnapshot(kind, templateRuleDefinition.match, templateRuleDefinition.replace));
				}
			}
			return list.ToArray();
		}
	}
	internal sealed class TranslationRuleBrowserSnapshot
	{
		public int Version { get; }

		public TranslationRuleBrowserSourceSnapshot[] Sources { get; }

		public TranslationRuleBrowserSnapshot(int version, TranslationRuleBrowserSourceSnapshot[] sources)
		{
			Version = version;
			Sources = sources ?? Array.Empty<TranslationRuleBrowserSourceSnapshot>();
		}
	}
	internal sealed class TranslationRuleBrowserSourceSnapshot
	{
		public string SourceKey { get; }

		public TranslationRuleBrowserLanguageSnapshot[] Languages { get; }

		public TranslationRuleBrowserSourceSnapshot(string sourceKey, TranslationRuleBrowserLanguageSnapshot[] languages)
		{
			SourceKey = sourceKey ?? string.Empty;
			Languages = languages ?? Array.Empty<TranslationRuleBrowserLanguageSnapshot>();
		}
	}
	internal sealed class TranslationRuleBrowserLanguageSnapshot
	{
		public string LanguageCode { get; }

		public TranslationRuleBrowserFileSnapshot[] Files { get; }

		public TranslationRuleBrowserLanguageSnapshot(string languageCode, TranslationRuleBrowserFileSnapshot[] files)
		{
			LanguageCode = languageCode ?? string.Empty;
			Files = files ?? Array.Empty<TranslationRuleBrowserFileSnapshot>();
		}
	}
	internal sealed class TranslationRuleBrowserFileSnapshot
	{
		public string Id { get; }

		public string SourceKey { get; }

		public string LanguageCode { get; }

		public string FileName { get; }

		public TranslationRuleBrowserRuleSnapshot[] ExactRules { get; }

		public TranslationRuleBrowserRuleSnapshot[] TemplateRules { get; }

		public int TotalRuleCount => ExactRules.Length + TemplateRules.Length;

		public TranslationRuleBrowserFileSnapshot(string sourceKey, string languageCode, string fileName, TranslationRuleBrowserRuleSnapshot[] exactRules, TranslationRuleBrowserRuleSnapshot[] templateRules)
		{
			SourceKey = sourceKey ?? string.Empty;
			LanguageCode = languageCode ?? string.Empty;
			FileName = fileName ?? string.Empty;
			ExactRules = exactRules ?? Array.Empty<TranslationRuleBrowserRuleSnapshot>();
			TemplateRules = templateRules ?? Array.Empty<TranslationRuleBrowserRuleSnapshot>();
			Id = SourceKey + "|" + LanguageCode + "|" + FileName;
		}
	}
	internal sealed class TranslationRuleBrowserRuleSnapshot
	{
		public TranslationRuleBrowserRuleKind Kind { get; }

		public string Match { get; }

		public string Replace { get; }

		public TranslationRuleBrowserRuleSnapshot(TranslationRuleBrowserRuleKind kind, string match, string replace)
		{
			Kind = kind;
			Match = match ?? string.Empty;
			Replace = replace ?? string.Empty;
		}
	}
	internal enum TranslationRuleBrowserRuleKind
	{
		Exact,
		Template
	}
	internal static class TranslationRuleLoader
	{
		private sealed class RuleAccumulator
		{
			public string LanguageName { get; }

			public Dictionary<string, TrackedExactRule> ExactRules { get; } = new Dictionary<string, TrackedExactRule>(StringComparer.Ordinal);


			public Dictionary<string, TrackedTemplateRule> TemplateRules { get; } = new Dictionary<string, TrackedTemplateRule>(StringComparer.Ordinal);


			public List<KeyValuePair<string, TrackedTemplateRule>> OrderedTemplateRules { get; } = new List<KeyValuePair<string, TrackedTemplateRule>>();


			public bool HasRules
			{
				get
				{
					if (ExactRules.Count <= 0)
					{
						return OrderedTemplateRules.Count > 0;
					}
					return true;
				}
			}

			public RuleAccumulator(string languageName)
			{
				LanguageName = languageName;
			}
		}

		private sealed class TrackedExactRule
		{
			public ExactRuleDefinition Rule { get; }

			public string SourcePath { get; }

			public TrackedExactRule(ExactRuleDefinition rule, string sourcePath)
			{
				Rule = rule;
				SourcePath = sourcePath ?? string.Empty;
			}
		}

		private sealed class TrackedTemplateRule
		{
			public TemplateRuleDefinition Rule { get; }

			public string SourcePath { get; }

			public TrackedTemplateRule(TemplateRuleDefinition rule, string sourcePath)
			{
				Rule = rule;
				SourcePath = sourcePath ?? string.Empty;
			}
		}

		private const string EnglishLanguage = "English";

		private const string ConfigFolderName = "com.paxton0505.localization";

		public static string ConfigRootPath => Path.Combine(Paths.ConfigPath, "com.paxton0505.localization");

		public static string EnglishFolderPath => GetLanguagePath("English");

		public static TranslationLoadResult Load(string languageName, TranslationSyncSnapshot remoteSnapshot = null)
		{
			string text = (string.IsNullOrWhiteSpace(languageName) ? "English" : languageName);
			TranslationSyncSnapshot remoteSnapshot2 = remoteSnapshot ?? TranslationSyncSnapshot.Empty;
			Directory.CreateDirectory(ConfigRootPath);
			Directory.CreateDirectory(EnglishFolderPath);
			string languagePath = GetLanguagePath(text);
			Directory.CreateDirectory(languagePath);
			int fileCount;
			RuleAccumulator ruleAccumulator = LoadLanguageRules("English", out fileCount);
			int fileCount2;
			RuleAccumulator ruleAccumulator2 = LoadSyncedLanguageRules(remoteSnapshot2, "English", out fileCount2);
			RuleAccumulator localActiveRules;
			RuleAccumulator syncedActiveRules;
			int fileCount3;
			int fileCount4;
			if (string.Equals(text, "English", StringComparison.Ordinal))
			{
				localActiveRules = ruleAccumulator;
				syncedActiveRules = ruleAccumulator2;
				fileCount3 = 0;
				fileCount4 = 0;
			}
			else
			{
				localActiveRules = LoadLanguageRules(text, out fileCount3);
				syncedActiveRules = LoadSyncedLanguageRules(remoteSnapshot2, text, out fileCount4);
			}
			List<RuleAccumulator> precedenceOrderedLayers = BuildRuleLayers(text, ruleAccumulator, ruleAccumulator2, localActiveRules, syncedActiveRules);
			Dictionary<string, RuleTraceMetadata> exactRuleMetadata;
			Dictionary<string, string> exactRules = BuildExactRules(precedenceOrderedLayers, out exactRuleMetadata);
			Dictionary<string, string> originalNormalizedExactMatches;
			Dictionary<string, RuleTraceMetadata> normalizedExactRuleMetadata;
			Dictionary<string, string> englishExactRulesIgnoreCase = BuildNormalizedExactRules(precedenceOrderedLayers, out originalNormalizedExactMatches, out normalizedExactRuleMetadata);
			List<CompiledTemplateRule> templateRules = BuildCompiledTemplates(precedenceOrderedLayers);
			CompiledRuleSet compiledRuleSet = new CompiledRuleSet(exactRules, englishExactRulesIgnoreCase, originalNormalizedExactMatches, exactRuleMetadata, normalizedExactRuleMetadata, templateRules);
			return new TranslationLoadResult(text, EnglishFolderPath, fileCount, fileCount2, languagePath, fileCount3, fileCount4, compiledRuleSet.ExactRules.Count, compiledRuleSet.TemplateRules.Count, compiledRuleSet);
		}

		private static List<RuleAccumulator> BuildRuleLayers(string resolvedLanguage, RuleAccumulator localEnglishRules, RuleAccumulator syncedEnglishRules, RuleAccumulator localActiveRules, RuleAccumulator syncedActiveRules)
		{
			List<RuleAccumulator> list = new List<RuleAccumulator>(4);
			if (!string.Equals(resolvedLanguage, "English", StringComparison.Ordinal))
			{
				AddRuleLayer(list, syncedActiveRules);
				AddRuleLayer(list, localActiveRules);
			}
			AddRuleLayer(list, syncedEnglishRules);
			AddRuleLayer(list, localEnglishRules);
			return list;
		}

		private static void AddRuleLayer(List<RuleAccumulator> layers, RuleAccumulator accumulator)
		{
			if (accumulator.HasRules)
			{
				layers.Add(accumulator);
			}
		}

		private static Dictionary<string, string> BuildExactRules(IReadOnlyList<RuleAccumulator> precedenceOrderedLayers, out Dictionary<string, RuleTraceMetadata> exactRuleMetadata)
		{
			int capacity = precedenceOrderedLayers.Sum((RuleAccumulator layer) => layer.ExactRules.Count);
			Dictionary<string, string> dictionary = new Dictionary<string, string>(capacity, StringComparer.Ordinal);
			exactRuleMetadata = new Dictionary<string, RuleTraceMetadata>(capacity, StringComparer.Ordinal);
			foreach (RuleAccumulator precedenceOrderedLayer in precedenceOrderedLayers)
			{
				foreach (KeyValuePair<string, TrackedExactRule> exactRule in precedenceOrderedLayer.ExactRules)
				{
					if (!dictionary.ContainsKey(exactRule.Key))
					{
						dictionary.Add(exactRule.Key, exactRule.Value.Rule.replace);
						exactRuleMetadata.Add(exactRule.Key, new RuleTraceMetadata(exactRule.Key, exactRule.Value.Rule.replace, exactRule.Value.SourcePath));
					}
				}
			}
			return dictionary;
		}

		private static Dictionary<string, string> BuildNormalizedExactRules(IReadOnlyList<RuleAccumulator> precedenceOrderedLayers, out Dictionary<string, string> originalNormalizedExactMatches, out Dictionary<string, RuleTraceMetadata> normalizedExactRuleMetadata)
		{
			int capacity = precedenceOrderedLayers.Sum((RuleAccumulator layer) => layer.ExactRules.Count);
			Dictionary<string, string> dictionary = new Dictionary<string, string>(capacity, StringComparer.OrdinalIgnoreCase);
			originalNormalizedExactMatches = new Dictionary<string, string>(capacity, StringComparer.OrdinalIgnoreCase);
			normalizedExactRuleMetadata = new Dictionary<string, RuleTraceMetadata>(capacity, StringComparer.OrdinalIgnoreCase);
			foreach (RuleAccumulator precedenceOrderedLayer in precedenceOrderedLayers)
			{
				MergeNormalizedExactRules(dictionary, originalNormalizedExactMatches, normalizedExactRuleMetadata, precedenceOrderedLayer);
			}
			return dictionary;
		}

		private static void MergeNormalizedExactRules(Dictionary<string, string> ignoreCaseRules, Dictionary<string, string> originalNormalizedExactMatches, Dictionary<string, RuleTraceMetadata> normalizedExactRuleMetadata, RuleAccumulator accumulator)
		{
			foreach (KeyValuePair<string, TrackedExactRule> rule in accumulator.ExactRules)
			{
				string text = TextMatchNormalizer.Normalize(rule.Key);
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				if (ignoreCaseRules.ContainsKey(text))
				{
					PluginMain.DebugLog(() => "Duplicate normalized exact fallback rule '" + rule.Key + "' in language '" + accumulator.LanguageName + "'. Later definition was ignored.");
				}
				else
				{
					ignoreCaseRules.Add(text, rule.Value.Rule.replace);
					originalNormalizedExactMatches.Add(text, rule.Key);
					normalizedExactRuleMetadata.Add(text, new RuleTraceMetadata(rule.Key, rule.Value.Rule.replace, rule.Value.SourcePath));
				}
			}
		}

		private static List<CompiledTemplateRule> BuildCompiledTemplates(IReadOnlyList<RuleAccumulator> precedenceOrderedLayers)
		{
			List<CompiledTemplateRule> list = new List<CompiledTemplateRule>(precedenceOrderedLayers.Sum((RuleAccumulator layer) => layer.OrderedTemplateRules.Count));
			HashSet<string> seenTemplateMatches = new HashSet<string>(StringComparer.Ordinal);
			foreach (RuleAccumulator precedenceOrderedLayer in precedenceOrderedLayers)
			{
				LoadCompiledTemplates(precedenceOrderedLayer.OrderedTemplateRules, precedenceOrderedLayer.LanguageName, list, seenTemplateMatches);
			}
			return list;
		}

		private static void LoadCompiledTemplates(IReadOnlyList<KeyValuePair<string, TrackedTemplateRule>> sourceRules, string languageName, List<CompiledTemplateRule> orderedTemplates, HashSet<string> seenTemplateMatches)
		{
			foreach (KeyValuePair<string, TrackedTemplateRule> sourceRule in sourceRules)
			{
				if (seenTemplateMatches.Add(sourceRule.Key))
				{
					if (!CompiledTemplateRule.TryCreate(sourceRule.Value.Rule.match, sourceRule.Value.Rule.replace, sourceRule.Value.SourcePath, out var rule, out var error))
					{
						PluginMain.Log.LogError((object)("Failed to compile template rule '" + sourceRule.Key + "' from language '" + languageName + "': " + error));
					}
					else
					{
						orderedTemplates.Add(rule);
					}
				}
			}
		}

		private static RuleAccumulator LoadLanguageRules(string languageName, out int fileCount)
		{
			string languagePath = GetLanguagePath(languageName);
			RuleAccumulator ruleAccumulator = new RuleAccumulator(languageName);
			string[] array = Directory.GetFiles(languagePath, "*.json", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string path) => Path.GetFileName(path), StringComparer.OrdinalIgnoreCase).ToArray();
			fileCount = array.Length;
			string[] array2 = array;
			foreach (string filePath in array2)
			{
				try
				{
					string text = File.ReadAllText(filePath);
					RuleFileModel model = JsonConvert.DeserializeObject<RuleFileModel>(text) ?? new RuleFileModel();
					PluginMain.DebugLog(delegate
					{
						object[] obj = new object[4] { filePath, languageName, null, null };
						ExactRuleDefinition[] exact = model.exact;
						obj[2] = ((exact != null) ? exact.Length : 0);
						TemplateRuleDefinition[] templates = model.templates;
						obj[3] = ((templates != null) ? templates.Length : 0);
						return string.Format("Loaded local translation file '{0}' for language '{1}': exact={2}, templates={3}.", obj);
					});
					MergeExactRules(ruleAccumulator, model.exact, filePath);
					MergeTemplateRules(ruleAccumulator, model.templates, filePath);
				}
				catch (Exception ex)
				{
					PluginMain.Log.LogError((object)("Failed to load translation file '" + filePath + "': " + ex.Message));
				}
			}
			return ruleAccumulator;
		}

		private static RuleAccumulator LoadSyncedLanguageRules(TranslationSyncSnapshot remoteSnapshot, string languageName, out int fileCount)
		{
			RuleAccumulator ruleAccumulator = new RuleAccumulator(languageName);
			fileCount = 0;
			if (remoteSnapshot == null || !remoteSnapshot.TryGetLanguage(languageName, out var languageRules) || languageRules.files == null)
			{
				return ruleAccumulator;
			}
			SyncedRuleFile[] array = languageRules.files.Where((SyncedRuleFile file) => file != null && !string.IsNullOrWhiteSpace(file.fileName)).OrderBy<SyncedRuleFile, string>((SyncedRuleFile file) => file.fileName, StringComparer.OrdinalIgnoreCase).ToArray();
			fileCount = array.Length;
			SyncedRuleFile[] array2 = array;
			foreach (SyncedRuleFile syncedRuleFile in array2)
			{
				RuleFileModel model = syncedRuleFile.rules ?? new RuleFileModel();
				string snapshotPath = "serversync://" + languageName + "/" + syncedRuleFile.fileName;
				PluginMain.DebugLog(delegate
				{
					string arg = snapshotPath;
					ExactRuleDefinition[] exact = model.exact;
					object arg2 = ((exact != null) ? exact.Length : 0);
					TemplateRuleDefinition[] templates = model.templates;
					return $"Loaded synced translation file '{arg}': exact={arg2}, templates={((templates != null) ? templates.Length : 0)}.";
				});
				MergeExactRules(ruleAccumulator, model.exact, snapshotPath);
				MergeTemplateRules(ruleAccumulator, model.templates, snapshotPath);
			}
			return ruleAccumulator;
		}

		private static void MergeExactRules(RuleAccumulator accumulator, ExactRuleDefinition[] rules, string filePath)
		{
			if (rules == null)
			{
				return;
			}
			foreach (ExactRuleDefinition rule in rules)
			{
				if (rule == null || string.IsNullOrWhiteSpace(rule.match) || rule.replace == null)
				{
					PluginMain.Log.LogWarning((object)("Ignoring invalid exact rule in '" + filePath + "'."));
				}
				else if (accumulator.ExactRules.ContainsKey(rule.match))
				{
					PluginMain.DebugLog(() => "Duplicate exact rule '" + rule.match + "' in language '" + accumulator.LanguageName + "'. Later definition from '" + filePath + "' was ignored.");
				}
				else
				{
					accumulator.ExactRules.Add(rule.match, new TrackedExactRule(rule, filePath));
				}
			}
		}

		private static void MergeTemplateRules(RuleAccumulator accumulator, TemplateRuleDefinition[] rules, string filePath)
		{
			if (rules == null)
			{
				return;
			}
			foreach (TemplateRuleDefinition rule in rules)
			{
				if (rule == null || string.IsNullOrWhiteSpace(rule.match) || rule.replace == null)
				{
					PluginMain.Log.LogWarning((object)("Ignoring invalid template rule in '" + filePath + "'."));
				}
				else if (accumulator.TemplateRules.ContainsKey(rule.match))
				{
					PluginMain.DebugLog(() => "Duplicate template rule '" + rule.match + "' in language '" + accumulator.LanguageName + "'. Later definition from '" + filePath + "' was ignored.");
				}
				else
				{
					TrackedTemplateRule value = new TrackedTemplateRule(rule, filePath);
					accumulator.TemplateRules.Add(rule.match, value);
					accumulator.OrderedTemplateRules.Add(new KeyValuePair<string, TrackedTemplateRule>(rule.match, value));
				}
			}
		}

		private static string GetLanguagePath(string languageName)
		{
			return Path.Combine(ConfigRootPath, languageName);
		}
	}
	internal static class TranslationRuntime
	{
		private const string EnglishLanguage = "English";

		private const int MaxTranslationCacheEntries = 16384;

		private const int MaxMissCacheEntries = 4096;

		private const int MaxPlaceholderCacheEntries = 4096;

		private const int MaxPlaceholderMissCacheEntries = 2048;

		private static readonly BoundedStringDictionary<string> translationCache = new BoundedStringDictionary<string>(16384, StringComparer.Ordinal);

		private static readonly BoundedStringSet missCache = new BoundedStringSet(4096, StringComparer.Ordinal);

		private static readonly Dictionary<string, int> knownTranslatedOutputCounts = new Dictionary<string, int>(StringComparer.Ordinal);

		private static readonly BoundedStringDictionary<string> placeholderCache = new BoundedStringDictionary<string>(4096, StringComparer.Ordinal);

		private static readonly BoundedStringSet placeholderMissCache = new BoundedStringSet(2048, StringComparer.Ordinal);

		private static CompiledRuleSet compiledRuleSet = CompiledRuleSet.Empty;

		private static TranslationSyncSnapshot remoteSnapshot = TranslationSyncSnapshot.Empty;

		private static string currentLanguage = "English";

		private static TranslationLoadResult lastLoadResult;

		private static bool initialized;

		private static int interceptionStateVersion;

		internal static int InterceptionStateVersion => Volatile.Read(ref interceptionStateVersion);

		public static void Initialize()
		{
			if (!initialized)
			{
				initialized = true;
				currentLanguage = ResolveCurrentLanguage();
				PluginMain.Log.LogInfo((object)PluginMain.LocalizeFormat("runtime.log.config_root", "Translation config root: {0}", TranslationRuleLoader.ConfigRootPath));
				if (!RuntimeDebugConfig.TranslationEnabled)
				{
					DisableRuntime("startup", logInfo: true);
					return;
				}
				TranslationLoadResult loadResult = ReloadCompiledRules();
				LogLoadResult("Loaded", loadResult);
			}
		}

		internal static TranslationRuntimeDiagnostics GetDiagnostics()
		{
			TranslationLoadResult translationLoadResult = lastLoadResult;
			return new TranslationRuntimeDiagnostics(initialized, translationLoadResult?.LanguageName ?? currentLanguage, RuntimeDebugConfig.TranslationEnabled, RuntimeDebugConfig.Enabled, TranslationRuleLoader.ConfigRootPath, translationLoadResult?.ExactRuleCount ?? compiledRuleSet.ExactRules.Count, translationLoadResult?.TemplateRuleCount ?? compiledRuleSet.TemplateRules.Count, translationLoadResult?.LocalEnglishFileCount ?? 0, translationLoadResult?.SyncedEnglishFileCount ?? 0, translationLoadResult?.LocalActiveFileCount ?? 0, translationLoadResult?.SyncedActiveFileCount ?? 0, translationCache.Count, missCache.Count, placeholderCache.Count, placeholderMissCache.Count, remoteSnapshot != TranslationSyncSnapshot.Empty, TranslationPerformanceMetrics.GetSnapshot());
		}

		internal static CompiledRuleSet GetCompiledRuleSetSnapshot()
		{
			return compiledRuleSet ?? CompiledRuleSet.Empty;
		}

		internal static TranslationAnalysisResult AnalyzeTranslation(string input)
		{
			return AnalyzeTranslation(input, compiledRuleSet);
		}

		internal static TranslationAnalysisResult AnalyzeTranslation(string input, CompiledRuleSet rules)
		{
			CompiledRuleSet activeRuleSet = rules ?? CompiledRuleSet.Empty;
			List<TranslationAnalysisSection> list = new List<TranslationAnalysisSection>();
			string text = input ?? string.Empty;
			List<string> list2 = new List<string>();
			string text2 = PluginMain.Localize("runtime.analysis.pass_title_one", "Pass 1");
			string text3 = PluginMain.Localize("runtime.analysis.pass_title_two", "Pass 2");
			list2.Add(PluginMain.LocalizeFormat("runtime.analysis.runtime_initialized", "Runtime initialized: {0}", initialized ? PluginMain.Localize("common.yes", "Yes") : PluginMain.Localize("common.no", "No")));
			list2.Add(PluginMain.LocalizeFormat("runtime.analysis.translation_enabled", "Translation enabled: {0}", RuntimeDebugConfig.TranslationEnabled ? PluginMain.Localize("common.yes", "Yes") : PluginMain.Localize("common.no", "No")));
			list2.Add(PluginMain.Localize("runtime.analysis.runtime_pass_chain", "Top-level pass chain: fixed 2 passes. Additional whole string longest match rewrites are shown as step N inside a pass."));
			if (!initialized)
			{
				list2.Add(PluginMain.Localize("runtime.analysis.runtime_not_initialized", "Analysis stopped because the translation runtime is not initialized."));
				list.Add(new TranslationAnalysisSection(PluginMain.Localize("runtime.analysis.runtime_state", "Runtime State"), list2.ToArray()));
				return new TranslationAnalysisResult(text, text, list.ToArray());
			}
			if (text.Length == 0)
			{
				list2.Add(PluginMain.Localize("runtime.analysis.runtime_empty", "Analysis stopped because the selected string is empty."));
				list.Add(new TranslationAnalysisSection(PluginMain.Localize("runtime.analysis.runtime_state", "Runtime State"), list2.ToArray()));
				return new TranslationAnalysisResult(text, text, list.ToArray());
			}
			if (!RuntimeDebugConfig.TranslationEnabled)
			{
				list2.Add(PluginMain.Localize("runtime.analysis.runtime_disabled", "Translation is currently disabled; analysis is using the current in-memory rule state."));
			}
			list.Add(new TranslationAnalysisSection(PluginMain.Localize("runtime.analysis.runtime_state", "Runtime State"), list2.ToArray()));
			List<string> list3 = new List<string>();
			TranslationAnalysisPassView passView;
			string text4 = AnalyzeTranslationPass(activeRuleSet, text, text2, list3, out passView);
			list.Add(new TranslationAnalysisSection(text2, list3.ToArray(), passView));
			if (string.Equals(text4, text, StringComparison.Ordinal))
			{
				list.Add(new TranslationAnalysisSection(PluginMain.Localize("runtime.analysis.final_title", "Final"), new string[2]
				{
					PluginMain.Localize("runtime.analysis.pass_result_no_change", "Pass 1 result: no translation rule changed the input."),
					PluginMain.LocalizeFormat("runtime.analysis.final_output", "Final output: '{0}'", PluginMain.FormatTextForDebug(text))
				}));
				return new TranslationAnalysisResult(text, text, list.ToArray());
			}
			List<string> list4 = new List<string>();
			TranslationAnalysisPassView passView2;
			string text5 = AnalyzeTranslationPass(activeRuleSet, text4, text3, list4, out passView2);
			list.Add(new TranslationAnalysisSection(text3, list4.ToArray(), passView2));
			string text6 = text4;
			List<string> list5 = new List<string>();
			if (string.Equals(text5, text4, StringComparison.Ordinal))
			{
				list5.Add(PluginMain.Localize("runtime.analysis.pass_result_no_further_change", "Pass 2 result: no further translation rule changed the first pass output."));
			}
			else if (string.Equals(text5, text, StringComparison.Ordinal))
			{
				list5.Add(PluginMain.Localize("runtime.analysis.pass_result_loop", "Pass 2 result: a translation loop back to the original input was detected, so the pass 1 output was kept."));
			}
			else
			{
				text6 = text5;
				list5.Add(PluginMain.LocalizeFormat("runtime.analysis.pass_result_updated", "Pass 2 result: output updated to '{0}'.", PluginMain.FormatTextForDebug(text6)));
			}
			list5.Add(PluginMain.LocalizeFormat("runtime.analysis.final_output", "Final output: '{0}'", PluginMain.FormatTextForDebug(text6)));
			list.Add(new TranslationAnalysisSection(PluginMain.Localize("runtime.analysis.final_title", "Final"), list5.ToArray()));
			return new TranslationAnalysisResult(text, text6, list.ToArray());
		}

		public static string Translate(string input)
		{
			if (!initialized || !RuntimeDebugConfig.TranslationEnabled || string.IsNullOrEmpty(input))
			{
				return input;
			}
			long startTimestamp = TranslationPerformanceMetrics.StartTiming();
			TranslationPerformanceMetrics.RecordTranslationCall();
			try
			{
				if (translationCache.TryGetValue(input, out var cachedValue))
				{
					TranslationPerformanceMetrics.RecordTranslationCacheHit();
					if (PluginMain.DebugModeEnabled)
					{
						PluginMain.DebugLog(() => "Translation cache hit: '" + PluginMain.FormatTextForDebug(input) + "' -> '" + PluginMain.FormatTextForDebug(cachedValue) + "'.");
						string replayedValue = TranslateCore(input);
						if (!string.Equals(replayedValue, cachedValue, StringComparison.Ordinal))
						{
							PluginMain.DebugLog(() => "Cached translation replay diverged from the stored value: cached='" + PluginMain.FormatTextForDebug(cachedValue) + "', replayed='" + PluginMain.FormatTextForDebug(replayedValue) + "'.");
						}
					}
					return cachedValue;
				}
				if (missCache.Contains(input))
				{
					TranslationPerformanceMetrics.RecordTranslationMissCacheHit();
					if (PluginMain.DebugModeEnabled)
					{
						PluginMain.DebugLog(() => "Translation miss cache hit: '" + PluginMain.FormatTextForDebug(input) + "'.");
					}
					return input;
				}
				string translated = TranslateCore(input);
				if (string.Equals(translated, input, StringComparison.Ordinal))
				{
					AddTranslationMiss(input);
					if (PluginMain.DebugModeEnabled)
					{
						PluginMain.DebugLog(() => "No translation rule matched: '" + PluginMain.FormatTextForDebug(input) + "'.");
					}
					return input;
				}
				AddTranslationHit(input, translated);
				if (PluginMain.DebugModeEnabled)
				{
					PluginMain.DebugLog(() => "Translation result: '" + PluginMain.FormatTextForDebug(input) + "' -> '" + PluginMain.FormatTextForDebug(translated) + "'.");
				}
				return translated;
			}
			finally
			{
				TranslationPerformanceMetrics.AddTranslationDuration(startTimestamp);
			}
		}

		internal static string ResolveTemplatePlaceholder(string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				return input;
			}
			if (placeholderCache.TryGetValue(input, out var cachedValue))
			{
				TranslationPerformanceMetrics.RecordPlaceholderCacheHit();
				if (PluginMain.DebugModeEnabled)
				{
					PluginMain.DebugLog(() => "Template placeholder cache hit: '" + PluginMain.FormatTextForDebug(input) + "' -> '" + PluginMain.FormatTextForDebug(cachedValue) + "'.");
				}
				return cachedValue;
			}
			if (placeholderMissCache.Contains(input))
			{
				TranslationPerformanceMetrics.RecordPlaceholderMissCacheHit();
				if (PluginMain.DebugModeEnabled)
				{
					PluginMain.DebugLog(() => "Template placeholder miss cache hit: '" + PluginMain.FormatTextForDebug(input) + "'.");
				}
				return input;
			}
			string text = ResolveTemplatePlaceholderCore(input);
			if (string.Equals(text, input, StringComparison.Ordinal))
			{
				AddPlaceholderMiss(input);
				return input;
			}
			AddPlaceholderHit(input, text);
			return text;
		}

		private static string ResolveTemplatePlaceholderCore(string input)
		{
			string translated = TranslatePlaceholderChain(input);
			if (!string.Equals(translated, input, StringComparison.Ordinal))
			{
				if (PluginMain.DebugModeEnabled)
				{
					PluginMain.DebugLog(() => "Template placeholder resolved through exact/whole-string chain: '" + PluginMain.FormatTextForDebug(input) + "' -> '" + PluginMain.FormatTextForDebug(translated) + "'.");
				}
				return translated;
			}
			if (GameTranslationResolver.TryResolve(input, out var gameResolvedValue))
			{
				string resolved = TranslatePlaceholderChain(gameResolvedValue);
				if (PluginMain.DebugModeEnabled)
				{
					PluginMain.DebugLog(() => "Template placeholder resolved through game localization + exact/whole-string chain: '" + PluginMain.FormatTextForDebug(input) + "' -> '" + PluginMain.FormatTextForDebug(gameResolvedValue) + "' -> '" + PluginMain.FormatTextForDebug(resolved) + "'.");
				}
				return resolved;
			}
			return input;
		}

		private static string TranslateCore(string input)
		{
			return TranslateChain(input, TranslateSinglePass);
		}

		private static string AnalyzeTranslationPass(CompiledRuleSet activeRuleSet, string input, string passLabel, List<string> lines, out TranslationAnalysisPassView passView)
		{
			List<TranslationAnalysisPassStage> list = new List<TranslationAnalysisPassStage>();
			lines.Add(PluginMain.LocalizeFormat("runtime.analysis.pass_input", "{0} input: '{1}'", passLabel, PluginMain.FormatTextForDebug(input)));
			string text = PluginMain.Localize("runtime.analysis.stage.exact", "Exact");
			string text2 = PluginMain.Localize("runtime.analysis.stage.normalized_exact", "Normalized Exact");
			string text3 = PluginMain.Localize("runtime.analysis.stage.template", "Template");
			string text4 = PluginMain.Localize("runtime.analysis.stage.whole_string_longest_match", "Whole String Longest Match");
			if (activeRuleSet.ExactRules.TryGetValue(input, out var value))
			{
				RuleTraceMetadata metadata;
				RuleTraceMetadata ruleTraceMetadata = (activeRuleSet.TryGetExactRuleMetadata(input, out metadata) ? metadata : new RuleTraceMetadata(input, value, null));
				string text5 = PluginMain.LocalizeFormat("runtime.analysis.pass_exact_hit", "{0} exact: hit target='{1}', match='{2}', replace='{3}', file='{4}' -> '{5}'", passLabel, PluginMain.FormatTextForDebug(input), PluginMain.FormatTextForDebug(ruleTraceMetadata.MatchText), PluginMain.FormatTextForDebug(ruleTraceMetadata.ReplaceText), PluginMain.FormatTextForDebug(FormatTraceSourcePath(ruleTraceMetadata.SourcePath)), PluginMain.FormatTextForDebug(value));
				lines.Add(text5);
				list.Add(CreateAnalysisStage(text, TranslationAnalysisStageStatus.Hit, value, text5));
				list.Add(CreateNotExecutedStage(passLabel, text2, text, lines));
				list.Add(CreateNotExecutedStage(passLabel, text3, text, lines));
				list.Add(CreateNotExecutedStage(passLabel, text4, text, lines));
				passView = new TranslationAnalysisPassView(input, value, list.ToArray());
				return value;
			}
			string text6 = PluginMain.LocalizeFormat("runtime.analysis.pass_exact_miss", "{0} exact: miss", passLabel);
			lines.Add(text6);
			list.Add(CreateAnalysisStage(text, TranslationAnalysisStageStatus.Miss, input, text6));
			TextMatchNormalizer.NormalizedText normalizedInput = TextMatchNormalizer.Analyze(input);
			List<string> list2 = new List<string>();
			if (!string.Equals(normalizedInput.Value, input, StringComparison.Ordinal))
			{
				string item = PluginMain.LocalizeFormat("runtime.analysis.pass_normalized_input", "{0} normalized input: '{1}'", passLabel, PluginMain.FormatTextForDebug(normalizedInput.Value));
				lines.Add(item);
				list2.Add(item);
			}
			if (activeRuleSet.MatchNormalizedExactRules.TryGetValue(normalizedInput.Value, out var value2))
			{
				string text7 = normalizedInput.WrapWholeMatch(value2);
				RuleTraceMetadata metadata2;
				RuleTraceMetadata ruleTraceMetadata2 = (activeRuleSet.TryGetNormalizedExactRuleMetadata(normalizedInput.Value, out metadata2) ? metadata2 : new RuleTraceMetadata(normalizedInput.Value, value2, null));
				string item2 = PluginMain.LocalizeFormat("runtime.analysis.pass_normalized_exact_hit", "{0} normalized exact: hit target='{1}', match='{2}', replace='{3}', file='{4}' -> '{5}'", passLabel, PluginMain.FormatTextForDebug(normalizedInput.Value), PluginMain.FormatTextForDebug(ruleTraceMetadata2.MatchText), PluginMain.FormatTextForDebug(ruleTraceMetadata2.ReplaceText), PluginMain.FormatTextForDebug(FormatTraceSourcePath(ruleTraceMetadata2.SourcePath)), PluginMain.FormatTextForDebug(text7));
				lines.Add(item2);
				list2.Add(item2);
				list.Add(CreateAnalysisStage(text2, TranslationAnalysisStageStatus.Hit, text7, list2.ToArray()));
				list.Add(CreateNotExecutedStage(passLabel, text3, text2, lines));
				list.Add(CreateNotExecutedStage(passLabel, text4, text2, lines));
				passView = new TranslationAnalysisPassView(input, text7, list.ToArray());
				return text7;
			}
			string item3 = PluginMain.LocalizeFormat("runtime.analysis.pass_normalized_exact_miss", "{0} normalized exact: miss", passLabel);
			lines.Add(item3);
			list2.Add(item3);
			list.Add(CreateAnalysisStage(text2, TranslationAnalysisStageStatus.Miss, null, list2.ToArray()));
			List<string> list3 = new List<string>();
			foreach (CompiledTemplateRule templateCandidate in activeRuleSet.GetTemplateCandidates(normalizedInput.Value))
			{
				if (templateCandidate.TryTranslate(normalizedInput, out var translated))
				{
					string item4 = PluginMain.LocalizeFormat("runtime.analysis.pass_template_hit", "{0} template: hit target='{1}', match='{2}', replace='{3}', file='{4}' -> '{5}'", passLabel, PluginMain.FormatTextForDebug(normalizedInput.Value), PluginMain.FormatTextForDebug(templateCandidate.Signature), PluginMain.FormatTextForDebug(templateCandidate.ReplaceTemplate), PluginMain.FormatTextForDebug(FormatTraceSourcePath(templateCandidate.SourcePath)), PluginMain.FormatTextForDebug(translated));
					lines.Add(item4);
					list3.Add(item4);
					list.Add(CreateAnalysisStage(text3, TranslationAnalysisStageStatus.Hit, translated, list3.ToArray()));
					list.Add(CreateNotExecutedStage(passLabel, text4, text3, lines));
					passView = new TranslationAnalysisPassView(input, translated, list.ToArray());
					return translated;
				}
			}
			string item5 = PluginMain.LocalizeFormat("runtime.analysis.pass_template_miss", "{0} template: miss", passLabel);
			lines.Add(item5);
			list3.Add(item5);
			list.Add(CreateAnalysisStage(text3, TranslationAnalysisStageStatus.Miss, null, list3.ToArray()));
			List<string> list4 = new List<string>();
			if (activeRuleSet.TryTranslateGreedyExact(normalizedInput, out var translated2))
			{
				if (activeRuleSet.TryAnalyzeGreedyExact(normalizedInput, out var analysis))
				{
					for (int i = 0; i < analysis.Steps.Length; i++)
					{
						GreedyExactAnalysisStep greedyExactAnalysisStep = analysis.Steps[i];
						int num = i + 1;
						string item6 = PluginMain.LocalizeFormat("runtime.analysis.pass_whole_string_longest_match_step_input", "{0} whole string longest match step {1} input: '{2}'", passLabel, num, PluginMain.FormatTextForDebug(greedyExactAnalysisStep.Input));
						lines.Add(item6);
						list4.Add(item6);
						for (int j = 0; j < greedyExactAnalysisStep.Matches.Length; j++)
						{
							GreedyExactAnalysisMatch greedyExactAnalysisMatch = greedyExactAnalysisStep.Matches[j];
							string item7 = PluginMain.LocalizeFormat("runtime.analysis.pass_whole_string_longest_match_step_hit", "{0} whole string longest match step {1} hit [{2}..{3}): target='{4}', match='{5}', replace='{6}', file='{7}'", passLabel, num, greedyExactAnalysisMatch.StartIndex, greedyExactAnalysisMatch.EndIndex, PluginMain.FormatTextForDebug(greedyExactAnalysisMatch.InputSegment), PluginMain.FormatTextForDebug(greedyExactAnalysisMatch.Match), PluginMain.FormatTextForDebug(greedyExactAnalysisMatch.Replace), PluginMain.FormatTextForDebug(FormatTraceSourcePath(greedyExactAnalysisMatch.SourcePath)));
							lines.Add(item7);
							list4.Add(item7);
						}
						string item8 = PluginMain.LocalizeFormat("runtime.analysis.pass_whole_string_longest_match_step_output", "{0} whole string longest match step {1} output: '{2}'", passLabel, num, PluginMain.FormatTextForDebug(greedyExactAnalysisStep.Output));
						lines.Add(item8);
						list4.Add(item8);
					}
					if (analysis.LoopDetected)
					{
						string item9 = PluginMain.LocalizeFormat("runtime.analysis.pass_whole_string_longest_match_loop", "{0} whole string longest match: detected a loop and kept the last non-loop output.", passLabel);
						lines.Add(item9);
						list4.Add(item9);
					}
					string item10 = PluginMain.LocalizeFormat("runtime.analysis.pass_whole_string_longest_match_final", "{0} whole string longest match: final -> '{1}'", passLabel, PluginMain.FormatTextForDebug(analysis.Output));
					lines.Add(item10);
					list4.Add(item10);
					list.Add(CreateAnalysisStage(text4, TranslationAnalysisStageStatus.Hit, analysis.Output, list4.ToArray()));
					passView = new TranslationAnalysisPassView(input, analysis.Output, list.ToArray());
					return analysis.Output;
				}
				string item11 = PluginMain.LocalizeFormat("runtime.analysis.pass_whole_string_longest_match_matched", "{0} whole string longest match: matched -> '{1}'", passLabel, PluginMain.FormatTextForDebug(translated2));
				lines.Add(item11);
				list4.Add(item11);
				list.Add(CreateAnalysisStage(text4, TranslationAnalysisStageStatus.Hit, translated2, list4.ToArray()));
				passView = new TranslationAnalysisPassView(input, translated2, list.ToArray());
				return translated2;
			}
			string item12 = PluginMain.LocalizeFormat("runtime.analysis.pass_whole_string_longest_match_miss", "{0} whole string longest match: miss", passLabel);
			lines.Add(item12);
			list4.Add(item12);
			list.Add(CreateAnalysisStage(text4, TranslationAnalysisStageStatus.Miss, null, list4.ToArray()));
			passView = new TranslationAnalysisPassView(input, input, list.ToArray());
			return input;
		}

		private static TranslationAnalysisPassStage CreateAnalysisStage(string title, TranslationAnalysisStageStatus status, string output, params string[] details)
		{
			return new TranslationAnalysisPassStage(title, status, (status == TranslationAnalysisStageStatus.Hit) ? PluginMain.LocalizeFormat("runtime.analysis.stage_summary_output", "Output: '{0}'", PluginMain.FormatTextForDebug(output)) : PluginMain.Localize("runtime.analysis.stage_summary_miss", "No rule matched."), details ?? Array.Empty<string>());
		}

		private static TranslationAnalysisPassStage CreateNotExecutedStage(string passLabel, string stageTitle, string previousStageTitle, List<string> lines)
		{
			string text = PluginMain.LocalizeFormat("runtime.analysis.pass_stage_not_executed", "{0} {1}: not executed ({2} already produced output)", passLabel, stageTitle, previousStageTitle);
			lines.Add(text);
			return new TranslationAnalysisPassStage(stageTitle, TranslationAnalysisStageStatus.NotExecuted, PluginMain.LocalizeFormat("runtime.analysis.stage_summary_not_executed", "Skipped because {0} already produced output.", previousStageTitle), new string[1] { text });
		}

		private static string FormatTraceSourcePath(string sourcePath)
		{
			if (!string.IsNullOrWhiteSpace(sourcePath))
			{
				return sourcePath;
			}
			return PluginMain.Localize("common.unknown", "<unknown>");
		}

		private static string TranslateSinglePass(string input)
		{
			if (compiledRuleSet.ExactRules.TryGetValue(input, out var value))
			{
				LogMatch("exact", input, value);
				return value;
			}
			TextMatchNormalizer.NormalizedText normalizedInput = TextMatchNormalizer.Analyze(input);
			if (compiledRuleSet.MatchNormalizedExactRules.TryGetValue(normalizedInput.Value, out var value2))
			{
				string text = normalizedInput.WrapWholeMatch(value2);
				string originalMatch;
				string detail = (compiledRuleSet.TryGetOriginalNormalizedExactMatch(normalizedInput.Value, out originalMatch) ? originalMatch : normalizedInput.Value);
				LogMatch("normalized exact", input, text, normalizedInput.Value, detail);
				return text;
			}
			long startTimestamp = TranslationPerformanceMetrics.StartTiming();
			IReadOnlyList<CompiledTemplateRule> templateCandidates = compiledRuleSet.GetTemplateCandidates(normalizedInput.Value);
			TranslationPerformanceMetrics.RecordTemplateDispatch(templateCandidates.Count);
			try
			{
				for (int i = 0; i < templateCandidates.Count; i++)
				{
					CompiledTemplateRule compiledTemplateRule = templateCandidates[i];
					TranslationPerformanceMetrics.RecordTemplateRuleAttempt(compiledTemplateRule.UsesConstrainedPlaceholders);
					if (compiledTemplateRule.TryTranslate(normalizedInput, out var translated))
					{
						TranslationPerformanceMetrics.RecordTemplateMatch();
						LogMatch("template", input, translated, normalizedInput.Value, compiledTemplateRule.Signature);
						return translated;
					}
				}
			}
			finally
			{
				TranslationPerformanceMetrics.AddTemplateDuration(startTimestamp);
			}
			long startTimestamp2 = TranslationPerformanceMetrics.StartTiming();
			TranslationPerformanceMetrics.RecordGreedyAttempt();
			try
			{
				if (compiledRuleSet.TryTranslateGreedyExact(normalizedInput, out var translated2))
				{
					TranslationPerformanceMetrics.RecordGreedyMatch();
					LogMatch("whole-string longest-match exact replacement", input, translated2, normalizedInput.Value);
					return translated2;
				}
				return input;
			}
			finally
			{
				TranslationPerformanceMetrics.AddGreedyDuration(startTimestamp2);
			}
		}

		private static string TranslateExactChain(string input)
		{
			return TranslateChain(input, TranslateExactSinglePass);
		}

		private static string TranslatePlaceholderChain(string input)
		{
			return TranslateChain(input, TranslatePlaceholderSinglePass);
		}

		private static string TranslateExactSinglePass(string input)
		{
			return TranslateExactSinglePass(input, TextMatchNormalizer.Analyze(input));
		}

		private static string TranslateExactSinglePass(string input, TextMatchNormalizer.NormalizedText normalizedInput)
		{
			if (compiledRuleSet.ExactRules.TryGetValue(input, out var value))
			{
				LogMatch("exact", input, value);
				return value;
			}
			if (compiledRuleSet.MatchNormalizedExactRules.TryGetValue(normalizedInput.Value, out var value2))
			{
				string text = normalizedInput.WrapWholeMatch(value2);
				string originalMatch;
				string detail = (compiledRuleSet.TryGetOriginalNormalizedExactMatch(normalizedInput.Value, out originalMatch) ? originalMatch : normalizedInput.Value);
				LogMatch("normalized exact", input, text, normalizedInput.Value, detail);
				return text;
			}
			return input;
		}

		private static string TranslatePlaceholderSinglePass(string input)
		{
			TextMatchNormalizer.NormalizedText normalizedInput = TextMatchNormalizer.Analyze(input);
			string text = TranslateExactSinglePass(input, normalizedInput);
			if (!string.Equals(text, input, StringComparison.Ordinal))
			{
				return text;
			}
			long startTimestamp = TranslationPerformanceMetrics.StartTiming();
			TranslationPerformanceMetrics.RecordGreedyAttempt();
			try
			{
				if (compiledRuleSet.TryTranslateGreedyExact(normalizedInput, out var translated))
				{
					TranslationPerformanceMetrics.RecordGreedyMatch();
					LogMatch("whole-string longest-match exact replacement", input, translated, normalizedInput.Value);
					return translated;
				}
				return input;
			}
			finally
			{
				TranslationPerformanceMetrics.AddGreedyDuration(startTimestamp);
			}
		}

		private static string TranslateChain(string input, Func<string, string> translatePass)
		{
			string firstPass = translatePass(input);
			if (string.Equals(firstPass, input, StringComparison.Ordinal))
			{
				return input;
			}
			string text = translatePass(firstPass);
			if (string.Equals(text, firstPass, StringComparison.Ordinal))
			{
				return firstPass;
			}
			if (string.Equals(text, input, StringComparison.Ordinal))
			{
				PluginMain.DebugLog(() => "Detected translation loop while translating '" + PluginMain.FormatTextForDebug(input) + "'. Returning '" + PluginMain.FormatTextForDebug(firstPass) + "'.");
				return firstPass;
			}
			return text;
		}

		public static void NotifyLanguageChanged(string languageName)
		{
			if (!initialized)
			{
				return;
			}
			string a = (string.IsNullOrWhiteSpace(languageName) ? "English" : languageName);
			if (!string.Equals(a, currentLanguage, StringComparison.Ordinal))
			{
				currentLanguage = a;
				if (!RuntimeDebugConfig.TranslationEnabled)
				{
					DisableRuntime("language change", logInfo: false);
					return;
				}
				TranslationLoadResult loadResult = ReloadCompiledRules();
				LogLoadResult("Reloaded", loadResult);
			}
		}

		public static void NotifyLanguageReset()
		{
			NotifyLanguageChanged("English");
		}

		internal static void NotifyRuntimeSettingsChanged(bool translationEnabledChanged)
		{
			if (!initialized)
			{
				return;
			}
			if (translationEnabledChanged)
			{
				if (!RuntimeDebugConfig.TranslationEnabled)
				{
					DisableRuntime("runtime settings change", logInfo: true);
					return;
				}
				TranslationLoadResult loadResult = ReloadCompiledRules();
				LogLoadResult("Reloaded", loadResult);
				return;
			}
			translationCache.Clear();
			missCache.Clear();
			knownTranslatedOutputCounts.Clear();
			placeholderCache.Clear();
			placeholderMissCache.Clear();
			GameTranslationResolver.ClearCaches();
			InvalidateInterceptionState();
			if (PluginMain.DebugModeEnabled)
			{
				PluginMain.DebugLog("Cleared translation caches after runtime settings change.");
			}
		}

		internal static void NotifyLocalRulesChanged()
		{
			if (initialized)
			{
				if (!RuntimeDebugConfig.TranslationEnabled)
				{
					DisableRuntime("local rule change", logInfo: false);
					return;
				}
				TranslationLoadResult loadResult = ReloadCompiledRules();
				LogLoadResult("Reloaded", loadResult);
			}
		}

		internal static void NotifySyncedRulesChanged(TranslationSyncSnapshot snapshot)
		{
			remoteSnapshot = snapshot ?? TranslationSyncSnapshot.Empty;
			if (initialized)
			{
				if (!RuntimeDebugConfig.TranslationEnabled)
				{
					DisableRuntime("synced rule change", logInfo: false);
					return;
				}
				TranslationLoadResult loadResult = ReloadCompiledRules();
				LogLoadResult("Reloaded", loadResult);
			}
		}

		private static string ResolveCurrentLanguage()
		{
			string @string = PlayerPrefs.GetString("language", "English");
			if (!string.IsNullOrWhiteSpace(@string))
			{
				return @string;
			}
			return "English";
		}

		private static TranslationLoadResult ReloadCompiledRules()
		{
			TranslationLoadResult translationLoadResult = TranslationRuleLoader.Load(currentLanguage, remoteSnapshot);
			compiledRuleSet = translationLoadResult.RuleSet;
			lastLoadResult = translationLoadResult;
			TranslationRuleBrowserSnapshotProvider.Invalidate();
			ClearRuntimeCaches();
			GameTranslationResolver.ClearCaches();
			InvalidateInterceptionState();
			return translationLoadResult;
		}

		private static void DisableRuntime(string reason, bool logInfo)
		{
			compiledRuleSet = CompiledRuleSet.Empty;
			lastLoadResult = null;
			TranslationRuleBrowserSnapshotProvider.Invalidate();
			ClearRuntimeCaches();
			GameTranslationResolver.ClearCaches();
			InvalidateInterceptionState();
			if (logInfo)
			{
				ManualLogSource log = PluginMain.Log;
				if (log != null)
				{
					log.LogInfo((object)PluginMain.LocalizeFormat("runtime.log.disabled_after_reason", "Translation runtime disabled; skipped rule loading after {0}.", reason));
				}
			}
		}

		private static void AddPlaceholderHit(string input, string translated)
		{
			if (placeholderCache.Set(input, translated, out var _))
			{
				TranslationPerformanceMetrics.RecordPlaceholderCacheEviction();
			}
		}

		private static void AddPlaceholderMiss(string input)
		{
			if (placeholderMissCache.Add(input, out var evictedKey) && evictedKey != null)
			{
				TranslationPerformanceMetrics.RecordPlaceholderMissCacheEviction();
			}
		}

		private static void LogMatch(string stage, string input, string output, string normalizedInput = null, string detail = null)
		{
			if (!PluginMain.DebugModeEnabled)
			{
				return;
			}
			PluginMain.DebugLog(delegate
			{
				string text = stage + " match: '" + PluginMain.FormatTextForDebug(input) + "' -> '" + PluginMain.FormatTextForDebug(output) + "'";
				if (!string.IsNullOrWhiteSpace(detail))
				{
					text = text + " using '" + PluginMain.FormatTextForDebug(detail) + "'";
				}
				if (!string.IsNullOrEmpty(normalizedInput) && !string.Equals(normalizedInput, input, StringComparison.Ordinal))
				{
					text = text + " (normalized='" + PluginMain.FormatTextForDebug(normalizedInput) + "')";
				}
				return text;
			});
		}

		private static void LogLoadResult(string verb, TranslationLoadResult loadResult)
		{
			PluginMain.Log.LogInfo((object)PluginMain.LocalizeFormat("runtime.log.load_result", "{0} translation rules for '{1}'. English='{2}' (local={3}, synced={4}), Active='{5}' (local={6}, synced={7}), exact={8}, templates={9}.", verb, loadResult.LanguageName, loadResult.EnglishFolderPath, loadResult.LocalEnglishFileCount, loadResult.SyncedEnglishFileCount, loadResult.ActiveFolderPath, loadResult.LocalActiveFileCount, loadResult.SyncedActiveFileCount, loadResult.ExactRuleCount, loadResult.TemplateRuleCount));
		}

		internal static bool IsKnownTranslatedOutput(string input)
		{
			if (!string.IsNullOrEmpty(input))
			{
				return knownTranslatedOutputCounts.ContainsKey(input);
			}
			return false;
		}

		private static void InvalidateInterceptionState()
		{
			Interlocked.Increment(ref interceptionStateVersion);
		}

		private static void AddTranslationHit(string input, string translated)
		{
			if (translationCache.Set(input, translated, out var evictedEntry))
			{
				TranslationPerformanceMetrics.RecordTranslationCacheEviction();
				UntrackKnownTranslatedOutput(evictedEntry.Value);
			}
			TrackKnownTranslatedOutput(translated);
		}

		private static void AddTranslationMiss(string input)
		{
			if (missCache.Add(input, out var evictedKey) && evictedKey != null)
			{
				TranslationPerformanceMetrics.RecordTranslationMissCacheEviction();
			}
		}

		private static void ClearRuntimeCaches()
		{
			translationCache.Clear();
			missCache.Clear();
			knownTranslatedOutputCounts.Clear();
			placeholderCache.Clear();
			placeholderMissCache.Clear();
		}

		private static void TrackKnownTranslatedOutput(string translated)
		{
			if (!string.IsNullOrEmpty(translated))
			{
				if (knownTranslatedOutputCounts.TryGetValue(translated, out var value))
				{
					knownTranslatedOutputCounts[translated] = value + 1;
				}
				else
				{
					knownTranslatedOutputCounts.Add(translated, 1);
				}
			}
		}

		private static void UntrackKnownTranslatedOutput(string translated)
		{
			if (!string.IsNullOrEmpty(translated) && knownTranslatedOutputCounts.TryGetValue(translated, out var value))
			{
				if (value <= 1)
				{
					knownTranslatedOutputCounts.Remove(translated);
				}
				else
				{
					knownTranslatedOutputCounts[translated] = value - 1;
				}
			}
		}
	}
	internal static class TranslationServerSyncBridge
	{
		private const string SnapshotIdentifier = "translation-rules-snapshot";

		private const double ConfigSnapshotDebounceMilliseconds = 500.0;

		private static readonly ConfigSync configSync = new ConfigSync("com.paxton0505.localization")
		{
			DisplayName = "Localization",
			CurrentVersion = "2.0.1",
			MinimumRequiredVersion = "2.0.1"
		};

		private static readonly CustomSyncedValue<string> syncedSnapshotJson = new CustomSyncedValue<string>(configSync, "translation-rules-snapshot", string.Empty);

		private static FileSystemWatcher configWatcher;

		private static System.Timers.Timer configSnapshotDebounceTimer;

		private static TranslationSyncSnapshot lastAppliedRemoteSnapshot = TranslationSyncSnapshot.Empty;

		private static bool initialized;

		public static void Initialize()
		{
			if (!initialized)
			{
				initialized = true;
				Directory.CreateDirectory(TranslationRuleLoader.ConfigRootPath);
				syncedSnapshotJson.ValueChanged += OnSnapshotValueChanged;
				configSync.SourceOfTruthChanged += OnSourceOfTruthChanged;
				SetupWatcher();
				if (ShouldPublishServerSnapshot())
				{
					PublishLocalSnapshot("startup");
				}
				else
				{
					syncedSnapshotJson.Value = string.Empty;
				}
				ApplyRemoteSnapshot();
			}
		}

		public static void Shutdown()
		{
			if (initialized)
			{
				if (configWatcher != null)
				{
					configWatcher.EnableRaisingEvents = false;
					configWatcher.Changed -= OnConfigFilesChanged;
					configWatcher.Created -= OnConfigFilesChanged;
					configWatcher.Deleted -= OnConfigFilesChanged;
					configWatcher.Renamed -= OnConfigFilesChanged;
					configWatcher.Dispose();
					configWatcher = null;
				}
				if (configSnapshotDebounceTimer != null)
				{
					configSnapshotDebounceTimer.Stop();
					configSnapshotDebounceTimer.Elapsed -= OnConfigSnapshotDebounceElapsed;
					configSnapshotDebounceTimer.Dispose();
					configSnapshotDebounceTimer = null;
				}
				syncedSnapshotJson.ValueChanged -= OnSnapshotValueChanged;
				configSync.SourceOfTruthChanged -= OnSourceOfTruthChanged;
				lastAppliedRemoteSnapshot = TranslationSyncSnapshot.Empty;
				initialized = false;
			}
		}

		internal static TranslationSyncSnapshot GetLocalSnapshotForBrowsing()
		{
			return BuildLocalSnapshot();
		}

		internal static TranslationSyncSnapshot GetServerSnapshotForBrowsing()
		{
			return lastAppliedRemoteSnapshot ?? TranslationSyncSnapshot.Empty;
		}

		private static void SetupWatcher()
		{
			configWatcher = new FileSystemWatcher(TranslationRuleLoader.ConfigRootPath, "*.json")
			{
				IncludeSubdirectories = true,
				SynchronizingObject = ThreadingHelper.SynchronizingObject,
				NotifyFilter = (NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite | NotifyFilters.CreationTime)
			};
			configWatcher.Changed += OnConfigFilesChanged;
			configWatcher.Created += OnConfigFilesChanged;
			configWatcher.Deleted += OnConfigFilesChanged;
			configWatcher.Renamed += OnConfigFilesChanged;
			configWatcher.EnableRaisingEvents = true;
			configSnapshotDebounceTimer = new System.Timers.Timer(500.0)
			{
				AutoReset = false,
				SynchronizingObject = ThreadingHelper.SynchronizingObject
			};
			configSnapshotDebounceTimer.Elapsed += OnConfigSnapshotDebounceElapsed;
		}

		private static void OnConfigFilesChanged(object sender, FileSystemEventArgs e)
		{
			ScheduleLocalSnapshotPublish();
		}

		private static void OnConfigSnapshotDebounceElapsed(object sender, ElapsedEventArgs e)
		{
			if (ShouldPublishServerSnapshot())
			{
				PublishLocalSnapshot("debounced local config change");
			}
			TranslationRuntime.NotifyLocalRulesChanged();
		}

		private static void ScheduleLocalSnapshotPublish()
		{
			if (configSnapshotDebounceTimer == null)
			{
				if (ShouldPublishServerSnapshot())
				{
					PublishLocalSnapshot("local config change");
				}
				TranslationRuntime.NotifyLocalRulesChanged();
			}
			else
			{
				configSnapshotDebounceTimer.Stop();
				configSnapshotDebounceTimer.Start();
			}
		}

		private static void OnSnapshotValueChanged()
		{
			if (!configSync.IsSourceOfTruth)
			{
				ApplyRemoteSnapshot();
			}
		}

		private static void OnSourceOfTruthChanged(bool isSourceOfTruth)
		{
			if (isSourceOfTruth && PluginMain.IsDedicatedServer)
			{
				if (PluginMain.Log != null)
				{
					PluginMain.Log.LogInfo((object)PluginMain.Localize("serversync.log.source_of_truth", "ServerSync source-of-truth enabled; local config hot reload is active."));
				}
				TranslationRuntime.NotifySyncedRulesChanged(TranslationSyncSnapshot.Empty);
				configSnapshotDebounceTimer?.Stop();
				PublishLocalSnapshot("source-of-truth activation");
			}
			else
			{
				configSnapshotDebounceTimer?.Stop();
				if (isSourceOfTruth)
				{
					syncedSnapshotJson.Value = string.Empty;
				}
				TranslationRuntime.NotifySyncedRulesChanged(TranslationSyncSnapshot.Empty);
			}
		}

		private static void PublishLocalSnapshot(string reason)
		{
			TranslationSyncSnapshot translationSyncSnapshot = BuildLocalSnapshot();
			string value = SerializeSnapshot(translationSyncSnapshot);
			syncedSnapshotJson.Value = value;
			if (!configSync.IsSourceOfTruth || PluginMain.Log == null)
			{
				return;
			}
			SyncedLanguageRules[] languages = translationSyncSnapshot.languages;
			int num = ((languages != null) ? languages.Length : 0);
			int num2 = 0;
			if (translationSyncSnapshot.languages != null)
			{
				SyncedLanguageRules[] languages2 = translationSyncSnapshot.languages;
				foreach (SyncedLanguageRules syncedLanguageRules in languages2)
				{
					if (syncedLanguageRules?.files != null)
					{
						num2 += syncedLanguageRules.files.Length;
					}
				}
			}
			PluginMain.Log.LogInfo((object)PluginMain.LocalizeFormat("serversync.log.snapshot_published", "Published local translation snapshot after {0}: {1} language folder(s), {2} file(s).", reason, num, num2));
		}

		private static void ApplyRemoteSnapshot()
		{
			if (configSync.IsSourceOfTruth)
			{
				lastAppliedRemoteSnapshot = TranslationSyncSnapshot.Empty;
				TranslationRuntime.NotifySyncedRulesChanged(TranslationSyncSnapshot.Empty);
			}
			else
			{
				TranslationRuntime.NotifySyncedRulesChanged(lastAppliedRemoteSnapshot = DeserializeSnapshot(syncedSnapshotJson.Value));
			}
		}

		private static bool ShouldPublishServerSnapshot()
		{
			if (PluginMain.IsDedicatedServer)
			{
				return configSync.IsSourceOfTruth;
			}
			return false;
		}

		private static TranslationSyncSnapshot BuildLocalSnapshot()
		{
			Directory.CreateDirectory(TranslationRuleLoader.ConfigRootPath);
			List<SyncedLanguageRules> list = new List<SyncedLanguageRules>();
			foreach (string item in Directory.GetDirectories(TranslationRuleLoader.ConfigRootPath).OrderBy<string, string>((string path) => Path.GetFileName(path), StringComparer.OrdinalIgnoreCase))
			{
				string fileName = Path.GetFileName(item);
				if (string.IsNullOrWhiteSpace(fileName))
				{
					continue;
				}
				List<SyncedRuleFile> list2 = new List<SyncedRuleFile>();
				foreach (string item2 in Directory.GetFiles(item, "*.json", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string path) => Path.GetFileName(path), StringComparer.OrdinalIgnoreCase))
				{
					try
					{
						RuleFileModel rules = JsonConvert.DeserializeObject<RuleFileModel>(File.ReadAllText(item2)) ?? new RuleFileModel();
						list2.Add(new SyncedRuleFile
						{
							fileName = Path.GetFileName(item2),
							rules = rules
						});
					}
					catch (Exception ex)
					{
						PluginMain.Log.LogError((object)("Failed to serialize translation file '" + item2 + "' for ServerSync: " + ex.Message));
					}
				}
				list.Add(new SyncedLanguageRules
				{
					name = fileName,
					files = list2.ToArray()
				});
			}
			return new TranslationSyncSnapshot
			{
				languages = list.ToArray()
			};
		}

		private static string SerializeSnapshot(TranslationSyncSnapshot snapshot)
		{
			return JsonConvert.SerializeObject((object)snapshot);
		}

		private static TranslationSyncSnapshot DeserializeSnapshot(string serializedSnapshot)
		{
			if (string.IsNullOrWhiteSpace(serializedSnapshot))
			{
				return TranslationSyncSnapshot.Empty;
			}
			try
			{
				return JsonConvert.DeserializeObject<TranslationSyncSnapshot>(serializedSnapshot) ?? TranslationSyncSnapshot.Empty;
			}
			catch (Exception ex)
			{
				PluginMain.Log.LogError((object)("Failed to deserialize ServerSync translation snapshot: " + ex.Message));
				return TranslationSyncSnapshot.Empty;
			}
		}
	}
	[Serializable]
	internal sealed class TranslationSyncSnapshot
	{
		public static readonly TranslationSyncSnapshot Empty = new TranslationSyncSnapshot();

		public SyncedLanguageRules[] languages = Array.Empty<SyncedLanguageRules>();

		public bool TryGetLanguage(string languageName, out SyncedLanguageRules languageRules)
		{
			if (languages != null)
			{
				SyncedLanguageRules[] array = languages;
				foreach (SyncedLanguageRules syncedLanguageRules in array)
				{
					if (syncedLanguageRules != null && !string.IsNullOrWhiteSpace(syncedLanguageRules.name) && string.Equals(syncedLanguageRules.name, languageName, StringComparison.Ordinal))
					{
						languageRules = syncedLanguageRules;
						return true;
					}
				}
			}
			languageRules = null;
			return false;
		}
	}
	[Serializable]
	internal sealed class SyncedLanguageRules
	{
		public string name = string.Empty;

		public SyncedRuleFile[] files = Array.Empty<SyncedRuleFile>();
	}
	[Serializable]
	internal sealed class SyncedRuleFile
	{
		public string fileName = string.Empty;

		public RuleFileModel rules = new RuleFileModel();
	}
}
namespace Localization.DevTools
{
	internal sealed class DevToolsAutoLayoutContainer : MonoBehaviour
	{
		private RectTransform rectTransform;

		private HorizontalOrVerticalLayoutGroup layoutGroup;

		private LayoutElement layoutElement;

		private ContentSizeFitter contentSizeFitter;

		internal RectTransform RectTransform => rectTransform ?? (rectTransform = ((Component)this).GetComponent<RectTransform>());

		internal void Bind(HorizontalOrVerticalLayoutGroup group, LayoutElement element)
		{
			rectTransform = ((Component)this).GetComponent<RectTransform>();
			layoutGroup = group;
			layoutElement = element;
			contentSizeFitter = ((Component)this).GetComponent<ContentSizeFitter>();
		}

		internal void Apply(DevToolsSurfaceOptions options)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			HorizontalOrVerticalLayoutGroup val = ResolveLayoutGroup();
			if (!((Object)(object)val == (Object)null))
			{
				((LayoutGroup)val).childAlignment = options.ChildAlignment;
				val.childControlWidth = options.ChildControlWidth;
				val.childControlHeight = options.ChildControlHeight;
				val.childForceExpandWidth = options.ChildForceExpandWidth;
				val.childForceExpandHeight = options.ChildForceExpandHeight;
				val.spacing = options.Spacing;
				((LayoutGroup)val).padding = ClonePadding(options.Padding);
				DevToolsUiFactory.ApplyLayoutElement(ResolveLayoutElement(), options.PreferredWidth, options.PreferredHeight, options.MinWidth, options.MinHeight, options.FlexibleWidth, options.FlexibleHeight);
			}
		}

		internal void ConfigureContentFitter(FitMode horizontalFit, FitMode verticalFit)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			ContentSizeFitter val = ResolveContentSizeFitter();
			if ((Object)(object)val == (Object)null)
			{
				val = (contentSizeFitter = ((Component)this).gameObject.AddComponent<ContentSizeFitter>());
			}
			val.horizontalFit = horizontalFit;
			val.verticalFit = verticalFit;
		}

		internal void UseTopAnchoredStretchContent()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = RectTransform;
			obj.anchorMin = new Vector2(0f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
		}

		internal void UseStretchFill()
		{
			DevToolsUiFactory.StretchToFill(RectTransform);
		}

		internal void Rebuild()
		{
			LayoutRebuilder.ForceRebuildLayoutImmediate(RectTransform);
		}

		private HorizontalOrVerticalLayoutGroup ResolveLayoutGroup()
		{
			if ((Object)(object)layoutGroup != (Object)null)
			{
				return layoutGroup;
			}
			layoutGroup = (HorizontalOrVerticalLayoutGroup)(object)((Component)this).GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)layoutGroup == (Object)null)
			{
				layoutGroup = (HorizontalOrVerticalLayoutGroup)(object)((Component)this).GetComponent<HorizontalLayoutGroup>();
			}
			return layoutGroup;
		}

		private LayoutElement ResolveLayoutElement()
		{
			return layoutElement ?? (layoutElement = ((Component)this).GetComponent<LayoutElement>());
		}

		private ContentSizeFitter ResolveContentSizeFitter()
		{
			return contentSizeFitter ?? (contentSizeFitter = ((Component)this).GetComponent<ContentSizeFitter>());
		}

		private static RectOffset ClonePadding(RectOffset padding)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			if (padding != null)
			{
				return new RectOffset(padding.left, padding.right, padding.top, padding.bottom);
			}
			return new RectOffset(0, 0, 0, 0);
		}
	}
	internal readonly struct DevToolsTextOptions
	{
		public int FontSize { get; }

		public TextAnchor Alignment { get; }

		public HorizontalWrapMode HorizontalOverflow { get; }

		public VerticalWrapMode VerticalOverflow { get; }

		public bool SupportRichText { get; }

		public bool UseLocalizationFallback { get; }

		public float LineSpacing { get; }

		public Vector2 OffsetMin { get; }

		public Vector2 OffsetMax { get; }

		public DevToolsTextOptions(int fontSize, TextAnchor alignment, HorizontalWrapMode horizontalOverflow, VerticalWrapMode verticalOverflow, bool supportRichText, bool useLocalizationFallback, float lineSpacing, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			FontSize = Mathf.Max(1, fontSize);
			Alignment = alignment;
			HorizontalOverflow = horizontalOverflow;
			VerticalOverflow = verticalOverflow;
			SupportRichText = supportRichText;
			UseLocalizationFallback = useLocalizationFallback;
			LineSpacing = ((lineSpacing <= 0f) ? 1f : lineSpacing);
			OffsetMin = offsetMin;
			OffsetMax = offsetMax;
		}

		public DevToolsTextOptions WithFontSize(int fontSize)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsTextOptions(fontSize, Alignment, HorizontalOverflow, VerticalOverflow, SupportRichText, UseLocalizationFallback, LineSpacing, OffsetMin, OffsetMax);
		}

		public DevToolsTextOptions WithAlignment(TextAnchor alignment)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsTextOptions(FontSize, alignment, HorizontalOverflow, VerticalOverflow, SupportRichText, UseLocalizationFallback, LineSpacing, OffsetMin, OffsetMax);
		}

		public DevToolsTextOptions WithOverflow(HorizontalWrapMode horizontalOverflow, VerticalWrapMode verticalOverflow)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsTextOptions(FontSize, Alignment, horizontalOverflow, verticalOverflow, SupportRichText, UseLocalizationFallback, LineSpacing, OffsetMin, OffsetMax);
		}

		public DevToolsTextOptions WithInsets(Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsTextOptions(FontSize, Alignment, HorizontalOverflow, VerticalOverflow, SupportRichText, UseLocalizationFallback, LineSpacing, offsetMin, offsetMax);
		}

		public DevToolsTextOptions WithRichText(bool supportRichText, bool useLocalizationFallback)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsTextOptions(FontSize, Alignment, HorizontalOverflow, VerticalOverflow, supportRichText, useLocalizationFallback, LineSpacing, OffsetMin, OffsetMax);
		}
	}
	internal readonly struct DevToolsButtonOptions
	{
		public float Width { get; }

		public float Height { get; }

		public bool FlexibleWidth { get; }

		public int FontSize { get; }

		public TextAnchor TextAlignment { get; }

		public bool Wrap { get; }

		public bool SupportRichText { get; }

		public bool UseLocalizationFallback { get; }

		public Vector2 TextOffsetMin { get; }

		public Vector2 TextOffsetMax { get; }

		public DevToolsButtonOptions(float width, float height, bool flexibleWidth, int fontSize, TextAnchor textAlignment, bool wrap, bool supportRichText, bool useLocalizationFallback, Vector2 textOffsetMin, Vector2 textOffsetMax)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			Width = Mathf.Max(0f, width);
			Height = Mathf.Max(0f, height);
			FlexibleWidth = flexibleWidth;
			FontSize = Mathf.Max(1, fontSize);
			TextAlignment = textAlignment;
			Wrap = wrap;
			SupportRichText = supportRichText;
			UseLocalizationFallback = useLocalizationFallback;
			TextOffsetMin = textOffsetMin;
			TextOffsetMax = textOffsetMax;
		}

		public DevToolsButtonOptions WithSize(float width, float height, bool? flexibleWidth = null)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsButtonOptions(width, height, flexibleWidth ?? FlexibleWidth, FontSize, TextAlignment, Wrap, SupportRichText, UseLocalizationFallback, TextOffsetMin, TextOffsetMax);
		}

		public DevToolsButtonOptions WithFontSize(int fontSize)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsButtonOptions(Width, Height, FlexibleWidth, fontSize, TextAlignment, Wrap, SupportRichText, UseLocalizationFallback, TextOffsetMin, TextOffsetMax);
		}

		public DevToolsButtonOptions WithContent(TextAnchor textAlignment, bool wrap, bool supportRichText, bool useLocalizationFallback)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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)
			return new DevToolsButtonOptions(Width, Height, FlexibleWidth, FontSize, textAlignment, wrap, supportRichText, useLocalizationFallback, TextOffsetMin, TextOffsetMax);
		}

		public DevToolsButtonOptions WithInsets(Vector2 textOffsetMin, Vector2 textOffsetMax)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsButtonOptions(Width, Height, FlexibleWidth, FontSize, TextAlignment, Wrap, SupportRichText, UseLocalizationFallback, textOffsetMin, textOffsetMax);
		}
	}
	internal readonly struct DevToolsSurfaceOptions
	{
		public string SpriteName { get; }

		public Type ImageType { get; }

		public Color Color { get; }

		public TextAnchor ChildAlignment { get; }

		public bool ChildControlWidth { get; }

		public bool ChildControlHeight { get; }

		public bool ChildForceExpandWidth { get; }

		public bool ChildForceExpandHeight { get; }

		public float Spacing { get; }

		public RectOffset Padding { get; }

		public float PreferredWidth { get; }

		public float PreferredHeight { get; }

		public float MinWidth { get; }

		public float MinHeight { get; }

		public float FlexibleWidth { get; }

		public float FlexibleHeight { get; }

		public DevToolsSurfaceOptions(string spriteName, Type imageType, Color color, TextAnchor childAlignment, bool childControlWidth, bool childControlHeight, bool childForceExpandWidth, bool childForceExpandHeight, float spacing, RectOffset padding, float preferredWidth, float preferredHeight, float minWidth, float minHeight, float flexibleWidth, float flexibleHeight)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			SpriteName = spriteName ?? string.Empty;
			ImageType = imageType;
			Color = color;
			ChildAlignment = childAlignment;
			ChildControlWidth = childControlWidth;
			ChildControlHeight = childControlHeight;
			ChildForceExpandWidth = childForceExpandWidth;
			ChildForceExpandHeight = childForceExpandHeight;
			Spacing = spacing;
			Padding = (RectOffset)(((object)padding) ?? ((object)new RectOffset(0, 0, 0, 0)));
			PreferredWidth = preferredWidth;
			PreferredHeight = preferredHeight;
			MinWidth = minWidth;
			MinHeight = minHeight;
			FlexibleWidth = flexibleWidth;
			FlexibleHeight = flexibleHeight;
		}

		public DevToolsSurfaceOptions WithSize(float preferredWidth, float preferredHeight, float minWidth, float minHeight, float flexibleWidth, float flexibleHeight)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsSurfaceOptions(SpriteName, ImageType, Color, ChildAlignment, ChildControlWidth, ChildControlHeight, ChildForceExpandWidth, ChildForceExpandHeight, Spacing, Padding, preferredWidth, preferredHeight, minWidth, minHeight, flexibleWidth, flexibleHeight);
		}

		public DevToolsSurfaceOptions WithLayout(float spacing, RectOffset padding)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsSurfaceOptions(SpriteName, ImageType, Color, ChildAlignment, ChildControlWidth, ChildControlHeight, ChildForceExpandWidth, ChildForceExpandHeight, spacing, padding, PreferredWidth, PreferredHeight, MinWidth, MinHeight, FlexibleWidth, FlexibleHeight);
		}
	}
	internal readonly struct DevToolsScrollViewOptions
	{
		public float ViewportAlpha { get; }

		public bool ShowViewportGraphic { get; }

		public float ScrollSensitivity { get; }

		public bool Horizontal { get; }

		public bool Vertical { get; }

		public MovementType MovementType { get; }

		public float FlexibleWidth { get; }

		public float FlexibleHeight { get; }

		public float MinWidth { get; }

		public float MinHeight { get; }

		public DevToolsScrollViewOptions(float viewportAlpha, bool showViewportGraphic, float scrollSensitivity, bool horizontal, bool vertical, MovementType movementType, float flexibleWidth, float flexibleHeight, float minWidth, float minHeight)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			ViewportAlpha = Mathf.Clamp01(viewportAlpha);
			ShowViewportGraphic = showViewportGraphic;
			ScrollSensitivity = Mathf.Max(1f, scrollSensitivity);
			Horizontal = horizontal;
			Vertical = vertical;
			MovementType = movementType;
			FlexibleWidth = flexibleWidth;
			FlexibleHeight = flexibleHeight;
			MinWidth = minWidth;
			MinHeight = minHeight;
		}
	}
	internal readonly struct DevToolsInputFieldOptions
	{
		public float PreferredHeight { get; }

		public float MinHeight { get; }

		public bool ReadOnly { get; }

		public LineType LineType { get; }

		public Transition Transition { get; }

		public Vector2 ViewportOffsetMin { get; }

		public Vector2 ViewportOffsetMax { get; }

		public Vector2 TextOffsetMin { get; }

		public Vector2 TextOffsetMax { get; }

		public float ViewportAlpha { get; }

		public bool ShowViewportGraphic { get; }

		public DevToolsInputFieldOptions(float preferredHeight, float minHeight, bool readOnly, LineType lineType, Transition transition, Vector2 viewportOffsetMin, Vector2 viewportOffsetMax, Vector2 textOffsetMin, Vector2 textOffsetMax, float viewportAlpha, bool showViewportGraphic)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			PreferredHeight = Mathf.Max(0f, preferredHeight);
			MinHeight = Mathf.Max(0f, minHeight);
			ReadOnly = readOnly;
			LineType = lineType;
			Transition = transition;
			ViewportOffsetMin = viewportOffsetMin;
			ViewportOffsetMax = viewportOffsetMax;
			TextOffsetMin = textOffsetMin;
			TextOffsetMax = textOffsetMax;
			ViewportAlpha = Mathf.Clamp01(viewportAlpha);
			ShowViewportGraphic = showViewportGraphic;
		}

		public DevToolsInputFieldOptions WithHeight(float preferredHeight, float minHeight)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			return new DevToolsInputFieldOptions(preferredHeight, minHeight, ReadOnly, LineType, Transition, ViewportOffsetMin, ViewportOffsetMax, TextOffsetMin, TextOffsetMax, ViewportAlpha, ShowViewportGraphic);
		}
	}
	internal static class DevToolsComponentDefaults
	{
		internal static readonly DevToolsTextOptions PlainText = new DevToolsTextOptions(15, (TextAnchor)3, (HorizontalWrapMode)1, (VerticalWrapMode)1, supportRichText: false, useLocalizationFallback: true, 1f, Vector2.zero, Vector2.zero);

		internal static readonly DevToolsTextOptions WrappedBodyText = PlainText.WithOverflow((HorizontalWrapMode)0, (VerticalWrapMode)1);

		internal static readonly DevToolsTextOptions HeaderTitleText = new DevToolsTextOptions(18, (TextAnchor)3, (HorizontalWrapMode)1, (VerticalWrapMode)1, supportRichText: false, useLocalizationFallback: true, 1f, new Vector2(14f, 0f), new Vector2(-14f, 0f));

		internal static readonly DevToolsTextOptions SearchPlaceholderText = new DevToolsTextOptions(15, (TextAnchor)3, (HorizontalWrapMode)1, (VerticalWrapMode)1, supportRichText: false, useLocalizationFallback: true, 1f, new Vector2(12f, 0f), new Vector2(-12f, 0f));

		internal static readonly DevToolsTextOptions MultilineInputText = new DevToolsTextOptions(15, (TextAnchor)0, (HorizontalWrapMode)0, (VerticalWrapMode)1, supportRichText: false, useLocalizationFallback: true, 1f, new Vector2(4f, 4f), new Vector2(-4f, -4f));

		internal static readonly DevToolsTextOptions RichWrappedText = WrappedBodyText.WithRichText(supportRichText: true, useLocalizationFallback: false);

		internal static readonly DevToolsButtonOptions StandardButton = new DevToolsButtonOptions(156f, 38f, flexibleWidth: false, 15, (TextAnchor)4, wrap: true, supportRichText: false, useLocalizationFallback: true, Vector2.zero, Vector2.zero);

		internal static readonly DevToolsButtonOptions RouterButton = new DevToolsButtonOptions(220f, 42f, flexibleWidth: false, 16, (TextAnchor)4, wrap: true, supportRichText: false, useLocalizationFallback: true, Vector2.zero, Vector2.zero);

		internal static readonly DevToolsButtonOptions CloseButton = new DevToolsButtonOptions(64f, 48f, flexibleWidth: false, 16, (TextAnchor)4, wrap: false, supportRichText: false, useLocalizationFallback: true, Vector2.zero, Vector2.zero);

		internal static readonly DevToolsButtonOptions ListEntryButton = new DevToolsButtonOptions(320f, 58f, flexibleWidth: false, 15, (TextAnchor)3, wrap: true, supportRichText: true, useLocalizationFallback: false, new Vector2(12f, 0f), new Vector2(-12f, 0f));

		internal static readonly DevToolsSurfaceOptions CardSurface = new DevToolsSurfaceOptions("text_field", (Type)1, new Color(1f, 1f, 1f, 0.18f), (TextAnchor)0, childControlWidth: true, childControlHeight: true, childForceExpandWidth: true, childForceExpandHeight: false, 0f, new RectOffset(0, 0, 0, 0), 0f, 0f, 0f, 0f, 1f, 0f);

		internal static readonly DevToolsSurfaceOptions HeaderSurface = new DevToolsSurfaceOptions("woodpanel_settings", (Type)1, new Color(0.78f, 0.73f, 0.64f, 0.95f), (TextAnchor)3, childControlWidth: true, childControlHeight: true, childForceExpandWidth: false, childForceExpandHeight: false, 8f, new RectOffset(14, 14, 0, 0), 0f, 42f, 0f, 42f, 1f, 0f);

		internal static readonly DevToolsSurfaceOptions HorizontalRowSurface = new DevToolsSurfaceOptions("text_field", (Type)1, new Color(1f, 1f, 1f, 0.18f), (TextAnchor)3, childControlWidth: true, childControlHeight: true, childForceExpandWidth: false, childForceExpandHeight: false, 0f, new RectOffset(0, 0, 0, 0), 0f, 42f, 0f, 42f, 1f, 0f);

		internal static readonly DevToolsSurfaceOptions ContentStackSurface = new DevToolsSurfaceOptions(string.Empty, (Type)0, new Color(0f, 0f, 0f, 0f), (TextAnchor)0, childControlWidth: true, childControlHeight: true, childForceExpandWidth: true, childForceExpandHeight: false, 0f, new RectOffset(0, 0, 0, 0), 0f, 0f, 0f, 0f, 1f, 0f);

		internal static readonly DevToolsScrollViewOptions ScrollView = new DevToolsScrollViewOptions(0.08f, showViewportGraphic: true, 24f, horizontal: false, vertical: true, (MovementType)2, 1f, 1f, 0f, 0f);

		internal static readonly DevToolsInputFieldOptions SingleLineInput = new DevToolsInputFieldOptions(42f, 42f, readOnly: false, (LineType)0, (Transition)1, new Vector2(8f, 8f), new Vector2(-8f, -8f), new Vector2(4f, 4f), new Vector2(-4f, -4f), 0.02f, showViewportGraphic: false);

		internal static readonly DevToolsInputFieldOptions MultiLineInput = new DevToolsInputFieldOptions(96f, 96f, readOnly: false, (LineType)2, (Transition)1, new Vector2(8f, 8f), new Vector2(-8f, -8f), new Vector2(4f, 4f), new Vector2(-4f, -4f), 0.02f, showViewportGraphic: false);

		internal static readonly DevToolsInputFieldOptions ReadOnlyTextArea = new DevToolsInputFieldOptions(96f, 96f, readOnly: true, (LineType)2, (Transition)1, new Vector2(8f, 8f), new Vector2(-8f, -8f), new Vector2(4f, 4f), new Vector2(-4f, -4f), 0.02f, showViewportGraphic: false);
	}
	internal static class DevToolsInputFieldFactory
	{
		internal static InputField CreateField(Transform parent, string name, string placeholder, DevToolsInputFieldOptions fieldOptions, DevToolsTextOptions placeholderOptions, DevToolsTextOptions valueOptions, out LayoutElement fieldLayout, out Text placeholderText, out Text valueText)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_00aa: 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)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Invalid comparison between Unknown and I4
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(InputField),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			DevToolsSurfaceFactory.ApplySurfaceStyle(component, DevToolsComponentDefaults.CardSurface);
			fieldLayout = val.GetComponent<LayoutElement>();
			DevToolsUiFactory.ApplyLayoutElement(fieldLayout, 0f, fieldOptions.PreferredHeight, 0f, fieldOptions.MinHeight, 1f, 0f);
			InputField component2 = val.GetComponent<InputField>();
			component2.readOnly = fieldOptions.ReadOnly;
			component2.lineType = fieldOptions.LineType;
			((Selectable)component2).transition = fieldOptions.Transition;
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			component2.caretColor = Color.white;
			component2.customCaretColor = true;
			bool flag = (int)fieldOptions.LineType > 0;
			GameObject val2 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Mask)
			});
			val2.transform.SetParent(val.transform, false);
			((Graphic)val2.GetComponent<Image>()).color = new Color(0f, 0f, 0f, fieldOptions.ViewportAlpha);
			val2.GetComponent<Mask>().showMaskGraphic = fieldOptions.ShowViewportGraphic;
			RectTransform component3 = val2.GetComponent<RectTransform>();
			DevToolsUiFactory.StretchToFill(component3, fieldOptions.ViewportOffsetMin, fieldOptions.ViewportOffsetMax);
			if (placeholder != null)
			{
				placeholderText = DevToolsUiFactory.CreateTextBlock(val2.transform, "Placeholder", placeholder, placeholderOptions);
				((Graphic)placeholderText).color = new Color(1f, 1f, 1f, 0.45f);
				DevToolsUiFactory.SetTextInsets(placeholderText, fieldOptions.TextOffsetMin, fieldOptions.TextOffsetMax);
				component2.placeholder = (Graphic)(object)placeholderText;
			}
			else
			{
				placeholderText = null;
			}
			valueText = DevToolsUiFactory.CreateTextBlock(val2.transform, "Text", string.Empty, valueOptions);
			component2.textComponent = valueText;
			if (flag)
			{
				Scrollbar scrollbar = DevToolsScrollbars.CreateVerticalScrollbar(val.GetComponent<RectTransform>(), component3, "VerticalScrollbar");
				val.AddComponent<DevToolsScrollableInputField>().Bind(component3, valueText, scrollbar, fieldOptions.TextOffsetMin, fieldOptions.TextOffsetMax, DevToolsComponentDefaults.ScrollView.ScrollSensitivity);
			}
			else
			{
				DevToolsUiFactory.SetTextInsets(valueText, fieldOptions.TextOffsetMin, fieldOptions.TextOffsetMax);
			}
			return component2;
		}
	}
	internal sealed class DevToolsScrollableInputField : MonoBehaviour, IScrollHandler, IEventSystemHandler, IPointerDownHandler, IPointerClickHandler
	{
		private const float DefaultScrollSensitivity = 24f;

		private InputField inputField;

		private RectTransform viewportRect;

		private RectTransform textRect;

		private Text valueText;

		private Scrollbar verticalScrollbar;

		private float scrollSensitivity = 24f;

		private float leftInset;

		private float rightInset;

		private float topInset;

		private float bottomInset;

		private float currentContentHeight;

		private float currentScrollOffset;

		private bool suppressScrollbarCallback;

		private Vector2 lastViewportSize = new Vector2(float.MinValue, float.MinValue);

		private string lastValue;

		private int lastFontSize = -1;

		internal void Bind(RectTransform viewport, Text textComponent, Scrollbar scrollbar, Vector2 textOffsetMin, Vector2 textOffsetMax, float sensitivity)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			inputField = ((Component)this).GetComponent<InputField>();
			viewportRect = viewport;
			valueText = textComponent;
			textRect = (((Object)(object)textComponent != (Object)null) ? ((Graphic)textComponent).rectTransform : null);
			verticalScrollbar = scrollbar;
			scrollSensitivity = ((sensitivity <= 0f) ? 24f : sensitivity);
			leftInset = textOffsetMin.x;
			bottomInset = textOffsetMin.y;
			rightInset = textOffsetMax.x;
			topInset = 0f - textOffsetMax.y;
			if ((Object)(object)verticalScrollbar != (Object)null)
			{
				((UnityEvent<float>)(object)verticalScrollbar.onValueChanged).RemoveListener((UnityAction<float>)HandleScrollbarChanged);
				((UnityEvent<float>)(object)verticalScrollbar.onValueChanged).AddListener((UnityAction<float>)HandleScrollbarChanged);
			}
			ConfigureTextRect();
			Refresh(force: true);
		}

		public void OnScroll(PointerEventData eventData)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (eventData != null && CanScroll())
			{
				SetScrollOffset(currentScrollOffset - eventData.scrollDelta.y * scrollSensitivity);
				((AbstractEventData)eventData).Use();
			}
		}

		public void OnPointerDown(PointerEventData eventData)
		{
			ActivateInputField();
		}

		public void OnPointerClick(PointerEventData eventData)
		{
			ActivateInputField();
		}

		private void LateUpdate()
		{
			Refresh(force: false);
		}

		private void OnDestroy()
		{
			if ((Object)(object)verticalScrollbar != (Object)null)
			{
				((UnityEvent<float>)(object)verticalScrollbar.onValueChanged).RemoveListener((UnityAction<float>)HandleScrollbarChanged);
			}
		}

		private void ConfigureTextRect()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)textRect == (Object)null) && !((Object)(object)valueText == (Object)null))
			{
				textRect.anchorMin = new Vector2(0f, 1f);
				textRect.anchorMax = new Vector2(1f, 1f);
				textRect.pivot = new Vector2(0.5f, 1f);
				DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)valueText, (FitMode)0, (FitMode)2);
			}
		}

		private void Refresh(bool force)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_008d: 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_00bb: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)viewportRect == (Object)null) && !((Object)(object)textRect == (Object)null) && !((Object)(object)valueText == (Object)null))
			{
				Rect rect = viewportRect.rect;
				Vector2 size = ((Rect)(ref rect)).size;
				string a = valueText.text ?? string.Empty;
				int fontSize = valueText.fontSize;
				if (force || !(size == lastViewportSize) || fontSize != lastFontSize || !string.Equals(a, lastValue, StringComparison.Ordinal))
				{
					lastViewportSize = size;
					lastValue = a;
					lastFontSize = fontSize;
					LayoutRebuilder.ForceRebuildLayoutImmediate(textRect);
					rect = viewportRect.rect;
					float num = Mathf.Max(0f, ((Rect)(ref rect)).height);
					float contentHeight = Mathf.Max(Mathf.Max(1f, num - topInset - bottomInset), LayoutUtility.GetPreferredHeight(textRect));
					ApplyContentRect(contentHeight);
				}
			}
		}

		private void HandleScrollbarChanged(float value)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!suppressScrollbarCallback && !((Object)(object)viewportRect == (Object)null))
			{
				float num = topInset + currentContentHeight + bottomInset;
				Rect rect = viewportRect.rect;
				float num2 = Mathf.Max(0f, num - ((Rect)(ref rect)).height);
				SetScrollOffset((num2 <= 0f) ? 0f : ((1f - value) * num2));
			}
		}

		private void ApplyContentRect(float contentHeight)
		{
			//IL_0039: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)textRect == (Object)null) && !((Object)(object)viewportRect == (Object)null))
			{
				currentContentHeight = Mathf.Max(1f, contentHeight);
				Rect rect = viewportRect.rect;
				float num = Mathf.Max(0f, ((Rect)(ref rect)).height);
				float num2 = topInset + currentContentHeight + bottomInset;
				float num3 = Mathf.Max(0f, num2 - num);
				currentScrollOffset = Mathf.Clamp(currentScrollOffset, 0f, num3);
				textRect.offsetMin = new Vector2(leftInset, 0f - (topInset + currentContentHeight + bottomInset) + currentScrollOffset);
				textRect.offsetMax = new Vector2(rightInset, 0f - topInset + currentScrollOffset);
				UpdateScrollbar(num, num2, num3);
			}
		}

		private void SetScrollOffset(float value)
		{
			currentScrollOffset = Mathf.Max(0f, value);
			ApplyContentRect((currentContentHeight <= 0f) ? 1f : currentContentHeight);
		}

		private void UpdateScrollbar(float viewportHeight, float totalContentHeight, float maxScrollOffset)
		{
			if (!((Object)(object)verticalScrollbar == (Object)null))
			{
				suppressScrollbarCallback = true;
				verticalScrollbar.size = ((maxScrollOffset <= 0f) ? 1f : Mathf.Clamp01(viewportHeight / Mathf.Max(totalContentHeight, viewportHeight)));
				verticalScrollbar.value = ((maxScrollOffset <= 0f) ? 1f : (1f - currentScrollOffset / maxScrollOffset));
				((Selectable)verticalScrollbar).interactable = maxScrollOffset > 0f;
				suppressScrollbarCallback = false;
			}
		}

		private bool CanScroll()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)viewportRect == (Object)null)
			{
				return false;
			}
			float num = topInset + currentContentHeight + bottomInset;
			Rect rect = viewportRect.rect;
			return num - ((Rect)(ref rect)).height > 0.5f;
		}

		private void ActivateInputField()
		{
			if (!((Object)(object)inputField == (Object)null) && ((UIBehaviour)inputField).IsActive() && ((Selectable)inputField).IsInteractable())
			{
				((Selectable)inputField).Select();
				inputField.ActivateInputField();
			}
		}
	}
	internal static class DevToolsScrollViewFactory
	{
		internal static ScrollRect CreateViewportScrollView(Transform parent, string name, out RectTransform viewportRect, out LayoutElement layoutElement, DevToolsScrollViewOptions? optionsOverride = null)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			DevToolsScrollViewOptions devToolsScrollViewOptions = optionsOverride ?? DevToolsComponentDefaults.ScrollView;
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(ScrollRect),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			DevToolsUiFactory.StretchToFill(component);
			layoutElement = val.GetComponent<LayoutElement>();
			DevToolsUiFactory.ApplyLayoutElement(layoutElement, 0f, 0f, devToolsScrollViewOptions.MinWidth, devToolsScrollViewOptions.MinHeight, devToolsScrollViewOptions.FlexibleWidth, devToolsScrollViewOptions.FlexibleHeight);
			GameObject val2 = new GameObject("Viewport", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Mask)
			});
			val2.transform.SetParent(val.transform, false);
			((Graphic)val2.GetComponent<Image>()).color = new Color(0f, 0f, 0f, devToolsScrollViewOptions.ViewportAlpha);
			val2.GetComponent<Mask>().showMaskGraphic = devToolsScrollViewOptions.ShowViewportGraphic;
			viewportRect = val2.GetComponent<RectTransform>();
			DevToolsUiFactory.StretchToFill(viewportRect);
			ScrollRect component2 = val.GetComponent<ScrollRect>();
			component2.viewport = viewportRect;
			component2.horizontal = devToolsScrollViewOptions.Horizontal;
			component2.vertical = devToolsScrollViewOptions.Vertical;
			component2.movementType = devToolsScrollViewOptions.MovementType;
			component2.scrollSensitivity = devToolsScrollViewOptions.ScrollSensitivity;
			DevToolsScrollbars.AttachVerticalScrollbar(component, viewportRect, component2, "VerticalScrollbar");
			return component2;
		}

		internal static ScrollRect CreateVerticalScrollView(Transform parent, string name, out RectTransform contentRect, out VerticalLayoutGroup contentLayout, out LayoutElement layoutElement, DevToolsScrollViewOptions? optionsOverride = null)
		{
			RectTransform viewportRect;
			ScrollRect obj = CreateViewportScrollView(parent, name, out viewportRect, out layoutElement, optionsOverride);
			contentRect = DevToolsSurfaceFactory.CreateVerticalContentContainer((Transform)(object)viewportRect, "Content", DevToolsComponentDefaults.ContentStackSurface, out contentLayout, out var autoLayout);
			autoLayout.ConfigureContentFitter((FitMode)0, (FitMode)2);
			autoLayout.UseTopAnchoredStretchContent();
			obj.content = contentRect;
			return obj;
		}
	}
	internal abstract class DevToolsStructuredInfoPage : DevToolsPage
	{
		protected sealed class PageColumnDefinition
		{
			public string Name { get; }

			public float FlexWeight { get; }

			public PageSectionDefinition[] Sections { get; }

			public PageColumnDefinition(string name, float flexWeight, params PageSectionDefinition[] sections)
			{
				Name = (string.IsNullOrWhiteSpace(name) ? "Column" : name);
				FlexWeight = ((flexWeight <= 0f) ? 1f : flexWeight);
				Sections = sections ?? Array.Empty<PageSectionDefinition>();
			}
		}

		protected sealed class PageSectionDefinition
		{
			public string Title { get; }

			public int DisplayItemCount { get; }

			public PageRowDefinition[] Rows { get; }

			public PageSectionDefinition(string title, params PageRowDefinition[] rows)
				: this(title, 0, rows)
			{
			}

			public PageSectionDefinition(string title, int displayItemCount, params PageRowDefinition[] rows)
			{
				Title = title ?? string.Empty;
				DisplayItemCount = ((displayItemCount > 0) ? displayItemCount : 0);
				Rows = rows ?? Array.Empty<PageRowDefinition>();
			}
		}

		protected sealed class PageRowActionDefinition
		{
			public string Label { get; }

			public Action Action { get; }

			public PageRowActionDefinition(string label, Action action)
			{
				Label = (string.IsNullOrWhiteSpace(label) ? "Action" : label);
				Action = action;
			}
		}

		protected sealed class PageRowDefinition
		{
			public string Label { get; }

			public string Key { get; }

			public PageRowActionDefinition[] Actions { get; }

			public PageRowDefinition(string label, string key, params PageRowActionDefinition[] actions)
			{
				Label = label ?? string.Empty;
				Key = (string.IsNullOrWhiteSpace(key) ? (label ?? string.Empty) : key);
				Actions = actions ?? Array.Empty<PageRowActionDefinition>();
			}
		}

		private const float DefaultActionButtonWidth = 96f;

		private const float DefaultActionButtonHeight = 32f;

		private readonly List<VerticalLayoutGroup> columnLayouts = new List<VerticalLayoutGroup>();

		private readonly List<VerticalLayoutGroup> sectionLayouts = new List<VerticalLayoutGroup>();

		private readonly List<LayoutElement> sectionLayoutElements = new List<LayoutElement>();

		private readonly List<LayoutElement> sectionHeaderLayouts = new List<LayoutElement>();

		private readonly List<Text> sectionHeaderTexts = new List<Text>();

		private readonly List<PageSectionDefinition> builtSectionDefinitions = new List<PageSectionDefinition>();

		private readonly List<HorizontalLayoutGroup> rowLayouts = new List<HorizontalLayoutGroup>();

		private readonly List<LayoutElement> rowLayoutElements = new List<LayoutElement>();

		private readonly List<bool> rowHasActions = new List<bool>();

		private readonly List<LayoutElement> spacerRowLayouts = new List<LayoutElement>();

		private readonly List<Text> labelTexts = new List<Text>();

		private readonly List<LayoutElement> labelLayouts = new List<LayoutElement>();

		private readonly List<Text> rowValueTexts = new List<Text>();

		private readonly List<LayoutElement> valueLayouts = new List<LayoutElement>();

		private readonly List<TextAnchor> valueTextAlignments = new List<TextAnchor>();

		private readonly List<PageRowDefinition> valueRowDefinitions = new List<PageRowDefinition>();

		private readonly List<Button> actionButtons = new List<Button>();

		private readonly List<LayoutElement> actionButtonLayouts = new List<LayoutElement>();

		private readonly Dictionary<string, Text> valueTexts = new Dictionary<string, Text>(StringComparer.Ordinal);

		private HorizontalLayoutGroup columnsLayout;

		private ScrollRect pageScrollRect;

		private RectTransform pageScrollViewportRect;

		private RectTransform pageScrollContentRect;

		protected virtual bool UseScrollView => false;

		protected override void Build(RectTransform parent)
		{
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Expected O, but got Unknown
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			columnLayouts.Clear();
			sectionLayouts.Clear();
			sectionLayoutElements.Clear();
			sectionHeaderLayouts.Clear();
			sectionHeaderTexts.Clear();
			builtSectionDefinitions.Clear();
			rowLayouts.Clear();
			rowLayoutElements.Clear();
			rowHasActions.Clear();
			spacerRowLayouts.Clear();
			labelTexts.Clear();
			labelLayouts.Clear();
			rowValueTexts.Clear();
			valueLayouts.Clear();
			valueTextAlignments.Clear();
			valueRowDefinitions.Clear();
			actionButtons.Clear();
			actionButtonLayouts.Clear();
			valueTexts.Clear();
			pageScrollRect = null;
			pageScrollViewportRect = null;
			pageScrollContentRect = null;
			LayoutElement layoutElement;
			RectTransform val2;
			if (UseScrollView)
			{
				RectTransform contentRect;
				VerticalLayoutGroup contentLayout;
				ScrollRect val = DevToolsScrollViewFactory.CreateVerticalScrollView((Transform)(object)parent, Id + "Scroll", out contentRect, out contentLayout, out layoutElement);
				((HorizontalOrVerticalLayoutGroup)contentLayout).spacing = 0f;
				((LayoutGroup)contentLayout).padding = new RectOffset(0, 0, 0, 0);
				((LayoutGroup)contentLayout).childAlignment = (TextAnchor)0;
				((HorizontalOrVerticalLayoutGroup)contentLayout).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)contentLayout).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)contentLayout).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)contentLayout).childForceExpandHeight = false;
				val2 = DevToolsSurfaceFactory.CreateHorizontalContentContainer((Transform)(object)contentRect, Id + "Columns", DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 0f), out columnsLayout, out var autoLayout);
				autoLayout.ConfigureContentFitter((FitMode)0, (FitMode)2);
				autoLayout.UseTopAnchoredStretchContent();
				pageScrollRect = val;
				pageScrollViewportRect = val.viewport;
				pageScrollContentRect = contentRect;
			}
			else
			{
				val2 = DevToolsSurfaceFactory.CreateHorizontalContainer((Transform)(object)parent, Id + "Columns", DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 1f), out columnsLayout, out layoutElement);
				DevToolsAutoLayoutContainer component = ((Component)val2).GetComponent<DevToolsAutoLayoutContainer>();
				if ((Object)(object)component != (Object)null)
				{
					component.UseStretchFill();
				}
			}
			RectTransform val3 = val2;
			if (!UseScrollView)
			{
				val3.anchorMin = Vector2.zero;
				val3.anchorMax = Vector2.one;
				val3.offsetMin = Vector2.zero;
				val3.offsetMax = Vector2.zero;
			}
			((HorizontalOrVerticalLayoutGroup)columnsLayout).spacing = 0f;
			((LayoutGroup)columnsLayout).padding = new RectOffset(0, 0, 0, 0);
			((LayoutGroup)columnsLayout).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandHeight = false;
			PageColumnDefinition[] columns = GetColumns();
			foreach (PageColumnDefinition pageColumnDefinition in columns)
			{
				RectTransform parent2 = CreateColumn(((Component)val2).transform, pageColumnDefinition.Name, pageColumnDefinition.FlexWeight);
				for (int j = 0; j < pageColumnDefinition.Sections.Length; j++)
				{
					PageSectionDefinition pageSectionDefinition = pageColumnDefinition.Sections[j];
					RectTransform parent3 = CreateSectionCard((Transform)(object)parent2, pageSectionDefinition.Title);
					builtSectionDefinitions.Add(pageSectionDefinition);
					for (int k = 0; k < pageSectionDefinition.Rows.Length; k++)
					{
						PageRowDefinition rowDefinition = pageSectionDefinition.Rows[k];
						CreateInfoRow((Transform)(object)parent3, rowDefinition);
					}
					int sectionDisplayItemCount = GetSectionDisplayItemCount(pageSectionDefinition);
					for (int l = pageSectionDefinition.Rows.Length; l < sectionDisplayItemCount; l++)
					{
						CreateSpacerRow((Transform)(object)parent3, string.Format("{0}Spacer{1}", pageSectionDefinition.Title.Replace(" ", string.Empty), l));
					}
				}
			}
		}

		public override void ApplyLayout(DevToolsLayoutMetrics metrics)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Expected O, but got Unknown
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			if (metrics == null || (Object)(object)columnsLayout == (Object)null)
			{
				return;
			}
			((HorizontalOrVerticalLayoutGroup)columnsLayout).spacing = metrics.SectionColumnSpacing;
			for (int i = 0; i < columnLayouts.Count; i++)
			{
				VerticalLayoutGroup val = columnLayouts[i];
				if ((Object)(object)val != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val).spacing = metrics.SectionGroupSpacing;
					((HorizontalOrVerticalLayoutGroup)val).childControlHeight = true;
					((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = !UseScrollView;
				}
			}
			for (int j = 0; j < sectionLayouts.Count; j++)
			{
				VerticalLayoutGroup val2 = sectionLayouts[j];
				LayoutElement val3 = ((j < sectionLayoutElements.Count) ? sectionLayoutElements[j] : null);
				PageSectionDefinition sectionDefinition = ((j < builtSectionDefinitions.Count) ? builtSectionDefinitions[j] : null);
				if ((Object)(object)val2 != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val2).spacing = metrics.SectionContentSpacing;
					((LayoutGroup)val2).padding = new RectOffset(metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding);
					((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
				}
				if ((Object)(object)val3 != (Object)null)
				{
					int sectionMinimumHeight = GetSectionMinimumHeight(metrics, sectionDefinition);
					val3.minHeight = sectionMinimumHeight;
					if (UseScrollView)
					{
						val3.preferredHeight = sectionMinimumHeight;
						val3.flexibleHeight = 0f;
					}
					else
					{
						val3.preferredHeight = 0f;
						val3.flexibleHeight = GetSectionFlexWeight(metrics, sectionDefinition);
					}
				}
			}
			for (int k = 0; k < sectionHeaderLayouts.Count; k++)
			{
				LayoutElement val4 = sectionHeaderLayouts[k];
				if ((Object)(object)val4 != (Object)null)
				{
					int sectionHeaderHeight = GetSectionHeaderHeight(metrics);
					val4.preferredHeight = sectionHeaderHeight;
					val4.minHeight = sectionHeaderHeight;
				}
				if (k < sectionHeaderTexts.Count && (Object)(object)sectionHeaderTexts[k] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(sectionHeaderTexts[k], GUIManager.Instance.ValheimOrange, GetSectionTitleFontSize(metrics), true);
					DevToolsUiFactory.StretchToFill(((Graphic)sectionHeaderTexts[k]).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
				}
			}
			for (int l = 0; l < rowLayouts.Count; l++)
			{
				HorizontalLayoutGroup val5 = rowLayouts[l];
				if ((Object)(object)val5 != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val5).spacing = metrics.InfoRowSpacing;
					((LayoutGroup)val5).padding = new RectOffset(metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingVertical, metrics.InfoRowPaddingVertical);
				}
				if (l < rowLayoutElements.Count && (Object)(object)rowLayoutElements[l] != (Object)null)
				{
					bool hasActions = l < rowHasActions.Count && rowHasActions[l];
					PageRowDefinition rowDefinition = ((l < valueRowDefinitions.Count) ? valueRowDefinitions[l] : null);
					int infoRowHeight = GetInfoRowHeight(metrics, rowDefinition, hasActions);
					rowLayoutElements[l].preferredHeight = infoRowHeight;
					rowLayoutElements[l].minHeight = infoRowHeight;
				}
				if (l < labelTexts.Count && (Object)(object)labelTexts[l] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(labelTexts[l], GUIManager.Instance.AveriaSerifBold, GUIManager.Instance.ValheimOrange, metrics.InfoRowFontSize, true);
				}
				if (l < labelLayouts.Count && (Object)(object)labelLayouts[l] != (Object)null)
				{
					PageRowDefinition rowDefinition2 = ((l < valueRowDefinitions.Count) ? valueRowDefinitions[l] : null);
					labelLayouts[l].flexibleWidth = GetInfoLabelFlexWeight(metrics, rowDefinition2);
				}
				if (l < rowValueTexts.Count && (Object)(object)rowValueTexts[l] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(rowValueTexts[l], GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
					if (l < valueTextAlignments.Count)
					{
						rowValueTexts[l].alignment = valueTextAlignments[l];
					}
					OnValueTextStyled(rowValueTexts[l], metrics, (l < valueRowDefinitions.Count) ? valueRowDefinitions[l] : null);
				}
				if (l < valueLayouts.Count && (Object)(object)valueLayouts[l] != (Object)null)
				{
					PageRowDefinition rowDefinition3 = ((l < valueRowDefinitions.Count) ? valueRowDefinitions[l] : null);
					valueLayouts[l].flexibleWidth = GetInfoValueFlexWeight(metrics, rowDefinition3);
				}
			}
			for (int m = 0; m < spacerRowLayouts.Count; m++)
			{
				if ((Object)(object)spacerRowLayouts[m] != (Object)null)
				{
					spacerRowLayouts[m].preferredHeight = metrics.InfoRowHeight;
					spacerRowLayouts[m].minHeight = metrics.InfoRowHeight;
				}
			}
			for (int n = 0; n < actionButtons.Count; n++)
			{
				if (n < actionButtonLayouts.Count && (Object)(object)actionButtonLayouts[n] != (Object)null)
				{
					actionButtonLayouts[n].preferredWidth = metrics.InfoActionButtonWidth;
					actionButtonLayouts[n].minWidth = metrics.InfoActionButtonWidth;
					actionButtonLayouts[n].preferredHeight = GetInfoActionButtonHeight(metrics);
					actionButtonLayouts[n].minHeight = GetInfoActionButtonHeight(metrics);
					actionButtonLayouts[n].flexibleWidth = 0f;
					actionButtonLayouts[n].flexibleHeight = 0f;
				}
				Button val6 = actionButtons[n];
				if ((Object)(object)val6 != (Object)null)
				{
					GUIManager.Instance.ApplyButtonStyle(val6, GetInfoActionButtonFontSize(metrics));
					Text componentInChildren = ((Component)val6).GetComponentInChildren<Text>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						componentInChildren.alignment = (TextAnchor)4;
					}
				}
			}
			RefreshScrollContentBounds();
		}

		protected abstract PageColumnDefinition[] GetColumns();

		protected virtual int GetSectionDisplayItemCount(PageSectionDefinition sectionDefinition)
		{
			return Mathf.Max(sectionDefinition.DisplayItemCount, sectionDefinition.Rows.Length);
		}

		protected virtual int GetSectionHeaderHeight(DevToolsLayoutMetrics metrics)
		{
			return metrics.SectionHeaderHeight;
		}

		protected virtual int GetSectionTitleFontSize(DevToolsLayoutMetrics metrics)
		{
			return metrics.SectionTitleFontSize;
		}

		protected virtual int GetInfoRowHeight(DevToolsLayoutMetrics metrics, PageRowDefinition rowDefinition, bool hasActions)
		{
			return metrics.InfoRowHeight;
		}

		protected virtual float GetInfoLabelFlexWeight(DevToolsLayoutMetrics metrics, PageRowDefinition rowDefinition)
		{
			return metrics.InfoLabelFlexWeight;
		}

		protected virtual float GetInfoValueFlexWeight(DevToolsLayoutMetrics metrics, PageRowDefinition rowDefinition)
		{
			return metrics.InfoValueFlexWeight;
		}

		protected virtual float GetSectionFlexWeight(DevToolsLayoutMetrics metrics, PageSectionDefinition sectionDefinition)
		{
			return Mathf.Max(1f, (float)GetSectionDisplayItemCount(sectionDefinition));
		}

		protected virtual int GetSectionMinimumHeight(DevToolsLayoutMetrics metrics, PageSectionDefinition sectionDefinition)
		{
			int num = Mathf.Max(1, GetSectionDisplayItemCount(sectionDefinition));
			return metrics.SectionPadding * 2 + GetSectionHeaderHeight(metrics) + num * metrics.InfoRowHeight + Mathf.Max(0, num - 1) * metrics.SectionContentSpacing;
		}

		protected virtual int GetInfoActionButtonHeight(DevToolsLayoutMetrics metrics)
		{
			float num = (float)metrics.InfoRowHeight - (float)metrics.InfoRowPaddingVertical * 2f;
			return Mathf.Max(24, Mathf.FloorToInt(Mathf.Min(32f, num)));
		}

		protected virtual int GetInfoActionButtonFontSize(DevToolsLayoutMetrics metrics)
		{
			return Mathf.Max(12, metrics.InfoRowFontSize - 1);
		}

		protected virtual TextAnchor GetValueTextAlignment(PageRowDefinition rowDefinition)
		{
			return (TextAnchor)3;
		}

		protected virtual void OnValueTextStyled(Text valueText, DevToolsLayoutMetrics metrics, PageRowDefinition rowDefinition)
		{
		}

		protected void SetValue(string key, string value)
		{
			if (valueTexts.TryGetValue(key, out var value2))
			{
				DevToolsUiFactory.SetTextValue(value2, string.IsNullOrEmpty(value) ? "-" : value);
			}
		}

		protected static string FormatBoolean(bool value)
		{
			if (!value)
			{
				return PluginMain.Localize("common.no", "No");
			}
			return PluginMain.Localize("common.yes", "Yes");
		}

		private RectTransform CreateColumn(Transform parent, string name, float flexWeight)
		{
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateVerticalContainer(parent, name, DevToolsComponentDefaults.CardSurface.WithSize(0f, 0f, 0f, 0f, flexWeight, 1f), out layout, out layoutElement);
			((HorizontalOrVerticalLayoutGroup)layout).childForceExpandHeight = !UseScrollView;
			layoutElement.flexibleWidth = flexWeight;
			if (UseScrollView)
			{
				layoutElement.minHeight = -1f;
				layoutElement.preferredHeight = -1f;
				layoutElement.flexibleHeight = 0f;
			}
			else
			{
				layoutElement.minHeight = 0f;
				layoutElement.preferredHeight = 0f;
				layoutElement.flexibleHeight = 1f;
			}
			if (UseScrollView)
			{
				DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)layout, (FitMode)0, (FitMode)2);
				DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
				if ((Object)(object)component != (Object)null)
				{
					component.UseTopAnchoredStretchContent();
				}
			}
			columnLayouts.Add(layout);
			return val;
		}

		private RectTransform CreateSectionCard(Transform parent, string title)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform obj = DevToolsSurfaceFactory.CreateVerticalContainer(parent, title.Replace(" ", string.Empty) + "Section", DevToolsComponentDefaults.CardSurface, out layout, out layoutElement);
			sectionLayouts.Add(layout);
			sectionLayoutElements.Add(layoutElement);
			layoutElement.flexibleWidth = 1f;
			layoutElement.flexibleHeight = (UseScrollView ? 0f : 1f);
			layoutElement.minHeight = 0f;
			layoutElement.preferredHeight = 0f;
			LayoutElement layoutElement2;
			RectTransform parent2 = DevToolsSurfaceFactory.CreatePanel((Transform)(object)obj, "SectionHeader", DevToolsComponentDefaults.HeaderSurface, out layoutElement2);
			sectionHeaderLayouts.Add(layoutElement2);
			Text val = DevToolsUiFactory.CreateTextBlock((Transform)(object)parent2, "Title", title, DevToolsComponentDefaults.HeaderTitleText);
			GUIManager.Instance.ApplyTextStyle(val, GUIManager.Instance.ValheimOrange, 18, true);
			val.alignment = (TextAnchor)3;
			sectionHeaderTexts.Add(val);
			return obj;
		}

		private void CreateInfoRow(Transform parent, PageRowDefinition rowDefinition)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			HorizontalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, "Row" + rowDefinition.Key, DevToolsComponentDefaults.HorizontalRowSurface, out layout, out layoutElement);
			((HorizontalOrVerticalLayoutGroup)layout).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)layout).childForceExpandHeight = false;
			rowLayouts.Add(layout);
			rowLayoutElements.Add(layoutElement);
			rowHasActions.Add(rowDefinition.Actions != null && rowDefinition.Actions.Length != 0);
			Text val = CreateTextElement((Transform)(object)parent2, "Label" + rowDefinition.Key, rowDefinition.Label, 15);
			GUIManager.Instance.ApplyTextStyle(val, GUIManager.Instance.AveriaSerifBold, GUIManager.Instance.ValheimOrange, 15, true);
			val.alignment = (TextAnchor)3;
			LayoutElement val2 = ((Component)val).gameObject.AddComponent<LayoutElement>();
			val2.minWidth = 0f;
			val2.flexibleWidth = 42f;
			labelLayouts.Add(val2);
			labelTexts.Add(val);
			Text val3 = CreateTextElement((Transform)(object)parent2, "Value" + rowDefinition.Key, string.Empty, 15);
			GUIManager.Instance.ApplyTextStyle(val3, GUIManager.Instance.AveriaSerif, Color.white, 15, true);
			TextAnchor item = (val3.alignment = GetValueTextAlignment(rowDefinition));
			val3.horizontalOverflow = (HorizontalWrapMode)1;
			val3.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement val4 = ((Component)val3).gameObject.AddComponent<LayoutElement>();
			val4.minWidth = 0f;
			val4.flexibleWidth = 58f;
			valueLayouts.Add(val4);
			valueTextAlignments.Add(item);
			valueRowDefinitions.Add(rowDefinition);
			rowValueTexts.Add(val3);
			for (int i = 0; i < rowDefinition.Actions.Length; i++)
			{
				PageRowActionDefinition pageRowActionDefinition = rowDefinition.Actions[i];
				if (pageRowActionDefinition != null && pageRowActionDefinition.Action != null)
				{
					Button val5 = CreateActionButton((Transform)(object)parent2, pageRowActionDefinition.Label, pageRowActionDefinition.Action);
					actionButtons.Add(val5);
					actionButtonLayouts.Add(((Component)val5).GetComponent<LayoutElement>());
				}
			}
			valueTexts[rowDefinition.Key] = val3;
		}

		private void CreateSpacerRow(Transform parent, string name)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredWidth = 0f;
			component.minWidth = 0f;
			component.flexibleWidth = 1f;
			component.flexibleHeight = (UseScrollView ? 0f : 1f);
			spacerRowLayouts.Add(component);
		}

		private Button CreateActionButton(Transform parent, string label, Action onClick)
		{
			return DevToolsUiFactory.CreateButton(parent, label.Replace(" ", string.Empty) + "Button", label, onClick, DevToolsComponentDefaults.StandardButton.WithSize(96f, 32f));
		}

		private static Text CreateTextElement(Transform parent, string name, string text, int fontSize)
		{
			return DevToolsUiFactory.CreateTextBlock(parent, name, text, DevToolsComponentDefaults.PlainText.WithFontSize(fontSize));
		}

		private static ScrollRect CreateScrollView(Transform parent, string name, out RectTransform viewportRect)
		{
			LayoutElement layoutElement;
			return DevToolsScrollViewFactory.CreateViewportScrollView(parent, name, out viewportRect, out layoutElement);
		}

		private void RefreshScrollContentBounds()
		{
			if (!UseScrollView || (Object)(object)pageScrollRect == (Object)null || (Object)(object)pageScrollViewportRect == (Object)null || (Object)(object)pageScrollContentRect == (Object)null)
			{
				return;
			}
			for (int i = 0; i < sectionLayouts.Count; i++)
			{
				VerticalLayoutGroup val = sectionLayouts[i];
				if ((Object)(object)val != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)val).GetComponent<RectTransform>());
				}
			}
			for (int j = 0; j < columnLayouts.Count; j++)
			{
				VerticalLayoutGroup val2 = columnLayouts[j];
				if ((Object)(object)val2 != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)val2).GetComponent<RectTransform>());
				}
			}
			if ((Object)(object)columnsLayout != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)columnsLayout).GetComponent<RectTransform>());
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(pageScrollContentRect);
			LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)pageScrollRect).GetComponent<RectTransform>());
		}
	}
	internal static class DevToolsSurfaceFactory
	{
		internal static RectTransform CreatePanel(Transform parent, string name, DevToolsSurfaceOptions options, out LayoutElement layoutElement)
		{
			RectTransform val = CreateRectObject(name, parent, typeof(Image), typeof(LayoutElement));
			ApplySurfaceStyle(((Component)val).GetComponent<Image>(), options);
			layoutElement = ((Component)val).GetComponent<LayoutElement>();
			ApplyLayoutElement(layoutElement, options);
			return val;
		}

		internal static RectTransform CreateHorizontalSurface(Transform parent, string name, DevToolsSurfaceOptions options, out HorizontalLayoutGroup layout, out LayoutElement layoutElement)
		{
			RectTransform val = CreateRectObject(name, parent, typeof(Image), typeof(HorizontalLayoutGroup), typeof(LayoutElement), typeof(DevToolsAutoLayoutContainer));
			ApplySurfaceStyle(((Component)val).GetComponent<Image>(), options);
			layout = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			layoutElement = ((Component)val).GetComponent<LayoutElement>();
			ApplyAutoLayout(val, (HorizontalOrVerticalLayoutGroup)(object)layout, layoutElement, options);
			return val;
		}

		internal static RectTransform CreateVerticalSurface(Transform parent, string name, DevToolsSurfaceOptions options, out VerticalLayoutGroup layout, out LayoutElement layoutElement)
		{
			RectTransform val = CreateRectObject(name, parent, typeof(Image), typeof(VerticalLayoutGroup), typeof(LayoutElement), typeof(DevToolsAutoLayoutContainer));
			ApplySurfaceStyle(((Component)val).GetComponent<Image>(), options);
			layout = ((Component)val).GetComponent<VerticalLayoutGroup>();
			layoutElement = ((Component)val).GetComponent<LayoutElement>();
			ApplyAutoLayout(val, (HorizontalOrVerticalLayoutGroup)(object)layout, layoutElement, options);
			return val;
		}

		internal static RectTransform CreateHorizontalContainer(Transform parent, string name, DevToolsSurfaceOptions options, out HorizontalLayoutGroup layout, out LayoutElement layoutElement)
		{
			RectTransform val = CreateRectObject(name, parent, typeof(HorizontalLayoutGroup), typeof(LayoutElement), typeof(DevToolsAutoLayoutContainer));
			layout = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			layoutElement = ((Component)val).GetComponent<LayoutElement>();
			ApplyAutoLayout(val, (HorizontalOrVerticalLayoutGroup)(object)layout, layoutElement, options);
			return val;
		}

		internal static RectTransform CreateVerticalContainer(Transform parent, string name, DevToolsSurfaceOptions options, out VerticalLayoutGroup layout, out LayoutElement layoutElement)
		{
			RectTransform val = CreateRectObject(name, parent, typeof(VerticalLayoutGroup), typeof(LayoutElement), typeof(DevToolsAutoLayoutContainer));
			layout = ((Component)val).GetComponent<VerticalLayoutGroup>();
			layoutElement = ((Component)val).GetComponent<LayoutElement>();
			ApplyAutoLayout(val, (HorizontalOrVerticalLayoutGroup)(object)layout, layoutElement, options);
			return val;
		}

		internal static RectTransform CreateVerticalContentContainer(Transform parent, string name, DevToolsSurfaceOptions options, out VerticalLayoutGroup layout, out DevToolsAutoLayoutContainer autoLayout)
		{
			RectTransform val = CreateRectObject(name, parent, typeof(VerticalLayoutGroup), typeof(ContentSizeFitter), typeof(DevToolsAutoLayoutContainer));
			layout = ((Component)val).GetComponent<VerticalLayoutGroup>();
			autoLayout = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			autoLayout.Bind((HorizontalOrVerticalLayoutGroup)(object)layout, null);
			autoLayout.Apply(options);
			return val;
		}

		internal static RectTransform CreateHorizontalContentContainer(Transform parent, string name, DevToolsSurfaceOptions options, out HorizontalLayoutGroup layout, out DevToolsAutoLayoutContainer autoLayout)
		{
			RectTransform val = CreateRectObject(name, parent, typeof(HorizontalLayoutGroup), typeof(ContentSizeFitter), typeof(DevToolsAutoLayoutContainer));
			layout = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			autoLayout = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			autoLayout.Bind((HorizontalOrVerticalLayoutGroup)(object)layout, null);
			autoLayout.Apply(options);
			return val;
		}

		internal static void ApplySurfaceStyle(Image image, DevToolsSurfaceOptions options)
		{
			//IL_0039: 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)
			if (!((Object)(object)image == (Object)null))
			{
				if (!string.IsNullOrEmpty(options.SpriteName) && GUIManager.Instance != null)
				{
					image.sprite = GUIManager.Instance.GetSprite(options.SpriteName);
				}
				image.type = options.ImageType;
				((Graphic)image).color = options.Color;
			}
		}

		internal static void ApplyHorizontalLayoutGroup(HorizontalLayoutGroup layout, DevToolsSurfaceOptions options)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)layout == (Object)null))
			{
				((LayoutGroup)layout).childAlignment = options.ChildAlignment;
				((HorizontalOrVerticalLayoutGroup)layout).childControlWidth = options.ChildControlWidth;
				((HorizontalOrVerticalLayoutGroup)layout).childControlHeight = options.ChildControlHeight;
				((HorizontalOrVerticalLayoutGroup)layout).childForceExpandWidth = options.ChildForceExpandWidth;
				((HorizontalOrVerticalLayoutGroup)layout).childForceExpandHeight = options.ChildForceExpandHeight;
				((HorizontalOrVerticalLayoutGroup)layout).spacing = options.Spacing;
				((LayoutGroup)layout).padding = ClonePadding(options.Padding);
			}
		}

		internal static void ApplyVerticalLayoutGroup(VerticalLayoutGroup layout, DevToolsSurfaceOptions options)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)layout == (Object)null))
			{
				((LayoutGroup)layout).childAlignment = options.ChildAlignment;
				((HorizontalOrVerticalLayoutGroup)layout).childControlWidth = options.ChildControlWidth;
				((HorizontalOrVerticalLayoutGroup)layout).childControlHeight = options.ChildControlHeight;
				((HorizontalOrVerticalLayoutGroup)layout).childForceExpandWidth = options.ChildForceExpandWidth;
				((HorizontalOrVerticalLayoutGroup)layout).childForceExpandHeight = options.ChildForceExpandHeight;
				((HorizontalOrVerticalLayoutGroup)layout).spacing = options.Spacing;
				((LayoutGroup)layout).padding = ClonePadding(options.Padding);
			}
		}

		private static void ApplyLayoutElement(LayoutElement layoutElement, DevToolsSurfaceOptions options)
		{
			DevToolsUiFactory.ApplyLayoutElement(layoutElement, options.PreferredWidth, options.PreferredHeight, options.MinWidth, options.MinHeight, options.FlexibleWidth, options.FlexibleHeight);
		}

		private static void ApplyAutoLayout(RectTransform rectTransform, HorizontalOrVerticalLayoutGroup layoutGroup, LayoutElement layoutElement, DevToolsSurfaceOptions options)
		{
			DevToolsAutoLayoutContainer component = ((Component)rectTransform).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.Bind(layoutGroup, layoutElement);
				component.Apply(options);
				return;
			}
			HorizontalLayoutGroup val = (HorizontalLayoutGroup)(object)((layoutGroup is HorizontalLayoutGroup) ? layoutGroup : null);
			if (val != null)
			{
				ApplyHorizontalLayoutGroup(val, options);
			}
			else
			{
				VerticalLayoutGroup val2 = (VerticalLayoutGroup)(object)((layoutGroup is VerticalLayoutGroup) ? layoutGroup : null);
				if (val2 != null)
				{
					ApplyVerticalLayoutGroup(val2, options);
				}
			}
			ApplyLayoutElement(layoutElement, options);
		}

		private static RectTransform CreateRectObject(string name, Transform parent, params Type[] additionalComponents)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Type[] array;
			if (additionalComponents == null || additionalComponents.Length == 0)
			{
				array = new Type[1] { typeof(RectTransform) };
			}
			else
			{
				array = new Type[additionalComponents.Length + 1];
				array[0] = typeof(RectTransform);
				for (int i = 0; i < additionalComponents.Length; i++)
				{
					array[i + 1] = additionalComponents[i];
				}
			}
			GameObject val = new GameObject(name, array);
			val.transform.SetParent(parent, false);
			return val.GetComponent<RectTransform>();
		}

		private static RectOffset ClonePadding(RectOffset padding)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			if (padding != null)
			{
				return new RectOffset(padding.left, padding.right, padding.top, padding.bottom);
			}
			return new RectOffset(0, 0, 0, 0);
		}
	}
	internal readonly struct DevToolsButtonSizing
	{
		public float Width { get; }

		public float Height { get; }

		public bool FlexibleWidth { get; }

		public DevToolsButtonSizing(float width, float height, bool flexibleWidth)
		{
			Width = Mathf.Max(0f, width);
			Height = Mathf.Max(0f, height);
			FlexibleWidth = flexibleWidth;
		}

		public static DevToolsButtonSizing Fixed(float width, float height)
		{
			return new DevToolsButtonSizing(width, height, flexibleWidth: false);
		}

		public static DevToolsButtonSizing FillWidth(float height)
		{
			return new DevToolsButtonSizing(0f, height, flexibleWidth: true);
		}
	}
	internal sealed class DevToolsTextBlock : MonoBehaviour
	{
		private Text textComponent;

		internal Text TextComponent => textComponent ?? (textComponent = ((Component)this).GetComponent<Text>());

		internal static Text Create(Transform parent, string name, string value, DevToolsTextOptions options)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Text),
				typeof(DevToolsTextBlock)
			});
			val.transform.SetParent(parent, false);
			DevToolsTextBlock component = val.GetComponent<DevToolsTextBlock>();
			component.textComponent = val.GetComponent<Text>();
			component.ApplyOptions(options);
			component.SetValue(value, options.UseLocalizationFallback);
			return component.TextComponent;
		}

		internal static Text Create(Transform parent, string name, string value, int fontSize, TextAnchor alignment, bool wrap, bool supportRichText, bool useLocalizationFallback)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			DevToolsTextOptions options = new DevToolsTextOptions(fontSize, alignment, (HorizontalWrapMode)((!wrap) ? 1 : 0), (VerticalWrapMode)1, supportRichText, useLocalizationFallback, 1f, Vector2.zero, Vector2.zero);
			return Create(parent, name, value, options);
		}

		internal void ApplyOptions(DevToolsTextOptions options)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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)
			Text obj = TextComponent;
			obj.fontSize = options.FontSize;
			obj.supportRichText = options.SupportRichText;
			obj.alignment = options.Alignment;
			obj.horizontalOverflow = options.HorizontalOverflow;
			obj.verticalOverflow = options.VerticalOverflow;
			obj.lineSpacing = options.LineSpacing;
			SetInsets(options.OffsetMin, options.OffsetMax);
		}

		internal void SetValue(string value, bool useLocalizationFallback)
		{
			TextComponent.text = (useLocalizationFallback ? PluginMain.LocalizeFallback(value ?? string.Empty) : (value ?? string.Empty));
		}

		internal void SetInsets(Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			RectTransform rectTransform = ((Graphic)TextComponent).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = offsetMin;
			rectTransform.offsetMax = offsetMax;
		}

		internal static DevToolsTextBlock From(Text text)
		{
			if (!((Object)(object)text != (Object)null))
			{
				return null;
			}
			return ((Component)text).GetComponent<DevToolsTextBlock>();
		}
	}
	internal static class DevToolsUiFactory
	{
		internal static Text CreateTextBlock(Transform parent, string name, string value, int fontSize, TextAnchor alignment, bool wrap, bool supportRichText, bool useLocalizationFallback)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			return DevToolsTextBlock.Create(parent, name, value, fontSize, alignment, wrap, supportRichText, useLocalizationFallback);
		}

		internal static Text CreateTextBlock(Transform parent, string name, string value, DevToolsTextOptions options)
		{
			return DevToolsTextBlock.Create(parent, name, value, options);
		}

		internal static void SetTextValue(Text text, string value, bool useLocalizationFallback = true)
		{
			DevToolsTextBlock devToolsTextBlock = DevToolsTextBlock.From(text);
			if ((Object)(object)devToolsTextBlock != (Object)null)
			{
				devToolsTextBlock.SetValue(value, useLocalizationFallback);
			}
			else if ((Object)(object)text != (Object)null)
			{
				text.text = (useLocalizationFallback ? PluginMain.LocalizeFallback(value ?? string.Empty) : (value ?? string.Empty));
			}
		}

		internal static void SetTextInsets(Text text, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			DevToolsTextBlock devToolsTextBlock = DevToolsTextBlock.From(text);
			if ((Object)(object)devToolsTextBlock != (Object)null)
			{
				devToolsTextBlock.SetInsets(offsetMin, offsetMax);
			}
			else if ((Object)(object)text != (Object)null)
			{
				StretchToFill(((Graphic)text).rectTransform, offsetMin, offsetMax);
			}
		}

		internal static Button CreateButton(Transform parent, string name, string label, Action onClick, int fontSize, DevToolsButtonSizing sizing, bool supportRichText, bool useLocalizationFallback)
		{
			DevToolsButtonOptions options = DevToolsComponentDefaults.StandardButton.WithSize(sizing.Width, sizing.Height, sizing.FlexibleWidth).WithFontSize(fontSize).WithContent((TextAnchor)4, wrap: true, supportRichText, useLocalizationFallback);
			return CreateButton(parent, name, label, onClick, options);
		}

		internal static Button CreateButton(Transform parent, string name, string label, Action onClick, DevToolsButtonOptions options)
		{
			//IL_0048: 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_005a: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			ApplyLayoutElement(val.GetComponent<LayoutElement>(), options.Width, options.Height, options.Width, options.Height, options.FlexibleWidth ? 1f : 0f, 0f);
			DevToolsTextOptions options2 = new DevToolsTextOptions(options.FontSize, options.TextAlignment, (HorizontalWrapMode)((!options.Wrap) ? 1 : 0), (VerticalWrapMode)1, options.SupportRichText, options.UseLocalizationFallback, 1f, options.TextOffsetMin, options.TextOffsetMax);
			Text val2 = CreateTextBlock(val.transform, "Text", label, options2);
			Button component = val.GetComponent<Button>();
			GUIManager.Instance.ApplyButtonStyle(component, options.FontSize);
			val2.alignment = options.TextAlignment;
			val2.supportRichText = options.SupportRichText;
			val2.horizontalOverflow = (HorizontalWrapMode)((!options.Wrap) ? 1 : 0);
			val2.verticalOverflow = (VerticalWrapMode)1;
			SetTextInsets(val2, options.TextOffsetMin, options.TextOffsetMax);
			if (onClick != null)
			{
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
			}
			return component;
		}

		internal static void ApplyButtonSizing(LayoutElement layout, DevToolsButtonSizing sizing)
		{
			if (!((Object)(object)layout == (Object)null))
			{
				ApplyLayoutElement(layout, sizing.Width, sizing.Height, sizing.Width, sizing.Height, sizing.FlexibleWidth ? 1f : 0f, 0f);
			}
		}

		internal static void ApplyLayoutElement(LayoutElement layout, float preferredWidth, float preferredHeight, float minWidth, float minHeight, float flexibleWidth, float flexibleHeight)
		{
			if (!((Object)(object)layout == (Object)null))
			{
				layout.preferredWidth = preferredWidth;
				layout.preferredHeight = preferredHeight;
				layout.minWidth = minWidth;
				layout.minHeight = minHeight;
				layout.flexibleWidth = flexibleWidth;
				layout.flexibleHeight = flexibleHeight;
			}
		}

		internal static ContentSizeFitter EnsureContentSizeFitter(Component component, FitMode horizontalFit, FitMode verticalFit)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			ContentSizeFitter val = component.GetComponent<ContentSizeFitter>();
			if ((Object)(object)val == (Object)null)
			{
				val = component.gameObject.AddComponent<ContentSizeFitter>();
			}
			val.horizontalFit = horizontalFit;
			val.verticalFit = verticalFit;
			return val;
		}

		internal static int GetInsetFittedHeight(float containerHeight, float verticalPadding, float preferredHeight, int minimumHeight = 24)
		{
			float num = containerHeight - verticalPadding * 2f;
			return Mathf.Max(minimumHeight, Mathf.FloorToInt(Mathf.Min(preferredHeight, num)));
		}

		internal static void StretchToFill(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			StretchToFill(rect, Vector2.zero, Vector2.zero);
		}

		internal static void StretchToFill(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_000b: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rect == (Object)null))
			{
				rect.anchorMin = Vector2.zero;
				rect.anchorMax = Vector2.one;
				rect.offsetMin = offsetMin;
				rect.offsetMax = offsetMax;
			}
		}
	}
	internal static class DevToolsBootstrap
	{
		private static DevToolsController controller;

		internal static void Initialize(PluginMain owner)
		{
			if ((Object)(object)owner == (Object)null || PluginMain.IsDedicatedServer)
			{
				return;
			}
			DevToolsConfig.Initialize();
			if ((Object)(object)controller == (Object)null)
			{
				controller = ((Component)owner).GetComponent<DevToolsController>();
				if ((Object)(object)controller == (Object)null)
				{
					controller = ((Component)owner).gameObject.AddComponent<DevToolsController>();
				}
			}
			controller.Initialize();
		}

		internal static void Shutdown()
		{
			if (!((Object)(object)controller == (Object)null))
			{
				controller.Shutdown();
				controller = null;
			}
		}
	}
	internal static class DevToolsConfig
	{
		internal static bool IsEnabled => RuntimeDebugConfig.DevToolsEnabled;

		internal static KeyboardShortcut ToggleShortcut => RuntimeDebugConfig.DevToolsToggleShortcut;

		internal static KeyboardShortcut DefaultShortcut => RuntimeDebugConfig.DefaultDevToolsShortcut;

		internal static void Initialize()
		{
		}

		internal static bool IsToggleShortcutDown()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return IsShortcutDown(ToggleShortcut);
		}

		internal static bool TrySetEnabled(bool value, out string error)
		{
			return RuntimeDebugConfig.TrySetDevToolsEnabled(value, out error);
		}

		internal static bool TrySetToggleShortcut(KeyboardShortcut shortcut, out string error)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return RuntimeDebugConfig.TrySetDevToolsToggleShortcut(shortcut, out error);
		}

		internal static bool ResetToggleShortcut(out string error)
		{
			return RuntimeDebugConfig.ResetDevToolsToggleShortcut(out error);
		}

		internal static string GetToggleShortcutDisplayString()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetShortcutDisplayString(ToggleShortcut);
		}

		internal static string GetShortcutDisplayString(KeyboardShortcut shortcut)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				AddDisplayPart(list, GetKeyDisplayName(modifier));
			}
			AddDisplayPart(list, GetKeyDisplayName(((KeyboardShortcut)(ref shortcut)).MainKey));
			if (list.Count != 0)
			{
				return string.Join(" + ", list.ToArray());
			}
			return "<unset>";
		}

		private static bool IsShortcutDown(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0 || !Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if (!IsModifierHeld(modifier))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsModifierHeld(KeyCode modifier)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected I4, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			switch (modifier - 303)
			{
			case 2:
			case 3:
				if (!Input.GetKey((KeyCode)306))
				{
					return Input.GetKey((KeyCode)305);
				}
				return true;
			case 0:
			case 1:
				if (!Input.GetKey((KeyCode)304))
				{
					return Input.GetKey((KeyCode)303);
				}
				return true;
			case 4:
			case 5:
				if (!Input.GetKey((KeyCode)308))
				{
					return Input.GetKey((KeyCode)307);
				}
				return true;
			case 6:
			case 7:
				if (!Input.GetKey((KeyCode)310))
				{
					return Input.GetKey((KeyCode)309);
				}
				return true;
			default:
				return Input.GetKey(modifier);
			}
		}

		private static string GetKeyDisplayName(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			if ((int)key != 0)
			{
				switch (key - 303)
				{
				case 2:
				case 3:
					return "Ctrl";
				case 0:
				case 1:
					return "Shift";
				case 4:
				case 5:
					return "Alt";
				case 6:
				case 7:
					return "Cmd";
				default:
					return ((object)(KeyCode)(ref key)).ToString().Replace("Alpha", string.Empty);
				}
			}
			return string.Empty;
		}

		private static void AddDisplayPart(List<string> parts, string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return;
			}
			for (int i = 0; i < parts.Count; i++)
			{
				if (string.Equals(parts[i], value, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
			}
			parts.Add(value);
		}
	}
	internal sealed class DevToolsController : MonoBehaviour
	{
		private const float RefreshIntervalSeconds = 0.25f;

		private const float RouterButtonFallbackWidth = 220f;

		private const float RouterButtonFallbackHeight = 42f;

		private const float CloseButtonInitialWidth = 64f;

		private const float CloseButtonInitialHeight = 48f;

		private readonly List<DevToolsPage> pages = new List<DevToolsPage>();

		private readonly List<Button> routerButtons = new List<Button>();

		private readonly List<LayoutElement> routerButtonLayouts = new List<LayoutElement>();

		private readonly List<Text> routerButtonTexts = new List<Text>();

		private GameObject uiRoot;

		private RectTransform rootRect;

		private RectTransform windowRect;

		private RectTransform contentHost;

		private RectTransform routerListRect;

		private Text titleText;

		private Button closeButton;

		private LayoutElement headerLayoutElement;

		private HorizontalLayoutGroup headerLayoutGroup;

		private VerticalLayoutGroup titleLayoutGroup;

		private VerticalLayoutGroup windowLayoutGroup;

		private HorizontalLayoutGroup bodyLayoutGroup;

		private LayoutElement closeButtonLayoutElement;

		private LayoutElement routerPanelLayoutElement;

		private LayoutElement contentPanelLayoutElement;

		private VerticalLayoutGroup routerListLayoutGroup;

		private bool initialized;

		private bool isOpen;

		private bool inputBlocked;

		private bool cursorStateCaptured;

		private CursorLockMode previousCursorLockState;

		private bool previousCursorVisible;

		private float refreshTimer;

		private int activePageIndex;

		private Vector2 lastViewportSize;

		private void Awake()
		{
			pages.Add(new DevToolsPluginPage());
			pages.Add(new DevToolsPerformancePage());
			pages.Add(new DevToolsTranslationTracePage());
			pages.Add(new DevToolsTranslationBrowserPage());
			pages.Add(new DevToolsTranslationPlaygroundPage());
		}

		internal void Initialize()
		{
			if (initialized)
			{
				if (isOpen || (Object)(object)uiRoot != (Object)null)
				{
					EnsureUiRoot();
				}
				SyncUiState();
				return;
			}
			initialized = true;
			GUIManager.OnCustomGUIAvailable += HandleCustomGuiAvailable;
			PluginLocalization.Reloaded += HandleLocalizationReloaded;
			if (isOpen)
			{
				EnsureUiRoot();
			}
			SyncUiState();
		}

		internal void Shutdown()
		{
			if (initialized)
			{
				GUIManager.OnCustomGUIAvailable -= HandleCustomGuiAvailable;
				PluginLocalization.Reloaded -= HandleLocalizationReloaded;
				CloseWithoutGuard();
				DestroyUiRoot();
				initialized = false;
			}
		}

		private void OnDestroy()
		{
			Shutdown();
		}

		private void Update()
		{
			if (!initialized || (!DevToolsConfig.IsEnabled && !isOpen))
			{
				return;
			}
			DevToolsPage activePage = GetActivePage();
			bool flag = isOpen && activePage != null && activePage.BlocksGlobalHotkeys;
			if (!flag && DevToolsConfig.IsToggleShortcutDown())
			{
				SetOpen(!isOpen);
			}
			else if (isOpen)
			{
				if (!flag && Input.GetKeyDown((KeyCode)27))
				{
					SetOpen(open: false);
				}
				else if (EnsureUiRoot())
				{
					RefreshOpenWindow();
				}
			}
		}

		private void HandleCustomGuiAvailable()
		{
			if (isOpen || !((Object)(object)uiRoot == (Object)null))
			{
				EnsureUiRoot();
				ApplyResponsiveLayout(force: true);
				SyncUiState();
			}
		}

		private void HandleLocalizationReloaded()
		{
			if (!((Object)(object)uiRoot != (Object)null) && !isOpen)
			{
				return;
			}
			DestroyUiRoot();
			if (EnsureUiRoot())
			{
				ApplyResponsiveLayout(force: true);
				SyncUiState();
				if (isOpen)
				{
					SelectPage(activePageIndex);
					refreshTimer = 0f;
					RefreshOpenWindow();
				}
			}
		}

		private void SetOpen(bool open)
		{
			if (open)
			{
				if (!EnsureUiRoot())
				{
					ManualLogSource log = PluginMain.Log;
					if (log != null)
					{
						log.LogWarning((object)PluginMain.Localize("plugin.log.devtools_not_ready", "Localization devtools UI is not ready yet."));
					}
					return;
				}
				ApplyResponsiveLayout();
				if (isOpen)
				{
					RefreshOpenWindow();
					return;
				}
				isOpen = true;
				CaptureCursorState();
				ApplyCursorUnlocked();
				BlockGameplayInput();
				Input.ResetInputAxes();
				SyncUiState();
				SelectPage(activePageIndex);
				refreshTimer = 0f;
				RefreshOpenWindow();
			}
			else if (isOpen)
			{
				CloseWithoutGuard();
			}
		}

		private void CloseWithoutGuard()
		{
			isOpen = false;
			if ((Object)(object)uiRoot != (Object)null)
			{
				uiRoot.SetActive(false);
			}
			ReleaseGameplayInput();
			RestoreCursorState();
			Input.ResetInputAxes();
		}

		private void RefreshOpenWindow()
		{
			ApplyResponsiveLayout();
			refreshTimer -= Time.unscaledDeltaTime;
			if (refreshTimer <= 0f)
			{
				RefreshActivePage();
				refreshTimer = 0.25f;
			}
			GetActivePage()?.Tick();
			ApplyCursorUnlocked();
		}

		private void SyncUiState()
		{
			if ((Object)(object)uiRoot != (Object)null)
			{
				uiRoot.SetActive(isOpen);
			}
			if (isOpen)
			{
				BlockGameplayInput();
				ApplyCursorUnlocked();
				if ((Object)(object)contentHost != (Object)null)
				{
					SelectPage(activePageIndex);
				}
			}
			else
			{
				ReleaseGameplayInput();
			}
		}

		private bool EnsureUiRoot()
		{
			if ((Object)(object)uiRoot != (Object)null && (Object)(object)contentHost != (Object)null)
			{
				return true;
			}
			if ((Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			BuildUiRoot(GUIManager.CustomGUIFront.transform);
			if ((Object)(object)uiRoot != (Object)null)
			{
				return (Object)(object)contentHost != (Object)null;
			}
			return false;
		}

		private void BuildUiRoot(Transform parent)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			DestroyUiRoot();
			uiRoot = ((Component)CreateRectObject("LocalizationDevToolsRoot", parent, typeof(DevToolsUiMarker))).gameObject;
			rootRect = uiRoot.GetComponent<RectTransform>();
			rootRect.anchorMin = Vector2.zero;
			rootRect.anchorMax = Vector2.one;
			rootRect.offsetMin = Vector2.zero;
			rootRect.offsetMax = Vector2.zero;
			uiRoot.SetActive(false);
			CreateBlocker(uiRoot.transform);
			windowRect = CreateWindow(uiRoot.transform);
			BuildHeader(windowRect);
			BuildBody(windowRect);
			for (int i = 0; i < pages.Count; i++)
			{
				pages[i].EnsureBuilt((Transform)(object)contentHost);
			}
			ApplyResponsiveLayout(force: true);
			uiRoot.SetActive(isOpen);
		}

		private void DestroyUiRoot()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)uiRoot != (Object)null)
			{
				Object.Destroy((Object)(object)uiRoot);
			}
			uiRoot = null;
			rootRect = null;
			windowRect = null;
			contentHost = null;
			routerListRect = null;
			titleText = null;
			closeButton = null;
			headerLayoutElement = null;
			headerLayoutGroup = null;
			titleLayoutGroup = null;
			windowLayoutGroup = null;
			bodyLayoutGroup = null;
			closeButtonLayoutElement = null;
			routerPanelLayoutElement = null;
			contentPanelLayoutElement = null;
			routerListLayoutGroup = null;
			routerButtons.Clear();
			routerButtonLayouts.Clear();
			routerButtonTexts.Clear();
			lastViewportSize = Vector2.zero;
			for (int i = 0; i < pages.Count; i++)
			{
				pages[i].ResetForRebuild();
			}
		}

		private void BuildHeader(RectTransform window)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			GameObject gameObject = ((Component)CreateRectObject("Header", (Transform)(object)window, typeof(Image), typeof(HorizontalLayoutGroup), typeof(LayoutElement))).gameObject;
			headerLayoutElement = gameObject.GetComponent<LayoutElement>();
			Image component = gameObject.GetComponent<Image>();
			ApplyShellFrameStyle(component, new Color(0.8f, 0.75f, 0.66f, 0.97f));
			headerLayoutGroup = gameObject.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)headerLayoutGroup).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)headerLayoutGroup).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)headerLayoutGroup).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)headerLayoutGroup).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)headerLayoutGroup).childForceExpandHeight = false;
			GameObject gameObject2 = ((Component)CreateRectObject("TitleBlock", gameObject.transform, typeof(VerticalLayoutGroup), typeof(LayoutElement))).gameObject;
			gameObject2.GetComponent<LayoutElement>().flexibleWidth = 1f;
			titleLayoutGroup = gameObject2.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)titleLayoutGroup).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)titleLayoutGroup).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)titleLayoutGroup).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)titleLayoutGroup).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)titleLayoutGroup).childForceExpandHeight = false;
			titleText = CreateText(gameObject2.transform, "Title", PluginMain.Localize("devtools.app.title", "Localization Devtools"), 28);
			GUIManager.Instance.ApplyTextStyle(titleText, GUIManager.Instance.ValheimOrange, 28, true);
			titleText.alignment = (TextAnchor)3;
			closeButton = CreateButton(gameObject.transform, "X", new UnityAction(CloseFromButton), 16, 64f, 48f);
			closeButtonLayoutElement = ((Component)closeButton).GetComponent<LayoutElement>();
			Text componentInChildren = ((Component)closeButton).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.alignment = (TextAnchor)4;
			}
		}

		private void BuildBody(RectTransform window)
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)CreateRectObject("Body", (Transform)(object)window, typeof(HorizontalLayoutGroup), typeof(LayoutElement))).gameObject;
			LayoutElement component = gameObject.GetComponent<LayoutElement>();
			component.flexibleHeight = 1f;
			component.flexibleWidth = 1f;
			bodyLayoutGroup = gameObject.GetComponent<HorizontalLayoutGroup>();
			((LayoutGroup)bodyLayoutGroup).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)bodyLayoutGroup).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)bodyLayoutGroup).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)bodyLayoutGroup).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)bodyLayoutGroup).childForceExpandHeight = true;
			RectTransform val = CreatePanel(gameObject.transform, "RouterPanel", 15f);
			routerPanelLayoutElement = ((Component)val).GetComponent<LayoutElement>();
			BuildRouter(val);
			RectTransform val2 = CreatePanel(gameObject.transform, "ContentPanel", 85f);
			contentPanelLayoutElement = ((Component)val2).GetComponent<LayoutElement>();
			contentHost = ((Component)CreateRectObject("ContentHost", (Transform)(object)val2)).GetComponent<RectTransform>();
			contentHost.anchorMin = Vector2.zero;
			contentHost.anchorMax = Vector2.one;
			contentHost.offsetMin = Vector2.zero;
			contentHost.offsetMax = Vector2.zero;
		}

		private void BuildRouter(RectTransform parent)
		{
			//IL_0036: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			GameObject gameObject = ((Component)CreateRectObject("RouterList", (Transform)(object)parent, typeof(VerticalLayoutGroup))).gameObject;
			routerListRect = gameObject.GetComponent<RectTransform>();
			routerListRect.anchorMin = Vector2.zero;
			routerListRect.anchorMax = Vector2.one;
			routerListRect.offsetMin = Vector2.zero;
			routerListRect.offsetMax = Vector2.zero;
			routerListLayoutGroup = gameObject.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)routerListLayoutGroup).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)routerListLayoutGroup).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)routerListLayoutGroup).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)routerListLayoutGroup).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)routerListLayoutGroup).childForceExpandHeight = false;
			for (int i = 0; i < pages.Count; i++)
			{
				int pageIndex = i;
				Button val = CreateButton(gameObject.transform, pages[i].DisplayName, (UnityAction)delegate
				{
					SelectPage(pageIndex);
				}, 16, 220f, 42f);
				routerButtons.Add(val);
				routerButtonLayouts.Add(((Component)val).GetComponent<LayoutElement>());
				routerButtonTexts.Add(((Component)val).GetComponentInChildren<Text>());
			}
		}

		private RectTransform CreateWindow(Transform parent)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = CreateRectObject("Window", parent, typeof(Image));
			val.anchorMin = new Vector2(0.09f, 0.11f);
			val.anchorMax = new Vector2(0.91f, 0.89f);
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			GUIManager.Instance.ApplyWoodpanelStyle((Transform)(object)val);
			windowLayoutGroup = ((Component)val).gameObject.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)windowLayoutGroup).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)windowLayoutGroup).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)windowLayoutGroup).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)windowLayoutGroup).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)windowLayoutGroup).childForceExpandHeight = false;
			return val;
		}

		private RectTransform CreatePanel(Transform parent, string name, float flexibleWidth)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			RectTransform obj = CreateRectObject(name, parent, typeof(Image), typeof(LayoutElement));
			Image component = ((Component)obj).GetComponent<Image>();
			ApplyShellFrameStyle(component, new Color(0.68f, 0.63f, 0.56f, 0.93f));
			LayoutElement component2 = ((Component)obj).GetComponent<LayoutElement>();
			component2.preferredWidth = 0f;
			component2.minWidth = 0f;
			component2.flexibleWidth = flexibleWidth;
			component2.flexibleHeight = 1f;
			return obj;
		}

		private void ApplyShellFrameStyle(Image image, Color color)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				image.sprite = GUIManager.Instance.GetSprite("woodpanel_settings");
				image.type = (Type)1;
				((Graphic)image).color = color;
			}
		}

		private void CreateBlocker(Transform parent)
		{
			//IL_0053: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)CreateRectObject("Blocker", parent, typeof(Image))).gameObject;
			Image component = gameObject.GetComponent<Image>();
			component.sprite = GUIManager.Instance.GetSprite("darken_blob");
			((Graphic)component).color = new Color(0f, 0f, 0f, 0.7f);
			((Graphic)component).raycastTarget = true;
			RectTransform component2 = gameObject.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
		}

		private void SelectPage(int index)
		{
			if (index >= 0 && index < pages.Count)
			{
				activePageIndex = index;
				for (int i = 0; i < pages.Count; i++)
				{
					pages[i].SetVisible(visible: false);
				}
				GetActivePage()?.SetVisible(visible: true);
				ApplyResponsiveLayout(force: true);
				UpdateRouterVisualState();
				RefreshActivePage();
				GetActivePage()?.RebuildLayout();
				if ((Object)(object)contentHost != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(contentHost);
				}
				if ((Object)(object)windowRect != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(windowRect);
				}
			}
		}

		private void RefreshActivePage()
		{
			DevToolsPage activePage = GetActivePage();
			if (activePage == null)
			{
				return;
			}
			try
			{
				activePage.Refresh();
			}
			catch (Exception arg)
			{
				ManualLogSource log = PluginMain.Log;
				if (log != null)
				{
					log.LogError((object)$"Failed to refresh devtools page '{activePage.Id}': {arg}");
				}
			}
		}

		private void UpdateRouterVisualState()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < routerButtons.Count; i++)
			{
				bool flag = i == activePageIndex;
				Image component = ((Component)routerButtons[i]).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (flag ? new Color(1f, 1f, 0.96f, 1f) : new Color(0.76f, 0.76f, 0.76f, 0.9f));
				}
				Text val = routerButtonTexts[i];
				if ((Object)(object)val != (Object)null)
				{
					((Graphic)val).color = (Color)(flag ? Color.white : new Color(0.88f, 0.72f, 0.34f, 1f));
				}
			}
		}

		private DevToolsPage GetActivePage()
		{
			if (activePageIndex < 0 || activePageIndex >= pages.Count)
			{
				return null;
			}
			return pages[activePageIndex];
		}

		private void CloseFromButton()
		{
			SetOpen(open: false);
		}

		private void BlockGameplayInput()
		{
			if (!inputBlocked)
			{
				GUIManager.BlockInput(true);
				inputBlocked = true;
			}
		}

		private void ReleaseGameplayInput()
		{
			if (inputBlocked)
			{
				GUIManager.BlockInput(false);
				inputBlocked = false;
			}
		}

		private void CaptureCursorState()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!cursorStateCaptured)
			{
				previousCursorLockState = Cursor.lockState;
				previousCursorVisible = Cursor.visible;
				cursorStateCaptured = true;
			}
		}

		private void RestoreCursorState()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (cursorStateCaptured)
			{
				Cursor.lockState = previousCursorLockState;
				Cursor.visible = previousCursorVisible;
				cursorStateCaptured = false;
			}
		}

		private static void ApplyCursorUnlocked()
		{
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}

		private Button CreateButton(Transform parent, string label, UnityAction onClick, int fontSize, float preferredWidth, float preferredHeight)
		{
			return DevToolsUiFactory.CreateButton(parent, label.Replace(" ", string.Empty) + "Button", label, delegate
			{
				UnityAction obj = onClick;
				if (obj != null)
				{
					obj.Invoke();
				}
			}, fontSize, DevToolsButtonSizing.Fixed(preferredWidth, preferredHeight), supportRichText: false, useLocalizationFallback: true);
		}

		private static RectTransform CreateRectObject(string name, Transform parent, params Type[] additionalComponents)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Type[] array;
			if (additionalComponents == null || additionalComponents.Length == 0)
			{
				array = new Type[1] { typeof(RectTransform) };
			}
			else
			{
				array = new Type[additionalComponents.Length + 1];
				array[0] = typeof(RectTransform);
				for (int i = 0; i < additionalComponents.Length; i++)
				{
					array[i + 1] = additionalComponents[i];
				}
			}
			GameObject val = new GameObject(name, array);
			val.transform.SetParent(parent, false);
			return val.GetComponent<RectTransform>();
		}

		private static Text CreateText(Transform parent, string name, string text, int fontSize)
		{
			return DevToolsUiFactory.CreateTextBlock(parent, name, text, fontSize, (TextAnchor)3, wrap: true, supportRichText: false, useLocalizationFallback: true);
		}

		private static void StretchToFill(RectTransform rectTransform)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
		}

		private void ApplyResponsiveLayout(bool force = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_0096: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rootRect == (Object)null || (Object)(object)windowRect == (Object)null)
			{
				return;
			}
			Rect rect = rootRect.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			if (size.x <= 0f || size.y <= 0f)
			{
				((Vector2)(ref size))..ctor((float)Screen.width, (float)Screen.height);
			}
			if (!force && size == lastViewportSize)
			{
				return;
			}
			lastViewportSize = size;
			DevToolsLayoutMetrics devToolsLayoutMetrics = DevToolsLayoutMetrics.Create(size);
			windowRect.anchorMin = devToolsLayoutMetrics.WindowAnchorMin;
			windowRect.anchorMax = devToolsLayoutMetrics.WindowAnchorMax;
			windowRect.offsetMin = Vector2.zero;
			windowRect.offsetMax = Vector2.zero;
			if ((Object)(object)windowLayoutGroup != (Object)null)
			{
				((LayoutGroup)windowLayoutGroup).padding = new RectOffset(devToolsLayoutMetrics.WindowPaddingHorizontal, devToolsLayoutMetrics.WindowPaddingHorizontal, devToolsLayoutMetrics.WindowPaddingVertical, devToolsLayoutMetrics.WindowPaddingVertical);
				((HorizontalOrVerticalLayoutGroup)windowLayoutGroup).spacing = devToolsLayoutMetrics.ShellSpacing;
			}
			if ((Object)(object)headerLayoutElement != (Object)null)
			{
				headerLayoutElement.preferredHeight = devToolsLayoutMetrics.HeaderHeight;
			}
			if ((Object)(object)headerLayoutGroup != (Object)null)
			{
				((LayoutGroup)headerLayoutGroup).padding = new RectOffset(devToolsLayoutMetrics.HeaderPaddingHorizontal, devToolsLayoutMetrics.HeaderPaddingHorizontal, devToolsLayoutMetrics.HeaderPaddingVertical, devToolsLayoutMetrics.HeaderPaddingVertical);
				((HorizontalOrVerticalLayoutGroup)headerLayoutGroup).spacing = devToolsLayoutMetrics.ShellSpacing;
			}
			if ((Object)(object)titleLayoutGroup != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)titleLayoutGroup).spacing = devToolsLayoutMetrics.TitleStackSpacing;
			}
			if ((Object)(object)titleText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(titleText, GUIManager.Instance.ValheimOrange, devToolsLayoutMetrics.HeaderTitleFontSize, true);
			}
			if ((Object)(object)closeButtonLayoutElement != (Object)null)
			{
				closeButtonLayoutElement.preferredWidth = devToolsLayoutMetrics.CloseButtonWidth;
				closeButtonLayoutElement.minWidth = devToolsLayoutMetrics.CloseButtonWidth;
				closeButtonLayoutElement.preferredHeight = devToolsLayoutMetrics.CloseButtonHeight;
			}
			if ((Object)(object)closeButton != (Object)null)
			{
				GUIManager.Instance.ApplyButtonStyle(closeButton, devToolsLayoutMetrics.RouterButtonFontSize);
				Text componentInChildren = ((Component)closeButton).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.alignment = (TextAnchor)4;
				}
			}
			if ((Object)(object)bodyLayoutGroup != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)bodyLayoutGroup).spacing = devToolsLayoutMetrics.ShellSpacing;
			}
			if ((Object)(object)routerPanelLayoutElement != (Object)null)
			{
				routerPanelLayoutElement.flexibleWidth = devToolsLayoutMetrics.RouterFlexWeight;
			}
			if ((Object)(object)contentPanelLayoutElement != (Object)null)
			{
				contentPanelLayoutElement.flexibleWidth = devToolsLayoutMetrics.ContentFlexWeight;
			}
			if ((Object)(object)routerListRect != (Object)null)
			{
				float num = devToolsLayoutMetrics.RouterListPadding;
				routerListRect.offsetMin = new Vector2(num, num);
				routerListRect.offsetMax = new Vector2(0f - num, 0f - num);
			}
			if ((Object)(object)routerListLayoutGroup != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)routerListLayoutGroup).spacing = devToolsLayoutMetrics.RouterListSpacing;
			}
			if ((Object)(object)contentHost != (Object)null)
			{
				float num2 = devToolsLayoutMetrics.PanelPadding;
				contentHost.offsetMin = new Vector2(num2, num2);
				contentHost.offsetMax = new Vector2(0f - num2, 0f - num2);
			}
			int num3 = 0;
			while (num3 < routerButtons.Count)
			{
				float num4;
				if (num3 < routerButtonLayouts.Count && (Object)(object)routerButtonLayouts[num3] != (Object)null)
				{
					if ((Object)(object)routerListRect != (Object)null)
					{
						rect = routerListRect.rect;
						if (((Rect)(ref rect)).width > 0f)
						{
							rect = routerListRect.rect;
							num4 = ((Rect)(ref rect)).width;
							goto IL_03ba;
						}
					}
					num4 = 220f;
					goto IL_03ba;
				}
				goto IL_042d;
				IL_042d:
				Button val = routerButtons[num3];
				if ((Object)(object)val != (Object)null)
				{
					GUIManager.Instance.ApplyButtonStyle(val, devToolsLayoutMetrics.RouterButtonFontSize);
				}
				num3++;
				continue;
				IL_03ba:
				float num5 = num4;
				routerButtonLayouts[num3].flexibleWidth = 0f;
				routerButtonLayouts[num3].preferredWidth = num5;
				routerButtonLayouts[num3].minWidth = num5;
				routerButtonLayouts[num3].preferredHeight = devToolsLayoutMetrics.RouterButtonHeight;
				routerButtonLayouts[num3].minHeight = devToolsLayoutMetrics.RouterButtonHeight;
				goto IL_042d;
			}
			for (int i = 0; i < pages.Count; i++)
			{
				pages[i].ApplyLayout(devToolsLayoutMetrics);
			}
			GetActivePage()?.RebuildLayout();
			if ((Object)(object)contentHost != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(contentHost);
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(windowRect);
			UpdateRouterVisualState();
		}
	}
	internal sealed class DevToolsLayoutMetrics
	{
		private const float WindowWidthRatio = 0.82f;

		private const float WindowHeightRatio = 0.78f;

		public Vector2 ViewportSize { get; }

		public Vector2 WindowAnchorMin { get; }

		public Vector2 WindowAnchorMax { get; }

		public float WindowWidth { get; }

		public float WindowHeight { get; }

		public int WindowPaddingHorizontal { get; }

		public int WindowPaddingVertical { get; }

		public int ShellSpacing { get; }

		public int HeaderHeight { get; }

		public int HeaderPaddingHorizontal { get; }

		public int HeaderPaddingVertical { get; }

		public int TitleStackSpacing { get; }

		public int HeaderTitleFontSize { get; }

		public int HeaderSubtitleFontSize { get; }

		public int CloseButtonWidth { get; }

		public int CloseButtonHeight { get; }

		public int PanelPadding { get; }

		public int RouterListPadding { get; }

		public int RouterListSpacing { get; }

		public int RouterButtonHeight { get; }

		public int RouterButtonFontSize { get; }

		public int SectionColumnSpacing { get; }

		public int SectionGroupSpacing { get; }

		public int SectionPadding { get; }

		public int SectionContentSpacing { get; }

		public int SectionHeaderHeight { get; }

		public int SectionHeaderInset { get; }

		public int SectionTitleFontSize { get; }

		public int InfoRowHeight { get; }

		public int InfoRowSpacing { get; }

		public int InfoRowPaddingHorizontal { get; }

		public int InfoRowPaddingVertical { get; }

		public int InfoRowFontSize { get; }

		public int InfoActionButtonWidth { get; }

		public float RouterFlexWeight => 15f;

		public float ContentFlexWeight => 85f;

		public float InfoLabelFlexWeight => 42f;

		public float InfoValueFlexWeight => 58f;

		private DevToolsLayoutMetrics(Vector2 viewportSize, Vector2 windowAnchorMin, Vector2 windowAnchorMax, float windowWidth, float windowHeight)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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)
			ViewportSize = viewportSize;
			WindowAnchorMin = windowAnchorMin;
			WindowAnchorMax = windowAnchorMax;
			WindowWidth = windowWidth;
			WindowHeight = windowHeight;
			WindowPaddingHorizontal = Mathf.RoundToInt(windowWidth * (3f / 160f));
			WindowPaddingVertical = Mathf.RoundToInt(windowHeight * 0.03158f);
			ShellSpacing = Mathf.RoundToInt(windowWidth * 0.01406f);
			HeaderHeight = Mathf.RoundToInt(windowHeight * 0.12105f);
			HeaderPaddingHorizontal = Mathf.RoundToInt(windowWidth * 0.01563f);
			HeaderPaddingVertical = Mathf.RoundToInt(windowHeight * 0.02368f);
			TitleStackSpacing = Mathf.RoundToInt(windowHeight * 0.00526f);
			HeaderTitleFontSize = Mathf.RoundToInt(windowHeight * 0.03684f);
			HeaderSubtitleFontSize = Mathf.RoundToInt(windowHeight * 0.02105f);
			CloseButtonWidth = Mathf.RoundToInt(windowWidth * 0.05f);
			CloseButtonHeight = Mathf.RoundToInt(windowHeight * 0.06316f);
			PanelPadding = Mathf.RoundToInt(windowWidth * 0.01406f);
			RouterListPadding = Mathf.RoundToInt(windowWidth * 0.0125f);
			RouterListSpacing = Mathf.RoundToInt(windowHeight * 0.01316f);
			RouterButtonHeight = Mathf.RoundToInt(windowHeight * 0.05526f);
			RouterButtonFontSize = HeaderSubtitleFontSize;
			SectionColumnSpacing = Mathf.RoundToInt(windowWidth * 0.0125f);
			SectionGroupSpacing = Mathf.RoundToInt(windowHeight * 0.01842f);
			SectionPadding = Mathf.RoundToInt(windowWidth * 0.00938f);
			SectionContentSpacing = Mathf.RoundToInt(windowHeight * 0.01053f);
			SectionHeaderHeight = Mathf.RoundToInt(windowHeight * 0.04737f);
			SectionHeaderInset = Mathf.RoundToInt(windowWidth * 0.00938f);
			SectionTitleFontSize = Mathf.RoundToInt(windowHeight * 0.02368f);
			InfoRowHeight = Mathf.RoundToInt(windowHeight * 0.04737f);
			InfoRowSpacing = Mathf.RoundToInt(windowWidth * 0.00938f);
			InfoRowPaddingHorizontal = Mathf.RoundToInt(windowWidth * 0.00781f);
			InfoRowPaddingVertical = Mathf.RoundToInt(windowHeight * 0.00789f);
			InfoRowFontSize = Mathf.RoundToInt(windowHeight * 0.01974f);
			InfoActionButtonWidth = Mathf.RoundToInt(windowWidth * (9f / 160f));
		}

		public static DevToolsLayoutMetrics Create(Vector2 viewportSize)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			float num = ((viewportSize.x > 0f) ? viewportSize.x : ((float)Screen.width));
			float num2 = ((viewportSize.y > 0f) ? viewportSize.y : ((float)Screen.height));
			Vector2 viewportSize2 = new Vector2(num, num2);
			float num3 = 0.09f;
			float num4 = 0.110000014f;
			return new DevToolsLayoutMetrics(viewportSize2, new Vector2(num3, num4), new Vector2(1f - num3, 1f - num4), num * 0.82f, num2 * 0.78f);
		}
	}
	internal abstract class DevToolsPage
	{
		private GameObject rootObject;

		public abstract string Id { get; }

		public abstract string DisplayName { get; }

		protected RectTransform RootTransform { get; private set; }

		public virtual bool BlocksGlobalHotkeys => false;

		public void EnsureBuilt(Transform parent)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rootObject != (Object)null))
			{
				rootObject = new GameObject(Id + "Page", new Type[1] { typeof(RectTransform) });
				RootTransform = rootObject.GetComponent<RectTransform>();
				((Transform)RootTransform).SetParent(parent, false);
				RootTransform.anchorMin = Vector2.zero;
				RootTransform.anchorMax = Vector2.one;
				RootTransform.offsetMin = Vector2.zero;
				RootTransform.offsetMax = Vector2.zero;
				Build(RootTransform);
			}
		}

		public void SetVisible(bool visible)
		{
			if (!((Object)(object)rootObject == (Object)null))
			{
				rootObject.SetActive(visible);
			}
		}

		public void ResetForRebuild()
		{
			OnResetForRebuild();
			rootObject = null;
			RootTransform = null;
		}

		protected virtual void OnResetForRebuild()
		{
		}

		internal void RebuildLayout()
		{
			if (!((Object)(object)RootTransform == (Object)null) && ((Component)RootTransform).gameObject.activeInHierarchy)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(RootTransform);
			}
		}

		public virtual void ApplyLayout(DevToolsLayoutMetrics metrics)
		{
		}

		public virtual void Tick()
		{
		}

		protected abstract void Build(RectTransform parent);

		public abstract void Refresh();
	}
	internal static class DevToolsScrollbars
	{
		private const float ScrollbarWidth = 10f;

		private const float ScrollbarPadding = 3f;

		internal static Scrollbar CreateVerticalScrollbar(RectTransform scrollRoot, RectTransform viewportRect, string name)
		{
			//IL_001f: 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_005d: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: 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_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)scrollRoot == (Object)null || (Object)(object)viewportRect == (Object)null)
			{
				return null;
			}
			viewportRect.offsetMax = new Vector2(-13f, 0f);
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			});
			val.transform.SetParent((Transform)(object)scrollRoot, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(1f, 1f);
			component.offsetMin = new Vector2(-10f, 0f);
			component.offsetMax = Vector2.zero;
			Image component2 = val.GetComponent<Image>();
			component2.sprite = GUIManager.Instance.GetSprite("text_field");
			component2.type = (Type)1;
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.18f);
			GameObject val2 = new GameObject("SlidingArea", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = new Vector2(1f, 2f);
			component3.offsetMax = new Vector2(-1f, -2f);
			GameObject val3 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent(val2.transform, false);
			RectTransform component4 = val3.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0f);
			component4.anchorMax = new Vector2(1f, 1f);
			component4.offsetMin = Vector2.zero;
			component4.offsetMax = Vector2.zero;
			Image component5 = val3.GetComponent<Image>();
			component5.sprite = GUIManager.Instance.GetSprite("woodpanel_settings");
			component5.type = (Type)1;
			((Graphic)component5).color = new Color(0.84f, 0.75f, 0.58f, 0.95f);
			Scrollbar component6 = val.GetComponent<Scrollbar>();
			component6.handleRect = component4;
			((Selectable)component6).targetGraphic = (Graphic)(object)component5;
			component6.direction = (Direction)2;
			((Selectable)component6).transition = (Transition)1;
			ColorBlock colors = ((Selectable)component6).colors;
			((ColorBlock)(ref colors)).normalColor = ((Graphic)component5).color;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.94f, 0.85f, 0.66f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.73f, 0.64f, 0.49f, 1f);
			((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).highlightedColor;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.4f, 0.4f, 0.4f, 0.6f);
			((Selectable)component6).colors = colors;
			return component6;
		}

		internal static void AttachVerticalScrollbar(RectTransform scrollRoot, RectTransform viewportRect, ScrollRect scrollRect, string name)
		{
			if (!((Object)(object)scrollRoot == (Object)null) && !((Object)(object)viewportRect == (Object)null) && !((Object)(object)scrollRect == (Object)null))
			{
				Scrollbar val = CreateVerticalScrollbar(scrollRoot, viewportRect, name);
				if (!((Object)(object)val == (Object)null))
				{
					scrollRect.verticalScrollbar = val;
					scrollRect.verticalScrollbarVisibility = (ScrollbarVisibility)0;
					scrollRect.verticalScrollbarSpacing = 3f;
				}
			}
		}
	}
	internal sealed class DevToolsUiMarker : MonoBehaviour
	{
	}
	internal sealed class DevToolsPerformancePage : DevToolsStructuredInfoPage
	{
		private static readonly string[] MonospaceFontNames = new string[7] { "Cascadia Mono", "Consolas", "Courier New", "Lucida Console", "DejaVu Sans Mono", "Liberation Mono", "Monaco" };

		private static Font monospaceFont;

		private static bool monospaceFontResolved;

		private string lastMetricsAction = "Cumulative since startup";

		protected override bool UseScrollView => true;

		public override string Id => "performance";

		public override string DisplayName => PluginMain.Localize("devtools.page.performance", "Performance");

		protected override PageColumnDefinition[] GetColumns()
		{
			return new PageColumnDefinition[2]
			{
				new PageColumnDefinition("LeftColumn", 1f, new PageSectionDefinition(PluginMain.Localize("devtools.performance.section.loaded_content", "Loaded Content"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.exact_rules", "Exact Rules"), "ExactRuleCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.template_rules", "Template Rules"), "TemplateRuleCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.local_english_files", "Local English Files"), "LocalEnglishFileCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.synced_english_files", "Synced English Files"), "SyncedEnglishFileCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.local_active_files", "Local Active Files"), "LocalActiveFileCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.synced_active_files", "Synced Active Files"), "SyncedActiveFileCount")), new PageSectionDefinition(PluginMain.Localize("devtools.performance.section.hot_path", "Hot Path"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.intercepts", "Intercepts"), "InterceptionCallCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.reuse_hits", "Reuse Hits"), "InterceptionStateReuseCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.reuse_hit_rate", "Reuse Hit Rate"), "InterceptionStateReuseRate"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.known_output_skips", "Known Output Skips"), "InterceptionKnownOutputSkipsCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.known_output_skip_rate", "Known Output Skip Rate"), "InterceptionKnownOutputSkipsRate"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.translation_cache_hits", "Translation Cache Hits"), "TranslationCacheHitCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.translation_cache_calls", "Translation Cache Calls"), "TranslationCallCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.translation_cache_hit_rate", "Translation Cache Rate"), "TranslationCacheHitRateValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.translation_miss_cache_hits", "Miss Cache Hits"), "TranslationMissCacheHitCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.translation_miss_cache_calls", "Miss Cache Calls"), "TranslationMissCallCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.miss_cache_hit_rate", "Miss Cache Rate"), "TranslationMissCacheHitRateValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.normalizer_cache_hits", "Normalizer Cache Hits"), "NormalizationCacheHitCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.normalizer_cache_calls", "Normalizer Cache Calls"), "NormalizationCallCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.normalizer_cache_hit_rate", "Normalizer Cache Rate"), "NormalizerCacheHitRateValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.avg_template_candidates", "Avg Template Candidates"), "AverageTemplateCandidateCount"))),
				new PageColumnDefinition("RightColumn", 1f, new PageSectionDefinition(PluginMain.Localize("devtools.performance.section.caches", "Caches"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.translation_cache", "Translation Cache"), "TranslationCacheCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.translation_miss_cache", "Translation Miss Cache"), "TranslationMissCacheCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.placeholder_cache", "Placeholder Cache"), "PlaceholderCacheCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.placeholder_miss_cache", "Placeholder Miss Cache"), "PlaceholderMissCacheCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.runtime_evictions", "Runtime Evictions"), "RuntimeEvictionCount"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.resolver_evictions", "Resolver Evictions"), "ResolverEvictionCount")), new PageSectionDefinition(PluginMain.Localize("devtools.performance.section.timings", "Timings"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.avg_intercept", "Avg Intercept"), "InterceptionAverageMilliseconds"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.avg_translate", "Avg Translate"), "TranslationAverageMilliseconds"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.avg_normalize", "Avg Normalize"), "NormalizationAverageMilliseconds"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.avg_template", "Avg Template"), "TemplateAverageMilliseconds"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.avg_whole_string_longest_match", "Avg Whole String Longest Match"), "GreedyAverageMilliseconds"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.template_attempts", "Template Attempts"), "TemplateAttemptCountValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.template_matches", "Template Hits"), "TemplateMatchCountValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.template_constrained", "Template Constrained"), "TemplateConstrainedAttemptCountValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.whole_string_longest_match_attempts", "Whole String Longest Match Attempts"), "GreedyAttemptCountValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.whole_string_longest_match_matches", "Whole String Longest Match Hits"), "GreedyMatchCountValue"), new PageRowDefinition(PluginMain.Localize("devtools.performance.row.metrics", "Metrics"), "MetricsState", new PageRowActionDefinition("Reset", ResetPerformanceMetrics))))
			};
		}

		protected override TextAnchor GetValueTextAlignment(PageRowDefinition rowDefinition)
		{
			return (TextAnchor)5;
		}

		protected override float GetInfoLabelFlexWeight(DevToolsLayoutMetrics metrics, PageRowDefinition rowDefinition)
		{
			return 60f;
		}

		protected override float GetInfoValueFlexWeight(DevToolsLayoutMetrics metrics, PageRowDefinition rowDefinition)
		{
			return 40f;
		}

		protected override void OnValueTextStyled(Text valueText, DevToolsLayoutMetrics metrics, PageRowDefinition rowDefinition)
		{
			if (!((Object)(object)valueText == (Object)null))
			{
				Font val = GetMonospaceFont();
				if ((Object)(object)val != (Object)null)
				{
					valueText.font = val;
				}
				valueText.fontSize = metrics.InfoRowFontSize;
				valueText.alignment = (TextAnchor)5;
				valueText.horizontalOverflow = (HorizontalWrapMode)1;
				valueText.verticalOverflow = (VerticalWrapMode)1;
			}
		}

		public override void Refresh()
		{
			TranslationRuntimeDiagnostics diagnostics = TranslationRuntime.GetDiagnostics();
			TranslationPerformanceSnapshot performance = diagnostics.Performance;
			SetValue("ExactRuleCount", FormatCount(diagnostics.ExactRuleCount));
			SetValue("TemplateRuleCount", FormatCount(diagnostics.TemplateRuleCount));
			SetValue("LocalEnglishFileCount", FormatCount(diagnostics.LocalEnglishFileCount));
			SetValue("SyncedEnglishFileCount", FormatCount(diagnostics.SyncedEnglishFileCount));
			SetValue("LocalActiveFileCount", FormatCount(diagnostics.LocalActiveFileCount));
			SetValue("SyncedActiveFileCount", FormatCount(diagnostics.SyncedActiveFileCount));
			SetValue("TranslationCacheCount", FormatCount(diagnostics.TranslationCacheCount));
			SetValue("TranslationMissCacheCount", FormatCount(diagnostics.TranslationMissCacheCount));
			SetValue("PlaceholderCacheCount", FormatCount(diagnostics.PlaceholderCacheCount));
			SetValue("PlaceholderMissCacheCount", FormatCount(diagnostics.PlaceholderMissCacheCount));
			SetValue("InterceptionCallCount", FormatCount(performance.InterceptionCallCount));
			SetValue("InterceptionStateReuseCount", FormatCount(performance.InterceptionStateReuseCount));
			SetValue("InterceptionStateReuseRate", FormatRate((performance.InterceptionCallCount > 0) ? new double?((double)performance.InterceptionStateReuseCount / (double)performance.InterceptionCallCount) : null));
			SetValue("InterceptionKnownOutputSkipsCount", FormatCount(performance.InterceptionKnownTranslatedOutputCount));
			SetValue("InterceptionKnownOutputSkipsRate", FormatRate((performance.InterceptionCallCount > 0) ? new double?((double)performance.InterceptionKnownTranslatedOutputCount / (double)performance.InterceptionCallCount) : null));
			SetValue("TranslationCacheHitCount", FormatCount(performance.TranslationCacheHitCount));
			SetValue("TranslationCallCount", FormatCount(performance.TranslationCallCount));
			SetValue("TranslationCacheHitRateValue", FormatRate((performance.TranslationCallCount > 0) ? new double?(performance.TranslationCacheHitRate) : null));
			SetValue("TranslationMissCacheHitCount", FormatCount(performance.TranslationMissCacheHitCount));
			SetValue("TranslationMissCallCount", FormatCount(performance.TranslationCallCount));
			SetValue("TranslationMissCacheHitRateValue", FormatRate((performance.TranslationCallCount > 0) ? new double?(performance.TranslationMissCacheHitRate) : null));
			SetValue("NormalizationCacheHitCount", FormatCount(performance.NormalizationCacheHitCount));
			SetValue("NormalizationCallCount", FormatCount(performance.NormalizationCallCount));
			SetValue("NormalizerCacheHitRateValue", FormatRate((performance.NormalizationCallCount > 0) ? new double?(performance.NormalizationCacheHitRate) : null));
			SetValue("AverageTemplateCandidateCount", FormatDecimal(performance.AverageTemplateCandidateCount, 2));
			SetValue("RuntimeEvictionCount", FormatCount(performance.TotalRuntimeCacheEvictions));
			SetValue("ResolverEvictionCount", FormatCount(performance.TotalResolverCacheEvictions));
			SetValue("InterceptionAverageMilliseconds", FormatMilliseconds(performance.InterceptionAverageMilliseconds));
			SetValue("TranslationAverageMilliseconds", FormatMilliseconds(performance.TranslationAverageMilliseconds));
			SetValue("NormalizationAverageMilliseconds", FormatMilliseconds(performance.NormalizationAverageMilliseconds));
			SetValue("TemplateAverageMilliseconds", FormatMilliseconds(performance.TemplateAverageMilliseconds));
			SetValue("GreedyAverageMilliseconds", FormatMilliseconds(performance.GreedyAverageMilliseconds));
			SetValue("TemplateAttemptCountValue", FormatCount(performance.TemplateRuleAttemptCount));
			SetValue("TemplateMatchCountValue", FormatCount(performance.TemplateMatchCount));
			SetValue("TemplateConstrainedAttemptCountValue", FormatCount(performance.TemplateConstrainedAttemptCount));
			SetValue("GreedyAttemptCountValue", FormatCount(performance.GreedyAttemptCount));
			SetValue("GreedyMatchCountValue", FormatCount(performance.GreedyMatchCount));
			SetValue("MetricsState", lastMetricsAction);
		}

		private void ResetPerformanceMetrics()
		{
			TranslationPerformanceMetrics.Reset();
			lastMetricsAction = PluginMain.Localize("devtools.performance.status.reset_now", "Reset just now");
			Refresh();
		}

		private static string FormatMilliseconds(double value)
		{
			return FormatDecimal(value, 3) + " ms";
		}

		private static string FormatCount(long value)
		{
			return value.ToString("N0", CultureInfo.InvariantCulture);
		}

		private static string FormatDecimal(double value, int decimalPlaces)
		{
			string text = ((decimalPlaces <= 2) ? "0.00" : "0.000");
			return value.ToString(text, CultureInfo.InvariantCulture);
		}

		private static string FormatRate(double? rate)
		{
			if (!rate.HasValue)
			{
				return "-";
			}
			return (rate.Value * 100.0).ToString("0.0", CultureInfo.InvariantCulture) + "%";
		}

		private static Font GetMonospaceFont()
		{
			if (!monospaceFontResolved)
			{
				monospaceFontResolved = true;
				try
				{
					monospaceFont = Font.CreateDynamicFontFromOSFont(MonospaceFontNames, 16);
				}
				catch
				{
					monospaceFont = null;
				}
			}
			return monospaceFont;
		}
	}
	internal sealed class DevToolsPluginPage : DevToolsStructuredInfoPage
	{
		private static readonly KeyCode[] CapturableKeys = (KeyCode[])Enum.GetValues(typeof(KeyCode));

		private const int TraceFeedCapacityStep = 128;

		private bool capturingToggleShortcut;

		private string lastConfigAction = "Ready";

		public override string Id => "plugin";

		public override string DisplayName => PluginMain.Localize("devtools.page.plugin", "Plugin");

		public override bool BlocksGlobalHotkeys => capturingToggleShortcut;

		protected override PageColumnDefinition[] GetColumns()
		{
			return new PageColumnDefinition[2]
			{
				new PageColumnDefinition("LeftColumn", 1f, new PageSectionDefinition("Overview", 5, new PageRowDefinition("Plugin Version", "PluginVersion"), new PageRowDefinition("Current Language", "LanguageName"), new PageRowDefinition("Remote Snapshot", "HasRemoteSnapshot")), new PageSectionDefinition("Devtools", 4, new PageRowDefinition("Overlay Enabled", "DevToolsEnabled", new PageRowActionDefinition("Toggle", ToggleDevToolsEnabled)), new PageRowDefinition("Toggle Shortcut", "ToggleShortcut", new PageRowActionDefinition("Capture", BeginToggleShortcutCapture), new PageRowActionDefinition("Reset", ResetToggleShortcut)), new PageRowDefinition("Close Actions", "CloseActions"))),
				new PageColumnDefinition("RightColumn", 1f, new PageSectionDefinition("Runtime", 5, new PageRowDefinition("Translation Enabled", "TranslationEnabled", new PageRowActionDefinition("Toggle", ToggleTranslationEnabled)), new PageRowDefinition("Debug Enabled", "DebugEnabled", new PageRowActionDefinition("Toggle", ToggleDebugEnabled)), new PageRowDefinition("Whole String Longest Match Mode", "GreedyExactMatchMode", new PageRowActionDefinition("Prev", SelectPreviousGreedyExactMatchMode), new PageRowActionDefinition("Next", SelectNextGreedyExactMatchMode)), new PageRowDefinition("Minimum Match Length", "GreedyExactMinimumMatchLength", new PageRowActionDefinition("-", DecreaseGreedyExactMinimumMatchLength), new PageRowActionDefinition("+", IncreaseGreedyExactMinimumMatchLength)), new PageRowDefinition(PluginMain.Localize("devtools.plugin.row.trace_feed_capacity", "Trace Feed Capacity"), "TraceFeedCapacity", new PageRowActionDefinition("-128", DecreaseTraceFeedCapacity), new PageRowActionDefinition("+128", IncreaseTraceFeedCapacity), new PageRowActionDefinition("Reset", ResetTraceFeedCapacity))), new PageSectionDefinition("Status", 4, new PageRowDefinition("Hot Update", "HotUpdateState"), new PageRowDefinition("Shortcut Capture", "ShortcutCaptureState"), new PageRowDefinition("Last Config Action", "LastConfigAction")))
			};
		}

		protected override TextAnchor GetValueTextAlignment(PageRowDefinition rowDefinition)
		{
			return (TextAnchor)5;
		}

		public override void Refresh()
		{
			TranslationRuntimeDiagnostics diagnostics = TranslationRuntime.GetDiagnostics();
			SetValue("PluginVersion", "2.0.1");
			SetValue("LanguageName", diagnostics.LanguageName);
			SetValue("HasRemoteSnapshot", DevToolsStructuredInfoPage.FormatBoolean(diagnostics.HasRemoteSnapshot));
			SetValue("CloseActions", "ESC");
			SetValue("DevToolsEnabled", DevToolsStructuredInfoPage.FormatBoolean(DevToolsConfig.IsEnabled));
			SetValue("ToggleShortcut", capturingToggleShortcut ? PluginMain.Localize("devtools.plugin.shortcut.capture_prompt", "Press a new shortcut...") : DevToolsConfig.GetToggleShortcutDisplayString());
			SetValue("TranslationEnabled", DevToolsStructuredInfoPage.FormatBoolean(diagnostics.TranslationEnabled));
			SetValue("DebugEnabled", DevToolsStructuredInfoPage.FormatBoolean(diagnostics.DebugEnabled));
			SetValue("GreedyExactMatchMode", FormatGreedyExactMatchMode(RuntimeDebugConfig.GreedyExactMatchMode));
			SetValue("GreedyExactMinimumMatchLength", RuntimeDebugConfig.GreedyExactMinimumMatchLength.ToString());
			SetValue("TraceFeedCapacity", RuntimeDebugConfig.TraceFeedMaxEntries.ToString());
			SetValue("HotUpdateState", PluginMain.Localize("devtools.plugin.hot_update_value", "Immediate"));
			SetValue("ShortcutCaptureState", capturingToggleShortcut ? PluginMain.Localize("devtools.plugin.shortcut.listening", "Listening (ESC cancels)") : PluginMain.Localize("devtools.plugin.shortcut.idle", "Idle"));
			SetValue("LastConfigAction", lastConfigAction);
		}

		public override void Tick()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (!capturingToggleShortcut)
			{
				return;
			}
			KeyboardShortcut shortcut;
			if (Input.GetKeyDown((KeyCode)27))
			{
				capturingToggleShortcut = false;
				lastConfigAction = PluginMain.Localize("devtools.plugin.status.capture_cancelled", "Shortcut capture cancelled.");
				Refresh();
			}
			else if (TryCaptureToggleShortcut(out shortcut))
			{
				capturingToggleShortcut = false;
				if (!DevToolsConfig.TrySetToggleShortcut(shortcut, out var error))
				{
					ReportConfigFailure("toggle shortcut", error);
					Refresh();
					return;
				}
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.toggle_shortcut_updated", "Toggle Shortcut -> {0}", DevToolsConfig.GetToggleShortcutDisplayString());
				Input.ResetInputAxes();
				Refresh();
			}
		}

		private void ToggleDevToolsEnabled()
		{
			if (!DevToolsConfig.TrySetEnabled(!DevToolsConfig.IsEnabled, out var error))
			{
				ReportConfigFailure("devtools enabled", error);
				Refresh();
			}
			else
			{
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.overlay_enabled_updated", "Overlay Enabled -> {0}", DevToolsStructuredInfoPage.FormatBoolean(DevToolsConfig.IsEnabled));
				Refresh();
			}
		}

		private void BeginToggleShortcutCapture()
		{
			capturingToggleShortcut = true;
			lastConfigAction = PluginMain.Localize("devtools.plugin.status.capture_started", "Press the new toggle shortcut. ESC cancels.");
			Refresh();
		}

		private void ResetToggleShortcut()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			capturingToggleShortcut = false;
			if (!DevToolsConfig.ResetToggleShortcut(out var error))
			{
				ReportConfigFailure("toggle shortcut reset", error);
				Refresh();
			}
			else
			{
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.toggle_shortcut_updated", "Toggle Shortcut -> {0}", DevToolsConfig.GetShortcutDisplayString(DevToolsConfig.DefaultShortcut));
				Refresh();
			}
		}

		private void ToggleTranslationEnabled()
		{
			if (!RuntimeDebugConfig.TrySetTranslationEnabled(!RuntimeDebugConfig.TranslationEnabled, out var error))
			{
				ReportConfigFailure("translation_enabled", error);
				Refresh();
			}
			else
			{
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.translation_enabled_updated", "Translation Enabled -> {0}", DevToolsStructuredInfoPage.FormatBoolean(RuntimeDebugConfig.TranslationEnabled));
				Refresh();
			}
		}

		private void ToggleDebugEnabled()
		{
			if (!RuntimeDebugConfig.TrySetDebugEnabled(!RuntimeDebugConfig.Enabled, out var error))
			{
				ReportConfigFailure("debug", error);
				Refresh();
			}
			else
			{
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.debug_enabled_updated", "Debug Enabled -> {0}", DevToolsStructuredInfoPage.FormatBoolean(RuntimeDebugConfig.Enabled));
				Refresh();
			}
		}

		private void SelectPreviousGreedyExactMatchMode()
		{
			CycleGreedyExactMatchMode(-1);
		}

		private void SelectNextGreedyExactMatchMode()
		{
			CycleGreedyExactMatchMode(1);
		}

		private void DecreaseGreedyExactMinimumMatchLength()
		{
			SetGreedyExactMinimumMatchLength(RuntimeDebugConfig.GreedyExactMinimumMatchLength - 1);
		}

		private void IncreaseGreedyExactMinimumMatchLength()
		{
			SetGreedyExactMinimumMatchLength(RuntimeDebugConfig.GreedyExactMinimumMatchLength + 1);
		}

		private void DecreaseTraceFeedCapacity()
		{
			SetTraceFeedCapacity(RuntimeDebugConfig.TraceFeedMaxEntries - 128);
		}

		private void IncreaseTraceFeedCapacity()
		{
			SetTraceFeedCapacity(RuntimeDebugConfig.TraceFeedMaxEntries + 128);
		}

		private void ResetTraceFeedCapacity()
		{
			SetTraceFeedCapacity(1024);
		}

		private void CycleGreedyExactMatchMode(int direction)
		{
			WholeStringGreedyExactMatchMode[] array = new WholeStringGreedyExactMatchMode[3]
			{
				WholeStringGreedyExactMatchMode.Off,
				WholeStringGreedyExactMatchMode.PerWord,
				WholeStringGreedyExactMatchMode.MinLength
			};
			int num = Array.IndexOf(array, RuntimeDebugConfig.GreedyExactMatchMode);
			if (num < 0)
			{
				num = 0;
			}
			int num2 = (num + direction + array.Length) % array.Length;
			if (!RuntimeDebugConfig.TrySetGreedyExactMatchMode(array[num2], out var error))
			{
				ReportConfigFailure("whole_string_longest_match_mode", error);
				Refresh();
			}
			else
			{
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.whole_string_longest_match_mode_updated", "Whole String Longest Match Mode -> {0}", FormatGreedyExactMatchMode(RuntimeDebugConfig.GreedyExactMatchMode));
				Refresh();
			}
		}

		private void SetGreedyExactMinimumMatchLength(int value)
		{
			if (!RuntimeDebugConfig.TrySetGreedyExactMinimumMatchLength((value <= 0) ? 1 : value, out var error))
			{
				ReportConfigFailure("whole_string_longest_match_min_length", error);
				Refresh();
			}
			else
			{
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.min_length_updated", "Minimum Match Length -> {0}", RuntimeDebugConfig.GreedyExactMinimumMatchLength);
				Refresh();
			}
		}

		private void SetTraceFeedCapacity(int value)
		{
			if (!RuntimeDebugConfig.TrySetTraceFeedMaxEntries((value <= 0) ? 1 : value, out var error))
			{
				ReportConfigFailure("trace_feed_max_entries", error);
				Refresh();
			}
			else
			{
				lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.trace_feed_capacity_updated", "Trace Feed Capacity -> {0}", RuntimeDebugConfig.TraceFeedMaxEntries);
				Refresh();
			}
		}

		private bool TryCaptureToggleShortcut(out KeyboardShortcut shortcut)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			shortcut = default(KeyboardShortcut);
			for (int i = 0; i < CapturableKeys.Length; i++)
			{
				KeyCode val = CapturableKeys[i];
				if (IsCapturableMainKey(val) && Input.GetKeyDown(val))
				{
					shortcut = new KeyboardShortcut(val, GetHeldModifiers());
					return true;
				}
			}
			return false;
		}

		private static KeyCode[] GetHeldModifiers()
		{
			List<KeyCode> list = new List<KeyCode>(4);
			AddModifierIfHeld(list, (KeyCode)306, (KeyCode)305, (KeyCode)306);
			AddModifierIfHeld(list, (KeyCode)304, (KeyCode)303, (KeyCode)304);
			AddModifierIfHeld(list, (KeyCode)308, (KeyCode)307, (KeyCode)308);
			AddModifierIfHeld(list, (KeyCode)310, (KeyCode)309, (KeyCode)310);
			return list.ToArray();
		}

		private static void AddModifierIfHeld(List<KeyCode> modifiers, KeyCode leftKey, KeyCode rightKey, KeyCode normalizedKey)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKey(leftKey) || Input.GetKey(rightKey))
			{
				modifiers.Add(normalizedKey);
			}
		}

		private static bool IsCapturableMainKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			if ((int)key == 0 || (int)key == 27)
			{
				return false;
			}
			if ((int)key == 306 || (int)key == 305 || (int)key == 304 || (int)key == 303 || (int)key == 308 || (int)key == 307 || (int)key == 310 || (int)key == 309)
			{
				return false;
			}
			string text = ((object)(KeyCode)(ref key)).ToString();
			if (!text.StartsWith("Mouse", StringComparison.Ordinal))
			{
				return text.IndexOf("Joystick", StringComparison.OrdinalIgnoreCase) < 0;
			}
			return false;
		}

		private static string FormatGreedyExactMatchMode(WholeStringGreedyExactMatchMode mode)
		{
			return mode switch
			{
				WholeStringGreedyExactMatchMode.Off => PluginMain.Localize("devtools.plugin.mode.off", "Off"), 
				WholeStringGreedyExactMatchMode.MinLength => PluginMain.Localize("devtools.plugin.mode.min_length", "Min Length"), 
				_ => PluginMain.Localize("devtools.plugin.mode.per_word", "Per Word"), 
			};
		}

		private void ReportConfigFailure(string settingName, string error)
		{
			lastConfigAction = PluginMain.LocalizeFormat("devtools.plugin.status.setting_failed", "{0} update failed: {1}", settingName, error);
			ManualLogSource log = PluginMain.Log;
			if (log != null)
			{
				log.LogError((object)PluginMain.LocalizeFormat("plugin.log.devtools_update_failed", "Failed to update {0} from the devtools UI: {1}", settingName, error));
			}
		}
	}
	internal sealed class DevToolsTranslationBrowserPage : DevToolsPage
	{
		private const string LocalSourceKey = "local";

		private const string ServerSourceKey = "server";

		private const float DefaultButtonWidth = 156f;

		private const float DefaultButtonHeight = 36f;

		private const float FileButtonFallbackWidth = 320f;

		private const float FileButtonFallbackHeight = 58f;

		private readonly List<GameObject> navigatorObjects = new List<GameObject>();

		private readonly List<Button> sourceTabButtons = new List<Button>();

		private readonly List<Text> sourceTabButtonTexts = new List<Text>();

		private readonly List<LayoutElement> sourceTabButtonLayouts = new List<LayoutElement>();

		private readonly List<Text> sourceHeaderTexts = new List<Text>();

		private readonly List<Text> languageHeaderTexts = new List<Text>();

		private readonly List<Button> fileButtons = new List<Button>();

		private readonly List<Text> fileButtonTexts = new List<Text>();

		private readonly List<LayoutElement> fileButtonLayouts = new List<LayoutElement>();

		private readonly List<GameObject> detailObjects = new List<GameObject>();

		private readonly List<VerticalLayoutGroup> detailCardLayouts = new List<VerticalLayoutGroup>();

		private readonly List<LayoutElement> detailCardLayoutsElements = new List<LayoutElement>();

		private readonly List<LayoutElement> detailCardHeaderLayouts = new List<LayoutElement>();

		private readonly List<Text> detailCardTitleTexts = new List<Text>();

		private readonly List<VerticalLayoutGroup> detailCardBodyContainerLayouts = new List<VerticalLayoutGroup>();

		private readonly List<VerticalLayoutGroup> detailCardFieldContainerLayouts = new List<VerticalLayoutGroup>();

		private readonly List<VerticalLayoutGroup> detailCardValueContainerLayouts = new List<VerticalLayoutGroup>();

		private readonly List<Text> detailCardFieldLabelTexts = new List<Text>();

		private readonly List<Text> detailCardBodyTexts = new List<Text>();

		private readonly List<Text> detailCardValueTexts = new List<Text>();

		private readonly List<LayoutElement> detailSectionHeaderLayouts = new List<LayoutElement>();

		private readonly List<Text> detailSectionHeaderTexts = new List<Text>();

		private readonly List<TranslationRuleBrowserFileSnapshot> filteredFiles = new List<TranslationRuleBrowserFileSnapshot>();

		private HorizontalLayoutGroup columnsLayout;

		private VerticalLayoutGroup navigatorPanelLayout;

		private VerticalLayoutGroup detailPanelLayout;

		private VerticalLayoutGroup navigatorContentLayout;

		private VerticalLayoutGroup detailContentLayout;

		private HorizontalLayoutGroup sourceTabLayout;

		private HorizontalLayoutGroup searchRowLayout;

		private HorizontalLayoutGroup detailSummaryLayout;

		private LayoutElement navigatorPanelWidthLayout;

		private LayoutElement detailPanelWidthLayout;

		private LayoutElement navigatorHeaderLayout;

		private LayoutElement detailHeaderLayout;

		private LayoutElement sourceTabLayoutElement;

		private LayoutElement searchRowLayoutElement;

		private LayoutElement navigatorStatusLayout;

		private LayoutElement detailSummaryLayoutElement;

		private LayoutElement searchFieldLayout;

		private LayoutElement clearSearchButtonLayout;

		private Text navigatorHeaderText;

		private Text detailHeaderText;

		private Text navigatorStatusText;

		private Text detailSummaryText;

		private Text searchPlaceholderText;

		private Text searchValueText;

		private InputField searchField;

		private Button clearSearchButton;

		private ScrollRect navigatorScrollRect;

		private ScrollRect detailScrollRect;

		private RectTransform navigatorContentRect;

		private RectTransform detailContentRect;

		private DevToolsLayoutMetrics lastMetrics;

		private TranslationRuleBrowserSnapshot snapshot;

		private string selectedFileId;

		private string activeSourceKey = "local";

		private string searchQuery = string.Empty;

		private int lastSnapshotVersion = -1;

		private bool navigatorDirty = true;

		private bool detailDirty = true;

		private RectTransform pendingScrollTarget;

		public override string Id => "browser";

		public override string DisplayName => PluginMain.Localize("devtools.page.browser", "Browser");

		protected override void Build(RectTransform parent)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateHorizontalContainer((Transform)(object)parent, "BrowserColumns", DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 1f), out columnsLayout, out layoutElement);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.UseStretchFill();
			}
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			((LayoutGroup)columnsLayout).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandHeight = true;
			RectTransform parent2 = CreateColumn((Transform)(object)val, "NavigatorPanel", out navigatorPanelLayout, out navigatorPanelWidthLayout);
			CreateHeaderRow((Transform)(object)parent2, PluginMain.Localize("devtools.browser.header.navigator", "Translation Browser"), out navigatorHeaderText, out navigatorHeaderLayout);
			CreateSearchRow((Transform)(object)parent2);
			CreateSourceTabsRow((Transform)(object)parent2);
			CreateInfoRow((Transform)(object)parent2, "NavigatorStatus", out navigatorStatusText, out navigatorStatusLayout);
			navigatorScrollRect = CreateScrollView((Transform)(object)parent2, "NavigatorScroll", out navigatorContentRect, out layoutElement);
			navigatorContentLayout = ((Component)navigatorContentRect).GetComponent<VerticalLayoutGroup>();
			RectTransform parent3 = CreateColumn((Transform)(object)val, "DetailPanel", out detailPanelLayout, out detailPanelWidthLayout);
			CreateHeaderRow((Transform)(object)parent3, PluginMain.Localize("devtools.browser.header.details", "File Details"), out detailHeaderText, out detailHeaderLayout);
			CreateDetailSummaryRow((Transform)(object)parent3);
			detailScrollRect = CreateScrollView((Transform)(object)parent3, "DetailScroll", out detailContentRect, out layoutElement);
			detailContentLayout = ((Component)detailContentRect).GetComponent<VerticalLayoutGroup>();
			UpdateStatusTexts();
		}

		public override void ApplyLayout(DevToolsLayoutMetrics metrics)
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Expected O, but got Unknown
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Expected O, but got Unknown
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Expected O, but got Unknown
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_069f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0741: Unknown result type (might be due to invalid IL or missing references)
			//IL_0765: Unknown result type (might be due to invalid IL or missing references)
			//IL_0777: Unknown result type (might be due to invalid IL or missing references)
			//IL_081d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0827: Expected O, but got Unknown
			//IL_0938: Unknown result type (might be due to invalid IL or missing references)
			//IL_0942: Expected O, but got Unknown
			//IL_08a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_098c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0996: Expected O, but got Unknown
			//IL_09e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ea: Expected O, but got Unknown
			//IL_0a33: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b05: Unknown result type (might be due to invalid IL or missing references)
			if (metrics == null || (Object)(object)columnsLayout == (Object)null)
			{
				return;
			}
			int detailIndentUnit = GetDetailIndentUnit(metrics);
			lastMetrics = metrics;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).spacing = metrics.SectionColumnSpacing;
			ApplyColumnLayout(navigatorPanelLayout, metrics);
			ApplyColumnLayout(detailPanelLayout, metrics);
			if ((Object)(object)navigatorPanelWidthLayout != (Object)null)
			{
				navigatorPanelWidthLayout.preferredWidth = 0f;
				navigatorPanelWidthLayout.minWidth = 0f;
				navigatorPanelWidthLayout.flexibleWidth = 34f;
			}
			if ((Object)(object)detailPanelWidthLayout != (Object)null)
			{
				detailPanelWidthLayout.preferredWidth = 0f;
				detailPanelWidthLayout.minWidth = 0f;
				detailPanelWidthLayout.flexibleWidth = 66f;
			}
			ApplyHeaderLayout(navigatorHeaderLayout, navigatorHeaderText, metrics);
			ApplyHeaderLayout(detailHeaderLayout, detailHeaderText, metrics);
			if ((Object)(object)searchRowLayoutElement != (Object)null)
			{
				searchRowLayoutElement.preferredHeight = metrics.InfoRowHeight;
			}
			if ((Object)(object)searchRowLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)searchRowLayout).spacing = metrics.InfoRowSpacing;
				((LayoutGroup)searchRowLayout).padding = new RectOffset(0, metrics.InfoRowPaddingHorizontal, 0, 0);
			}
			if ((Object)(object)sourceTabLayoutElement != (Object)null)
			{
				sourceTabLayoutElement.preferredHeight = metrics.InfoRowHeight;
			}
			if ((Object)(object)sourceTabLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)sourceTabLayout).spacing = metrics.InfoRowSpacing;
				((LayoutGroup)sourceTabLayout).padding = new RectOffset(metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingHorizontal, 0, 0);
			}
			if ((Object)(object)searchPlaceholderText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(searchPlaceholderText, GUIManager.Instance.AveriaSerif, new Color(1f, 1f, 1f, 0.45f), metrics.InfoRowFontSize, false);
			}
			if ((Object)(object)searchValueText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(searchValueText, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
			}
			if ((Object)(object)searchFieldLayout != (Object)null)
			{
				searchFieldLayout.flexibleWidth = 1f;
				searchFieldLayout.minWidth = 0f;
			}
			if ((Object)(object)clearSearchButtonLayout != (Object)null)
			{
				float num = (float)metrics.InfoActionButtonWidth * 1.45f;
				int insetFittedHeight = DevToolsUiFactory.GetInsetFittedHeight(metrics.InfoRowHeight, metrics.InfoRowPaddingVertical, 36f);
				clearSearchButtonLayout.preferredWidth = num;
				clearSearchButtonLayout.minWidth = num;
				clearSearchButtonLayout.preferredHeight = insetFittedHeight;
				clearSearchButtonLayout.minHeight = insetFittedHeight;
			}
			if ((Object)(object)clearSearchButton != (Object)null)
			{
				GUIManager.Instance.ApplyButtonStyle(clearSearchButton, Mathf.Max(12, metrics.InfoRowFontSize - 1));
			}
			for (int i = 0; i < sourceTabButtonLayouts.Count; i++)
			{
				LayoutElement val = sourceTabButtonLayouts[i];
				if ((Object)(object)val != (Object)null)
				{
					int insetFittedHeight2 = DevToolsUiFactory.GetInsetFittedHeight(metrics.InfoRowHeight, metrics.InfoRowPaddingVertical, 36f);
					val.flexibleWidth = 1f;
					val.preferredWidth = 0f;
					val.minWidth = 0f;
					val.preferredHeight = insetFittedHeight2;
					val.minHeight = insetFittedHeight2;
				}
				if (i < sourceTabButtons.Count && (Object)(object)sourceTabButtons[i] != (Object)null)
				{
					GUIManager.Instance.ApplyButtonStyle(sourceTabButtons[i], Mathf.Max(12, metrics.InfoRowFontSize - 1));
				}
			}
			ApplyInfoTextRow(navigatorStatusLayout, navigatorStatusText, metrics);
			ApplyInfoTextRow(detailSummaryLayoutElement, detailSummaryText, metrics);
			if ((Object)(object)detailSummaryLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)detailSummaryLayout).spacing = 0f;
				((LayoutGroup)detailSummaryLayout).padding = new RectOffset(detailIndentUnit, metrics.InfoRowPaddingHorizontal, 0, 0);
			}
			if ((Object)(object)navigatorContentLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)navigatorContentLayout).spacing = metrics.SectionContentSpacing;
				((LayoutGroup)navigatorContentLayout).padding = new RectOffset(0, 0, 0, 0);
			}
			if ((Object)(object)detailContentLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)detailContentLayout).spacing = metrics.SectionGroupSpacing;
				((LayoutGroup)detailContentLayout).padding = new RectOffset(0, 0, 0, 0);
			}
			for (int j = 0; j < sourceHeaderTexts.Count; j++)
			{
				Text val2 = sourceHeaderTexts[j];
				if (!((Object)(object)val2 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val2, GUIManager.Instance.ValheimOrange, metrics.SectionTitleFontSize, true);
					val2.alignment = (TextAnchor)3;
					StretchToFill(((Graphic)val2).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
				}
			}
			for (int k = 0; k < languageHeaderTexts.Count; k++)
			{
				Text val3 = languageHeaderTexts[k];
				if (!((Object)(object)val3 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val3, GUIManager.Instance.AveriaSerifBold, GUIManager.Instance.ValheimOrange, metrics.InfoRowFontSize, true);
					val3.alignment = (TextAnchor)3;
					StretchToFill(((Graphic)val3).rectTransform, new Vector2((float)(metrics.SectionHeaderInset + metrics.InfoRowPaddingHorizontal), 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
				}
			}
			for (int l = 0; l < fileButtonLayouts.Count; l++)
			{
				LayoutElement val4 = fileButtonLayouts[l];
				if ((Object)(object)val4 != (Object)null)
				{
					float num2 = (float)metrics.InfoRowHeight * 1.7f;
					val4.flexibleWidth = 1f;
					val4.preferredWidth = 0f;
					val4.minWidth = 0f;
					val4.preferredHeight = num2;
					val4.minHeight = num2;
				}
				if (l < fileButtons.Count && (Object)(object)fileButtons[l] != (Object)null)
				{
					GUIManager.Instance.ApplyButtonStyle(fileButtons[l], metrics.InfoRowFontSize);
				}
				if (l < fileButtonTexts.Count && (Object)(object)fileButtonTexts[l] != (Object)null)
				{
					Text obj = fileButtonTexts[l];
					obj.alignment = (TextAnchor)3;
					obj.horizontalOverflow = (HorizontalWrapMode)0;
					obj.verticalOverflow = (VerticalWrapMode)0;
					StretchToFill(((Graphic)obj).rectTransform, new Vector2((float)metrics.InfoRowPaddingHorizontal, 0f), new Vector2((float)(-metrics.InfoRowPaddingHorizontal), 0f));
				}
			}
			for (int m = 0; m < detailSectionHeaderLayouts.Count; m++)
			{
				LayoutElement val5 = detailSectionHeaderLayouts[m];
				if ((Object)(object)val5 != (Object)null)
				{
					val5.preferredHeight = metrics.SectionHeaderHeight;
				}
				if (m < detailSectionHeaderTexts.Count && (Object)(object)detailSectionHeaderTexts[m] != (Object)null)
				{
					Text val6 = detailSectionHeaderTexts[m];
					GUIManager.Instance.ApplyTextStyle(val6, GUIManager.Instance.ValheimOrange, metrics.SectionTitleFontSize, true);
					StretchToFill(((Graphic)val6).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
				}
			}
			for (int n = 0; n < detailCardLayouts.Count; n++)
			{
				if (n < detailCardLayoutsElements.Count && (Object)(object)detailCardLayoutsElements[n] != (Object)null)
				{
					detailCardLayoutsElements[n].minWidth = 0f;
				}
				VerticalLayoutGroup val7 = detailCardLayouts[n];
				if ((Object)(object)val7 != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val7).spacing = metrics.SectionContentSpacing;
					((LayoutGroup)val7).padding = new RectOffset(metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding);
				}
				if (n < detailCardHeaderLayouts.Count && (Object)(object)detailCardHeaderLayouts[n] != (Object)null)
				{
					detailCardHeaderLayouts[n].preferredHeight = metrics.SectionHeaderHeight;
				}
				if (n < detailCardTitleTexts.Count && (Object)(object)detailCardTitleTexts[n] != (Object)null)
				{
					Text val8 = detailCardTitleTexts[n];
					GUIManager.Instance.ApplyTextStyle(val8, GUIManager.Instance.ValheimOrange, metrics.InfoRowFontSize, true);
					val8.alignment = (TextAnchor)3;
					StretchToFill(((Graphic)val8).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
				}
			}
			for (int num3 = 0; num3 < detailCardBodyContainerLayouts.Count; num3++)
			{
				VerticalLayoutGroup val9 = detailCardBodyContainerLayouts[num3];
				if (!((Object)(object)val9 == (Object)null))
				{
					((HorizontalOrVerticalLayoutGroup)val9).spacing = 0f;
					((LayoutGroup)val9).padding = new RectOffset(detailIndentUnit, metrics.InfoRowPaddingHorizontal, 0, 0);
				}
			}
			for (int num4 = 0; num4 < detailCardFieldContainerLayouts.Count; num4++)
			{
				VerticalLayoutGroup val10 = detailCardFieldContainerLayouts[num4];
				if (!((Object)(object)val10 == (Object)null))
				{
					((HorizontalOrVerticalLayoutGroup)val10).spacing = 0f;
					((LayoutGroup)val10).padding = new RectOffset(detailIndentUnit, metrics.InfoRowPaddingHorizontal, 0, 0);
				}
			}
			for (int num5 = 0; num5 < detailCardValueContainerLayouts.Count; num5++)
			{
				VerticalLayoutGroup val11 = detailCardValueContainerLayouts[num5];
				if (!((Object)(object)val11 == (Object)null))
				{
					((HorizontalOrVerticalLayoutGroup)val11).spacing = 0f;
					((LayoutGroup)val11).padding = new RectOffset(detailIndentUnit, metrics.InfoRowPaddingHorizontal, 0, 0);
				}
			}
			for (int num6 = 0; num6 < detailCardFieldLabelTexts.Count; num6++)
			{
				Text val12 = detailCardFieldLabelTexts[num6];
				if (!((Object)(object)val12 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val12, GUIManager.Instance.AveriaSerifBold, GUIManager.Instance.ValheimOrange, metrics.InfoRowFontSize, true);
					val12.alignment = (TextAnchor)3;
					StretchToFill(((Graphic)val12).rectTransform);
				}
			}
			for (int num7 = 0; num7 < detailCardBodyTexts.Count; num7++)
			{
				Text val13 = detailCardBodyTexts[num7];
				if (!((Object)(object)val13 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val13, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
					val13.alignment = (TextAnchor)0;
					StretchToFill(((Graphic)val13).rectTransform);
				}
			}
			for (int num8 = 0; num8 < detailCardValueTexts.Count; num8++)
			{
				Text val14 = detailCardValueTexts[num8];
				if (!((Object)(object)val14 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val14, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
					val14.alignment = (TextAnchor)0;
					StretchToFill(((Graphic)val14).rectTransform);
				}
			}
			UpdateSourceTabVisuals();
		}

		public override void Refresh()
		{
			TranslationRuleBrowserSnapshot translationRuleBrowserSnapshot = TranslationRuleBrowserSnapshotProvider.GetSnapshot();
			if (snapshot == null || translationRuleBrowserSnapshot.Version != lastSnapshotVersion)
			{
				snapshot = translationRuleBrowserSnapshot;
				lastSnapshotVersion = translationRuleBrowserSnapshot.Version;
				navigatorDirty = true;
				detailDirty = true;
			}
			if (navigatorDirty)
			{
				RebuildNavigator();
			}
			UpdateStatusTexts();
			if (detailDirty)
			{
				RebuildDetails();
			}
			UpdateSourceTabVisuals();
			UpdateFileButtonVisuals();
		}

		private void HandleSearchChanged(string value)
		{
			string b = value ?? string.Empty;
			if (!string.Equals(searchQuery, b, StringComparison.Ordinal))
			{
				searchQuery = b;
				navigatorDirty = true;
				detailDirty = true;
				Refresh();
			}
		}

		private void ClearSearch()
		{
			if (!((Object)(object)searchField == (Object)null) && !string.IsNullOrEmpty(searchField.text))
			{
				searchField.text = string.Empty;
			}
		}

		private void SelectFile(TranslationRuleBrowserFileSnapshot file)
		{
			if (file != null && !string.Equals(selectedFileId, file.Id, StringComparison.Ordinal))
			{
				selectedFileId = file.Id;
				detailDirty = true;
				Refresh();
			}
		}

		private void RebuildNavigator()
		{
			navigatorDirty = false;
			filteredFiles.Clear();
			for (int i = 0; i < navigatorObjects.Count; i++)
			{
				if ((Object)(object)navigatorObjects[i] != (Object)null)
				{
					Object.Destroy((Object)(object)navigatorObjects[i]);
				}
			}
			navigatorObjects.Clear();
			sourceHeaderTexts.Clear();
			languageHeaderTexts.Clear();
			fileButtons.Clear();
			fileButtonTexts.Clear();
			fileButtonLayouts.Clear();
			if ((Object)(object)navigatorContentRect == (Object)null || snapshot == null)
			{
				return;
			}
			TranslationRuleBrowserSourceSnapshot sourceSnapshot = GetSourceSnapshot(activeSourceKey);
			if (sourceSnapshot?.Languages != null)
			{
				for (int j = 0; j < sourceSnapshot.Languages.Length; j++)
				{
					TranslationRuleBrowserLanguageSnapshot translationRuleBrowserLanguageSnapshot = sourceSnapshot.Languages[j];
					if (translationRuleBrowserLanguageSnapshot == null)
					{
						continue;
					}
					List<TranslationRuleBrowserFileSnapshot> list = new List<TranslationRuleBrowserFileSnapshot>();
					for (int k = 0; k < translationRuleBrowserLanguageSnapshot.Files.Length; k++)
					{
						TranslationRuleBrowserFileSnapshot translationRuleBrowserFileSnapshot = translationRuleBrowserLanguageSnapshot.Files[k];
						if (translationRuleBrowserFileSnapshot != null && FileMatchesSearch(translationRuleBrowserFileSnapshot))
						{
							list.Add(translationRuleBrowserFileSnapshot);
						}
					}
					if (list.Count != 0)
					{
						for (int l = 0; l < list.Count; l++)
						{
							TranslationRuleBrowserFileSnapshot translationRuleBrowserFileSnapshot2 = list[l];
							filteredFiles.Add(translationRuleBrowserFileSnapshot2);
							CreateFileButton(translationRuleBrowserFileSnapshot2);
						}
					}
				}
			}
			if (filteredFiles.Count == 0)
			{
				selectedFileId = null;
				CreateEmptyNavigatorMessage(PluginMain.Localize("devtools.browser.empty.no_results", "No translation files matched the current search."));
			}
			else if (!string.IsNullOrWhiteSpace(searchQuery))
			{
				if (!string.Equals(selectedFileId, filteredFiles[0].Id, StringComparison.Ordinal))
				{
					selectedFileId = filteredFiles[0].Id;
					detailDirty = true;
				}
			}
			else if (!ContainsFilteredFile(selectedFileId))
			{
				selectedFileId = filteredFiles[0].Id;
				detailDirty = true;
			}
			if (lastMetrics != null)
			{
				ApplyLayout(lastMetrics);
			}
			if ((Object)(object)navigatorScrollRect != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(navigatorContentRect);
				navigatorScrollRect.verticalNormalizedPosition = 1f;
			}
		}

		private void RebuildDetails()
		{
			detailDirty = false;
			pendingScrollTarget = null;
			for (int i = 0; i < detailObjects.Count; i++)
			{
				if ((Object)(object)detailObjects[i] != (Object)null)
				{
					Object.Destroy((Object)(object)detailObjects[i]);
				}
			}
			detailObjects.Clear();
			detailCardLayouts.Clear();
			detailCardLayoutsElements.Clear();
			detailCardHeaderLayouts.Clear();
			detailCardTitleTexts.Clear();
			detailCardBodyContainerLayouts.Clear();
			detailCardFieldContainerLayouts.Clear();
			detailCardValueContainerLayouts.Clear();
			detailCardFieldLabelTexts.Clear();
			detailCardBodyTexts.Clear();
			detailCardValueTexts.Clear();
			detailSectionHeaderLayouts.Clear();
			detailSectionHeaderTexts.Clear();
			if (!((Object)(object)detailContentRect == (Object)null))
			{
				TranslationRuleBrowserFileSnapshot selectedFile = GetSelectedFile();
				if (selectedFile == null)
				{
					CreateDetailCard(PluginMain.Localize("devtools.page.browser", "Browser"), string.IsNullOrWhiteSpace(searchQuery) ? PluginMain.Localize("devtools.browser.empty.no_selection", "Select a translation file on the left to inspect its rules.") : PluginMain.Localize("devtools.browser.empty.no_results", "No translation files matched the current search."));
				}
				else if (selectedFile.TotalRuleCount == 0)
				{
					CreateDetailCard(BuildDisplayPath(selectedFile), PluginMain.Localize("devtools.browser.empty.no_rules", "This file does not contain any rules."));
				}
				else
				{
					CreateRuleSection(PluginMain.Localize("devtools.performance.row.exact_rules", "Exact Rules"), selectedFile.ExactRules);
					CreateRuleSection(PluginMain.Localize("devtools.performance.row.template_rules", "Template Rules"), selectedFile.TemplateRules);
				}
				if (lastMetrics != null)
				{
					ApplyLayout(lastMetrics);
				}
				if ((Object)(object)detailScrollRect != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(detailContentRect);
					ScrollDetailToPendingTarget();
				}
			}
		}

		private void CreateSourceHeader(string value)
		{
			Text item = CreateNavigatorHeader(value, 18, (TextAnchor)3, wrap: false);
			sourceHeaderTexts.Add(item);
		}

		private void CreateLanguageHeader(string value)
		{
			Text item = CreateNavigatorHeader("• " + value, 15, (TextAnchor)3, wrap: false);
			languageHeaderTexts.Add(item);
		}

		private Text CreateNavigatorHeader(string value, int fontSize, TextAnchor alignment, bool wrap)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			Text val = DevToolsUiFactory.CreateTextBlock((Transform)(object)navigatorContentRect, "NavigatorHeader", HighlightSearch(value ?? string.Empty, searchQuery), fontSize, alignment, wrap, supportRichText: true, useLocalizationFallback: false);
			navigatorObjects.Add(((Component)val).gameObject);
			LayoutElement obj = ((Component)val).gameObject.AddComponent<LayoutElement>();
			obj.flexibleWidth = 1f;
			obj.minWidth = 0f;
			obj.preferredHeight = -1f;
			obj.minHeight = -1f;
			DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)val, (FitMode)0, (FitMode)2);
			DevToolsUiFactory.SetTextInsets(val, Vector2.zero, Vector2.zero);
			return val;
		}

		private void CreateFileButton(TranslationRuleBrowserFileSnapshot file)
		{
			Button val = CreateButton((Transform)(object)navigatorContentRect, BuildFileButtonLabel(file), delegate
			{
				SelectFile(file);
			}, 320f, 58f, supportRichText: true, useLocalizationFallback: false);
			((Object)val).name = file.Id;
			navigatorObjects.Add(((Component)val).gameObject);
			fileButtons.Add(val);
			fileButtonLayouts.Add(((Component)val).GetComponent<LayoutElement>());
			Text componentInChildren = ((Component)val).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.supportRichText = true;
				fileButtonTexts.Add(componentInChildren);
			}
		}

		private void CreateEmptyNavigatorMessage(string value)
		{
			Text item = CreateNavigatorHeader(value, 15, (TextAnchor)0, wrap: true);
			languageHeaderTexts.Add(item);
		}

		private void CreateRuleSection(string title, TranslationRuleBrowserRuleSnapshot[] rules)
		{
			if (rules == null || rules.Length == 0)
			{
				return;
			}
			CreateSectionHeader(title);
			for (int i = 0; i < rules.Length; i++)
			{
				TranslationRuleBrowserRuleSnapshot rule = rules[i];
				bool flag = RuleMatchesSearch(rule);
				RectTransform val = CreateRuleDetailCard(PluginMain.LocalizeFormat("devtools.browser.rule.title", "Rule #{0}", i + 1), rule);
				if ((Object)(object)pendingScrollTarget == (Object)null && flag)
				{
					pendingScrollTarget = val;
				}
			}
		}

		private void CreateSectionHeader(string title)
		{
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreatePanel((Transform)(object)detailContentRect, title.Replace(" ", string.Empty) + "SectionHeader", DevToolsComponentDefaults.HeaderSurface, out layoutElement);
			detailObjects.Add(((Component)val).gameObject);
			detailSectionHeaderLayouts.Add(layoutElement);
			Text item = DevToolsUiFactory.CreateTextBlock((Transform)(object)val, "Title", title, DevToolsComponentDefaults.HeaderTitleText);
			detailSectionHeaderTexts.Add(item);
		}

		private RectTransform CreateDetailCard(string title, string body)
		{
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateVerticalSurface((Transform)(object)detailContentRect, title.Replace(" ", string.Empty) + "Card", DevToolsComponentDefaults.CardSurface, out layout, out layoutElement);
			detailObjects.Add(((Component)val).gameObject);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.ConfigureContentFitter((FitMode)0, (FitMode)2);
				component.UseTopAnchoredStretchContent();
			}
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			layoutElement.minHeight = -1f;
			layoutElement.preferredHeight = -1f;
			LayoutElement layoutElement2;
			Text item = DevToolsUiFactory.CreateTextBlock((Transform)(object)DevToolsSurfaceFactory.CreatePanel((Transform)(object)val, "Header", DevToolsComponentDefaults.HeaderSurface, out layoutElement2), "Title", title, DevToolsComponentDefaults.HeaderTitleText.WithFontSize(16));
			VerticalLayoutGroup layout2;
			RectTransform parent = CreateIndentedTextContainer((Transform)(object)val, "BodyContainer", out layout2);
			Text val2 = CreateText((Transform)(object)parent, "Body", body, 15, (TextAnchor)0, wrap: true, supportRichText: false);
			val2.horizontalOverflow = (HorizontalWrapMode)0;
			val2.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement obj = ((Component)val2).gameObject.AddComponent<LayoutElement>();
			obj.minHeight = 0f;
			obj.flexibleWidth = 1f;
			DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)val2, (FitMode)0, (FitMode)2);
			detailCardLayouts.Add(layout);
			detailCardLayoutsElements.Add(layoutElement);
			detailCardHeaderLayouts.Add(layoutElement2);
			detailCardTitleTexts.Add(item);
			detailCardBodyContainerLayouts.Add(layout2);
			detailCardBodyTexts.Add(val2);
			return val;
		}

		private RectTransform CreateRuleDetailCard(string title, TranslationRuleBrowserRuleSnapshot rule)
		{
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateVerticalSurface((Transform)(object)detailContentRect, title.Replace(" ", string.Empty) + "Card", DevToolsComponentDefaults.CardSurface, out layout, out layoutElement);
			detailObjects.Add(((Component)val).gameObject);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.ConfigureContentFitter((FitMode)0, (FitMode)2);
				component.UseTopAnchoredStretchContent();
			}
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			layoutElement.minHeight = -1f;
			layoutElement.preferredHeight = -1f;
			LayoutElement layoutElement2;
			Text item = DevToolsUiFactory.CreateTextBlock((Transform)(object)DevToolsSurfaceFactory.CreatePanel((Transform)(object)val, "Header", DevToolsComponentDefaults.HeaderSurface, out layoutElement2), "Title", title, DevToolsComponentDefaults.HeaderTitleText.WithFontSize(16));
			CreateDetailFieldBlock((Transform)(object)val, PluginMain.Localize("devtools.playground.field.match", "Match"), HighlightSearch(rule?.Match, searchQuery));
			CreateDetailFieldBlock((Transform)(object)val, PluginMain.Localize("devtools.playground.field.replace", "Replace"), HighlightSearch(rule?.Replace, searchQuery));
			detailCardLayouts.Add(layout);
			detailCardLayoutsElements.Add(layoutElement);
			detailCardHeaderLayouts.Add(layoutElement2);
			detailCardTitleTexts.Add(item);
			return val;
		}

		private void CreateDetailFieldBlock(Transform parent, string label, string value)
		{
			VerticalLayoutGroup layout;
			RectTransform parent2 = CreateIndentedTextContainer(parent, label.Replace(" ", string.Empty) + "FieldContainer", out layout);
			Text val = CreateText((Transform)(object)parent2, "FieldLabel", label, 15, (TextAnchor)3, wrap: false, supportRichText: false);
			LayoutElement obj = ((Component)val).gameObject.AddComponent<LayoutElement>();
			obj.flexibleWidth = 1f;
			obj.minWidth = 0f;
			detailCardFieldContainerLayouts.Add(layout);
			detailCardFieldLabelTexts.Add(val);
			string value2 = (string.IsNullOrEmpty(value) ? "-" : value);
			VerticalLayoutGroup layout2;
			RectTransform parent3 = CreateIndentedTextContainer((Transform)(object)parent2, "ValueContainer", out layout2);
			Text val2 = CreateText((Transform)(object)parent3, "FieldValue", value2, 15, (TextAnchor)0, wrap: true, supportRichText: true);
			val2.horizontalOverflow = (HorizontalWrapMode)0;
			val2.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement obj2 = ((Component)val2).gameObject.AddComponent<LayoutElement>();
			obj2.minHeight = 0f;
			obj2.flexibleWidth = 1f;
			DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)val2, (FitMode)0, (FitMode)2);
			detailCardValueContainerLayouts.Add(layout2);
			detailCardValueTexts.Add(val2);
		}

		private void UpdateStatusTexts()
		{
			int num = CountFiles(snapshot, activeSourceKey);
			int count = filteredFiles.Count;
			if ((Object)(object)navigatorStatusText != (Object)null)
			{
				navigatorStatusText.text = PluginMain.LocalizeFormat("devtools.browser.status.results", "Showing {0} / {1} files", count, num);
			}
			if ((Object)(object)detailSummaryText != (Object)null)
			{
				TranslationRuleBrowserFileSnapshot selectedFile = GetSelectedFile();
				detailSummaryText.text = ((selectedFile == null) ? PluginMain.Localize("devtools.browser.empty.no_selection", "Select a translation file on the left to inspect its rules.") : PluginMain.LocalizeFormat("devtools.browser.status.selection", "{0}  |  {1} exact / {2} template", BuildDisplayPath(selectedFile), selectedFile.ExactRules.Length, selectedFile.TemplateRules.Length));
			}
		}

		private void UpdateSourceTabVisuals()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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)
			for (int i = 0; i < sourceTabButtons.Count; i++)
			{
				Button val = sourceTabButtons[i];
				if (!((Object)(object)val == (Object)null))
				{
					bool flag = string.Equals(((Object)val).name, activeSourceKey, StringComparison.Ordinal);
					Image component = ((Component)val).GetComponent<Image>();
					if ((Object)(object)component != (Object)null)
					{
						((Graphic)component).color = (flag ? new Color(1f, 1f, 0.96f, 1f) : new Color(0.76f, 0.76f, 0.76f, 0.9f));
					}
					Text val2 = ((i < sourceTabButtonTexts.Count) ? sourceTabButtonTexts[i] : null);
					if ((Object)(object)val2 != (Object)null)
					{
						((Graphic)val2).color = (flag ? Color.white : GUIManager.Instance.ValheimOrange);
					}
				}
			}
		}

		private void UpdateFileButtonVisuals()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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)
			for (int i = 0; i < fileButtons.Count; i++)
			{
				Button val = fileButtons[i];
				if (!((Object)(object)val == (Object)null))
				{
					bool flag = string.Equals(((Object)val).name, selectedFileId, StringComparison.Ordinal);
					Image component = ((Component)val).GetComponent<Image>();
					if ((Object)(object)component != (Object)null)
					{
						((Graphic)component).color = (flag ? new Color(1f, 1f, 0.96f, 1f) : new Color(0.76f, 0.76f, 0.76f, 0.9f));
					}
					Text val2 = ((i < fileButtonTexts.Count) ? fileButtonTexts[i] : null);
					if ((Object)(object)val2 != (Object)null)
					{
						((Graphic)val2).color = (flag ? Color.white : GUIManager.Instance.ValheimOrange);
					}
				}
			}
		}

		private TranslationRuleBrowserFileSnapshot GetSelectedFile()
		{
			for (int i = 0; i < filteredFiles.Count; i++)
			{
				TranslationRuleBrowserFileSnapshot translationRuleBrowserFileSnapshot = filteredFiles[i];
				if (translationRuleBrowserFileSnapshot != null && string.Equals(translationRuleBrowserFileSnapshot.Id, selectedFileId, StringComparison.Ordinal))
				{
					return translationRuleBrowserFileSnapshot;
				}
			}
			return null;
		}

		private bool ContainsFilteredFile(string fileId)
		{
			if (string.IsNullOrWhiteSpace(fileId))
			{
				return false;
			}
			for (int i = 0; i < filteredFiles.Count; i++)
			{
				if (string.Equals(filteredFiles[i].Id, fileId, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private bool FileMatchesSearch(TranslationRuleBrowserFileSnapshot file)
		{
			if (file == null || string.IsNullOrWhiteSpace(searchQuery))
			{
				return file != null;
			}
			if (ContainsIgnoreCase(file.SourceKey, searchQuery) || ContainsIgnoreCase(GetSourceLabel(file.SourceKey), searchQuery) || ContainsIgnoreCase(BuildDisplayPath(file), searchQuery))
			{
				return true;
			}
			if (!AnyRuleMatchesSearch(file.ExactRules))
			{
				return AnyRuleMatchesSearch(file.TemplateRules);
			}
			return true;
		}

		private bool AnyRuleMatchesSearch(TranslationRuleBrowserRuleSnapshot[] rules)
		{
			if (rules == null)
			{
				return false;
			}
			for (int i = 0; i < rules.Length; i++)
			{
				if (RuleMatchesSearch(rules[i]))
				{
					return true;
				}
			}
			return false;
		}

		private bool RuleMatchesSearch(TranslationRuleBrowserRuleSnapshot rule)
		{
			if (rule == null || string.IsNullOrWhiteSpace(searchQuery))
			{
				return false;
			}
			if (!ContainsIgnoreCase(rule.Match, searchQuery) && !ContainsIgnoreCase(rule.Replace, searchQuery) && !ContainsIgnoreCase(rule.Kind.ToString(), searchQuery))
			{
				return ContainsIgnoreCase(GetRuleKindLabel(rule.Kind), searchQuery);
			}
			return true;
		}

		private string BuildFileButtonLabel(TranslationRuleBrowserFileSnapshot file)
		{
			string value = PluginMain.LocalizeFormat("devtools.browser.file.summary", "{0} exact / {1} template", file.ExactRules.Length, file.TemplateRules.Length);
			return HighlightSearch(BuildDisplayPath(file), searchQuery) + "\n<color=#E7C978>" + HighlightSearch(value, searchQuery) + "</color>";
		}

		private static string BuildDisplayPath(TranslationRuleBrowserFileSnapshot file)
		{
			if (file == null)
			{
				return string.Empty;
			}
			if (string.IsNullOrWhiteSpace(file.LanguageCode))
			{
				return file.FileName ?? string.Empty;
			}
			return file.LanguageCode + "/" + (file.FileName ?? string.Empty);
		}

		private void ScrollDetailToPendingTarget()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_007b: 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)
			if ((Object)(object)detailScrollRect == (Object)null || (Object)(object)detailContentRect == (Object)null)
			{
				return;
			}
			if ((Object)(object)pendingScrollTarget == (Object)null)
			{
				detailScrollRect.verticalNormalizedPosition = 1f;
				return;
			}
			Rect rect = detailContentRect.rect;
			float height = ((Rect)(ref rect)).height;
			float num;
			if (!((Object)(object)detailScrollRect.viewport != (Object)null))
			{
				num = 0f;
			}
			else
			{
				rect = detailScrollRect.viewport.rect;
				num = ((Rect)(ref rect)).height;
			}
			float num2 = num;
			float num3 = Mathf.Max(0f, height - num2);
			if (num3 <= 0f)
			{
				detailScrollRect.verticalNormalizedPosition = 1f;
				return;
			}
			float num4 = Mathf.Max(0f, 0f - ((Transform)pendingScrollTarget).localPosition.y - 8f);
			float verticalNormalizedPosition = 1f - Mathf.Clamp01(num4 / num3);
			detailScrollRect.verticalNormalizedPosition = verticalNormalizedPosition;
		}

		private RectTransform CreateColumn(Transform parent, string name, out VerticalLayoutGroup layout, out LayoutElement widthLayout)
		{
			RectTransform result = DevToolsSurfaceFactory.CreateVerticalContainer(parent, name, DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 1f), out layout, out widthLayout);
			widthLayout.preferredWidth = 0f;
			widthLayout.flexibleWidth = 1f;
			widthLayout.flexibleHeight = 1f;
			widthLayout.minWidth = 0f;
			return result;
		}

		private void CreateHeaderRow(Transform parent, string title, out Text titleText, out LayoutElement headerLayout)
		{
			HorizontalLayoutGroup layout;
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, title.Replace(" ", string.Empty) + "Header", DevToolsComponentDefaults.HeaderSurface, out layout, out headerLayout);
			titleText = CreateText((Transform)(object)parent2, "Title", title, 18, (TextAnchor)3, wrap: false, supportRichText: false);
			((Component)titleText).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
		}

		private void CreateSearchRow(Transform parent)
		{
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, "SearchRow", DevToolsComponentDefaults.HorizontalRowSurface, out searchRowLayout, out searchRowLayoutElement);
			searchField = CreateSearchField((Transform)(object)parent2, out searchFieldLayout, out searchPlaceholderText, out searchValueText);
			((UnityEvent<string>)(object)searchField.onValueChanged).AddListener((UnityAction<string>)HandleSearchChanged);
			clearSearchButton = CreateButton((Transform)(object)parent2, PluginMain.Localize("common.clear", "Clear"), ClearSearch);
			clearSearchButtonLayout = ((Component)clearSearchButton).GetComponent<LayoutElement>();
			clearSearchButtonLayout.flexibleWidth = 0f;
		}

		private void CreateSourceTabsRow(Transform parent)
		{
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, "SourceTabsRow", DevToolsComponentDefaults.HorizontalRowSurface, out sourceTabLayout, out sourceTabLayoutElement);
			CreateSourceTabButton((Transform)(object)parent2, "local");
			CreateSourceTabButton((Transform)(object)parent2, "server");
		}

		private void CreateInfoRow(Transform parent, string name, out Text text, out LayoutElement layoutElement)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			RectTransform parent2 = DevToolsSurfaceFactory.CreatePanel(parent, name, DevToolsComponentDefaults.CardSurface, out layoutElement);
			text = CreateText((Transform)(object)parent2, "Value", string.Empty, 15, (TextAnchor)3, wrap: true, supportRichText: false);
			DevToolsUiFactory.StretchToFill(((Graphic)text).rectTransform, new Vector2(12f, 0f), new Vector2(-12f, 0f));
		}

		private void CreateDetailSummaryRow(Transform parent)
		{
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, "DetailSummary", DevToolsComponentDefaults.HorizontalRowSurface, out detailSummaryLayout, out detailSummaryLayoutElement);
			((HorizontalOrVerticalLayoutGroup)detailSummaryLayout).childForceExpandWidth = true;
			detailSummaryText = CreateText((Transform)(object)parent2, "Summary", string.Empty, 15, (TextAnchor)3, wrap: true, supportRichText: false);
			LayoutElement obj = ((Component)detailSummaryText).gameObject.AddComponent<LayoutElement>();
			obj.flexibleWidth = 1f;
			obj.minWidth = 0f;
		}

		private ScrollRect CreateScrollView(Transform parent, string name, out RectTransform contentRect, out LayoutElement layoutElement)
		{
			VerticalLayoutGroup contentLayout;
			return DevToolsScrollViewFactory.CreateVerticalScrollView(parent, name, out contentRect, out contentLayout, out layoutElement);
		}

		private RectTransform CreateIndentedTextContainer(Transform parent, string name, out VerticalLayoutGroup layout)
		{
			DevToolsAutoLayoutContainer autoLayout;
			RectTransform result = DevToolsSurfaceFactory.CreateVerticalContentContainer(parent, name, DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 0f), out layout, out autoLayout);
			autoLayout.ConfigureContentFitter((FitMode)0, (FitMode)2);
			autoLayout.UseTopAnchoredStretchContent();
			return result;
		}

		private InputField CreateSearchField(Transform parent, out LayoutElement fieldLayout, out Text placeholderText, out Text valueText)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			return DevToolsInputFieldFactory.CreateField(parent, "SearchField", PluginMain.Localize("devtools.browser.search.placeholder", "Search file path, match, or replace..."), DevToolsComponentDefaults.SingleLineInput, DevToolsComponentDefaults.SearchPlaceholderText, DevToolsComponentDefaults.PlainText.WithInsets(new Vector2(12f, 0f), new Vector2(-12f, 0f)), out fieldLayout, out placeholderText, out valueText);
		}

		private void CreateSourceTabButton(Transform parent, string sourceKey)
		{
			Button val = CreateButton(parent, GetSourceLabel(sourceKey), delegate
			{
				SwitchSourceTab(sourceKey);
			});
			((Object)val).name = sourceKey;
			sourceTabButtons.Add(val);
			LayoutElement component = ((Component)val).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				sourceTabButtonLayouts.Add(component);
			}
			Text componentInChildren = ((Component)val).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				sourceTabButtonTexts.Add(componentInChildren);
			}
		}

		private Button CreateButton(Transform parent, string label, Action onClick)
		{
			return CreateButton(parent, label, onClick, 156f, 36f, supportRichText: false, useLocalizationFallback: true);
		}

		private Button CreateButton(Transform parent, string label, Action onClick, float width, float height, bool supportRichText, bool useLocalizationFallback)
		{
			return DevToolsUiFactory.CreateButton(parent, label.Replace(" ", string.Empty) + "Button", label, onClick, 15, DevToolsButtonSizing.Fixed(width, height), supportRichText, useLocalizationFallback);
		}

		private Text CreateText(Transform parent, string name, string value, int fontSize, TextAnchor alignment, bool wrap, bool supportRichText)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return DevToolsUiFactory.CreateTextBlock(parent, name, value, fontSize, alignment, wrap, supportRichText, !supportRichText);
		}

		private void ApplyColumnLayout(VerticalLayoutGroup layout, DevToolsLayoutMetrics metrics)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (!((Object)(object)layout == (Object)null))
			{
				((HorizontalOrVerticalLayoutGroup)layout).spacing = metrics.SectionGroupSpacing;
				((LayoutGroup)layout).padding = new RectOffset(0, 0, 0, 0);
			}
		}

		private void ApplyHeaderLayout(LayoutElement layout, Text titleText, DevToolsLayoutMetrics metrics)
		{
			//IL_002a: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)layout != (Object)null)
			{
				layout.preferredHeight = metrics.SectionHeaderHeight;
			}
			if ((Object)(object)titleText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(titleText, GUIManager.Instance.ValheimOrange, metrics.SectionTitleFontSize, true);
				StretchToFill(((Graphic)titleText).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
			}
		}

		private void ApplyInfoTextRow(LayoutElement layout, Text text, DevToolsLayoutMetrics metrics)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)layout != (Object)null)
			{
				layout.preferredHeight = metrics.InfoRowHeight;
				layout.minHeight = metrics.InfoRowHeight;
			}
			if ((Object)(object)text != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(text, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
				text.alignment = (TextAnchor)3;
			}
		}

		private static int GetDetailIndentUnit(DevToolsLayoutMetrics metrics)
		{
			return Mathf.Max(metrics.InfoRowPaddingHorizontal, Mathf.RoundToInt((float)(metrics.SectionHeaderInset + metrics.InfoRowPaddingHorizontal) * 0.5f));
		}

		private void ApplyHeaderStyle(Image image)
		{
			DevToolsSurfaceFactory.ApplySurfaceStyle(image, DevToolsComponentDefaults.HeaderSurface);
		}

		private void ApplyCardStyle(Image image)
		{
			DevToolsSurfaceFactory.ApplySurfaceStyle(image, DevToolsComponentDefaults.CardSurface);
		}

		private void SwitchSourceTab(string sourceKey)
		{
			if (!string.IsNullOrWhiteSpace(sourceKey) && !string.Equals(activeSourceKey, sourceKey, StringComparison.Ordinal))
			{
				activeSourceKey = sourceKey;
				navigatorDirty = true;
				detailDirty = true;
				Refresh();
			}
		}

		private TranslationRuleBrowserSourceSnapshot GetSourceSnapshot(string sourceKey)
		{
			if (snapshot?.Sources == null)
			{
				return null;
			}
			for (int i = 0; i < snapshot.Sources.Length; i++)
			{
				TranslationRuleBrowserSourceSnapshot translationRuleBrowserSourceSnapshot = snapshot.Sources[i];
				if (translationRuleBrowserSourceSnapshot != null && string.Equals(translationRuleBrowserSourceSnapshot.SourceKey, sourceKey, StringComparison.OrdinalIgnoreCase))
				{
					return translationRuleBrowserSourceSnapshot;
				}
			}
			return null;
		}

		private string GetSourceLabel(string sourceKey)
		{
			if (!string.Equals(sourceKey, "server", StringComparison.OrdinalIgnoreCase))
			{
				return PluginMain.Localize("devtools.browser.source.local", "Local");
			}
			return PluginMain.Localize("devtools.browser.source.server", "Server");
		}

		private static string GetRuleKindLabel(TranslationRuleBrowserRuleKind kind)
		{
			if (kind != TranslationRuleBrowserRuleKind.Template)
			{
				return PluginMain.Localize("devtools.playground.kind.exact", "Exact");
			}
			return PluginMain.Localize("devtools.playground.kind.template", "Template");
		}

		private static int CountFiles(TranslationRuleBrowserSnapshot currentSnapshot, string sourceKey)
		{
			if (currentSnapshot == null || currentSnapshot.Sources == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < currentSnapshot.Sources.Length; i++)
			{
				TranslationRuleBrowserSourceSnapshot translationRuleBrowserSourceSnapshot = currentSnapshot.Sources[i];
				if (translationRuleBrowserSourceSnapshot?.Languages != null && string.Equals(translationRuleBrowserSourceSnapshot.SourceKey, sourceKey, StringComparison.OrdinalIgnoreCase))
				{
					for (int j = 0; j < translationRuleBrowserSourceSnapshot.Languages.Length; j++)
					{
						num += (translationRuleBrowserSourceSnapshot.Languages[j]?.Files?.Length).GetValueOrDefault();
					}
				}
			}
			return num;
		}

		private static bool ContainsIgnoreCase(string value, string query)
		{
			if (!string.IsNullOrEmpty(value) && !string.IsNullOrWhiteSpace(query))
			{
				return value.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private static string HighlightSearch(string value, string query)
		{
			string text = value ?? string.Empty;
			if (string.IsNullOrWhiteSpace(query))
			{
				return EscapeRichText(text);
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			while (num < text.Length)
			{
				int num2 = text.IndexOf(query, num, StringComparison.OrdinalIgnoreCase);
				if (num2 < 0)
				{
					stringBuilder.Append(EscapeRichText(text.Substring(num)));
					break;
				}
				if (num2 > num)
				{
					stringBuilder.Append(EscapeRichText(text.Substring(num, num2 - num)));
				}
				stringBuilder.Append("<color=#FFF1A8><b>");
				stringBuilder.Append(EscapeRichText(text.Substring(num2, query.Length)));
				stringBuilder.Append("</b></color>");
				num = num2 + query.Length;
			}
			return stringBuilder.ToString();
		}

		private static string EscapeRichText(string value)
		{
			return (value ?? string.Empty).Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;");
		}

		private static void StretchToFill(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			StretchToFill(rect, Vector2.zero, Vector2.zero);
		}

		private static void StretchToFill(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}
	}
	internal sealed class DevToolsTranslationPlaygroundPage : DevToolsPage
	{
		private enum PlaygroundRuleKind
		{
			Exact,
			Template
		}

		private sealed class PlaygroundRuleEntry
		{
			public PlaygroundRuleKind Kind { get; }

			public string Match { get; }

			public string Replace { get; }

			public PlaygroundRuleEntry(PlaygroundRuleKind kind, string match, string replace)
			{
				Kind = kind;
				Match = match ?? string.Empty;
				Replace = replace ?? string.Empty;
			}
		}

		private const float DefaultButtonWidth = 156f;

		private const float DefaultButtonHeight = 38f;

		private const float PreviewRefreshDebounceSeconds = 0.2f;

		private const float MinimumFixedButtonWidth = 212f;

		private const float MaximumFixedButtonWidth = 248f;

		private readonly List<PlaygroundRuleEntry> savedRules = new List<PlaygroundRuleEntry>();

		private readonly List<GameObject> sectionObjects = new List<GameObject>();

		private readonly List<VerticalLayoutGroup> sectionLayouts = new List<VerticalLayoutGroup>();

		private readonly List<LayoutElement> sectionHeaderLayouts = new List<LayoutElement>();

		private readonly List<Text> sectionHeaderTexts = new List<Text>();

		private readonly List<HorizontalLayoutGroup> actionRowLayouts = new List<HorizontalLayoutGroup>();

		private readonly List<LayoutElement> actionRowLayoutElements = new List<LayoutElement>();

		private readonly List<Text> fieldLabelTexts = new List<Text>();

		private readonly List<Text> bodyTexts = new List<Text>();

		private readonly List<Text> placeholderTexts = new List<Text>();

		private readonly List<GameObject> ruleRowObjects = new List<GameObject>();

		private readonly List<HorizontalLayoutGroup> ruleRowLayouts = new List<HorizontalLayoutGroup>();

		private readonly List<LayoutElement> ruleRowLayoutElements = new List<LayoutElement>();

		private readonly List<Text> ruleRowTexts = new List<Text>();

		private readonly List<Button> ruleRemoveButtons = new List<Button>();

		private readonly List<LayoutElement> ruleRemoveButtonLayouts = new List<LayoutElement>();

		private HorizontalLayoutGroup columnsLayout;

		private VerticalLayoutGroup editorPanelLayout;

		private VerticalLayoutGroup previewPanelLayout;

		private VerticalLayoutGroup editorContentLayout;

		private VerticalLayoutGroup previewContentLayout;

		private ScrollRect editorScrollRect;

		private ScrollRect previewScrollRect;

		private RectTransform editorContentRect;

		private RectTransform previewContentRect;

		private LayoutElement editorPanelWidthLayout;

		private LayoutElement previewPanelWidthLayout;

		private LayoutElement editorHeaderLayout;

		private LayoutElement previewHeaderLayout;

		private Text editorHeaderText;

		private Text previewHeaderText;

		private RectTransform activeRulesRect;

		private VerticalLayoutGroup activeRulesLayout;

		private InputField inputField;

		private InputField matchField;

		private InputField replaceField;

		private Text summaryText;

		private Text highlightText;

		private Text outputText;

		private Text jsonText;

		private Text activeRulesEmptyText;

		private InputField summaryBlock;

		private InputField highlightBlock;

		private InputField outputBlock;

		private InputField jsonBlock;

		private Button draftModeButton;

		private Button includeLoadedButton;

		private Button addRuleButton;

		private Button clearRulesButton;

		private Button copyJsonButton;

		private LayoutElement scenarioInputLayout;

		private LayoutElement matchFieldLayout;

		private LayoutElement replaceFieldLayout;

		private LayoutElement summaryLayout;

		private LayoutElement highlightLayout;

		private LayoutElement outputLayout;

		private LayoutElement jsonLayout;

		private LayoutElement draftModeButtonLayout;

		private LayoutElement includeLoadedButtonLayout;

		private LayoutElement addRuleButtonLayout;

		private LayoutElement clearRulesButtonLayout;

		private LayoutElement copyJsonButtonLayout;

		private DevToolsLayoutMetrics lastMetrics;

		private PlaygroundRuleKind draftRuleKind;

		private bool includeLoadedTranslations = true;

		private bool previewDirty = true;

		private float scheduledPreviewRefreshTime = -1f;

		private string lastStatus = string.Empty;

		public override string Id => "playground";

		public override string DisplayName => PluginMain.Localize("devtools.page.playground", "Playground");

		protected override void OnResetForRebuild()
		{
			sectionObjects.Clear();
			sectionLayouts.Clear();
			sectionHeaderLayouts.Clear();
			sectionHeaderTexts.Clear();
			actionRowLayouts.Clear();
			actionRowLayoutElements.Clear();
			fieldLabelTexts.Clear();
			bodyTexts.Clear();
			placeholderTexts.Clear();
			ruleRowObjects.Clear();
			ruleRowLayouts.Clear();
			ruleRowLayoutElements.Clear();
			ruleRowTexts.Clear();
			ruleRemoveButtons.Clear();
			ruleRemoveButtonLayouts.Clear();
			columnsLayout = null;
			editorPanelLayout = null;
			previewPanelLayout = null;
			editorContentLayout = null;
			previewContentLayout = null;
			editorScrollRect = null;
			previewScrollRect = null;
			editorContentRect = null;
			previewContentRect = null;
			editorPanelWidthLayout = null;
			previewPanelWidthLayout = null;
			editorHeaderLayout = null;
			previewHeaderLayout = null;
			editorHeaderText = null;
			previewHeaderText = null;
			activeRulesRect = null;
			activeRulesLayout = null;
			inputField = null;
			matchField = null;
			replaceField = null;
			summaryText = null;
			highlightText = null;
			outputText = null;
			jsonText = null;
			activeRulesEmptyText = null;
			summaryBlock = null;
			highlightBlock = null;
			outputBlock = null;
			jsonBlock = null;
			draftModeButton = null;
			includeLoadedButton = null;
			addRuleButton = null;
			clearRulesButton = null;
			copyJsonButton = null;
			scenarioInputLayout = null;
			matchFieldLayout = null;
			replaceFieldLayout = null;
			summaryLayout = null;
			highlightLayout = null;
			outputLayout = null;
			jsonLayout = null;
			draftModeButtonLayout = null;
			includeLoadedButtonLayout = null;
			addRuleButtonLayout = null;
			clearRulesButtonLayout = null;
			copyJsonButtonLayout = null;
			lastMetrics = null;
		}

		protected override void Build(RectTransform parent)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateHorizontalContainer((Transform)(object)parent, "PlaygroundColumns", DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 1f), out columnsLayout, out layoutElement);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.UseStretchFill();
			}
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			((LayoutGroup)columnsLayout).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandHeight = true;
			RectTransform parent2 = CreateColumn((Transform)(object)val, "EditorPanel", out editorPanelLayout, out editorPanelWidthLayout);
			CreateHeaderRow((Transform)(object)parent2, PluginMain.Localize("devtools.playground.header.editor", "Scenario & Rules"), out editorHeaderText, out editorHeaderLayout);
			editorScrollRect = CreateScrollView((Transform)(object)parent2, "EditorScroll", out editorContentRect, out layoutElement);
			editorContentLayout = ((Component)editorContentRect).GetComponent<VerticalLayoutGroup>();
			RectTransform parent3 = CreateColumn((Transform)(object)val, "PreviewPanel", out previewPanelLayout, out previewPanelWidthLayout);
			CreateHeaderRow((Transform)(object)parent3, PluginMain.Localize("devtools.playground.header.preview", "Preview & Export"), out previewHeaderText, out previewHeaderLayout);
			previewScrollRect = CreateScrollView((Transform)(object)parent3, "PreviewScroll", out previewContentRect, out layoutElement);
			previewContentLayout = ((Component)previewContentRect).GetComponent<VerticalLayoutGroup>();
			RectTransform parent4 = CreateSectionCard((Transform)(object)editorContentRect, PluginMain.Localize("devtools.playground.section.scenario", "Scenario"));
			inputField = CreateInputFieldBlock((Transform)(object)parent4, PluginMain.Localize("devtools.playground.field.test_input", "Test Input"), PluginMain.Localize("devtools.playground.placeholder.test_input", "Enter text to evaluate against the active playground rule set."), multiline: true, out scenarioInputLayout);
			RectTransform parent5 = CreateSectionCard((Transform)(object)editorContentRect, PluginMain.Localize("devtools.playground.section.rule_editor", "Rule Editor"));
			HorizontalLayoutGroup val2 = CreateActionRow((Transform)(object)parent5, "EditorActions");
			draftModeButton = CreateButton(((Component)val2).transform, string.Empty, CycleDraftRuleKind);
			draftModeButtonLayout = ((Component)draftModeButton).GetComponent<LayoutElement>();
			addRuleButton = CreateButton(((Component)val2).transform, PluginMain.Localize("devtools.playground.button.add_rule", "Add Rule"), AddDraftRule);
			addRuleButtonLayout = ((Component)addRuleButton).GetComponent<LayoutElement>();
			matchField = CreateInputFieldBlock((Transform)(object)parent5, PluginMain.Localize("devtools.playground.field.match", "Match"), PluginMain.Localize("devtools.playground.placeholder.match", "Exact text or template match."), multiline: true, out matchFieldLayout);
			replaceField = CreateInputFieldBlock((Transform)(object)parent5, PluginMain.Localize("devtools.playground.field.replace", "Replace"), PluginMain.Localize("devtools.playground.placeholder.replace", "Translated output for the match above."), multiline: true, out replaceFieldLayout);
			RectTransform parent6 = CreateSectionCard((Transform)(object)editorContentRect, PluginMain.Localize("devtools.playground.section.enabled_rules", "Enabled Rules"));
			CreateBodyText((Transform)(object)parent6, PluginMain.Localize("devtools.playground.label.include_external_rules", "Include translation files loaded outside the Playground in the preview."), richText: false);
			HorizontalLayoutGroup val3 = CreateActionRow((Transform)(object)parent6, "EnabledRulesActions");
			includeLoadedButton = CreateButton(((Component)val3).transform, string.Empty, ToggleIncludeLoadedTranslations);
			includeLoadedButtonLayout = ((Component)includeLoadedButton).GetComponent<LayoutElement>();
			clearRulesButton = CreateButton(((Component)val3).transform, PluginMain.Localize("devtools.playground.button.clear_rules", "Clear Rules"), ClearSavedRules);
			clearRulesButtonLayout = ((Component)clearRulesButton).GetComponent<LayoutElement>();
			activeRulesEmptyText = CreateBodyText((Transform)(object)parent6, PluginMain.Localize("devtools.playground.empty_rules", "No saved playground rules yet."), richText: false);
			activeRulesRect = CreateVerticalContainer((Transform)(object)parent6, "ActiveRulesList", out activeRulesLayout);
			RectTransform parent7 = CreateSectionCard((Transform)(object)previewContentRect, PluginMain.Localize("devtools.playground.section.preview", "Preview"));
			summaryBlock = CreateReadOnlyBlock((Transform)(object)parent7, PluginMain.Localize("devtools.playground.field.summary", "Summary"), richText: false, out summaryText, out summaryLayout);
			highlightBlock = CreateReadOnlyBlock((Transform)(object)parent7, PluginMain.Localize("devtools.playground.field.rule_editor_match_preview", "Rule Editor Match Preview"), richText: false, out highlightText, out highlightLayout);
			outputBlock = CreateReadOnlyBlock((Transform)(object)parent7, PluginMain.Localize("devtools.playground.field.output", "Output"), richText: false, out outputText, out outputLayout);
			RectTransform parent8 = CreateSectionCard((Transform)(object)previewContentRect, PluginMain.Localize("devtools.playground.section.generated_test_set", "Generated Test Set"));
			CreateBodyText((Transform)(object)parent8, PluginMain.Localize("devtools.playground.label.copy_json_help", "Copy only the saved playground rules as a bare Localization rule file."), richText: false);
			HorizontalLayoutGroup val4 = CreateActionRow((Transform)(object)parent8, "JsonActions");
			copyJsonButton = CreateButton(((Component)val4).transform, PluginMain.Localize("devtools.playground.button.copy_json", "Copy JSON"), CopyJsonToClipboard);
			copyJsonButtonLayout = ((Component)copyJsonButton).GetComponent<LayoutElement>();
			jsonBlock = CreateReadOnlyBlock((Transform)(object)parent8, PluginMain.Localize("devtools.playground.field.json_preview", "JSON Preview"), richText: false, out jsonText, out jsonLayout);
			WireInputField(inputField);
			WireInputField(matchField);
			WireInputField(replaceField);
			lastStatus = PluginMain.Localize("devtools.playground.status.ready", "Ready.");
			RebuildRuleRows();
			RefreshPreviewState();
		}

		public override void ApplyLayout(DevToolsLayoutMetrics metrics)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Expected O, but got Unknown
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Expected O, but got Unknown
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Expected O, but got Unknown
			//IL_079f: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			if (metrics == null || (Object)(object)columnsLayout == (Object)null)
			{
				return;
			}
			lastMetrics = metrics;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).spacing = metrics.SectionColumnSpacing;
			ApplyColumnLayout(editorPanelLayout, metrics);
			ApplyColumnLayout(previewPanelLayout, metrics);
			if ((Object)(object)editorPanelWidthLayout != (Object)null)
			{
				editorPanelWidthLayout.preferredWidth = 0f;
				editorPanelWidthLayout.minWidth = 0f;
				editorPanelWidthLayout.flexibleWidth = 56f;
			}
			if ((Object)(object)previewPanelWidthLayout != (Object)null)
			{
				previewPanelWidthLayout.preferredWidth = 0f;
				previewPanelWidthLayout.minWidth = 0f;
				previewPanelWidthLayout.flexibleWidth = 44f;
			}
			ApplyHeaderLayout(editorHeaderLayout, editorHeaderText, metrics);
			ApplyHeaderLayout(previewHeaderLayout, previewHeaderText, metrics);
			if ((Object)(object)editorContentLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)editorContentLayout).spacing = metrics.SectionGroupSpacing;
				((LayoutGroup)editorContentLayout).padding = new RectOffset(0, 0, 0, 0);
			}
			if ((Object)(object)previewContentLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)previewContentLayout).spacing = metrics.SectionGroupSpacing;
				((LayoutGroup)previewContentLayout).padding = new RectOffset(0, 0, 0, 0);
			}
			for (int i = 0; i < sectionLayouts.Count; i++)
			{
				VerticalLayoutGroup val = sectionLayouts[i];
				if ((Object)(object)val != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val).spacing = metrics.SectionContentSpacing;
					((LayoutGroup)val).padding = new RectOffset(metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding);
				}
			}
			for (int j = 0; j < sectionHeaderLayouts.Count; j++)
			{
				LayoutElement val2 = sectionHeaderLayouts[j];
				if ((Object)(object)val2 != (Object)null)
				{
					val2.preferredHeight = metrics.SectionHeaderHeight;
					val2.minHeight = metrics.SectionHeaderHeight;
				}
				if (j < sectionHeaderTexts.Count && (Object)(object)sectionHeaderTexts[j] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(sectionHeaderTexts[j], GUIManager.Instance.ValheimOrange, metrics.SectionTitleFontSize, true);
					StretchToFill(((Graphic)sectionHeaderTexts[j]).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
				}
			}
			if ((Object)(object)activeRulesLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)activeRulesLayout).spacing = metrics.SectionContentSpacing;
				((LayoutGroup)activeRulesLayout).padding = new RectOffset(0, 0, 0, 0);
			}
			for (int k = 0; k < actionRowLayouts.Count; k++)
			{
				HorizontalLayoutGroup val3 = actionRowLayouts[k];
				if ((Object)(object)val3 != (Object)null)
				{
					((LayoutGroup)val3).childAlignment = (TextAnchor)3;
					((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = false;
					((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
					((HorizontalOrVerticalLayoutGroup)val3).spacing = metrics.InfoRowSpacing;
					((LayoutGroup)val3).padding = new RectOffset(0, 0, 0, 0);
				}
				if (k < actionRowLayoutElements.Count && (Object)(object)actionRowLayoutElements[k] != (Object)null)
				{
					float num = DevToolsUiFactory.GetInsetFittedHeight(metrics.InfoRowHeight, metrics.InfoRowPaddingVertical, 38f);
					actionRowLayoutElements[k].preferredHeight = num;
					actionRowLayoutElements[k].minHeight = num;
				}
			}
			for (int l = 0; l < fieldLabelTexts.Count; l++)
			{
				GUIManager.Instance.ApplyTextStyle(fieldLabelTexts[l], GUIManager.Instance.AveriaSerifBold, GUIManager.Instance.ValheimOrange, metrics.InfoRowFontSize, true);
			}
			for (int m = 0; m < bodyTexts.Count; m++)
			{
				Text val4 = bodyTexts[m];
				if (!((Object)(object)val4 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val4, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
				}
			}
			for (int n = 0; n < placeholderTexts.Count; n++)
			{
				Text val5 = placeholderTexts[n];
				if (!((Object)(object)val5 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val5, GUIManager.Instance.AveriaSerif, new Color(1f, 1f, 1f, 0.45f), metrics.InfoRowFontSize, false);
				}
			}
			ApplyInputLayout(scenarioInputLayout, (float)metrics.InfoRowHeight * 4.2f);
			ApplyInputLayout(matchFieldLayout, (float)metrics.InfoRowHeight * 2.4f);
			ApplyInputLayout(replaceFieldLayout, (float)metrics.InfoRowHeight * 2.4f);
			ApplyReadOnlyLayout(summaryLayout, (float)metrics.InfoRowHeight * 2.2f);
			ApplyReadOnlyLayout(highlightLayout, (float)metrics.InfoRowHeight * 3.2f);
			ApplyReadOnlyLayout(outputLayout, (float)metrics.InfoRowHeight * 3.2f);
			ApplyReadOnlyLayout(jsonLayout, (float)metrics.InfoRowHeight * 5.2f);
			ApplyButtonLayout(includeLoadedButtonLayout, includeLoadedButton, metrics);
			ApplyButtonLayout(draftModeButtonLayout, draftModeButton, metrics);
			ApplyButtonLayout(addRuleButtonLayout, addRuleButton, metrics);
			ApplyButtonLayout(clearRulesButtonLayout, clearRulesButton, metrics);
			ApplyButtonLayout(copyJsonButtonLayout, copyJsonButton, metrics);
			for (int num2 = 0; num2 < ruleRowLayouts.Count; num2++)
			{
				HorizontalLayoutGroup val6 = ruleRowLayouts[num2];
				if ((Object)(object)val6 != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val6).spacing = metrics.InfoRowSpacing;
					((LayoutGroup)val6).padding = new RectOffset(metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingVertical, metrics.InfoRowPaddingVertical);
				}
				if (num2 < ruleRowLayoutElements.Count && (Object)(object)ruleRowLayoutElements[num2] != (Object)null)
				{
					ruleRowLayoutElements[num2].preferredHeight = (float)metrics.InfoRowHeight * 1.7f;
					ruleRowLayoutElements[num2].minHeight = (float)metrics.InfoRowHeight * 1.7f;
				}
				if (num2 < ruleRowTexts.Count && (Object)(object)ruleRowTexts[num2] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(ruleRowTexts[num2], GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
					ruleRowTexts[num2].alignment = (TextAnchor)3;
				}
				if (num2 < ruleRemoveButtons.Count && (Object)(object)ruleRemoveButtons[num2] != (Object)null)
				{
					GUIManager.Instance.ApplyButtonStyle(ruleRemoveButtons[num2], Mathf.Max(12, metrics.InfoRowFontSize - 1));
				}
				if (num2 < ruleRemoveButtonLayouts.Count && (Object)(object)ruleRemoveButtonLayouts[num2] != (Object)null)
				{
					ApplyButtonLayout(ruleRemoveButtonLayouts[num2], ruleRemoveButtons[num2], metrics, (float)metrics.InfoRowHeight * 1.7f);
				}
			}
			if ((Object)(object)activeRulesEmptyText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(activeRulesEmptyText, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
				activeRulesEmptyText.alignment = (TextAnchor)0;
				StretchToFill(((Graphic)activeRulesEmptyText).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
			}
		}

		public override void Refresh()
		{
			UpdateButtonLabels();
			if (previewDirty)
			{
				RefreshPreviewState();
			}
		}

		public override void Tick()
		{
			if (previewDirty && !(scheduledPreviewRefreshTime < 0f) && !(Time.unscaledTime < scheduledPreviewRefreshTime))
			{
				scheduledPreviewRefreshTime = -1f;
				Refresh();
			}
		}

		private void ToggleIncludeLoadedTranslations()
		{
			includeLoadedTranslations = !includeLoadedTranslations;
			lastStatus = (includeLoadedTranslations ? PluginMain.Localize("devtools.playground.status.include_external_rules_enabled", "Translation files loaded outside the Playground are now included in preview evaluation.") : PluginMain.Localize("devtools.playground.status.include_external_rules_disabled", "Preview evaluation now uses only Playground rules."));
			MarkPreviewDirty();
		}

		private void CycleDraftRuleKind()
		{
			draftRuleKind = ((draftRuleKind == PlaygroundRuleKind.Exact) ? PlaygroundRuleKind.Template : PlaygroundRuleKind.Exact);
			lastStatus = PluginMain.LocalizeFormat("devtools.playground.status.draft_mode_switched", "Draft mode switched to {0}.", GetRuleKindLabel(draftRuleKind));
			MarkPreviewDirty();
		}

		private void AddDraftRule()
		{
			if (!TryBuildDraftRule(out var draftRule, out var message, validateTemplateSyntax: true))
			{
				lastStatus = message;
				MarkPreviewDirty();
				return;
			}
			savedRules.Add(draftRule);
			matchField.text = string.Empty;
			replaceField.text = string.Empty;
			lastStatus = PluginMain.LocalizeFormat("devtools.playground.status.rule_saved", "Saved {0} rule #{1}.", GetRuleKindLabel(draftRule.Kind), savedRules.Count);
			RebuildRuleRows();
			MarkPreviewDirty();
		}

		private void ClearSavedRules()
		{
			savedRules.Clear();
			lastStatus = PluginMain.Localize("devtools.playground.status.rules_cleared", "Cleared all saved playground rules.");
			RebuildRuleRows();
			MarkPreviewDirty();
		}

		private void RemoveRuleAt(int index)
		{
			if (index >= 0 && index < savedRules.Count)
			{
				PlaygroundRuleEntry playgroundRuleEntry = savedRules[index];
				savedRules.RemoveAt(index);
				lastStatus = PluginMain.LocalizeFormat("devtools.playground.status.rule_removed", "Removed {0} rule #{1}.", GetRuleKindLabel(playgroundRuleEntry.Kind), index + 1);
				RebuildRuleRows();
				MarkPreviewDirty();
			}
		}

		private void CopyJsonToClipboard()
		{
			GUIUtility.systemCopyBuffer = BuildSavedRulesJson();
			lastStatus = PluginMain.Localize("devtools.playground.status.json_copied", "Copied playground JSON to clipboard.");
			MarkPreviewDirty();
		}

		private void RefreshPreviewState()
		{
			previewDirty = false;
			scheduledPreviewRefreshTime = -1f;
			UpdateButtonLabels();
			string text = (((Object)(object)inputField != (Object)null) ? (inputField.text ?? string.Empty) : string.Empty);
			List<PlaygroundRuleEntry> list = new List<PlaygroundRuleEntry>(savedRules);
			PlaygroundRuleEntry draftRule;
			string message;
			bool flag = TryBuildDraftRule(out draftRule, out message, validateTemplateSyntax: true);
			if (flag)
			{
				list.Add(draftRule);
			}
			List<RuleTraceMetadata> list2 = new List<RuleTraceMetadata>();
			List<CompiledTemplateRule> list3 = new List<CompiledTemplateRule>();
			if (includeLoadedTranslations)
			{
				CompiledRuleSet compiledRuleSetSnapshot = TranslationRuntime.GetCompiledRuleSetSnapshot();
				foreach (KeyValuePair<string, RuleTraceMetadata> exactRuleMetadatum in compiledRuleSetSnapshot.ExactRuleMetadata)
				{
					list2.Add(exactRuleMetadatum.Value);
				}
				for (int i = 0; i < compiledRuleSetSnapshot.TemplateRules.Count; i++)
				{
					list3.Add(compiledRuleSetSnapshot.TemplateRules[i]);
				}
			}
			int num = 0;
			int num2 = 0;
			for (int j = 0; j < list.Count; j++)
			{
				PlaygroundRuleEntry playgroundRuleEntry = list[j];
				CompiledTemplateRule rule;
				string error;
				if (playgroundRuleEntry.Kind == PlaygroundRuleKind.Exact)
				{
					num++;
					list2.Add(new RuleTraceMetadata(playgroundRuleEntry.Match, playgroundRuleEntry.Replace, "[Playground]"));
				}
				else if (CompiledTemplateRule.TryCreate(playgroundRuleEntry.Match, playgroundRuleEntry.Replace, "[Playground]", out rule, out error))
				{
					num2++;
					list3.Add(rule);
				}
				else
				{
					message = PluginMain.LocalizeFormat("devtools.playground.status.draft_invalid", "Template invalid: {0}", error);
				}
			}
			CompiledRuleSet compiledRuleSet = CompiledRuleSet.CreateAdHoc(list2, list3);
			TranslationAnalysisResult translationAnalysisResult = TranslationRuntime.AnalyzeTranslation(text, compiledRuleSet);
			string value = BuildDraftMatchPreviewText(text, flag ? draftRule : null, message);
			string matchedStage;
			string matchedStage2 = BuildStackedResultStageLabel(compiledRuleSet, text, out matchedStage);
			if ((Object)(object)summaryText != (Object)null)
			{
				SetReadOnlyBlockValue(summaryBlock, summaryText, BuildSummaryText(num, num2, message, matchedStage2));
			}
			if ((Object)(object)highlightText != (Object)null)
			{
				SetReadOnlyBlockValue(highlightBlock, highlightText, value);
			}
			if ((Object)(object)outputText != (Object)null)
			{
				SetReadOnlyBlockValue(outputBlock, outputText, string.IsNullOrEmpty(text) ? PluginMain.Localize("devtools.playground.status.output_empty", "Enter input to see the translated output.") : (translationAnalysisResult.Output ?? string.Empty));
			}
			if ((Object)(object)jsonText != (Object)null)
			{
				SetReadOnlyBlockValue(jsonBlock, jsonText, BuildSavedRulesJson());
			}
		}

		private string BuildSummaryText(int previewExactRuleCount, int previewTemplateRuleCount, string draftMessage, string matchedStage)
		{
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < savedRules.Count; i++)
			{
				if (savedRules[i].Kind == PlaygroundRuleKind.Exact)
				{
					num++;
				}
				else
				{
					num2++;
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(lastStatus);
			stringBuilder.AppendLine(PluginMain.LocalizeFormat("devtools.playground.summary.saved_rules", "Saved rules: {0} ({1} exact / {2} template)", savedRules.Count, num, num2));
			stringBuilder.AppendLine(PluginMain.LocalizeFormat("devtools.playground.summary.preview_rules_with_external", "Preview rule set: {0} exact / {1} template + external rules {2}", previewExactRuleCount, previewTemplateRuleCount, includeLoadedTranslations ? PluginMain.Localize("common.on", "On") : PluginMain.Localize("common.off", "Off")));
			stringBuilder.AppendLine(PluginMain.LocalizeFormat("devtools.playground.summary.stacked_result_winning_stage", "Stacked result winning stage: {0}", matchedStage));
			stringBuilder.AppendLine(PluginMain.Localize("devtools.playground.summary.match_preview_scope", "Rule editor match preview uses only the current Match field. Output remains the full stacked rule result."));
			if (!string.IsNullOrWhiteSpace(draftMessage))
			{
				stringBuilder.AppendLine(PluginMain.LocalizeFormat("devtools.playground.summary.draft", "Draft: {0}", draftMessage));
			}
			return stringBuilder.ToString().TrimEnd(Array.Empty<char>());
		}

		private bool TryBuildDraftRule(out PlaygroundRuleEntry draftRule, out string message, bool validateTemplateSyntax)
		{
			draftRule = null;
			string text = (((Object)(object)matchField != (Object)null) ? (matchField.text ?? string.Empty) : string.Empty);
			string text2 = (((Object)(object)replaceField != (Object)null) ? (replaceField.text ?? string.Empty) : string.Empty);
			if (string.IsNullOrWhiteSpace(text) && string.IsNullOrWhiteSpace(text2))
			{
				message = PluginMain.Localize("devtools.playground.status.draft_empty", "Draft empty.");
				return false;
			}
			if (string.IsNullOrWhiteSpace(text) || string.IsNullOrWhiteSpace(text2))
			{
				message = PluginMain.Localize("devtools.playground.status.draft_incomplete", "Draft incomplete. Both match and replace are required.");
				return false;
			}
			if (draftRuleKind == PlaygroundRuleKind.Template && validateTemplateSyntax && !CompiledTemplateRule.TryCreate(text, text2, "[Playground Draft]", out var _, out var error))
			{
				message = PluginMain.LocalizeFormat("devtools.playground.status.draft_invalid", "Template invalid: {0}", error);
				return false;
			}
			draftRule = new PlaygroundRuleEntry(draftRuleKind, text, text2);
			message = PluginMain.LocalizeFormat("devtools.playground.status.draft_ready", "Draft ready as {0}.", GetRuleKindLabel(draftRuleKind));
			return true;
		}

		private void RebuildRuleRows()
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < ruleRowObjects.Count; i++)
			{
				if ((Object)(object)ruleRowObjects[i] != (Object)null)
				{
					Object.Destroy((Object)(object)ruleRowObjects[i]);
				}
			}
			ruleRowObjects.Clear();
			ruleRowLayouts.Clear();
			ruleRowLayoutElements.Clear();
			ruleRowTexts.Clear();
			ruleRemoveButtons.Clear();
			ruleRemoveButtonLayouts.Clear();
			if ((Object)(object)activeRulesEmptyText != (Object)null)
			{
				((Component)activeRulesEmptyText).gameObject.SetActive(savedRules.Count == 0);
			}
			if ((Object)(object)activeRulesRect == (Object)null)
			{
				return;
			}
			for (int j = 0; j < savedRules.Count; j++)
			{
				int captureIndex = j;
				PlaygroundRuleEntry rule = savedRules[j];
				HorizontalLayoutGroup layout;
				LayoutElement layoutElement;
				RectTransform val = DevToolsSurfaceFactory.CreateHorizontalSurface((Transform)(object)activeRulesRect, $"Rule{j + 1}", DevToolsComponentDefaults.HorizontalRowSurface, out layout, out layoutElement);
				((HorizontalOrVerticalLayoutGroup)layout).childForceExpandWidth = true;
				Text val2 = CreateText((Transform)(object)val, "RuleText", BuildRuleRowText(j, rule), 15, (TextAnchor)3, wrap: true, supportRichText: false);
				LayoutElement obj = ((Component)val2).gameObject.AddComponent<LayoutElement>();
				obj.flexibleWidth = 1f;
				obj.minWidth = 0f;
				StretchToFill(((Graphic)val2).rectTransform, new Vector2(12f, 0f), new Vector2(-12f, 0f));
				Button val3 = CreateButton((Transform)(object)val, PluginMain.Localize("devtools.playground.button.remove", "Remove"), delegate
				{
					RemoveRuleAt(captureIndex);
				});
				LayoutElement component = ((Component)val3).GetComponent<LayoutElement>();
				component.flexibleWidth = 0f;
				ruleRowObjects.Add(((Component)val).gameObject);
				ruleRowLayouts.Add(layout);
				ruleRowLayoutElements.Add(layoutElement);
				ruleRowTexts.Add(val2);
				ruleRemoveButtons.Add(val3);
				ruleRemoveButtonLayouts.Add(component);
			}
			if (lastMetrics != null)
			{
				ApplyLayout(lastMetrics);
			}
			if ((Object)(object)editorScrollRect != (Object)null && (Object)(object)editorContentRect != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(editorContentRect);
			}
			if ((Object)(object)previewScrollRect != (Object)null && (Object)(object)previewContentRect != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(previewContentRect);
			}
		}

		private static string BuildRuleRowText(int index, PlaygroundRuleEntry rule)
		{
			return PluginMain.LocalizeFormat("devtools.playground.rule_row", "#{0} [{1}] {2} => {3}", index + 1, GetRuleKindLabel(rule.Kind), FormatPreview(rule.Match, 96), FormatPreview(rule.Replace, 96));
		}

		private string BuildDraftMatchPreviewText(string input, PlaygroundRuleEntry draftRule, string draftMessage)
		{
			string text = input ?? string.Empty;
			if (text.Length == 0)
			{
				return PluginMain.Localize("devtools.playground.preview.no_input", "Enter test input to preview the current rule editor match.");
			}
			if (draftRule == null)
			{
				if (!string.IsNullOrWhiteSpace(draftMessage))
				{
					return PluginMain.LocalizeFormat("devtools.playground.summary.draft", "Draft: {0}", draftMessage);
				}
				return PluginMain.Localize("devtools.playground.preview.no_draft", "Fill Match and Replace to preview the current rule editor match.");
			}
			bool applies;
			string draftMatchStageLabel = GetDraftMatchStageLabel(draftRule, text, out applies);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(PluginMain.LocalizeFormat("devtools.playground.preview.current_match", "Current Match field: {0}", PluginMain.FormatTextForDebug(draftRule.Match)));
			stringBuilder.AppendLine(PluginMain.LocalizeFormat("devtools.playground.preview.applies", "Applies to current test input: {0}", applies ? PluginMain.Localize("common.yes", "Yes") : PluginMain.Localize("common.no", "No")));
			stringBuilder.AppendLine(PluginMain.LocalizeFormat("devtools.playground.preview.stage", "Draft preview stage: {0}", draftMatchStageLabel));
			stringBuilder.AppendLine();
			stringBuilder.AppendLine(PluginMain.Localize("devtools.playground.field.test_input", "Test Input"));
			stringBuilder.Append(text);
			return stringBuilder.ToString().TrimEnd(Array.Empty<char>());
		}

		private static string BuildStackedResultStageLabel(CompiledRuleSet previewRuleSet, string input, out string matchedStage)
		{
			string text = input ?? string.Empty;
			if (text.Length == 0)
			{
				matchedStage = PluginMain.Localize("devtools.playground.status.no_input", "No input");
				return matchedStage;
			}
			if (previewRuleSet.ExactRules.TryGetValue(text, out var value))
			{
				matchedStage = PluginMain.Localize("devtools.playground.kind.exact", "Exact");
				return matchedStage;
			}
			TextMatchNormalizer.NormalizedText normalizedInput = TextMatchNormalizer.Analyze(text);
			if (previewRuleSet.MatchNormalizedExactRules.TryGetValue(normalizedInput.Value, out value))
			{
				matchedStage = PluginMain.Localize("devtools.playground.status.normalized_exact", "Normalized Exact");
				return matchedStage;
			}
			foreach (CompiledTemplateRule templateCandidate in previewRuleSet.GetTemplateCandidates(normalizedInput.Value))
			{
				if (templateCandidate.TryTranslate(normalizedInput, out value))
				{
					matchedStage = PluginMain.Localize("devtools.playground.kind.template", "Template") + " (" + templateCandidate.Signature + ")";
					return matchedStage;
				}
			}
			if (previewRuleSet.TryAnalyzeGreedyExact(normalizedInput, out var analysis) && analysis.Steps.Length != 0 && analysis.Steps[0].Matches.Length != 0)
			{
				matchedStage = PluginMain.Localize("devtools.playground.status.whole_string_longest_match", "Whole-String Longest-Match");
				return matchedStage;
			}
			matchedStage = PluginMain.Localize("devtools.playground.status.no_match", "No Match");
			return matchedStage;
		}

		private static string GetDraftMatchStageLabel(PlaygroundRuleEntry draftRule, string input, out bool applies)
		{
			string text = input ?? string.Empty;
			TextMatchNormalizer.NormalizedText normalizedInput = TextMatchNormalizer.Analyze(text);
			if (draftRule == null)
			{
				applies = false;
				return PluginMain.Localize("devtools.playground.status.no_match", "No Match");
			}
			if (draftRule.Kind == PlaygroundRuleKind.Exact)
			{
				if (string.Equals(text, draftRule.Match, StringComparison.Ordinal))
				{
					applies = true;
					return PluginMain.Localize("devtools.playground.kind.exact", "Exact");
				}
				string text2 = TextMatchNormalizer.Normalize(draftRule.Match);
				if (!string.IsNullOrWhiteSpace(text2) && string.Equals(normalizedInput.Value, text2, StringComparison.OrdinalIgnoreCase))
				{
					applies = true;
					return PluginMain.Localize("devtools.playground.status.normalized_exact", "Normalized Exact");
				}
				applies = false;
				return PluginMain.Localize("devtools.playground.status.no_match", "No Match");
			}
			if (CompiledTemplateRule.TryCreate(draftRule.Match, draftRule.Replace, "[Playground Draft Preview]", out var rule, out var error) && rule.TryTranslate(normalizedInput, out error))
			{
				applies = true;
				return PluginMain.Localize("devtools.playground.kind.template", "Template");
			}
			applies = false;
			return PluginMain.Localize("devtools.playground.status.no_match", "No Match");
		}

		private string BuildSavedRulesJson()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("{");
			stringBuilder.AppendLine("  \"exact\": [");
			bool flag = false;
			for (int i = 0; i < savedRules.Count; i++)
			{
				PlaygroundRuleEntry playgroundRuleEntry = savedRules[i];
				if (playgroundRuleEntry.Kind == PlaygroundRuleKind.Exact)
				{
					if (flag)
					{
						stringBuilder.AppendLine(",");
					}
					stringBuilder.Append("    { \"match\": ");
					AppendJsonString(stringBuilder, playgroundRuleEntry.Match);
					stringBuilder.Append(", \"replace\": ");
					AppendJsonString(stringBuilder, playgroundRuleEntry.Replace);
					stringBuilder.Append(" }");
					flag = true;
				}
			}
			if (flag)
			{
				stringBuilder.AppendLine();
			}
			stringBuilder.AppendLine("  ],");
			stringBuilder.AppendLine("  \"templates\": [");
			bool flag2 = false;
			for (int j = 0; j < savedRules.Count; j++)
			{
				PlaygroundRuleEntry playgroundRuleEntry2 = savedRules[j];
				if (playgroundRuleEntry2.Kind == PlaygroundRuleKind.Template)
				{
					if (flag2)
					{
						stringBuilder.AppendLine(",");
					}
					stringBuilder.Append("    { \"match\": ");
					AppendJsonString(stringBuilder, playgroundRuleEntry2.Match);
					stringBuilder.Append(", \"replace\": ");
					AppendJsonString(stringBuilder, playgroundRuleEntry2.Replace);
					stringBuilder.Append(" }");
					flag2 = true;
				}
			}
			if (flag2)
			{
				stringBuilder.AppendLine();
			}
			stringBuilder.AppendLine("  ]");
			stringBuilder.Append('}');
			return stringBuilder.ToString();
		}

		private static void AppendJsonString(StringBuilder builder, string value)
		{
			builder.Append('"');
			string text = value ?? string.Empty;
			foreach (char c in text)
			{
				switch (c)
				{
				case '\\':
					builder.Append("\\\\");
					break;
				case '"':
					builder.Append("\\\"");
					break;
				case '\r':
					builder.Append("\\r");
					break;
				case '\n':
					builder.Append("\\n");
					break;
				case '\t':
					builder.Append("\\t");
					break;
				default:
					builder.Append(c);
					break;
				}
			}
			builder.Append('"');
		}

		private void UpdateButtonLabels()
		{
			SetButtonText(draftModeButton, PluginMain.LocalizeFormat("devtools.playground.button.rule_type", "Rule Type: {0}", GetRuleKindLabel(draftRuleKind)));
			SetButtonText(includeLoadedButton, includeLoadedTranslations ? PluginMain.Localize("devtools.playground.button.external_rules_on", "External Rules: On") : PluginMain.Localize("devtools.playground.button.external_rules_off", "External Rules: Off"));
		}

		private void WireInputField(InputField field)
		{
			if (!((Object)(object)field == (Object)null))
			{
				((UnityEvent<string>)(object)field.onValueChanged).AddListener((UnityAction<string>)delegate
				{
					MarkPreviewDirty(immediate: false);
				});
			}
		}

		private void MarkPreviewDirty(bool immediate = true)
		{
			previewDirty = true;
			if (!immediate)
			{
				scheduledPreviewRefreshTime = Time.unscaledTime + 0.2f;
				return;
			}
			scheduledPreviewRefreshTime = -1f;
			Refresh();
		}

		private static string EscapeRichText(string value)
		{
			return (value ?? string.Empty).Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;");
		}

		private RectTransform CreateSectionCard(Transform parent, string title)
		{
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateVerticalSurface(parent, title.Replace(" ", string.Empty) + "Section", DevToolsComponentDefaults.CardSurface, out layout, out layoutElement);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.ConfigureContentFitter((FitMode)0, (FitMode)2);
				component.UseTopAnchoredStretchContent();
			}
			sectionLayouts.Add(layout);
			sectionObjects.Add(((Component)val).gameObject);
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			layoutElement.minHeight = -1f;
			layoutElement.preferredHeight = -1f;
			LayoutElement layoutElement2;
			RectTransform parent2 = DevToolsSurfaceFactory.CreatePanel((Transform)(object)val, "Header", DevToolsComponentDefaults.HeaderSurface, out layoutElement2);
			sectionHeaderLayouts.Add(layoutElement2);
			Text item = DevToolsUiFactory.CreateTextBlock((Transform)(object)parent2, "Title", title, DevToolsComponentDefaults.HeaderTitleText);
			sectionHeaderTexts.Add(item);
			return val;
		}

		private RectTransform CreateSectionRow(Transform parent, string name, out HorizontalLayoutGroup layout, out LayoutElement layoutElement)
		{
			RectTransform result = DevToolsSurfaceFactory.CreateHorizontalContainer(parent, name, DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 0f), out layout, out layoutElement);
			((LayoutGroup)layout).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)layout).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)layout).childForceExpandHeight = false;
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			return result;
		}

		private HorizontalLayoutGroup CreateActionRow(Transform parent, string name)
		{
			DevToolsSurfaceFactory.CreateHorizontalContainer(parent, name, DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 0f), out var layout, out var layoutElement);
			((LayoutGroup)layout).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)layout).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)layout).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)layout).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)layout).childForceExpandHeight = false;
			actionRowLayouts.Add(layout);
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			actionRowLayoutElements.Add(layoutElement);
			return layout;
		}

		private void CreateActionLabel(Transform parent, string value)
		{
			Text val = CreateText(parent, "Label", value, 15, (TextAnchor)3, wrap: true, supportRichText: false);
			LayoutElement obj = ((Component)val).gameObject.AddComponent<LayoutElement>();
			obj.flexibleWidth = 1f;
			obj.minWidth = 0f;
			bodyTexts.Add(val);
		}

		private InputField CreateInputFieldBlock(Transform parent, string label, string placeholder, bool multiline, out LayoutElement fieldLayout)
		{
			//IL_004e: 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)
			CreateFieldLabel(parent, label);
			DevToolsInputFieldOptions fieldOptions = (multiline ? DevToolsComponentDefaults.MultiLineInput : DevToolsComponentDefaults.SingleLineInput);
			DevToolsTextOptions placeholderOptions = (multiline ? DevToolsComponentDefaults.MultilineInputText.WithRichText(supportRichText: false, useLocalizationFallback: true) : DevToolsComponentDefaults.SearchPlaceholderText);
			DevToolsTextOptions valueOptions = (multiline ? DevToolsComponentDefaults.MultilineInputText : DevToolsComponentDefaults.PlainText.WithAlignment((TextAnchor)3).WithInsets(new Vector2(4f, 4f), new Vector2(-4f, -4f)));
			Text placeholderText;
			Text valueText;
			InputField result = DevToolsInputFieldFactory.CreateField(parent, label.Replace(" ", string.Empty) + "Field", placeholder, fieldOptions, placeholderOptions, valueOptions, out fieldLayout, out placeholderText, out valueText);
			placeholderTexts.Add(placeholderText);
			bodyTexts.Add(valueText);
			return result;
		}

		private InputField CreateReadOnlyBlock(Transform parent, string label, bool richText, out Text text, out LayoutElement containerLayout)
		{
			CreateFieldLabel(parent, label);
			DevToolsTextOptions valueOptions = (richText ? DevToolsComponentDefaults.RichWrappedText.WithAlignment((TextAnchor)0).WithFontSize(15) : DevToolsComponentDefaults.MultilineInputText);
			Text placeholderText;
			InputField result = DevToolsInputFieldFactory.CreateField(parent, label.Replace(" ", string.Empty) + "Block", null, DevToolsComponentDefaults.ReadOnlyTextArea, DevToolsComponentDefaults.MultilineInputText, valueOptions, out containerLayout, out placeholderText, out text);
			text.verticalOverflow = (VerticalWrapMode)1;
			bodyTexts.Add(text);
			return result;
		}

		private RectTransform CreateVerticalContainer(Transform parent, string name, out VerticalLayoutGroup layout)
		{
			DevToolsAutoLayoutContainer autoLayout;
			RectTransform result = DevToolsSurfaceFactory.CreateVerticalContentContainer(parent, name, DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 0f), out layout, out autoLayout);
			autoLayout.ConfigureContentFitter((FitMode)0, (FitMode)2);
			autoLayout.UseTopAnchoredStretchContent();
			return result;
		}

		private void CreateFieldLabel(Transform parent, string value)
		{
			Text item = CreateText(parent, "Label", value, 15, (TextAnchor)3, wrap: false, supportRichText: false);
			fieldLabelTexts.Add(item);
		}

		private Text CreateBodyText(Transform parent, string value, bool richText)
		{
			//IL_002f: 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)
			Text val = CreateText(parent, "Body", value, 15, (TextAnchor)3, wrap: true, richText);
			bodyTexts.Add(val);
			StretchToFill(((Graphic)val).rectTransform, new Vector2(12f, 0f), new Vector2(-12f, 0f));
			return val;
		}

		private Button CreateButton(Transform parent, string label, Action onClick)
		{
			return DevToolsUiFactory.CreateButton(parent, label.Replace(" ", string.Empty) + "Button", label, onClick, DevToolsComponentDefaults.StandardButton.WithSize(156f, 38f));
		}

		private ScrollRect CreateScrollView(Transform parent, string name, out RectTransform content, out LayoutElement layoutElement)
		{
			VerticalLayoutGroup contentLayout;
			return DevToolsScrollViewFactory.CreateVerticalScrollView(parent, name, out content, out contentLayout, out layoutElement);
		}

		private RectTransform CreateColumn(Transform parent, string name, out VerticalLayoutGroup layout, out LayoutElement widthLayout)
		{
			RectTransform result = DevToolsSurfaceFactory.CreateVerticalContainer(parent, name, DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 1f), out layout, out widthLayout);
			widthLayout.preferredWidth = 0f;
			widthLayout.minWidth = 0f;
			widthLayout.flexibleWidth = 1f;
			widthLayout.flexibleHeight = 1f;
			return result;
		}

		private void CreateHeaderRow(Transform parent, string title, out Text titleText, out LayoutElement headerLayout)
		{
			HorizontalLayoutGroup layout;
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, title.Replace(" ", string.Empty) + "Header", DevToolsComponentDefaults.HeaderSurface, out layout, out headerLayout);
			titleText = CreateText((Transform)(object)parent2, "Title", title, 18, (TextAnchor)3, wrap: false, supportRichText: false);
			((Component)titleText).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
		}

		private void ApplyColumnLayout(VerticalLayoutGroup layout, DevToolsLayoutMetrics metrics)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (!((Object)(object)layout == (Object)null))
			{
				((HorizontalOrVerticalLayoutGroup)layout).spacing = metrics.SectionGroupSpacing;
				((LayoutGroup)layout).padding = new RectOffset(0, 0, 0, 0);
			}
		}

		private void ApplyHeaderLayout(LayoutElement layout, Text titleText, DevToolsLayoutMetrics metrics)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)layout != (Object)null)
			{
				layout.preferredHeight = metrics.SectionHeaderHeight;
				layout.minHeight = metrics.SectionHeaderHeight;
			}
			if ((Object)(object)titleText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(titleText, GUIManager.Instance.ValheimOrange, metrics.SectionTitleFontSize, true);
				StretchToFill(((Graphic)titleText).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
			}
		}

		private static void SetButtonText(Button button, string value)
		{
			if (!((Object)(object)button == (Object)null))
			{
				Text componentInChildren = ((Component)button).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					DevToolsUiFactory.SetTextValue(componentInChildren, value ?? string.Empty);
				}
			}
		}

		private static void SetReadOnlyBlockValue(InputField field, Text text, string value)
		{
			string text2 = value ?? string.Empty;
			if ((Object)(object)field != (Object)null)
			{
				field.text = text2;
			}
			if ((Object)(object)text != (Object)null && !string.Equals(text.text, text2, StringComparison.Ordinal))
			{
				text.text = text2;
			}
		}

		private void ApplyButtonLayout(LayoutElement layout, Button button, DevToolsLayoutMetrics metrics, float rowHeight = -1f)
		{
			if ((Object)(object)layout != (Object)null)
			{
				float fixedButtonWidth = GetFixedButtonWidth(metrics);
				int insetFittedHeight = DevToolsUiFactory.GetInsetFittedHeight((rowHeight > 0f) ? rowHeight : ((float)metrics.InfoRowHeight), metrics.InfoRowPaddingVertical, 38f);
				layout.flexibleWidth = 0f;
				layout.preferredWidth = fixedButtonWidth;
				layout.minWidth = fixedButtonWidth;
				layout.preferredHeight = insetFittedHeight;
				layout.minHeight = insetFittedHeight;
			}
			if ((Object)(object)button != (Object)null)
			{
				GUIManager.Instance.ApplyButtonStyle(button, GetActionButtonFontSize(metrics));
			}
		}

		private static float GetFixedButtonWidth(DevToolsLayoutMetrics metrics)
		{
			return Mathf.Clamp((float)metrics.InfoActionButtonWidth * 2.45f, 212f, 248f);
		}

		private static int GetActionButtonFontSize(DevToolsLayoutMetrics metrics)
		{
			return Mathf.Max(12, metrics.InfoRowFontSize - 1);
		}

		private static void ApplyInputLayout(LayoutElement layout, float height)
		{
			if (!((Object)(object)layout == (Object)null))
			{
				layout.preferredHeight = height;
				layout.minHeight = height;
			}
		}

		private static void ApplyReadOnlyLayout(LayoutElement layout, float minimumHeight)
		{
			if (!((Object)(object)layout == (Object)null))
			{
				layout.minHeight = minimumHeight;
				layout.preferredHeight = minimumHeight;
			}
		}

		private void ApplyHeaderStyle(Image image)
		{
			DevToolsSurfaceFactory.ApplySurfaceStyle(image, DevToolsComponentDefaults.HeaderSurface);
		}

		private void ApplyCardStyle(Image image)
		{
			DevToolsSurfaceFactory.ApplySurfaceStyle(image, DevToolsComponentDefaults.CardSurface);
		}

		private Text CreateText(Transform parent, string name, string value, int fontSize, TextAnchor alignment, bool wrap, bool supportRichText)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return DevToolsUiFactory.CreateTextBlock(parent, name, value, fontSize, alignment, wrap, supportRichText, !supportRichText);
		}

		private static void StretchToFill(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			StretchToFill(rect, Vector2.zero, Vector2.zero);
		}

		private static void StretchToFill(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}

		private static string FormatPreview(string value, int maxLength)
		{
			string text = PluginMain.FormatTextForDebug(value ?? string.Empty);
			if (text.Length <= maxLength)
			{
				return text;
			}
			return text.Substring(0, maxLength) + "...";
		}

		private static string GetRuleKindLabel(PlaygroundRuleKind kind)
		{
			if (kind != 0)
			{
				return PluginMain.Localize("devtools.playground.kind.template", "Template");
			}
			return PluginMain.Localize("devtools.playground.kind.exact", "Exact");
		}
	}
	internal sealed class DevToolsTranslationTracePage : DevToolsPage
	{
		private const float DefaultButtonWidth = 156f;

		private const float DefaultButtonHeight = 36f;

		private const float EntryButtonFallbackWidth = 360f;

		private const float EntryButtonFallbackHeight = 60f;

		private const float StageStatusBadgeFixedWidth = 160f;

		private readonly List<Button> entryButtons = new List<Button>();

		private readonly List<LayoutElement> entryButtonLayouts = new List<LayoutElement>();

		private readonly List<Text> entryButtonTexts = new List<Text>();

		private readonly List<GameObject> analysisCardObjects = new List<GameObject>();

		private readonly List<VerticalLayoutGroup> analysisCardLayouts = new List<VerticalLayoutGroup>();

		private readonly List<LayoutElement> analysisCardLayoutElements = new List<LayoutElement>();

		private readonly List<LayoutElement> analysisCardHeaderLayouts = new List<LayoutElement>();

		private readonly List<Text> analysisCardTitleTexts = new List<Text>();

		private readonly List<VerticalLayoutGroup> analysisCardBodyContainerLayouts = new List<VerticalLayoutGroup>();

		private readonly List<Text> analysisCardBodyTexts = new List<Text>();

		private readonly List<VerticalLayoutGroup> analysisPassSummaryContainerLayouts = new List<VerticalLayoutGroup>();

		private readonly List<Text> analysisPassSummaryTexts = new List<Text>();

		private readonly List<VerticalLayoutGroup> analysisPassStageLayouts = new List<VerticalLayoutGroup>();

		private readonly List<LayoutElement> analysisPassStageLayoutElements = new List<LayoutElement>();

		private readonly List<LayoutElement> analysisPassStageHeaderRowLayouts = new List<LayoutElement>();

		private readonly List<Text> analysisPassStageTitleTexts = new List<Text>();

		private readonly List<Image> analysisPassStageStatusImages = new List<Image>();

		private readonly List<LayoutElement> analysisPassStageStatusLayouts = new List<LayoutElement>();

		private readonly List<Text> analysisPassStageStatusTexts = new List<Text>();

		private readonly List<TranslationAnalysisStageStatus> analysisPassStageStatuses = new List<TranslationAnalysisStageStatus>();

		private readonly List<VerticalLayoutGroup> analysisPassStageSummaryContainerLayouts = new List<VerticalLayoutGroup>();

		private readonly List<Text> analysisPassStageSummaryTexts = new List<Text>();

		private readonly List<VerticalLayoutGroup> analysisPassStageDetailLayouts = new List<VerticalLayoutGroup>();

		private readonly List<Text> analysisPassStageDetailTexts = new List<Text>();

		private HorizontalLayoutGroup columnsLayout;

		private VerticalLayoutGroup feedPanelLayout;

		private VerticalLayoutGroup analysisPanelLayout;

		private VerticalLayoutGroup feedContentLayout;

		private VerticalLayoutGroup analysisContentLayout;

		private HorizontalLayoutGroup feedControlsLayout;

		private HorizontalLayoutGroup feedSearchLayout;

		private HorizontalLayoutGroup analysisControlsLayout;

		private LayoutElement feedPanelWidthLayout;

		private LayoutElement analysisPanelWidthLayout;

		private LayoutElement feedHeaderLayout;

		private LayoutElement analysisHeaderLayout;

		private LayoutElement feedControlsLayoutElement;

		private LayoutElement feedSearchLayoutElement;

		private LayoutElement analysisControlsLayoutElement;

		private LayoutElement statusTextLayout;

		private LayoutElement toggleFeedButtonLayout;

		private LayoutElement feedSearchFieldLayout;

		private LayoutElement clearFeedSearchButtonLayout;

		private LayoutElement copyInputButtonLayout;

		private LayoutElement copyAnalysisButtonLayout;

		private Text feedHeaderText;

		private Text analysisHeaderText;

		private Text statusText;

		private Text feedSearchPlaceholderText;

		private Text feedSearchValueText;

		private Button toggleFeedButton;

		private Button clearFeedSearchButton;

		private Button copyInputButton;

		private Button copyAnalysisButton;

		private InputField feedSearchField;

		private RectTransform feedContentRect;

		private RectTransform analysisContentRect;

		private ScrollRect feedScrollRect;

		private ScrollRect analysisScrollRect;

		private string selectedInput;

		private string selectedSourceName;

		private TranslationAnalysisResult selectedAnalysis;

		private string feedSearchQuery = string.Empty;

		private int lastSnapshotVersion = -1;

		private bool analysisDirty = true;

		private bool feedDirty = true;

		private DevToolsLayoutMetrics lastMetrics;

		public override string Id => "trace";

		public override string DisplayName => PluginMain.Localize("devtools.page.trace", "Trace");

		protected override void Build(RectTransform parent)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateHorizontalContainer((Transform)(object)parent, "TraceColumns", DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 1f), out columnsLayout, out layoutElement);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.UseStretchFill();
			}
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			((LayoutGroup)columnsLayout).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).childForceExpandHeight = true;
			RectTransform parent2 = CreateColumn((Transform)(object)val, "FeedPanel", out feedPanelLayout, out feedPanelWidthLayout);
			CreateHeaderRow((Transform)(object)parent2, PluginMain.Localize("devtools.trace.header.feed", "Trace Feed"), out feedHeaderText, out feedHeaderLayout);
			CreateFeedControlsRow((Transform)(object)parent2);
			CreateFeedSearchRow((Transform)(object)parent2);
			CreateFeedScroll((Transform)(object)parent2);
			RectTransform parent3 = CreateColumn((Transform)(object)val, "AnalysisPanel", out analysisPanelLayout, out analysisPanelWidthLayout);
			CreateHeaderRow((Transform)(object)parent3, PluginMain.Localize("devtools.trace.header.analysis", "Translation Analysis"), out analysisHeaderText, out analysisHeaderLayout);
			CreateAnalysisControlsRow((Transform)(object)parent3);
			CreateAnalysisScroll((Transform)(object)parent3);
		}

		public override void ApplyLayout(DevToolsLayoutMetrics metrics)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Expected O, but got Unknown
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Expected O, but got Unknown
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_073c: Expected O, but got Unknown
			//IL_06d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Expected O, but got Unknown
			//IL_0959: Unknown result type (might be due to invalid IL or missing references)
			//IL_0963: Expected O, but got Unknown
			//IL_0845: Unknown result type (might be due to invalid IL or missing references)
			//IL_0887: Unknown result type (might be due to invalid IL or missing references)
			//IL_0899: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a19: Expected O, but got Unknown
			//IL_0a7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a87: Expected O, but got Unknown
			//IL_0dd3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ddd: Expected O, but got Unknown
			//IL_0b76: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e4a: Expected O, but got Unknown
			//IL_0ea2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d5d: Unknown result type (might be due to invalid IL or missing references)
			if (metrics == null || (Object)(object)columnsLayout == (Object)null)
			{
				return;
			}
			lastMetrics = metrics;
			((HorizontalOrVerticalLayoutGroup)columnsLayout).spacing = metrics.SectionColumnSpacing;
			ApplyColumnLayout(feedPanelLayout, metrics);
			ApplyColumnLayout(analysisPanelLayout, metrics);
			if ((Object)(object)feedPanelWidthLayout != (Object)null)
			{
				feedPanelWidthLayout.flexibleWidth = 42f;
			}
			if ((Object)(object)analysisPanelWidthLayout != (Object)null)
			{
				analysisPanelWidthLayout.flexibleWidth = 58f;
			}
			ApplyHeaderLayout(feedHeaderLayout, feedHeaderText, metrics);
			ApplyHeaderLayout(analysisHeaderLayout, analysisHeaderText, metrics);
			if ((Object)(object)feedControlsLayoutElement != (Object)null)
			{
				feedControlsLayoutElement.preferredHeight = metrics.InfoRowHeight;
			}
			if ((Object)(object)feedControlsLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)feedControlsLayout).spacing = metrics.InfoRowSpacing;
				((LayoutGroup)feedControlsLayout).padding = new RectOffset(metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingHorizontal, 0, 0);
			}
			if ((Object)(object)feedSearchLayoutElement != (Object)null)
			{
				feedSearchLayoutElement.preferredHeight = metrics.InfoRowHeight;
			}
			if ((Object)(object)feedSearchLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)feedSearchLayout).spacing = metrics.InfoRowSpacing;
				((LayoutGroup)feedSearchLayout).padding = new RectOffset(0, metrics.InfoRowPaddingHorizontal, 0, 0);
			}
			if ((Object)(object)statusText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(statusText, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
				statusText.alignment = (TextAnchor)3;
			}
			if ((Object)(object)statusTextLayout != (Object)null)
			{
				statusTextLayout.flexibleWidth = 1f;
				statusTextLayout.minWidth = 0f;
				statusTextLayout.preferredWidth = 0f;
			}
			if ((Object)(object)toggleFeedButtonLayout != (Object)null)
			{
				float num = (float)metrics.InfoActionButtonWidth * 2.35f;
				int insetFittedHeight = DevToolsUiFactory.GetInsetFittedHeight(metrics.InfoRowHeight, metrics.InfoRowPaddingVertical, 36f);
				toggleFeedButtonLayout.preferredWidth = num;
				toggleFeedButtonLayout.minWidth = num;
				toggleFeedButtonLayout.preferredHeight = insetFittedHeight;
				toggleFeedButtonLayout.minHeight = insetFittedHeight;
			}
			if ((Object)(object)toggleFeedButton != (Object)null)
			{
				GUIManager.Instance.ApplyButtonStyle(toggleFeedButton, Mathf.Max(12, metrics.InfoRowFontSize - 1));
			}
			if ((Object)(object)feedSearchPlaceholderText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(feedSearchPlaceholderText, GUIManager.Instance.AveriaSerif, new Color(1f, 1f, 1f, 0.45f), metrics.InfoRowFontSize, false);
			}
			if ((Object)(object)feedSearchValueText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(feedSearchValueText, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
			}
			if ((Object)(object)feedSearchFieldLayout != (Object)null)
			{
				feedSearchFieldLayout.flexibleWidth = 1f;
				feedSearchFieldLayout.minWidth = 0f;
			}
			if ((Object)(object)clearFeedSearchButtonLayout != (Object)null)
			{
				float num2 = (float)metrics.InfoActionButtonWidth * 1.45f;
				int insetFittedHeight2 = DevToolsUiFactory.GetInsetFittedHeight(metrics.InfoRowHeight, metrics.InfoRowPaddingVertical, 36f);
				clearFeedSearchButtonLayout.preferredWidth = num2;
				clearFeedSearchButtonLayout.minWidth = num2;
				clearFeedSearchButtonLayout.preferredHeight = insetFittedHeight2;
				clearFeedSearchButtonLayout.minHeight = insetFittedHeight2;
			}
			if ((Object)(object)clearFeedSearchButton != (Object)null)
			{
				GUIManager.Instance.ApplyButtonStyle(clearFeedSearchButton, Mathf.Max(12, metrics.InfoRowFontSize - 1));
			}
			if ((Object)(object)copyAnalysisButtonLayout != (Object)null)
			{
				float num3 = (float)metrics.InfoActionButtonWidth * 2.6f;
				int insetFittedHeight3 = DevToolsUiFactory.GetInsetFittedHeight(metrics.InfoRowHeight, metrics.InfoRowPaddingVertical, 36f);
				copyAnalysisButtonLayout.preferredWidth = num3;
				copyAnalysisButtonLayout.minWidth = num3;
				copyAnalysisButtonLayout.preferredHeight = insetFittedHeight3;
				copyAnalysisButtonLayout.minHeight = insetFittedHeight3;
			}
			if ((Object)(object)copyInputButtonLayout != (Object)null)
			{
				float num4 = (float)metrics.InfoActionButtonWidth * 2.6f;
				int insetFittedHeight4 = DevToolsUiFactory.GetInsetFittedHeight(metrics.InfoRowHeight, metrics.InfoRowPaddingVertical, 36f);
				copyInputButtonLayout.preferredWidth = num4;
				copyInputButtonLayout.minWidth = num4;
				copyInputButtonLayout.preferredHeight = insetFittedHeight4;
				copyInputButtonLayout.minHeight = insetFittedHeight4;
			}
			if ((Object)(object)analysisControlsLayoutElement != (Object)null)
			{
				analysisControlsLayoutElement.preferredHeight = metrics.InfoRowHeight;
			}
			if ((Object)(object)analysisControlsLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)analysisControlsLayout).spacing = metrics.InfoRowSpacing;
				((LayoutGroup)analysisControlsLayout).padding = new RectOffset(metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingHorizontal, 0, 0);
			}
			if ((Object)(object)copyAnalysisButton != (Object)null)
			{
				GUIManager.Instance.ApplyButtonStyle(copyAnalysisButton, Mathf.Max(12, metrics.InfoRowFontSize - 1));
			}
			if ((Object)(object)copyInputButton != (Object)null)
			{
				GUIManager.Instance.ApplyButtonStyle(copyInputButton, Mathf.Max(12, metrics.InfoRowFontSize - 1));
			}
			if ((Object)(object)feedContentLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)feedContentLayout).spacing = metrics.SectionContentSpacing;
				((LayoutGroup)feedContentLayout).padding = new RectOffset(0, 0, 0, 0);
			}
			for (int i = 0; i < entryButtonLayouts.Count; i++)
			{
				if ((Object)(object)entryButtonLayouts[i] != (Object)null)
				{
					float num5 = (float)metrics.InfoRowHeight * 1.45f;
					entryButtonLayouts[i].flexibleWidth = 1f;
					entryButtonLayouts[i].preferredWidth = 0f;
					entryButtonLayouts[i].minWidth = 0f;
					entryButtonLayouts[i].preferredHeight = num5;
					entryButtonLayouts[i].minHeight = num5;
				}
				if (i < entryButtons.Count && (Object)(object)entryButtons[i] != (Object)null)
				{
					GUIManager.Instance.ApplyButtonStyle(entryButtons[i], metrics.InfoRowFontSize);
				}
				if (i < entryButtonTexts.Count && (Object)(object)entryButtonTexts[i] != (Object)null)
				{
					entryButtonTexts[i].alignment = (TextAnchor)3;
					entryButtonTexts[i].horizontalOverflow = (HorizontalWrapMode)0;
					entryButtonTexts[i].verticalOverflow = (VerticalWrapMode)0;
					StretchToFill(((Graphic)entryButtonTexts[i]).rectTransform, new Vector2((float)metrics.InfoRowPaddingHorizontal, 0f), new Vector2((float)(-metrics.InfoRowPaddingHorizontal), 0f));
				}
			}
			if ((Object)(object)analysisContentLayout != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)analysisContentLayout).spacing = metrics.SectionGroupSpacing;
				((LayoutGroup)analysisContentLayout).padding = new RectOffset(0, 0, 0, 0);
			}
			for (int j = 0; j < analysisCardLayouts.Count; j++)
			{
				if (j < analysisCardLayoutElements.Count && (Object)(object)analysisCardLayoutElements[j] != (Object)null)
				{
					analysisCardLayoutElements[j].minWidth = 0f;
				}
				VerticalLayoutGroup val = analysisCardLayouts[j];
				if ((Object)(object)val != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val).spacing = metrics.SectionContentSpacing;
					((LayoutGroup)val).padding = new RectOffset(metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding, metrics.SectionPadding);
				}
				if (j < analysisCardHeaderLayouts.Count && (Object)(object)analysisCardHeaderLayouts[j] != (Object)null)
				{
					analysisCardHeaderLayouts[j].preferredHeight = metrics.SectionHeaderHeight;
				}
				if (j < analysisCardTitleTexts.Count && (Object)(object)analysisCardTitleTexts[j] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(analysisCardTitleTexts[j], GUIManager.Instance.ValheimOrange, metrics.SectionTitleFontSize, true);
					analysisCardTitleTexts[j].alignment = (TextAnchor)3;
					StretchToFill(((Graphic)analysisCardTitleTexts[j]).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
				}
				if (j < analysisCardBodyTexts.Count && (Object)(object)analysisCardBodyTexts[j] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(analysisCardBodyTexts[j], GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
					analysisCardBodyTexts[j].alignment = (TextAnchor)0;
				}
			}
			for (int k = 0; k < analysisCardBodyContainerLayouts.Count; k++)
			{
				VerticalLayoutGroup val2 = analysisCardBodyContainerLayouts[k];
				if (!((Object)(object)val2 == (Object)null))
				{
					((HorizontalOrVerticalLayoutGroup)val2).spacing = 0f;
					((LayoutGroup)val2).padding = new RectOffset(GetBodyIndent(metrics), metrics.InfoRowPaddingHorizontal, 0, 0);
				}
			}
			for (int l = 0; l < analysisPassSummaryTexts.Count; l++)
			{
				Text val3 = analysisPassSummaryTexts[l];
				if (!((Object)(object)val3 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val3, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
					val3.alignment = (TextAnchor)0;
				}
			}
			for (int m = 0; m < analysisPassSummaryContainerLayouts.Count; m++)
			{
				VerticalLayoutGroup val4 = analysisPassSummaryContainerLayouts[m];
				if (!((Object)(object)val4 == (Object)null))
				{
					((HorizontalOrVerticalLayoutGroup)val4).spacing = 0f;
					((LayoutGroup)val4).padding = new RectOffset(GetBodyIndent(metrics), metrics.InfoRowPaddingHorizontal, 0, 0);
				}
			}
			for (int n = 0; n < analysisPassStageLayouts.Count; n++)
			{
				VerticalLayoutGroup val5 = analysisPassStageLayouts[n];
				if ((Object)(object)val5 != (Object)null)
				{
					((HorizontalOrVerticalLayoutGroup)val5).spacing = Mathf.Max(6, metrics.SectionContentSpacing);
					((LayoutGroup)val5).padding = new RectOffset(metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingVertical, metrics.InfoRowPaddingVertical);
				}
				if (n < analysisPassStageLayoutElements.Count && (Object)(object)analysisPassStageLayoutElements[n] != (Object)null)
				{
					analysisPassStageLayoutElements[n].minHeight = Mathf.CeilToInt((float)metrics.InfoRowHeight * 1.4f);
				}
				if (n < analysisPassStageHeaderRowLayouts.Count && (Object)(object)analysisPassStageHeaderRowLayouts[n] != (Object)null)
				{
					float num6 = Mathf.CeilToInt((float)metrics.InfoRowHeight * 0.96f);
					analysisPassStageHeaderRowLayouts[n].preferredHeight = num6;
					analysisPassStageHeaderRowLayouts[n].minHeight = num6;
				}
				if (n < analysisPassStageTitleTexts.Count && (Object)(object)analysisPassStageTitleTexts[n] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(analysisPassStageTitleTexts[n], GUIManager.Instance.AveriaSerifBold, GUIManager.Instance.ValheimOrange, metrics.InfoRowFontSize, true);
					analysisPassStageTitleTexts[n].alignment = (TextAnchor)3;
				}
				if (n < analysisPassStageStatusLayouts.Count && (Object)(object)analysisPassStageStatusLayouts[n] != (Object)null)
				{
					float num7 = Mathf.Max(160f, (float)metrics.InfoActionButtonWidth * 2.35f);
					float num8 = Mathf.CeilToInt((float)metrics.InfoRowHeight * 0.92f);
					analysisPassStageStatusLayouts[n].flexibleWidth = 0f;
					analysisPassStageStatusLayouts[n].preferredWidth = num7;
					analysisPassStageStatusLayouts[n].minWidth = num7;
					analysisPassStageStatusLayouts[n].preferredHeight = num8;
					analysisPassStageStatusLayouts[n].minHeight = num8;
				}
				if (n < analysisPassStageStatusImages.Count && (Object)(object)analysisPassStageStatusImages[n] != (Object)null && n < analysisPassStageStatuses.Count)
				{
					((Graphic)analysisPassStageStatusImages[n]).color = GetAnalysisStageStatusColor(analysisPassStageStatuses[n]);
				}
				if (n < analysisPassStageStatusTexts.Count && (Object)(object)analysisPassStageStatusTexts[n] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(analysisPassStageStatusTexts[n], GUIManager.Instance.AveriaSerifBold, Color.white, Mathf.Max(metrics.InfoRowFontSize - 1, 13), true);
					analysisPassStageStatusTexts[n].alignment = (TextAnchor)4;
				}
				if (n < analysisPassStageSummaryTexts.Count && (Object)(object)analysisPassStageSummaryTexts[n] != (Object)null)
				{
					GUIManager.Instance.ApplyTextStyle(analysisPassStageSummaryTexts[n], GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
					analysisPassStageSummaryTexts[n].alignment = (TextAnchor)0;
				}
			}
			for (int num9 = 0; num9 < analysisPassStageSummaryContainerLayouts.Count; num9++)
			{
				VerticalLayoutGroup val6 = analysisPassStageSummaryContainerLayouts[num9];
				if (!((Object)(object)val6 == (Object)null))
				{
					((HorizontalOrVerticalLayoutGroup)val6).spacing = 0f;
					((LayoutGroup)val6).padding = new RectOffset(GetBodyIndent(metrics), metrics.InfoRowPaddingHorizontal, 0, 0);
				}
			}
			for (int num10 = 0; num10 < analysisPassStageDetailLayouts.Count; num10++)
			{
				VerticalLayoutGroup val7 = analysisPassStageDetailLayouts[num10];
				if (!((Object)(object)val7 == (Object)null))
				{
					((HorizontalOrVerticalLayoutGroup)val7).spacing = Mathf.Max(4, metrics.SectionContentSpacing / 2);
					((LayoutGroup)val7).padding = new RectOffset(GetBodyIndent(metrics), metrics.InfoRowPaddingHorizontal, metrics.InfoRowPaddingVertical, metrics.InfoRowPaddingVertical);
				}
			}
			for (int num11 = 0; num11 < analysisPassStageDetailTexts.Count; num11++)
			{
				Text val8 = analysisPassStageDetailTexts[num11];
				if (!((Object)(object)val8 == (Object)null))
				{
					GUIManager.Instance.ApplyTextStyle(val8, GUIManager.Instance.AveriaSerif, new Color(1f, 1f, 1f, 0.9f), Mathf.Max(metrics.InfoRowFontSize - 1, 12), true);
					val8.alignment = (TextAnchor)0;
				}
			}
		}

		public override void Refresh()
		{
			TranslationTraceSnapshot snapshot = TranslationTraceFeed.GetSnapshot();
			if (snapshot.Version != lastSnapshotVersion || feedDirty)
			{
				RebuildFeed(snapshot);
			}
			UpdateFeedStatus(snapshot);
			if (analysisDirty)
			{
				RebuildAnalysisCards();
			}
			UpdateEntryVisuals();
		}

		private void ToggleFeed()
		{
			TranslationTraceFeed.SetEnabled(!TranslationTraceFeed.GetSnapshot().Enabled);
			Refresh();
		}

		private void RebuildFeed(TranslationTraceSnapshot snapshot)
		{
			feedDirty = false;
			lastSnapshotVersion = snapshot.Version;
			for (int i = 0; i < entryButtons.Count; i++)
			{
				if ((Object)(object)entryButtons[i] != (Object)null)
				{
					((Component)entryButtons[i]).transform.SetParent((Transform)null, false);
					Object.Destroy((Object)(object)((Component)entryButtons[i]).gameObject);
				}
			}
			entryButtons.Clear();
			entryButtonLayouts.Clear();
			entryButtonTexts.Clear();
			if ((Object)(object)feedContentRect == (Object)null)
			{
				return;
			}
			TranslationTraceEntry translationTraceEntry = null;
			bool flag = false;
			for (int num = snapshot.Entries.Length - 1; num >= 0; num--)
			{
				TranslationTraceEntry translationTraceEntry2 = snapshot.Entries[num];
				if (MatchesFeedSearch(translationTraceEntry2))
				{
					if (translationTraceEntry == null)
					{
						translationTraceEntry = translationTraceEntry2;
					}
					if (!string.IsNullOrEmpty(selectedInput) && string.Equals(selectedInput, translationTraceEntry2.Text, StringComparison.Ordinal))
					{
						flag = true;
					}
					Button val = CreateEntryButton((Transform)(object)feedContentRect, translationTraceEntry2);
					entryButtons.Add(val);
					entryButtonLayouts.Add(((Component)val).GetComponent<LayoutElement>());
					entryButtonTexts.Add(((Component)val).GetComponentInChildren<Text>());
				}
			}
			if (!flag)
			{
				if (translationTraceEntry != null)
				{
					selectedInput = translationTraceEntry.Text;
					selectedSourceName = translationTraceEntry.SourceName;
					selectedAnalysis = TranslationRuntime.AnalyzeTranslation(translationTraceEntry.Text);
					analysisDirty = true;
				}
				else if (!string.IsNullOrWhiteSpace(feedSearchQuery))
				{
					selectedInput = null;
					selectedSourceName = null;
					selectedAnalysis = null;
					analysisDirty = true;
				}
			}
			if (lastMetrics != null)
			{
				ApplyLayout(lastMetrics);
			}
			if ((Object)(object)feedScrollRect != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(feedContentRect);
				feedScrollRect.verticalNormalizedPosition = 1f;
			}
		}

		private void UpdateFeedStatus(TranslationTraceSnapshot snapshot)
		{
			if ((Object)(object)statusText != (Object)null)
			{
				statusText.text = PluginMain.LocalizeFormat("devtools.trace.feed.unique_count", "Unique Strings: {0} / {1}", snapshot.Entries.Length, TranslationTraceFeed.Capacity);
			}
			if ((Object)(object)toggleFeedButton != (Object)null)
			{
				Text componentInChildren = ((Component)toggleFeedButton).GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = (snapshot.Enabled ? PluginMain.Localize("devtools.trace.button.stop_feed", "Stop Feed") : PluginMain.Localize("devtools.trace.button.start_feed", "Start Feed"));
				}
			}
		}

		private void SelectEntry(TranslationTraceEntry entry)
		{
			if (entry != null)
			{
				selectedInput = entry.Text;
				selectedSourceName = entry.SourceName;
				selectedAnalysis = TranslationRuntime.AnalyzeTranslation(entry.Text);
				analysisDirty = true;
				RebuildAnalysisCards();
				UpdateEntryVisuals();
				if ((Object)(object)analysisScrollRect != (Object)null)
				{
					LayoutRebuilder.ForceRebuildLayoutImmediate(analysisContentRect);
					analysisScrollRect.verticalNormalizedPosition = 1f;
				}
			}
		}

		private void RebuildAnalysisCards()
		{
			analysisDirty = false;
			for (int i = 0; i < analysisCardObjects.Count; i++)
			{
				if ((Object)(object)analysisCardObjects[i] != (Object)null)
				{
					Object.Destroy((Object)(object)analysisCardObjects[i]);
				}
			}
			analysisCardObjects.Clear();
			analysisCardLayouts.Clear();
			analysisCardLayoutElements.Clear();
			analysisCardHeaderLayouts.Clear();
			analysisCardTitleTexts.Clear();
			analysisCardBodyContainerLayouts.Clear();
			analysisCardBodyTexts.Clear();
			analysisPassSummaryContainerLayouts.Clear();
			analysisPassSummaryTexts.Clear();
			analysisPassStageLayouts.Clear();
			analysisPassStageLayoutElements.Clear();
			analysisPassStageHeaderRowLayouts.Clear();
			analysisPassStageTitleTexts.Clear();
			analysisPassStageStatusImages.Clear();
			analysisPassStageStatusLayouts.Clear();
			analysisPassStageStatusTexts.Clear();
			analysisPassStageStatuses.Clear();
			analysisPassStageSummaryContainerLayouts.Clear();
			analysisPassStageSummaryTexts.Clear();
			analysisPassStageDetailLayouts.Clear();
			analysisPassStageDetailTexts.Clear();
			if ((Object)(object)analysisContentRect == (Object)null)
			{
				return;
			}
			if (selectedAnalysis == null || string.IsNullOrEmpty(selectedInput))
			{
				CreateAnalysisCard(PluginMain.Localize("devtools.trace.section.how_to_use", "How To Use"), GetUsageLines());
			}
			else
			{
				CreateAnalysisCard(PluginMain.Localize("devtools.trace.section.overview", "Overview"), BuildOverviewLines(compactForUi: true));
				for (int j = 0; j < selectedAnalysis.Sections.Length; j++)
				{
					TranslationAnalysisSection translationAnalysisSection = selectedAnalysis.Sections[j];
					if (translationAnalysisSection != null)
					{
						if (translationAnalysisSection.PassView != null)
						{
							CreateAnalysisPassCard(translationAnalysisSection.Title, translationAnalysisSection.PassView);
						}
						else
						{
							CreateAnalysisCard(translationAnalysisSection.Title, CompactLinesForUi(translationAnalysisSection.Lines));
						}
					}
				}
			}
			if (lastMetrics != null)
			{
				ApplyLayout(lastMetrics);
			}
			if ((Object)(object)analysisScrollRect != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(analysisContentRect);
				analysisScrollRect.verticalNormalizedPosition = 1f;
			}
		}

		private void CreateAnalysisCard(string title, string[] lines)
		{
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateVerticalSurface((Transform)(object)analysisContentRect, title.Replace(" ", string.Empty) + "Card", DevToolsComponentDefaults.CardSurface, out layout, out layoutElement);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.ConfigureContentFitter((FitMode)0, (FitMode)2);
				component.UseTopAnchoredStretchContent();
			}
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			layoutElement.minHeight = -1f;
			layoutElement.preferredHeight = -1f;
			LayoutElement layoutElement2;
			RectTransform parent = DevToolsSurfaceFactory.CreatePanel((Transform)(object)val, "Header", DevToolsComponentDefaults.HeaderSurface, out layoutElement2);
			Text val2 = CreateText((Transform)(object)parent, "Title", title, 18, (TextAnchor)3, wrap: false);
			StretchToFill(((Graphic)val2).rectTransform);
			VerticalLayoutGroup layout2;
			RectTransform parent2 = CreateIndentedTextContainer((Transform)(object)val, "BodyContainer", out layout2);
			Text val3 = CreateText((Transform)(object)parent2, "Body", BuildBodyText(lines), 15, (TextAnchor)0, wrap: true);
			val3.horizontalOverflow = (HorizontalWrapMode)0;
			val3.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement obj = ((Component)val3).gameObject.AddComponent<LayoutElement>();
			obj.minHeight = 0f;
			obj.flexibleWidth = 1f;
			DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)val3, (FitMode)0, (FitMode)2);
			analysisCardObjects.Add(((Component)val).gameObject);
			analysisCardLayouts.Add(layout);
			analysisCardLayoutElements.Add(layoutElement);
			analysisCardHeaderLayouts.Add(layoutElement2);
			analysisCardTitleTexts.Add(val2);
			analysisCardBodyContainerLayouts.Add(layout2);
			analysisCardBodyTexts.Add(val3);
		}

		private void CreateAnalysisPassCard(string title, TranslationAnalysisPassView passView)
		{
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateVerticalSurface((Transform)(object)analysisContentRect, title.Replace(" ", string.Empty) + "PassCard", DevToolsComponentDefaults.CardSurface, out layout, out layoutElement);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.ConfigureContentFitter((FitMode)0, (FitMode)2);
				component.UseTopAnchoredStretchContent();
			}
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			layoutElement.minHeight = -1f;
			layoutElement.preferredHeight = -1f;
			LayoutElement layoutElement2;
			RectTransform parent = DevToolsSurfaceFactory.CreatePanel((Transform)(object)val, "Header", DevToolsComponentDefaults.HeaderSurface, out layoutElement2);
			Text val2 = CreateText((Transform)(object)parent, "Title", title, 18, (TextAnchor)3, wrap: false);
			StretchToFill(((Graphic)val2).rectTransform);
			VerticalLayoutGroup layout2;
			RectTransform parent2 = CreateIndentedTextContainer((Transform)(object)val, "PassSummaryContainer", out layout2);
			Text val3 = CreateText((Transform)(object)parent2, "PassSummary", BuildPassSummaryText(passView), 15, (TextAnchor)0, wrap: true);
			val3.horizontalOverflow = (HorizontalWrapMode)0;
			val3.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement obj = ((Component)val3).gameObject.AddComponent<LayoutElement>();
			obj.minHeight = 0f;
			obj.flexibleWidth = 1f;
			DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)val3, (FitMode)0, (FitMode)2);
			analysisPassSummaryContainerLayouts.Add(layout2);
			analysisPassSummaryTexts.Add(val3);
			TranslationAnalysisPassStage[] array = passView?.Stages ?? Array.Empty<TranslationAnalysisPassStage>();
			for (int i = 0; i < array.Length; i++)
			{
				CreateAnalysisPassStageRow((Transform)(object)val, array[i]);
			}
			analysisCardObjects.Add(((Component)val).gameObject);
			analysisCardLayouts.Add(layout);
			analysisCardLayoutElements.Add(layoutElement);
			analysisCardHeaderLayouts.Add(layoutElement2);
			analysisCardTitleTexts.Add(val2);
		}

		private void CreateAnalysisPassStageRow(Transform parent, TranslationAnalysisPassStage stage)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			VerticalLayoutGroup layout;
			LayoutElement layoutElement;
			RectTransform val = DevToolsSurfaceFactory.CreateVerticalSurface(parent, (stage?.Title ?? "Stage").Replace(" ", string.Empty) + "Row", DevToolsComponentDefaults.CardSurface, out layout, out layoutElement);
			((Graphic)((Component)val).GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.12f);
			DevToolsAutoLayoutContainer component = ((Component)val).GetComponent<DevToolsAutoLayoutContainer>();
			if ((Object)(object)component != (Object)null)
			{
				component.ConfigureContentFitter((FitMode)0, (FitMode)2);
				component.UseTopAnchoredStretchContent();
			}
			layoutElement.flexibleWidth = 1f;
			layoutElement.minWidth = 0f;
			layoutElement.minHeight = -1f;
			layoutElement.preferredHeight = -1f;
			HorizontalLayoutGroup layout2;
			LayoutElement layoutElement2;
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalContainer((Transform)(object)val, "HeaderRow", DevToolsComponentDefaults.HorizontalRowSurface.WithLayout(8f, new RectOffset(0, 0, 0, 0)).WithSize(0f, 0f, 0f, 0f, 1f, 0f), out layout2, out layoutElement2);
			((HorizontalOrVerticalLayoutGroup)layout2).childForceExpandWidth = false;
			Text val2 = CreateText((Transform)(object)parent2, "Title", stage?.Title ?? string.Empty, 15, (TextAnchor)3, wrap: false);
			LayoutElement obj = ((Component)val2).gameObject.AddComponent<LayoutElement>();
			obj.flexibleWidth = 1f;
			obj.minWidth = 0f;
			LayoutElement layoutElement3;
			RectTransform val3 = DevToolsSurfaceFactory.CreatePanel((Transform)(object)parent2, "StatusBadge", DevToolsComponentDefaults.CardSurface, out layoutElement3);
			Image component2 = ((Component)val3).GetComponent<Image>();
			layoutElement3.flexibleWidth = 0f;
			Text val4 = CreateText((Transform)(object)val3, "StatusText", GetStageStatusLabel(stage?.Status ?? TranslationAnalysisStageStatus.NotExecuted), 14, (TextAnchor)4, wrap: false);
			StretchToFill(((Graphic)val4).rectTransform, new Vector2(8f, 0f), new Vector2(-8f, 0f));
			VerticalLayoutGroup layout3;
			RectTransform parent3 = CreateIndentedTextContainer((Transform)(object)val, "SummaryContainer", out layout3);
			Text val5 = CreateText((Transform)(object)parent3, "Summary", stage?.Summary ?? string.Empty, 15, (TextAnchor)0, wrap: true);
			val5.horizontalOverflow = (HorizontalWrapMode)0;
			val5.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement obj2 = ((Component)val5).gameObject.AddComponent<LayoutElement>();
			obj2.minHeight = 0f;
			obj2.flexibleWidth = 1f;
			DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)val5, (FitMode)0, (FitMode)2);
			string[] array = CompactLinesForUi(stage?.Details);
			if (array.Length != 0)
			{
				VerticalLayoutGroup layout4;
				LayoutElement layoutElement4;
				RectTransform val6 = DevToolsSurfaceFactory.CreateVerticalSurface((Transform)(object)val, "DetailsList", DevToolsComponentDefaults.CardSurface, out layout4, out layoutElement4);
				((Graphic)((Component)val6).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.12f);
				layoutElement4.flexibleWidth = 1f;
				layoutElement4.minWidth = 0f;
				DevToolsAutoLayoutContainer component3 = ((Component)val6).GetComponent<DevToolsAutoLayoutContainer>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.ConfigureContentFitter((FitMode)0, (FitMode)2);
					component3.UseTopAnchoredStretchContent();
				}
				layoutElement4.minHeight = -1f;
				layoutElement4.preferredHeight = -1f;
				analysisPassStageDetailLayouts.Add(layout4);
				for (int i = 0; i < array.Length; i++)
				{
					Text val7 = CreateText((Transform)(object)val6, $"Detail{i}", array[i], 14, (TextAnchor)0, wrap: true);
					val7.horizontalOverflow = (HorizontalWrapMode)0;
					val7.verticalOverflow = (VerticalWrapMode)1;
					LayoutElement obj3 = ((Component)val7).gameObject.AddComponent<LayoutElement>();
					obj3.minHeight = 0f;
					obj3.flexibleWidth = 1f;
					DevToolsUiFactory.EnsureContentSizeFitter((Component)(object)val7, (FitMode)0, (FitMode)2);
					analysisPassStageDetailTexts.Add(val7);
				}
			}
			analysisPassStageLayouts.Add(layout);
			analysisPassStageLayoutElements.Add(layoutElement);
			analysisPassStageHeaderRowLayouts.Add(layoutElement2);
			analysisPassStageTitleTexts.Add(val2);
			analysisPassStageStatusImages.Add(component2);
			analysisPassStageStatusLayouts.Add(layoutElement3);
			analysisPassStageStatusTexts.Add(val4);
			analysisPassStageStatuses.Add(stage?.Status ?? TranslationAnalysisStageStatus.NotExecuted);
			analysisPassStageSummaryContainerLayouts.Add(layout3);
			analysisPassStageSummaryTexts.Add(val5);
		}

		private void UpdateEntryVisuals()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < entryButtons.Count; i++)
			{
				Button val = entryButtons[i];
				Text val2 = ((i < entryButtonTexts.Count) ? entryButtonTexts[i] : null);
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((Object)val).name;
					bool flag = !string.IsNullOrEmpty(selectedInput) && string.Equals(name, selectedInput, StringComparison.Ordinal);
					Image component = ((Component)val).GetComponent<Image>();
					if ((Object)(object)component != (Object)null)
					{
						((Graphic)component).color = (flag ? new Color(1f, 1f, 0.96f, 1f) : new Color(0.76f, 0.76f, 0.76f, 0.9f));
					}
					if ((Object)(object)val2 != (Object)null)
					{
						((Graphic)val2).color = (flag ? Color.white : GUIManager.Instance.ValheimOrange);
					}
				}
			}
		}

		private RectTransform CreateColumn(Transform parent, string name, out VerticalLayoutGroup layout, out LayoutElement widthLayout)
		{
			return DevToolsSurfaceFactory.CreateVerticalContainer(parent, name, DevToolsComponentDefaults.CardSurface.WithSize(0f, 0f, 0f, 0f, 1f, 1f), out layout, out widthLayout);
		}

		private RectTransform CreateHeaderRow(Transform parent, string title, out Text titleText, out LayoutElement headerLayout)
		{
			HorizontalLayoutGroup layout;
			RectTransform val = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, title.Replace(" ", string.Empty) + "Header", DevToolsComponentDefaults.HeaderSurface, out layout, out headerLayout);
			titleText = CreateText((Transform)(object)val, "Title", title, 18, (TextAnchor)3, wrap: false);
			((Component)titleText).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
			return val;
		}

		private void CreateFeedControlsRow(Transform parent)
		{
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, "FeedControls", DevToolsComponentDefaults.HorizontalRowSurface, out feedControlsLayout, out feedControlsLayoutElement);
			statusText = CreateText((Transform)(object)parent2, "FeedStatus", string.Empty, 15, (TextAnchor)3, wrap: false);
			statusTextLayout = ((Component)statusText).gameObject.AddComponent<LayoutElement>();
			statusTextLayout.flexibleWidth = 1f;
			statusTextLayout.minWidth = 0f;
			statusTextLayout.preferredWidth = 0f;
			toggleFeedButton = CreateButton((Transform)(object)parent2, "Start Feed", ToggleFeed);
			toggleFeedButtonLayout = ((Component)toggleFeedButton).GetComponent<LayoutElement>();
			toggleFeedButtonLayout.flexibleWidth = 0f;
		}

		private void CreateFeedSearchRow(Transform parent)
		{
			RectTransform parent2 = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, "FeedSearch", DevToolsComponentDefaults.HorizontalRowSurface, out feedSearchLayout, out feedSearchLayoutElement);
			feedSearchField = CreateSearchField((Transform)(object)parent2, out feedSearchFieldLayout, out feedSearchPlaceholderText, out feedSearchValueText);
			((UnityEvent<string>)(object)feedSearchField.onValueChanged).AddListener((UnityAction<string>)HandleFeedSearchChanged);
			clearFeedSearchButton = CreateButton((Transform)(object)parent2, PluginMain.Localize("common.clear", "Clear"), ClearFeedSearch);
			clearFeedSearchButtonLayout = ((Component)clearFeedSearchButton).GetComponent<LayoutElement>();
			clearFeedSearchButtonLayout.flexibleWidth = 0f;
		}

		private void CreateAnalysisControlsRow(Transform parent)
		{
			//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)
			RectTransform val = DevToolsSurfaceFactory.CreateHorizontalSurface(parent, "AnalysisControls", DevToolsComponentDefaults.HorizontalRowSurface, out analysisControlsLayout, out analysisControlsLayoutElement);
			((LayoutGroup)analysisControlsLayout).childAlignment = (TextAnchor)5;
			GameObject val2 = new GameObject("Spacer", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			});
			val2.transform.SetParent((Transform)(object)val, false);
			LayoutElement component = val2.GetComponent<LayoutElement>();
			component.flexibleWidth = 1f;
			component.minWidth = 0f;
			copyInputButton = CreateButton((Transform)(object)val, "Copy Input", CopyInputToClipboard);
			copyInputButtonLayout = ((Component)copyInputButton).GetComponent<LayoutElement>();
			copyInputButtonLayout.flexibleWidth = 0f;
			copyAnalysisButton = CreateButton((Transform)(object)val, "Copy Report", CopyAnalysisToClipboard);
			copyAnalysisButtonLayout = ((Component)copyAnalysisButton).GetComponent<LayoutElement>();
			copyAnalysisButtonLayout.flexibleWidth = 0f;
		}

		private void CreateFeedScroll(Transform parent)
		{
			feedScrollRect = CreateScrollView(parent, "FeedScroll", out var contentRect, out var _);
			feedContentRect = contentRect;
			feedContentLayout = ((Component)contentRect).GetComponent<VerticalLayoutGroup>();
		}

		private void CreateAnalysisScroll(Transform parent)
		{
			analysisScrollRect = CreateScrollView(parent, "AnalysisScroll", out var contentRect, out var _);
			analysisScrollRect.verticalNormalizedPosition = 1f;
			analysisContentRect = contentRect;
			analysisContentLayout = ((Component)contentRect).GetComponent<VerticalLayoutGroup>();
		}

		private ScrollRect CreateScrollView(Transform parent, string name, out RectTransform contentRect, out LayoutElement containerLayout)
		{
			VerticalLayoutGroup contentLayout;
			return DevToolsScrollViewFactory.CreateVerticalScrollView(parent, name, out contentRect, out contentLayout, out containerLayout);
		}

		private Button CreateEntryButton(Transform parent, TranslationTraceEntry entry)
		{
			Button obj = CreateButton(parent, BuildEntryLabel(entry), delegate
			{
				SelectEntry(entry);
			}, 360f, 60f, supportRichText: true, useLocalizationFallback: false);
			((Object)obj).name = entry.Text;
			Text componentInChildren = ((Component)obj).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.alignment = (TextAnchor)3;
				componentInChildren.supportRichText = true;
			}
			return obj;
		}

		private Button CreateButton(Transform parent, string label, Action onClick)
		{
			return CreateButton(parent, label, onClick, 156f, 36f, supportRichText: false, useLocalizationFallback: true);
		}

		private Button CreateButton(Transform parent, string label, Action onClick, float width, float height, bool supportRichText, bool useLocalizationFallback)
		{
			return DevToolsUiFactory.CreateButton(parent, label.Replace(" ", string.Empty) + "Button", label, onClick, 15, DevToolsButtonSizing.Fixed(width, height), supportRichText, useLocalizationFallback);
		}

		private void CopyAnalysisToClipboard()
		{
			GUIUtility.systemCopyBuffer = BuildAnalysisReport();
		}

		private void CopyInputToClipboard()
		{
			GUIUtility.systemCopyBuffer = selectedInput ?? string.Empty;
		}

		private string BuildAnalysisReport()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(PluginMain.Localize("devtools.trace.report.title", "Translation Analysis Report"));
			stringBuilder.AppendLine("===========================");
			if (selectedAnalysis == null || string.IsNullOrEmpty(selectedInput))
			{
				AppendAnalysisSection(stringBuilder, PluginMain.Localize("devtools.trace.section.how_to_use", "How To Use"), GetUsageLines());
				return stringBuilder.ToString().TrimEnd(Array.Empty<char>());
			}
			AppendAnalysisSection(stringBuilder, PluginMain.Localize("devtools.trace.section.overview", "Overview"), BuildOverviewLines(compactForUi: false));
			for (int i = 0; i < selectedAnalysis.Sections.Length; i++)
			{
				TranslationAnalysisSection translationAnalysisSection = selectedAnalysis.Sections[i];
				if (translationAnalysisSection != null)
				{
					AppendAnalysisSection(stringBuilder, translationAnalysisSection.Title, translationAnalysisSection.Lines);
				}
			}
			return stringBuilder.ToString().TrimEnd(Array.Empty<char>());
		}

		private string[] BuildOverviewLines(bool compactForUi)
		{
			if (selectedAnalysis == null || string.IsNullOrEmpty(selectedInput))
			{
				return Array.Empty<string>();
			}
			List<string> list = new List<string>();
			list.Add(PluginMain.LocalizeFormat("devtools.trace.overview.input", "Input: {0}", PluginMain.FormatTextForDebug(selectedAnalysis.Input)));
			List<string> list2 = list;
			if (!string.IsNullOrWhiteSpace(selectedSourceName))
			{
				list2.Add(PluginMain.LocalizeFormat("devtools.trace.overview.source", "Source: {0}", selectedSourceName));
			}
			list2.Add(PluginMain.LocalizeFormat("devtools.trace.overview.output", "Current Output: {0}", PluginMain.FormatTextForDebug(selectedAnalysis.Output)));
			if (!compactForUi)
			{
				return list2.ToArray();
			}
			return CompactLinesForUi(list2.ToArray());
		}

		private static string[] GetUsageLines()
		{
			return new string[3]
			{
				PluginMain.Localize("devtools.trace.usage.select", "Click a captured string on the left to run a fresh translation analysis."),
				PluginMain.Localize("devtools.trace.usage.replay", "The analysis always replays the translation flow live for the selected input."),
				PluginMain.LocalizeFormat("devtools.trace.usage.capacity", "Feed only stores unique strings and stops at {0} entries.", TranslationTraceFeed.Capacity)
			};
		}

		private static void AppendAnalysisSection(StringBuilder builder, string title, string[] lines)
		{
			if (builder.Length > 0)
			{
				builder.AppendLine();
			}
			string text = PluginMain.LocalizeFallback(title ?? string.Empty);
			builder.AppendLine(text);
			builder.AppendLine(new string('=', string.IsNullOrEmpty(text) ? 1 : text.Length));
			if (lines == null || lines.Length == 0)
			{
				builder.AppendLine("-");
				return;
			}
			for (int i = 0; i < lines.Length; i++)
			{
				builder.AppendLine(PluginMain.LocalizeFallback(lines[i] ?? string.Empty));
			}
		}

		private void ApplyTraceHeaderStyle(Image image)
		{
			DevToolsSurfaceFactory.ApplySurfaceStyle(image, DevToolsComponentDefaults.HeaderSurface);
		}

		private void ApplyTraceCardStyle(Image image)
		{
			DevToolsSurfaceFactory.ApplySurfaceStyle(image, DevToolsComponentDefaults.CardSurface);
		}

		private static string BuildBodyText(string[] lines)
		{
			if (lines == null || lines.Length == 0)
			{
				return "-";
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < lines.Length; i++)
			{
				if (i > 0)
				{
					stringBuilder.AppendLine();
				}
				stringBuilder.Append(PluginMain.LocalizeFallback(lines[i]));
			}
			return stringBuilder.ToString();
		}

		private static string[] CompactLinesForUi(string[] lines)
		{
			if (lines == null || lines.Length == 0)
			{
				return Array.Empty<string>();
			}
			string[] array = new string[lines.Length];
			for (int i = 0; i < lines.Length; i++)
			{
				array[i] = CompactUiLine(lines[i]);
			}
			return array;
		}

		private static string CompactUiLine(string value)
		{
			if (string.IsNullOrEmpty(value) || value.Length <= 280)
			{
				return value ?? string.Empty;
			}
			return value.Substring(0, 280) + PluginMain.Localize("devtools.trace.ui.truncated_suffix", "... [truncated in UI]");
		}

		private static string BuildPassSummaryText(TranslationAnalysisPassView passView)
		{
			if (passView == null)
			{
				return string.Empty;
			}
			return PluginMain.LocalizeFormat("devtools.trace.overview.input", "Input: {0}", PluginMain.FormatTextForDebug(passView.Input)) + "\n" + PluginMain.LocalizeFormat("runtime.analysis.stage_summary_output", "Output: '{0}'", PluginMain.FormatTextForDebug(passView.Output));
		}

		private static string GetStageStatusLabel(TranslationAnalysisStageStatus status)
		{
			return status switch
			{
				TranslationAnalysisStageStatus.Hit => PluginMain.Localize("devtools.trace.analysis.status.hit", "Hit"), 
				TranslationAnalysisStageStatus.Miss => PluginMain.Localize("devtools.trace.analysis.status.miss", "Miss"), 
				_ => PluginMain.Localize("devtools.trace.analysis.status.not_executed", "Not Executed"), 
			};
		}

		private static Color GetAnalysisStageStatusColor(TranslationAnalysisStageStatus status)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(status switch
			{
				TranslationAnalysisStageStatus.Hit => new Color(0.31f, 0.53f, 0.24f, 0.95f), 
				TranslationAnalysisStageStatus.Miss => new Color(0.62f, 0.27f, 0.19f, 0.95f), 
				_ => new Color(0.36f, 0.36f, 0.36f, 0.92f), 
			});
		}

		private void HandleFeedSearchChanged(string value)
		{
			string b = value ?? string.Empty;
			if (!string.Equals(feedSearchQuery, b, StringComparison.Ordinal))
			{
				feedSearchQuery = b;
				feedDirty = true;
				Refresh();
			}
		}

		private void ClearFeedSearch()
		{
			if (!((Object)(object)feedSearchField == (Object)null) && !string.IsNullOrEmpty(feedSearchField.text))
			{
				feedSearchField.text = string.Empty;
			}
		}

		private bool MatchesFeedSearch(TranslationTraceEntry entry)
		{
			if (entry == null)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(feedSearchQuery))
			{
				return true;
			}
			if (!ContainsIgnoreCase(entry.Text, feedSearchQuery))
			{
				return ContainsIgnoreCase(entry.SourceName, feedSearchQuery);
			}
			return true;
		}

		private string BuildEntryLabel(TranslationTraceEntry entry)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('[');
			stringBuilder.Append(entry.Sequence);
			stringBuilder.Append("] ");
			stringBuilder.Append(HighlightSearch(FormatPreview(entry.Text, 140), feedSearchQuery));
			if (!string.IsNullOrWhiteSpace(entry.SourceName))
			{
				stringBuilder.Append("\n<color=#E6C373>");
				stringBuilder.Append(HighlightSearch(FormatPreview(entry.SourceName, 72), feedSearchQuery));
				stringBuilder.Append("</color>");
			}
			return stringBuilder.ToString();
		}

		private Text CreateText(Transform parent, string name, string value, int fontSize, TextAnchor alignment, bool wrap)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return DevToolsUiFactory.CreateTextBlock(parent, name, value, fontSize, alignment, wrap, supportRichText: false, useLocalizationFallback: true);
		}

		private RectTransform CreateIndentedTextContainer(Transform parent, string name, out VerticalLayoutGroup layout)
		{
			DevToolsAutoLayoutContainer autoLayout;
			RectTransform result = DevToolsSurfaceFactory.CreateVerticalContentContainer(parent, name, DevToolsComponentDefaults.ContentStackSurface.WithSize(0f, 0f, 0f, 0f, 1f, 0f), out layout, out autoLayout);
			autoLayout.ConfigureContentFitter((FitMode)0, (FitMode)2);
			autoLayout.UseTopAnchoredStretchContent();
			return result;
		}

		private static int GetBodyIndent(DevToolsLayoutMetrics metrics)
		{
			return Mathf.Max(metrics.InfoRowPaddingHorizontal, Mathf.RoundToInt((float)(metrics.SectionHeaderInset + metrics.InfoRowPaddingHorizontal) * 0.5f));
		}

		private InputField CreateSearchField(Transform parent, out LayoutElement fieldLayout, out Text placeholderText, out Text valueText)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			return DevToolsInputFieldFactory.CreateField(parent, "SearchField", PluginMain.Localize("devtools.trace.search.placeholder", "Search captured strings or sources..."), DevToolsComponentDefaults.SingleLineInput, DevToolsComponentDefaults.SearchPlaceholderText, DevToolsComponentDefaults.PlainText.WithInsets(new Vector2(12f, 0f), new Vector2(-12f, 0f)), out fieldLayout, out placeholderText, out valueText);
		}

		private void ApplyColumnLayout(VerticalLayoutGroup layout, DevToolsLayoutMetrics metrics)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (!((Object)(object)layout == (Object)null))
			{
				((HorizontalOrVerticalLayoutGroup)layout).spacing = metrics.SectionGroupSpacing;
				((LayoutGroup)layout).padding = new RectOffset(0, 0, 0, 0);
			}
		}

		private void ApplyHeaderLayout(LayoutElement layout, Text titleText, DevToolsLayoutMetrics metrics)
		{
			//IL_002a: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)layout != (Object)null)
			{
				layout.preferredHeight = metrics.SectionHeaderHeight;
			}
			if ((Object)(object)titleText != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(titleText, GUIManager.Instance.ValheimOrange, metrics.SectionTitleFontSize, true);
				StretchToFill(((Graphic)titleText).rectTransform, new Vector2((float)metrics.SectionHeaderInset, 0f), new Vector2((float)(-metrics.SectionHeaderInset), 0f));
			}
		}

		private void ApplyInfoTextRow(LayoutElement layout, Text text, DevToolsLayoutMetrics metrics, TextAnchor alignment)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)layout != (Object)null)
			{
				layout.preferredHeight = (((int)alignment == 0) ? (metrics.InfoRowHeight * 2) : metrics.InfoRowHeight);
			}
			if ((Object)(object)text != (Object)null)
			{
				GUIManager.Instance.ApplyTextStyle(text, GUIManager.Instance.AveriaSerif, Color.white, metrics.InfoRowFontSize, true);
				text.alignment = alignment;
			}
		}

		private static void StretchToFill(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			StretchToFill(rect, Vector2.zero, Vector2.zero);
		}

		private static void StretchToFill(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}

		private static string FormatPreview(string value, int maxLength)
		{
			string text = PluginMain.FormatTextForDebug(value);
			if (text.Length <= maxLength)
			{
				return text;
			}
			return text.Substring(0, maxLength) + "...";
		}

		private static bool ContainsIgnoreCase(string value, string query)
		{
			if (!string.IsNullOrEmpty(value) && !string.IsNullOrWhiteSpace(query))
			{
				return value.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private static string HighlightSearch(string value, string query)
		{
			string text = value ?? string.Empty;
			if (string.IsNullOrWhiteSpace(query))
			{
				return EscapeRichText(text);
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			while (num < text.Length)
			{
				int num2 = text.IndexOf(query, num, StringComparison.OrdinalIgnoreCase);
				if (num2 < 0)
				{
					stringBuilder.Append(EscapeRichText(text.Substring(num)));
					break;
				}
				if (num2 > num)
				{
					stringBuilder.Append(EscapeRichText(text.Substring(num, num2 - num)));
				}
				stringBuilder.Append("<color=#FFF1A8><b>");
				stringBuilder.Append(EscapeRichText(text.Substring(num2, query.Length)));
				stringBuilder.Append("</b></color>");
				num = num2 + query.Length;
			}
			return stringBuilder.ToString();
		}

		private static string EscapeRichText(string value)
		{
			return (value ?? string.Empty).Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;");
		}
	}
	internal sealed class TranslationTraceEntry
	{
		public int Sequence { get; }

		public string Text { get; }

		public string SourceName { get; }

		public TranslationTraceEntry(int sequence, string text, string sourceName)
		{
			Sequence = sequence;
			Text = text ?? string.Empty;
			SourceName = sourceName ?? string.Empty;
		}
	}
	internal sealed class TranslationTraceSnapshot
	{
		public bool Enabled { get; }

		public int Version { get; }

		public TranslationTraceEntry[] Entries { get; }

		public TranslationTraceSnapshot(bool enabled, int version, TranslationTraceEntry[] entries)
		{
			Enabled = enabled;
			Version = version;
			Entries = entries ?? Array.Empty<TranslationTraceEntry>();
		}
	}
	internal static class TranslationTraceFeed
	{
		private static readonly object SyncRoot = new object();

		private static readonly List<TranslationTraceEntry> entries = new List<TranslationTraceEntry>();

		private static readonly Dictionary<string, TranslationTraceEntry> entriesByText = new Dictionary<string, TranslationTraceEntry>(StringComparer.Ordinal);

		private static volatile bool enabled;

		private static int nextSequence;

		private static int version;

		internal static int Capacity => GetConfiguredCapacity();

		internal static bool IsEnabled => enabled;

		internal static void SetEnabled(bool value)
		{
			lock (SyncRoot)
			{
				if (enabled != value)
				{
					enabled = value;
					version++;
				}
			}
		}

		internal static bool Capture(string text, string sourceName)
		{
			if (!enabled || string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			lock (SyncRoot)
			{
				if (!enabled || entriesByText.ContainsKey(text))
				{
					return false;
				}
				int configuredCapacity = GetConfiguredCapacity();
				TranslationTraceEntry translationTraceEntry = new TranslationTraceEntry(++nextSequence, text, sourceName);
				entries.Add(translationTraceEntry);
				entriesByText[text] = translationTraceEntry;
				TrimToCapacityLocked(configuredCapacity);
				version++;
				return true;
			}
		}

		internal static TranslationTraceSnapshot GetSnapshot()
		{
			lock (SyncRoot)
			{
				if (TrimToCapacityLocked(GetConfiguredCapacity()))
				{
					version++;
				}
				return new TranslationTraceSnapshot(enabled, version, entries.ToArray());
			}
		}

		private static int GetConfiguredCapacity()
		{
			int traceFeedMaxEntries = RuntimeDebugConfig.TraceFeedMaxEntries;
			if (traceFeedMaxEntries <= 0)
			{
				return 1024;
			}
			return traceFeedMaxEntries;
		}

		private static bool TrimToCapacityLocked(int capacity)
		{
			int num = ((capacity > 0) ? capacity : 1024);
			bool result = false;
			while (entries.Count > num)
			{
				TranslationTraceEntry translationTraceEntry = entries[0];
				entries.RemoveAt(0);
				entriesByText.Remove(translationTraceEntry.Text);
				result = true;
			}
			return result;
		}
	}
}
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;
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZRpc rpc2 = rpc;
				ZNet __instance2 = __instance;
				Dictionary<Assembly, BufferingSocket> __state2 = __state;
				ZNetPeer peer;
				if (__instance2.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance2).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc2.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc2, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance2, new object[1] { rpc2 });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state2[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc2.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc2.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance2).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			ConfigEntry<T> configEntry2 = configEntry;
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry2);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry2);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry2).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry2).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry2.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry2);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			CustomSyncedValueBase customValue2 = customValue;
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue2.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue2);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue2.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue2);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			OwnConfigEntryBase config2 = config;
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config2));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config2.SynchronizedConfig || config2.LocalBaseValue == null || (!configSync.IsLocked && (config2 != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZNetPeer peer2 = peer;
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer2.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer2.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer2.m_server ? 0 : peer2.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer2.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer2.m_uid} after 30 seconds config sending timeout");
						peer2.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer2);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			ZPackage package2 = package;
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package2.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package2 = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package2)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			ZRpc rpc2 = rpc;
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc2)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}