using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using Microsoft.Win32;

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyInformationalVersion("GIT master [cf85ca6f3fc361cf48bf56107e4cec9102b7f5eb] ")]
[assembly: AssemblyTitle("ExIni")]
[assembly: Guid("b8adf1ac-aade-485a-8997-14c4b42e0a8b")]
[assembly: AssemblyDescription("Extended INI File Handler")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyFileVersion("1.0.2.1")]
[assembly: AssemblyCompany("Usagirei")]
[assembly: AssemblyProduct("ExIni")]
[assembly: ComVisible(false)]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCopyright("Copyright © Usagirei 2015")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyVersion("1.0.2.1")]
namespace ExIni;

public class IniComment
{
	public List<string> Comments { get; set; }

	public IniComment()
	{
		Comments = new List<string>();
	}

	public override string ToString()
	{
		StringBuilder stringBuilder = new StringBuilder();
		for (int i = 0; i < Comments.Count; i++)
		{
			string text = Comments[i];
			string value = ((i < Comments.Count - 1) ? (";" + text + Environment.NewLine) : (";" + text));
			stringBuilder.Append(value);
		}
		return stringBuilder.ToString();
	}

	public void Append(params string[] comments)
	{
		Comments.AddRange(comments);
	}
}
public class IniFile
{
	private readonly IniComment _comments;

	private readonly List<IniSection> _sections;

	public IniSection this[string sec] => CreateSection(sec);

	public IniComment Comments => _comments;

	public List<IniSection> Sections => _sections;

	public IniFile()
	{
		_comments = new IniComment();
		_sections = new List<IniSection>();
	}

	public override string ToString()
	{
		StringBuilder stringBuilder = new StringBuilder();
		for (int i = 0; i < Sections.Count; i++)
		{
			IniSection iniSection = Sections[i];
			if (iniSection.Comments.Comments.Any())
			{
				stringBuilder.AppendLine(iniSection.Comments.ToString());
			}
			stringBuilder.AppendLine(iniSection.ToString());
			foreach (IniKey key in iniSection.Keys)
			{
				if (key.Comments.Comments.Any())
				{
					stringBuilder.AppendLine(key.Comments.ToString());
				}
				stringBuilder.AppendLine(key.ToString());
			}
			if (i < Sections.Count - 1)
			{
				stringBuilder.AppendLine();
			}
		}
		if (Comments.Comments.Any())
		{
			stringBuilder.AppendLine();
			stringBuilder.AppendLine(Comments.ToString());
		}
		return stringBuilder.ToString();
	}

	public IniSection CreateSection(string section)
	{
		IniSection section2 = GetSection(section);
		if (section2 != null)
		{
			return section2;
		}
		IniSection iniSection = new IniSection(section);
		_sections.Add(iniSection);
		return iniSection;
	}

	public bool DeleteSection(string section)
	{
		if (!HasSection(section))
		{
			return false;
		}
		Sections.Remove(GetSection(section));
		return true;
	}

	public IniSection GetSection(string section)
	{
		if (!HasSection(section))
		{
			return null;
		}
		return _sections.FirstOrDefault((IniSection iniSection) => iniSection.Section == section);
	}

	public bool HasSection(string section)
	{
		return _sections.Any((IniSection iniSection) => iniSection.Section == section);
	}

	public void Merge(IniFile ini)
	{
		Comments.Append(ini.Comments.Comments.ToArray());
		foreach (IniSection section in ini.Sections)
		{
			IniSection iniSection = this[section.Section];
			iniSection.Comments.Append(section.Comments.Comments.ToArray());
			foreach (IniKey key in section.Keys)
			{
				IniKey iniKey = iniSection[key.Key];
				iniKey.Comments.Append(key.Comments.Comments.ToArray());
				iniKey.Value = key.Value;
			}
		}
	}

	public void Save(string filePath)
	{
		string directoryName = Path.GetDirectoryName(filePath);
		if (!string.IsNullOrEmpty(directoryName))
		{
			Directory.CreateDirectory(directoryName);
		}
		File.WriteAllText(filePath, ToString(), Encoding.UTF8);
	}

	public static IniFile FromFile(string iniString)
	{
		return IniParser.Parse(File.ReadAllText(iniString));
	}

	public static IniFile FromString(string iniString)
	{
		return IniParser.Parse(iniString);
	}
}
public class IniKey
{
	private readonly IniComment _comments;

	public IniComment Comments => _comments;

	public string Key { get; set; }

	public string RawValue { get; set; }

	public string Value
	{
		get
		{
			return Resolve(RawValue);
		}
		set
		{
			RawValue = value;
		}
	}

	public IniKey(string key, string value = null)
	{
		Key = key;
		Value = value;
		_comments = new IniComment();
	}

	public override string ToString()
	{
		return $"{Key}={RawValue}";
	}

	private static string GetEnvironment(string env)
	{
		return Environment.ExpandEnvironmentVariables(env);
	}

	private static string GetRegistry(string path)
	{
		string directoryName = Path.GetDirectoryName(path);
		string fileName = Path.GetFileName(path);
		if (string.IsNullOrEmpty(directoryName))
		{
			return null;
		}
		return Registry.GetValue(directoryName, fileName, string.Empty)?.ToString();
	}

	private static string Resolve(string value)
	{
		if (value == null)
		{
			return null;
		}
		Regex regex = new Regex("\\$\\((?<reg>.*)\\)");
		Regex regex2 = new Regex("%.*%");
		while (regex.IsMatch(value) || regex2.IsMatch(value))
		{
			value = regex.Replace(value, (Match match) => GetRegistry(match.Groups["reg"].Value));
			value = GetEnvironment(value);
		}
		return value;
	}
}
internal class IniParser
{
	private static readonly Regex CommentRegex = new Regex("^;(?<com>.*)");

	private static readonly Regex KeyRegex = new Regex("^(?<key>[\\w\\s]+)=(?<val>.*)$");

	private static readonly Regex SectionRegex = new Regex("^\\[(?<sec>[\\w\\s]+)\\]$");

	private static readonly Regex VarRegex = new Regex("^\\@(?<key>[\\w\\s]+)=(?<val>.*)$");

	public static IniFile Parse(string iniString)
	{
		IniFile iniFile = new IniFile();
		string[] array = (from line in iniString.Split(new char[1] { '\n' })
			let trimmed = line.Trim()
			select trimmed.TrimEnd(new char[1] { '\r' })).ToArray();
		List<string> list = new List<string>();
		IniSection iniSection = null;
		bool flag = false;
		for (int i = 0; i < array.Length; i++)
		{
			string text = array[i];
			if (string.IsNullOrEmpty(text))
			{
				continue;
			}
			if (IsComment(text))
			{
				string comment = GetComment(text);
				list.Add(comment);
				if (IsVariable(comment))
				{
					string[] variable = GetVariable(comment);
					string variable2 = variable[0];
					string value = variable[1];
					Environment.SetEnvironmentVariable(variable2, value);
				}
				flag = true;
			}
			else if (IsSection(text))
			{
				iniSection = iniFile[GetSection(text)];
				if (flag)
				{
					iniSection.Comments.Append(list.ToArray());
					list.Clear();
					flag = false;
				}
			}
			else if (IsKey(text))
			{
				if (iniSection == null)
				{
					throw new Exception($"{i}: Sectionless Key Value Pair");
				}
				string[] key = GetKey(text);
				string key2 = key[0];
				string value2 = key[1];
				if (flag)
				{
					iniSection[key2].Comments.Append(list.ToArray());
					list.Clear();
					flag = false;
				}
				iniSection[key2].Value = value2;
			}
		}
		if (flag)
		{
			iniFile.Comments.Append(list.ToArray());
		}
		return iniFile;
	}

	private static string GetComment(string line)
	{
		return CommentRegex.Match(line).Groups["com"].Value;
	}

	private static string[] GetKey(string line)
	{
		Match match = KeyRegex.Match(line);
		return new string[2]
		{
			match.Groups["key"].Value,
			match.Groups["val"].Value
		};
	}

	private static string GetSection(string line)
	{
		return SectionRegex.Match(line).Groups["sec"].Value;
	}

	private static string[] GetVariable(string line)
	{
		Match match = VarRegex.Match(line);
		return new string[2]
		{
			match.Groups["key"].Value,
			match.Groups["val"].Value
		};
	}

	private static bool IsComment(string line)
	{
		return CommentRegex.IsMatch(line);
	}

	private static bool IsKey(string line)
	{
		return KeyRegex.IsMatch(line);
	}

	private static bool IsSection(string line)
	{
		return SectionRegex.IsMatch(line);
	}

	private static bool IsVariable(string line)
	{
		return VarRegex.IsMatch(line);
	}
}
public class IniSection
{
	private readonly IniComment _comments;

	private readonly List<IniKey> _keys;

	public IniKey this[string key] => CreateKey(key);

	public IniComment Comments => _comments;

	public List<IniKey> Keys => _keys;

	public string Section { get; set; }

	public IniSection(string section)
	{
		Section = section;
		_comments = new IniComment();
		_keys = new List<IniKey>();
	}

	public override string ToString()
	{
		return $"[{Section}]";
	}

	public IniKey CreateKey(string key)
	{
		IniKey key2 = GetKey(key);
		if (key2 != null)
		{
			return key2;
		}
		IniKey iniKey = new IniKey(key);
		_keys.Add(iniKey);
		return iniKey;
	}

	public IniKey GetKey(string key)
	{
		if (!HasKey(key))
		{
			return null;
		}
		return _keys.FirstOrDefault((IniKey iniKey) => iniKey.Key == key);
	}

	public bool HasKey(string key)
	{
		return _keys.Any((IniKey iniKey) => iniKey.Key == key);
	}

	public bool DeleteKey(string key)
	{
		if (!HasKey(key))
		{
			return false;
		}
		Keys.Remove(GetKey(key));
		return true;
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;
using SimpleJSON;
using UnityEngine;
using XUnity.AutoTranslator.Plugin.Core;
using XUnity.AutoTranslator.Plugin.Core.Constants;
using XUnity.AutoTranslator.Plugin.Core.Endpoints;
using XUnity.AutoTranslator.Plugin.Core.Endpoints.Http;
using XUnity.AutoTranslator.Plugin.Core.Extensions;
using XUnity.AutoTranslator.Plugin.Core.Utilities;
using XUnity.AutoTranslator.Plugin.Core.Web;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("BaiduTranslate")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BaiduTranslate")]
[assembly: AssemblyTitle("BaiduTranslate")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BaiduTranslate;

internal class BaiduTranslateEndpoint : HttpEndpoint
{
	private static readonly Dictionary<string, string> SupportedLanguages = new Dictionary<string, string>
	{
		{ "en", "en" },
		{ "ja", "jp" },
		{ "jp", "jp" },
		{ "zh", "zh" },
		{ "zh-Hans", "zh" },
		{ "zh-CN", "zh" },
		{ "zh-Hant", "cht" },
		{ "zh-TW", "cht" },
		{ "ko", "kor" },
		{ "kor", "kor" },
		{ "fra", "fra" },
		{ "fr", "fra" },
		{ "spa", "spa" },
		{ "es", "spa" },
		{ "ara", "ara" },
		{ "ar", "ara" },
		{ "bg", "bul" },
		{ "bul", "bul" },
		{ "et", "est" },
		{ "est", "est" },
		{ "da", "dan" },
		{ "dan", "dan" },
		{ "fi", "fin" },
		{ "fin", "fin" },
		{ "ro", "rom" },
		{ "rom", "rom" },
		{ "sl", "slo" },
		{ "slo", "slo" },
		{ "vi", "vie" },
		{ "vie", "vie" },
		{ "sv", "swe" },
		{ "swe", "swe" },
		{ "th", "th" },
		{ "ru", "ru" },
		{ "pt", "pt" },
		{ "de", "de" },
		{ "it", "it" },
		{ "el", "el" },
		{ "nl", "nl" },
		{ "pl", "pl" },
		{ "cs", "cs" },
		{ "hu", "hu" }
	};

	private static readonly string HttpServicePointTemplateUrl = "http://api.fanyi.baidu.com/api/trans/vip/translate?q={0}&from={1}&to={2}&appid={3}&salt={4}&sign={5}";

	private static readonly MD5 HashMD5 = MD5.Create();

	private string _appId;

	private string _appSecret;

	private float _delay;

	private float _lastRequestTimestamp;

	public override string Id => "BaiduTranslate";

	public override string FriendlyName => "Baidu Translator";

	private string FixLanguage(string lang)
	{
		if (SupportedLanguages.TryGetValue(lang, out var value))
		{
			return value;
		}
		return lang;
	}

	public override void Initialize(IInitializationContext context)
	{
		//IL_0063: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		_appId = context.GetOrCreateSetting<string>("Baidu", "BaiduAppId", "");
		_appSecret = context.GetOrCreateSetting<string>("Baidu", "BaiduAppSecret", "");
		_delay = context.GetOrCreateSetting<float>("Baidu", "DelaySeconds", 1f);
		if (string.IsNullOrEmpty(_appId))
		{
			throw new EndpointInitializationException("The BaiduTranslate endpoint requires an App Id which has not been provided.");
		}
		if (string.IsNullOrEmpty(_appSecret))
		{
			throw new EndpointInitializationException("The BaiduTranslate endpoint requires an App Secret which has not been provided.");
		}
		context.DisableCertificateChecksFor(new string[1] { "api.fanyi.baidu.com" });
		if (!SupportedLanguages.ContainsKey(context.SourceLanguage))
		{
			throw new EndpointInitializationException("The source language '" + context.SourceLanguage + "' is not supported.");
		}
		if (!SupportedLanguages.ContainsKey(context.DestinationLanguage))
		{
			throw new EndpointInitializationException("The destination language '" + context.DestinationLanguage + "' is not supported.");
		}
	}

	public override IEnumerator OnBeforeTranslate(IHttpTranslationContext context)
	{
		float num = Time.realtimeSinceStartup - _lastRequestTimestamp;
		if (num < _delay)
		{
			float num2 = _delay - num;
			IEnumerator waitForSecondsRealtime = Features.GetWaitForSecondsRealtime(num2);
			if (waitForSecondsRealtime != null)
			{
				yield return waitForSecondsRealtime;
			}
			else
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				float end = realtimeSinceStartup + num2;
				while (Time.realtimeSinceStartup < end)
				{
					yield return null;
				}
			}
		}
		_lastRequestTimestamp = Time.realtimeSinceStartup;
	}

	public override void OnCreateRequest(IHttpRequestCreationContext context)
	{
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Expected O, but got Unknown
		string text = DateTime.UtcNow.Millisecond.ToString();
		string text2 = CreateMD5(_appId + ((ITranslationContextBase)context).UntranslatedText + text + _appSecret);
		XUnityWebRequest val = new XUnityWebRequest(string.Format(HttpServicePointTemplateUrl, WwwHelper.EscapeUrl(((ITranslationContextBase)context).UntranslatedText), FixLanguage(((ITranslationContextBase)context).SourceLanguage), FixLanguage(((ITranslationContextBase)context).DestinationLanguage), _appId, text, text2));
		val.Headers[HttpRequestHeader.UserAgent] = (string.IsNullOrEmpty(AutoTranslatorSettings.UserAgent) ? UserAgents.Chrome_Win10_Latest : AutoTranslatorSettings.UserAgent);
		val.Headers[HttpRequestHeader.AcceptCharset] = "UTF-8";
		context.Complete(val);
	}

	public override void OnExtractTranslation(IHttpTranslationExtractionContext context)
	{
		//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)
		string data = ((IHttpResponseInspectionContext)context).Response.Data;
		if (data.StartsWith("{\"error"))
		{
			return;
		}
		JSONNode val = JSON.Parse(data);
		StringBuilder stringBuilder = new StringBuilder(data.Length);
		Enumerator enumerator = ((JSONNode)((JSONNode)val.AsObject)["trans_result"].AsArray).GetEnumerator();
		while (((Enumerator)(ref enumerator)).MoveNext())
		{
			string text = ((object)((JSONNode)JSONNode.op_Implicit(((Enumerator)(ref enumerator)).Current).AsObject)["dst"]).ToString();
			text = JsonHelper.Unescape(text.Substring(1, text.Length - 2));
			if (!StringBuilderExtensions.EndsWithWhitespaceOrNewline(stringBuilder))
			{
				stringBuilder.Append("\n");
			}
			stringBuilder.Append(text);
		}
		string text2 = stringBuilder.ToString();
		context.Complete(text2);
	}

	private static string CreateMD5(string input)
	{
		byte[] bytes = Encoding.UTF8.GetBytes(input);
		byte[] array = HashMD5.ComputeHash(bytes);
		StringBuilder stringBuilder = new StringBuilder();
		for (int i = 0; i < array.Length; i++)
		{
			stringBuilder.Append(array[i].ToString("X2"));
		}
		return stringBuilder.ToString().ToLower();
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using SimpleJSON;
using XUnity.AutoTranslator.Plugin.Core;
using XUnity.AutoTranslator.Plugin.Core.Constants;
using XUnity.AutoTranslator.Plugin.Core.Endpoints;
using XUnity.AutoTranslator.Plugin.Core.Endpoints.Http;
using XUnity.AutoTranslator.Plugin.Core.Shim;
using XUnity.AutoTranslator.Plugin.Core.Utilities;
using XUnity.AutoTranslator.Plugin.Core.Web;
using XUnity.Common.Logging;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("BingTranslate")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BingTranslate")]
[assembly: AssemblyTitle("BingTranslate")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BingTranslate;

internal class BingTranslateEndpoint : HttpEndpoint
{
	private static readonly HashSet<string> SupportedLanguages = new HashSet<string>
	{
		"auto-detect", "af", "ar", "bn", "bs", "bg", "yue", "ca", "zh-Hans", "zh-Hant",
		"hr", "cs", "da", "nl", "en", "et", "fj", "fil", "fi", "fr",
		"de", "el", "ht", "he", "hi", "mww", "hu", "is", "id", "it",
		"ja", "sw", "tlh", "tlh-Qaak", "ko", "lv", "lt", "mg", "ms", "mt",
		"nb", "fa", "pl", "pt", "otq", "ro", "ru", "sm", "sr-Cyrl", "sr-Latn",
		"sk", "sl", "es", "sv", "ty", "ta", "te", "th", "to", "tr",
		"uk", "ur", "vi", "cy", "yua"
	};

	private static readonly string HttpsServicePointTemplateUrl = "https://www.bing.com/ttranslatev3?isVertical=1&&IG={0}&IID={1}.{2}";

	private static readonly string HttpsServicePointTemplateUrlWithoutIG = "https://www.bing.com/ttranslatev3?isVertical=1";

	private static readonly string HttpsTranslateUserSite = "https://www.bing.com/translator";

	private static readonly string RequestTemplate = "&fromLang={1}&text={0}&to={2}";

	private static readonly Random RandomNumbers = new Random();

	private static readonly string[] Accepts = new string[1] { "*/*" };

	private static readonly string[] AcceptLanguages = new string[4] { null, "en-US,en;q=0.9", "en-US", "en" };

	private static readonly string[] Referers = new string[1] { "https://bing.com/translator" };

	private static readonly string[] Origins = new string[1] { "https://www.bing.com" };

	private static readonly string[] AcceptCharsets = new string[2]
	{
		null,
		Encoding.UTF8.WebName
	};

	private static readonly string[] ContentTypes = new string[1] { "application/x-www-form-urlencoded" };

	private static readonly string Accept = Accepts[RandomNumbers.Next(Accepts.Length)];

	private static readonly string AcceptLanguage = AcceptLanguages[RandomNumbers.Next(AcceptLanguages.Length)];

	private static readonly string Referer = Referers[RandomNumbers.Next(Referers.Length)];

	private static readonly string Origin = Origins[RandomNumbers.Next(Origins.Length)];

	private static readonly string AcceptCharset = AcceptCharsets[RandomNumbers.Next(AcceptCharsets.Length)];

	private static readonly string ContentType = ContentTypes[RandomNumbers.Next(ContentTypes.Length)];

	private CookieContainer _cookieContainer;

	private bool _hasSetup;

	private string _ig;

	private string _iid;

	private int _translationCount;

	private int _resetAfter = RandomNumbers.Next(75, 125);

	public override string Id => "BingTranslate";

	public override string FriendlyName => "Bing Translator";

	public BingTranslateEndpoint()
	{
		_cookieContainer = new CookieContainer();
	}

	private string FixLanguage(string lang)
	{
		switch (lang)
		{
		case "zh-CN":
		case "zh":
			return "zh-Hans";
		case "zh-TW":
			return "zh-Hant";
		case "auto":
			return "auto-detect";
		default:
			return lang;
		}
	}

	public override void Initialize(IInitializationContext context)
	{
		//IL_0041: 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)
		context.DisableCertificateChecksFor(new string[1] { "www.bing.com" });
		if (!SupportedLanguages.Contains(FixLanguage(context.SourceLanguage)))
		{
			throw new EndpointInitializationException("The source language '" + context.SourceLanguage + "' is not supported.");
		}
		if (!SupportedLanguages.Contains(FixLanguage(context.DestinationLanguage)))
		{
			throw new EndpointInitializationException("The destination language '" + context.DestinationLanguage + "' is not supported.");
		}
	}

	public override IEnumerator OnBeforeTranslate(IHttpTranslationContext context)
	{
		if (!_hasSetup || _translationCount % _resetAfter == 0)
		{
			_resetAfter = RandomNumbers.Next(75, 125);
			_translationCount = 0;
			_hasSetup = true;
			IEnumerator enumerator = SetupIGAndIID();
			while (enumerator.MoveNext())
			{
				yield return enumerator.Current;
			}
		}
	}

	public override void OnCreateRequest(IHttpRequestCreationContext context)
	{
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Expected O, but got Unknown
		_translationCount++;
		string text = null;
		text = ((_ig != null && _iid != null) ? string.Format(HttpsServicePointTemplateUrl, _ig, _iid, _translationCount) : HttpsServicePointTemplateUrlWithoutIG);
		string text2 = string.Format(RequestTemplate, Uri.EscapeDataString(((ITranslationContextBase)context).UntranslatedText), FixLanguage(((ITranslationContextBase)context).SourceLanguage), FixLanguage(((ITranslationContextBase)context).DestinationLanguage));
		XUnityWebRequest val = new XUnityWebRequest("POST", text, text2);
		val.Cookies = _cookieContainer;
		AddHeaders(val, isTranslationRequest: true);
		context.Complete(val);
	}

	public override void OnInspectResponse(IHttpResponseInspectionContext context)
	{
		InspectResponse(context.Response);
	}

	public override void OnExtractTranslation(IHttpTranslationExtractionContext context)
	{
		string text = ((object)((JSONNode)((JSONNode)JSON.Parse(((IHttpResponseInspectionContext)context).Response.Data).AsArray)[0]["translations"].AsArray)[0]["text"]).ToString();
		string text2 = JsonHelper.Unescape(text.Substring(1, text.Length - 2));
		context.Complete(text2);
	}

	private XUnityWebRequest CreateWebSiteRequest()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		XUnityWebRequest val = new XUnityWebRequest(HttpsTranslateUserSite);
		val.Cookies = _cookieContainer;
		AddHeaders(val, isTranslationRequest: false);
		return val;
	}

	private void AddHeaders(XUnityWebRequest request, bool isTranslationRequest)
	{
		request.Headers[HttpRequestHeader.UserAgent] = (string.IsNullOrEmpty(AutoTranslatorSettings.UserAgent) ? UserAgents.Chrome_Win10_Latest : AutoTranslatorSettings.UserAgent);
		if (AcceptLanguage != null)
		{
			request.Headers[HttpRequestHeader.AcceptLanguage] = AcceptLanguage;
		}
		if (Accept != null)
		{
			request.Headers[HttpRequestHeader.Accept] = Accept;
		}
		if (Referer != null && isTranslationRequest)
		{
			request.Headers[HttpRequestHeader.Referer] = Referer;
		}
		if (Origin != null && isTranslationRequest)
		{
			request.Headers["Origin"] = Origin;
		}
		if (AcceptCharset != null)
		{
			request.Headers[HttpRequestHeader.AcceptCharset] = AcceptCharset;
		}
		if (ContentType != null && isTranslationRequest)
		{
			request.Headers[HttpRequestHeader.ContentType] = ContentType;
		}
	}

	private void InspectResponse(XUnityWebResponse response)
	{
		CookieCollection newCookies = response.NewCookies;
		_cookieContainer.Add(newCookies);
	}

	public IEnumerator SetupIGAndIID()
	{
		_cookieContainer = new CookieContainer();
		XUnityWebResponse response;
		try
		{
			XUnityWebClient val = new XUnityWebClient();
			XUnityWebRequest val2 = CreateWebSiteRequest();
			response = val.Send(val2);
		}
		catch (Exception ex)
		{
			XuaLogger.AutoTranslator.Warn(ex, "An error occurred while setting up BingTranslate IG. Proceeding without...");
			yield break;
		}
		IEnumerator iterator = ((CustomYieldInstructionShim)response).GetSupportedEnumerator();
		while (iterator.MoveNext())
		{
			yield return iterator.Current;
		}
		if (((CustomYieldInstructionShim)response).IsTimedOut)
		{
			XuaLogger.AutoTranslator.Warn("A timeout error occurred while setting up BingTranslate IG. Proceeding without...");
			yield break;
		}
		if (response.Error != null)
		{
			XuaLogger.AutoTranslator.Warn(response.Error, "An error occurred while setting up BingTranslate IG. Proceeding without...");
			yield break;
		}
		if (response.Data == null)
		{
			XuaLogger.AutoTranslator.Warn((Exception)null, "An error occurred while setting up BingTranslate IG. Proceeding without...");
			yield break;
		}
		InspectResponse(response);
		try
		{
			string data = response.Data;
			_ig = Lookup("\",IG:\"", data);
			_iid = Lookup("data-iid=\"", data);
			if (_ig == null || _iid == null)
			{
				XuaLogger.AutoTranslator.Warn("An error occurred while setting up BingTranslate IG/IID. Proceeding without...");
			}
		}
		catch (Exception ex2)
		{
			XuaLogger.AutoTranslator.Warn(ex2, "An error occurred while setting up BingTranslate IG. Proceeding without...");
		}
	}

	private string Lookup(string lookFor, string html)
	{
		int num = html.IndexOf(lookFor);
		if (num > -1)
		{
			int num2 = num + lookFor.Length;
			int num3 = html.IndexOf("\"", num2);
			if (num2 > -1 && num3 > -1)
			{
				return html.Substring(num2, num3 - num2);
			}
		}
		return null;
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using SimpleJSON;
using XUnity.AutoTranslator.Plugin.Core.Endpoints;
using XUnity.AutoTranslator.Plugin.Core.Endpoints.Http;
using XUnity.AutoTranslator.Plugin.Core.Utilities;
using XUnity.AutoTranslator.Plugin.Core.Web;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("BingTranslateLegitimate")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BingTranslateLegitimate")]
[assembly: AssemblyTitle("BingTranslateLegitimate")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BingTranslateLegitimate;

public class BingTranslateLegitimateEndpoint : HttpEndpoint
{
	private static readonly HashSet<string> SupportedLanguages = new HashSet<string>
	{
		"af", "ar", "bn", "bs", "bg", "yue", "ca", "zh-Hans", "zh-Hant", "hr",
		"cs", "da", "nl", "en", "et", "fj", "fil", "fi", "fr", "de",
		"el", "ht", "he", "hi", "mww", "hu", "is", "id", "it", "ja",
		"sw", "tlh", "tlh-Qaak", "ko", "lv", "lt", "mg", "ms", "mt", "nb",
		"fa", "pl", "pt", "otq", "ro", "ru", "sm", "sr-Cyrl", "sr-Latn", "sk",
		"sl", "es", "sv", "ty", "ta", "te", "th", "to", "tr", "uk",
		"ur", "vi", "cy", "yua"
	};

	private static readonly string HttpsServicePointTemplateUrl = "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0&from={0}&to={1}";

	private static readonly Random RandomNumbers = new Random();

	private static readonly string[] Accepts = new string[1] { "application/json" };

	private static readonly string[] ContentTypes = new string[1] { "application/json" };

	private static readonly string Accept = Accepts[RandomNumbers.Next(Accepts.Length)];

	private static readonly string ContentType = ContentTypes[RandomNumbers.Next(ContentTypes.Length)];

	private string _key;

	public override string Id => "BingTranslateLegitimate";

	public override string FriendlyName => "Bing Translator (Authenticated)";

	public override int MaxTranslationsPerRequest => 10;

	private string FixLanguage(string lang)
	{
		switch (lang)
		{
		case "zh-CN":
		case "zh":
			return "zh-Hans";
		case "zh-TW":
			return "zh-Hant";
		default:
			return lang;
		}
	}

	public override void Initialize(IInitializationContext context)
	{
		//IL_002d: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		_key = context.GetOrCreateSetting<string>("BingLegitimate", "OcpApimSubscriptionKey", "");
		if (string.IsNullOrEmpty(_key))
		{
			throw new EndpointInitializationException("The BingTranslateLegitimate endpoint requires an API key which has not been provided.");
		}
		context.DisableCertificateChecksFor(new string[1] { "api.cognitive.microsofttranslator.com" });
		if (!SupportedLanguages.Contains(FixLanguage(context.SourceLanguage)))
		{
			throw new EndpointInitializationException("The source language '" + context.SourceLanguage + "' is not supported.");
		}
		if (!SupportedLanguages.Contains(FixLanguage(context.DestinationLanguage)))
		{
			throw new EndpointInitializationException("The destination language '" + context.DestinationLanguage + "' is not supported.");
		}
	}

	public override void OnCreateRequest(IHttpRequestCreationContext context)
	{
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Expected O, but got Unknown
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.Append("[");
		for (int i = 0; i < ((ITranslationContextBase)context).UntranslatedTexts.Length; i++)
		{
			string value = JsonHelper.Escape(((ITranslationContextBase)context).UntranslatedTexts[i]);
			stringBuilder.Append("{\"Text\":\"");
			stringBuilder.Append(value);
			stringBuilder.Append("\"}");
			if (((ITranslationContextBase)context).UntranslatedTexts.Length - 1 != i)
			{
				stringBuilder.Append(",");
			}
		}
		stringBuilder.Append("]");
		XUnityWebRequest val = new XUnityWebRequest("POST", string.Format(HttpsServicePointTemplateUrl, FixLanguage(((ITranslationContextBase)context).SourceLanguage), FixLanguage(((ITranslationContextBase)context).DestinationLanguage)), stringBuilder.ToString());
		if (Accept != null)
		{
			val.Headers[HttpRequestHeader.Accept] = Accept;
		}
		if (ContentType != null)
		{
			val.Headers[HttpRequestHeader.ContentType] = ContentType;
		}
		val.Headers["Ocp-Apim-Subscription-Key"] = _key;
		context.Complete(val);
	}

	public override void OnExtractTranslation(IHttpTranslationExtractionContext context)
	{
		JSONArray asArray = JSON.Parse(((IHttpResponseInspectionContext)context).Response.Data).AsArray;
		List<string> list = new List<string>();
		for (int i = 0; i < ((JSONNode)asArray).Count; i++)
		{
			JSONNode obj = ((JSONNode)((JSONNode)asArray)[i].AsObject)["translations"];
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				JSONNode obj3 = ((JSONNode)obj.AsArray)[0];
				obj2 = ((obj3 != null) ? ((object)((JSONNode)obj3.AsObject)["text"])?.ToString() : null);
			}
			string text = (string)obj2;
			string item = JsonHelper.Unescape(text.Substring(1, text.Length - 2));
			list.Add(item);
		}
		context.Complete(list.ToArray());
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using XUnity.AutoTranslator.Plugin.Core.Endpoints;
using XUnity.AutoTranslator.Plugin.Core.Endpoints.Http;
using XUnity.AutoTranslator.Plugin.Core.Web;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("CustomTranslate")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CustomTranslate")]
[assembly: AssemblyTitle("CustomTranslate")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace CustomTranslate;

internal class CustomTranslateEndpoint : HttpEndpoint
{
	private static readonly string ServicePointTemplateUrl = "{0}?from={1}&to={2}&text={3}";

	private string _endpoint;

	private string _friendlyName;

	public override string Id => "CustomTranslate";

	public override string FriendlyName => _friendlyName;

	public CustomTranslateEndpoint()
	{
		_friendlyName = "Custom";
	}

	public override void Initialize(IInitializationContext context)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		_endpoint = context.GetOrCreateSetting<string>("Custom", "Url", "");
		if (string.IsNullOrEmpty(_endpoint))
		{
			throw new EndpointInitializationException("The custom endpoint requires a url which has not been provided.");
		}
		Uri uri = new Uri(_endpoint);
		context.DisableCertificateChecksFor(new string[1] { uri.Host });
		_friendlyName = _friendlyName + " (" + uri.Host + ")";
	}

	public override void OnCreateRequest(IHttpRequestCreationContext context)
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Expected O, but got Unknown
		XUnityWebRequest val = new XUnityWebRequest(string.Format(ServicePointTemplateUrl, _endpoint, ((ITranslationContextBase)context).SourceLanguage, ((ITranslationContextBase)context).DestinationLanguage, Uri.EscapeDataString(((ITranslationContextBase)context).UntranslatedText)));
		context.Complete(val);
	}

	public override void OnExtractTranslation(IHttpTranslationExtractionContext context)
	{
		context.Complete(((IHttpResponseInspectionContext)context).Response.Data);
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using XUnity.AutoTranslator.Plugin.Core.Endpoints;
using XUnity.AutoTranslator.Plugin.Core.Endpoints.ExtProtocol;
using XUnity.Common.Logging;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("DeepLTranslate")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DeepLTranslate")]
[assembly: AssemblyTitle("DeepLTranslate")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace DeepLTranslate;

public class DeepLTranslate : ExtProtocolEndpoint
{
	private const float MinimumMinDelaySeconds = 1f;

	private const float MinimumMaxDelaySeconds = 3f;

	private static readonly HashSet<string> SupportedLanguages = new HashSet<string>
	{
		"bg", "cs", "da", "de", "el", "en", "es", "et", "fi", "fr",
		"hu", "it", "ja", "lt", "lv", "nl", "pl", "pt", "ro", "ru",
		"sk", "sl", "sv", "zh"
	};

	public override string Id => "DeepLTranslate";

	public override string FriendlyName => "DeepL Translator";

	public override int MaxConcurrency => 1;

	public override int MaxTranslationsPerRequest => 25;

	protected override string ConfigurationSectionName => "DeepL";

	private string FixLanguage(string lang)
	{
		if (lang == "zh-Hans" || lang == "zh-CN")
		{
			return "zh";
		}
		return lang;
	}

	public override void Initialize(IInitializationContext context)
	{
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		((ExtProtocolEndpoint)this).Initialize(context);
		((ExtProtocolEndpoint)this).MinDelay = context.GetOrCreateSetting<float>("DeepL", "MinDelaySeconds", 2f);
		if (((ExtProtocolEndpoint)this).MinDelay < 1f)
		{
			XuaLogger.AutoTranslator.Warn($"[DeepL] Cannot set MinDelaySeconds below {1f} second(s). Setting MinDelaySeconds={1f}");
			context.SetSetting<float>("DeepL", "MinDelaySeconds", 1f);
		}
		((ExtProtocolEndpoint)this).MaxDelay = context.GetOrCreateSetting<float>("DeepL", "MaxDelaySeconds", 7f);
		if (((ExtProtocolEndpoint)this).MaxDelay < 3f)
		{
			XuaLogger.AutoTranslator.Warn($"[DeepL] Cannot set MaxDelaySeconds below {3f} second(s). Setting MaxDelaySeconds={3f}");
			context.SetSetting<float>("DeepL", "MaxDelaySeconds", 3f);
		}
		if (!SupportedLanguages.Contains(FixLanguage(context.SourceLanguage)))
		{
			throw new EndpointInitializationException("The source language '" + context.SourceLanguage + "' is not supported.");
		}
		if (!SupportedLanguages.Contains(FixLanguage(context.DestinationLanguage)))
		{
			throw new EndpointInitializationException("The destination language '" + context.DestinationLanguage + "' is not supported.");
		}
		((ExtProtocolEndpoint)this).Arguments = Convert.ToBase64String(Encoding.UTF8.GetBytes("DeepLTranslate.ExtProtocol.ExtDeepLTranslate, DeepLTranslate.ExtProtocol"), Base64FormattingOptions.None);
	}
}
public class DeepLTranslateLegitimate : ExtProtocolEndpoint
{
	private static readonly HashSet<string> SupportedLanguages = new HashSet<string>
	{
		"bg", "cs", "da", "de", "el", "en", "es", "et", "fi", "fr",
		"hu", "it", "ja", "lt", "lv", "nl", "pl", "pt", "ro", "ru",
		"sk", "sl", "sv", "zh"
	};

	public override string Id => "DeepLTranslateLegitimate";

	public override string FriendlyName => "DeepL Translator (Authenticated)";

	public override int MaxConcurrency => 1;

	public override int MaxTranslationsPerRequest => 25;

	protected override string ConfigurationSectionName => "DeepLLegitimate";

	private string FixLanguage(string lang)
	{
		if (lang == "zh-Hans" || lang == "zh-CN")
		{
			return "zh";
		}
		return lang;
	}

	public override void Initialize(IInitializationContext context)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		((ExtProtocolEndpoint)this).Initialize(context);
		if (!SupportedLanguages.Contains(FixLanguage(context.SourceLanguage)))
		{
			throw new EndpointInitializationException("The source language '" + context.SourceLanguage + "' is not supported.");
		}
		if (!SupportedLanguages.Contains(FixLanguage(context.DestinationLanguage)))
		{
			throw new EndpointInitializationException("The destination language '" + context.DestinationLanguage + "' is not supported.");
		}
		string orCreateSetting = context.GetOrCreateSetting<string>(((ExtProtocolEndpoint)this).ConfigurationSectionName, "ApiKey", "");
		bool orCreateSetting2 = context.GetOrCreateSetting<bool>(((ExtProtocolEndpoint)this).ConfigurationSectionName, "Free", false);
		if (string.IsNullOrEmpty(orCreateSetting))
		{
			throw new EndpointInitializationException("The endpoint requires an API key which has not been provided.");
		}
		((ExtProtocolEndpoint)this).ConfigForExternalProcess = string.Join("\n", orCreateSetting, orCreateSetting2.ToString());
		((ExtProtocolEndpoint)this).Arguments = Convert.ToBase64String(Encoding.UTF8.GetBytes("DeepLTranslate.ExtProtocol.ExtDeepLTranslateLegitimate, DeepLTranslate.ExtProtocol"), Base64FormattingOptions.None);
	}
}