using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.WebSockets;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using AngleSharp.Dom;
using AngleSharp.Html.Parser;
using Esprima;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppScheduleOne;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.UI;
using Il2CppScheduleOne.UI.Input;
using Il2CppScheduleOne.UI.Phone;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using Jint;
using Jint.Native;
using Jint.Native.Function;
using Jint.Native.Object;
using Jint.Runtime;
using Jint.Runtime.Descriptors;
using Jint.Runtime.Interop;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Sideload;
using Sideload.Bundle;
using Sideload.Config;
using Sideload.Css;
using Sideload.Devtools.Cdp;
using Sideload.Dom;
using Sideload.Host;
using Sideload.Input;
using Sideload.Layout;
using Sideload.Model;
using Sideload.Net;
using Sideload.Paint;
using Sideload.Phone;
using Sideload.Script;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Core), "Sideload", "1.0.1", "DooDesch", "https://github.com/DooDesch-Mods/ScheduleOne-Sideload")]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("DooDesch")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © DooDesch")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+6974c626e698673232f2fb3ea70da64862741945")]
[assembly: AssemblyProduct("Sideload")]
[assembly: AssemblyTitle("Sideload")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Sideload
{
	public class Core : MelonMod
	{
		internal static Instance Log;

		public override void OnInitializeMelon()
		{
			Log = ((MelonBase)this).LoggerInstance;
			HostAllowlist.Log = delegate(string line)
			{
				Log.Warning(line);
			};
			PreloadRuntimeDependency("AngleSharp.dll");
			PreloadRuntimeDependency("Esprima.dll");
			PreloadRuntimeDependency("Jint.dll");
			try
			{
				((MelonBase)this).HarmonyInstance.PatchAll();
				Log.Msg("[Sideload] patches applied.");
			}
			catch (Exception ex)
			{
				Log.Error("[Sideload] PatchAll failed - no app will reach the phone: " + ex);
			}
			Preferences.Initialize();
			if (Preferences.DevTools)
			{
				CdpServer.Start(Preferences.DevToolsPort);
			}
		}

		public override void OnUpdate()
		{
			WebView.TickAll(Time.deltaTime);
			TurnInput.Tick();
			CdpServer.Pump();
		}

		public override void OnDeinitializeMelon()
		{
			CdpServer.Stop();
			ChromeLauncher.Close();
		}

		private static void PreloadRuntimeDependency(string fileName)
		{
			try
			{
				string text = Path.Combine(MelonEnvironment.UserLibsDirectory, fileName);
				if (!File.Exists(text))
				{
					string text2 = Path.Combine(Path.GetDirectoryName(typeof(Core).Assembly.Location) ?? MelonEnvironment.ModsDirectory, fileName);
					if (!File.Exists(text2))
					{
						Log.Warning("[Sideload] runtime dependency not found in UserLibs or next to the mod: " + fileName);
						return;
					}
					text = text2;
				}
				AssemblyName name = Assembly.LoadFrom(text).GetName();
				Log.Msg($"[Sideload] preloaded {name.Name} {name.Version}");
			}
			catch (Exception ex)
			{
				Log.Warning("[Sideload] preloading " + fileName + " failed: " + ex.Message);
			}
		}
	}
	internal sealed class AppRegistration
	{
		internal string Id;

		internal string Title;

		internal string IconLabel;

		internal string BundlePrefix;

		internal Assembly HostAssembly;

		internal AppBundle Bundle;

		internal Sprite IconSprite;

		internal bool Portrait;

		internal bool DeclaredPortrait;

		internal bool CanTurn;

		internal int Badge;

		internal Action OrientationChanged;

		internal bool Supports(bool portrait)
		{
			if (!CanTurn)
			{
				return DeclaredPortrait == portrait;
			}
			return true;
		}
	}
	internal static class Registry
	{
		private static readonly List<AppRegistration> _apps = new List<AppRegistration>();

		internal static IReadOnlyList<AppRegistration> Apps => _apps;

		internal static void RegisterApp(string id, string title, string iconLabel, string bundlePrefix, Assembly host)
		{
			if (string.IsNullOrWhiteSpace(id) || host == null)
			{
				return;
			}
			AppRegistration appRegistration = new AppRegistration
			{
				Id = id.Trim(),
				Title = (string.IsNullOrWhiteSpace(title) ? id : title),
				IconLabel = ((!string.IsNullOrWhiteSpace(iconLabel)) ? iconLabel : (string.IsNullOrWhiteSpace(title) ? id : title)),
				BundlePrefix = (bundlePrefix ?? ""),
				HostAssembly = host
			};
			appRegistration.Bundle = new AppBundle(appRegistration.Id, appRegistration.BundlePrefix, host);
			for (int i = 0; i < _apps.Count; i++)
			{
				if (string.Equals(_apps[i].Id, appRegistration.Id, StringComparison.OrdinalIgnoreCase))
				{
					_apps[i] = appRegistration;
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] app '" + appRegistration.Id + "' registered twice; the later registration wins.");
					}
					return;
				}
			}
			_apps.Add(appRegistration);
			Instance log2 = Core.Log;
			if (log2 != null)
			{
				log2.Msg($"[Sideload] app registered: {appRegistration.Id} ('{appRegistration.Title}') from {host.GetName().Name}");
			}
		}

		internal static void DeclareOrientations(string appId, string orientations)
		{
			AppRegistration appRegistration = Find(appId);
			if (appRegistration == null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] orientation: no app '" + appId + "'.");
				}
				return;
			}
			OrientationSet orientationSet = OrientationSet.Parse(orientations);
			foreach (string item in orientationSet.Ignored)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning($"[Sideload] '{appId}' declared orientation '{item}', which is neither 'portrait' " + "nor 'landscape' - ignored.");
				}
			}
			if (orientationSet.Declared)
			{
				appRegistration.DeclaredPortrait = orientationSet.Portrait;
				appRegistration.CanTurn = orientationSet.CanTurn;
				appRegistration.Portrait = orientationSet.Portrait;
			}
		}

		internal static void SetOrientation(string appId, string orientation)
		{
			AppRegistration appRegistration = Find(appId);
			if (appRegistration == null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] setOrientation: no app '" + appId + "'.");
				}
				return;
			}
			bool flag = string.Equals((orientation ?? "").Trim(), "portrait", StringComparison.OrdinalIgnoreCase);
			if (appRegistration.Portrait == flag)
			{
				return;
			}
			if (!appRegistration.Supports(flag))
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning($"[Sideload] '{appRegistration.Id}' was asked for {(flag ? "portrait" : "landscape")} but " + "only declared the other one - ignored. Declare both to allow turning: Apps.Register(...).Orientation(\"landscape\", \"portrait\").");
				}
			}
			else
			{
				appRegistration.Portrait = flag;
				appRegistration.OrientationChanged?.Invoke();
			}
		}

		internal static void SetBadge(string appId, int count)
		{
			AppRegistration appRegistration = Find(appId);
			if (appRegistration == null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] badge: no app '" + appId + "'.");
				}
			}
			else
			{
				appRegistration.Badge = Math.Max(0, count);
				LiveHost(appId)?.SetBadge(appRegistration.Badge);
			}
		}

		internal static void Notify(string appId, string title, string subtitle)
		{
			LiveHost(appId)?.Notify(title, subtitle);
		}

		internal static bool IsOnScreen(string appId)
		{
			return LiveHost(appId)?.IsShowing ?? false;
		}

		private static PhoneAppHost LiveHost(string appId)
		{
			IReadOnlyList<PhoneAppHost> hosts = HomeScreenPatch.Hosts;
			for (int i = 0; i < hosts.Count; i++)
			{
				if (string.Equals(hosts[i].Id, appId, StringComparison.OrdinalIgnoreCase) && hosts[i].IsAlive)
				{
					return hosts[i];
				}
			}
			return null;
		}

		internal static AppRegistration Find(string appId)
		{
			if (string.IsNullOrWhiteSpace(appId))
			{
				return null;
			}
			for (int i = 0; i < _apps.Count; i++)
			{
				if (string.Equals(_apps[i].Id, appId, StringComparison.OrdinalIgnoreCase))
				{
					return _apps[i];
				}
			}
			return null;
		}
	}
}
namespace Sideload.Script
{
	public sealed class Bridge
	{
		public sealed class JsStorage
		{
			private readonly string _path;

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

			private bool _loaded;

			internal JsStorage(string appId)
			{
				string path = Path.Combine(MelonEnvironment.UserDataDirectory, "Sideload");
				_path = Path.Combine(path, Sanitise(appId) + ".json");
			}

			public string Get(string key, string fallback = "")
			{
				Load();
				if (key == null || !_values.TryGetValue(key, out var value))
				{
					return fallback;
				}
				return value;
			}

			public void Set(string key, string value)
			{
				if (!string.IsNullOrEmpty(key))
				{
					Load();
					_values[key] = value ?? "";
					Save();
				}
			}

			public void Remove(string key)
			{
				if (!string.IsNullOrEmpty(key))
				{
					Load();
					if (_values.Remove(key))
					{
						Save();
					}
				}
			}

			public void Clear()
			{
				Load();
				_values.Clear();
				Save();
			}

			private void Load()
			{
				if (_loaded)
				{
					return;
				}
				_loaded = true;
				try
				{
					if (!File.Exists(_path))
					{
						return;
					}
					foreach (KeyValuePair<string, string> item in MiniJson.ParseObject(File.ReadAllText(_path)))
					{
						_values[item.Key] = item.Value;
					}
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] storage read failed: " + ex.Message);
					}
				}
			}

			private void Save()
			{
				try
				{
					Directory.CreateDirectory(Path.GetDirectoryName(_path));
					File.WriteAllText(_path, MiniJson.WriteObject(_values));
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] storage write failed: " + ex.Message);
					}
				}
			}

			private static string Sanitise(string id)
			{
				StringBuilder stringBuilder = new StringBuilder(id?.Length ?? 0);
				string text = id ?? "app";
				foreach (char c in text)
				{
					stringBuilder.Append((char.IsLetterOrDigit(c) || c == '-' || c == '_') ? c : '-');
				}
				if (stringBuilder.Length != 0)
				{
					return stringBuilder.ToString();
				}
				return "app";
			}
		}

		private static readonly Dictionary<string, Func<string, string, string>> _handlers = new Dictionary<string, Func<string, string, string>>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, List<Bridge>> _subscribers = new Dictionary<string, List<Bridge>>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, List<JsValue>> _listeners = new Dictionary<string, List<JsValue>>(StringComparer.OrdinalIgnoreCase);

		private readonly ScriptHost _host;

		private readonly string _appId;

		public JsStorage Storage { get; }

		public string AppId => _appId;

		public string Orientation
		{
			get
			{
				AppRegistration appRegistration = Registry.Find(_appId);
				if (appRegistration == null || !appRegistration.Portrait)
				{
					return "landscape";
				}
				return "portrait";
			}
		}

		internal Bridge(ScriptHost host, string appId)
		{
			_host = host;
			_appId = appId;
			Storage = new JsStorage(appId);
		}

		internal static void Handle(string appId, string name, Func<string, string, string> handler)
		{
			if (!string.IsNullOrWhiteSpace(name) && handler != null)
			{
				_handlers[Key(appId, name)] = handler;
			}
		}

		internal static void Emit(string appId, string name, string payload)
		{
			if (string.IsNullOrWhiteSpace(name) || !_subscribers.TryGetValue(name, out var value))
			{
				return;
			}
			Bridge[] array = value.ToArray();
			foreach (Bridge bridge in array)
			{
				if (appId == null || string.Equals(bridge._appId, appId, StringComparison.OrdinalIgnoreCase))
				{
					bridge.Deliver(name, payload ?? "");
				}
			}
		}

		private static string Key(string appId, string name)
		{
			return appId + "\0" + name.Trim();
		}

		public string Call(string name, string argument = "")
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return "";
			}
			if (!_handlers.TryGetValue(Key(_appId, name), out var value) && !_handlers.TryGetValue(Key(null, name), out value))
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning($"[Sideload] {_appId}: s1.call('{name}') has no handler.");
				}
				return "";
			}
			try
			{
				return value(_appId, argument ?? "") ?? "";
			}
			catch (Exception ex)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Error($"[Sideload] {_appId}: s1.call('{name}') threw: {ex.Message}");
				}
				return "";
			}
		}

		public void On(string name, JsValue handler)
		{
			if (!string.IsNullOrWhiteSpace(name) && !(handler == (JsValue)null) && JsValueExtensions.IsObject(handler))
			{
				if (!_listeners.TryGetValue(name, out var value))
				{
					value = (_listeners[name] = new List<JsValue>());
				}
				value.Add(handler);
				if (!_subscribers.TryGetValue(name, out var value2))
				{
					value2 = (_subscribers[name] = new List<Bridge>());
				}
				if (!value2.Contains(this))
				{
					value2.Add(this);
				}
			}
		}

		public void Log(params object[] args)
		{
			Instance log = Core.Log;
			if (log != null)
			{
				log.Msg("[" + _appId + "] " + string.Join(" ", Array.ConvertAll(args ?? Array.Empty<object>(), (object a) => a?.ToString() ?? "null")));
			}
		}

		public void SetOrientation(string orientation)
		{
			Registry.SetOrientation(_appId, orientation);
		}

		internal void Dispose()
		{
			foreach (KeyValuePair<string, List<Bridge>> subscriber in _subscribers)
			{
				subscriber.Value.Remove(this);
			}
			_listeners.Clear();
		}

		private void Deliver(string name, string payload)
		{
			if (!_listeners.TryGetValue(name, out var value))
			{
				return;
			}
			JsValue[] array = value.ToArray();
			foreach (JsValue val in array)
			{
				try
				{
					_host.Engine.Invoke(val, new object[1] { payload });
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Error($"[Sideload] {_appId}: s1.on('{name}') handler failed: {ex.Message}");
					}
				}
			}
		}
	}
	public sealed class JsElement
	{
		private readonly ScriptHost _host;

		internal IElement Native { get; }

		public string TagName => Native.LocalName;

		public string Id
		{
			get
			{
				return Native.Id ?? "";
			}
			set
			{
				if (Set(Native.Id, value))
				{
					Native.Id = value;
					_host.MarkDirty();
				}
			}
		}

		public string ClassName
		{
			get
			{
				return Native.ClassName ?? "";
			}
			set
			{
				if (Set(Native.ClassName, value))
				{
					Native.ClassName = value;
					_host.MarkDirty();
				}
			}
		}

		public JsClassList ClassList => new JsClassList(_host, Native);

		public JsStyle Style => new JsStyle(_host, Native);

		public string TextContent
		{
			get
			{
				return ((INode)Native).TextContent ?? "";
			}
			set
			{
				if (Set(((INode)Native).TextContent, value))
				{
					((INode)Native).TextContent = value;
					_host.MarkDirty();
				}
			}
		}

		public string InnerHTML
		{
			get
			{
				return Native.InnerHtml ?? "";
			}
			set
			{
				if (!Set(Native.InnerHtml, value))
				{
					return;
				}
				foreach (IElement item in (IEnumerable<IElement>)((IParentNode)Native).Children)
				{
					_host.Forget(item);
				}
				Native.InnerHtml = value;
				_host.MarkDirty();
			}
		}

		public string Value
		{
			get
			{
				return Native.GetAttribute("value") ?? "";
			}
			set
			{
				if (Set(Native.GetAttribute("value"), value))
				{
					Native.SetAttribute("value", value ?? "");
					_host.MarkDirty();
				}
			}
		}

		public bool Disabled
		{
			get
			{
				return Native.HasAttribute("disabled");
			}
			set
			{
				if (value)
				{
					Native.SetAttribute("disabled", "");
				}
				else
				{
					Native.RemoveAttribute("disabled");
				}
				_host.MarkDirty();
			}
		}

		public JsElement ParentElement => _host.Wrap(((INode)Native).ParentElement);

		public JsValue Children
		{
			get
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				List<JsValue> list = new List<JsValue>();
				foreach (IElement item in (IEnumerable<IElement>)((IParentNode)Native).Children)
				{
					list.Add(JsValue.FromObject(_host.Engine, (object)_host.Wrap(item)));
				}
				return (JsValue)new JsArray(_host.Engine, list.ToArray());
			}
		}

		internal JsElement(ScriptHost host, IElement element)
		{
			_host = host;
			Native = element;
		}

		public string GetAttribute(string name)
		{
			return Native.GetAttribute(name);
		}

		public void SetAttribute(string name, string value)
		{
			if (Set(Native.GetAttribute(name), value))
			{
				Native.SetAttribute(name, value ?? "");
				_host.MarkDirty();
			}
		}

		public void RemoveAttribute(string name)
		{
			if (Native.HasAttribute(name))
			{
				Native.RemoveAttribute(name);
				_host.MarkDirty();
			}
		}

		public bool HasAttribute(string name)
		{
			return Native.HasAttribute(name);
		}

		public JsElement QuerySelector(string selector)
		{
			return _host.Wrap(((IParentNode)Native).QuerySelector(selector));
		}

		public JsValue QuerySelectorAll(string selector)
		{
			return _host.WrapAll((IEnumerable<IElement>)((IParentNode)Native).QuerySelectorAll(selector));
		}

		public JsElement AppendChild(JsElement child)
		{
			if (child != null)
			{
				((INode)Native).AppendChild((INode)(object)child.Native);
				_host.MarkDirty();
			}
			return child;
		}

		public JsElement RemoveChild(JsElement child)
		{
			if (child == null)
			{
				return null;
			}
			((INode)Native).RemoveChild((INode)(object)child.Native);
			_host.Forget(child.Native);
			_host.MarkDirty();
			return child;
		}

		public JsElement InsertBefore(JsElement child, JsElement reference)
		{
			if (child == null)
			{
				return null;
			}
			((INode)Native).InsertBefore((INode)(object)child.Native, (INode)(object)reference?.Native);
			_host.MarkDirty();
			return child;
		}

		public void Remove()
		{
			((IChildNode)Native).Remove();
			_host.Forget(Native);
			_host.MarkDirty();
		}

		public void ReplaceChildren()
		{
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)Native).Children)
			{
				_host.Forget(item);
			}
			Native.InnerHtml = "";
			_host.MarkDirty();
		}

		public void AddEventListener(string type, JsValue handler)
		{
			_host.AddListener(Native, type, handler);
		}

		public void RemoveEventListener(string type, JsValue handler)
		{
			_host.RemoveListener(Native, type, handler);
		}

		public void Click()
		{
			_host.Dispatch(Native, "click");
		}

		public void Focus()
		{
			_host.RequestFocus(Native);
		}

		public void ScrollToEnd()
		{
			_host.RequestScrollToEnd(Native);
		}

		public override string ToString()
		{
			return "<" + Native.LocalName + ">";
		}

		private static bool Set(string current, string next)
		{
			return !string.Equals(current ?? "", next ?? "", StringComparison.Ordinal);
		}
	}
	public sealed class JsClassList
	{
		private readonly ScriptHost _host;

		private readonly IElement _element;

		public int Length => _element.ClassList.Length;

		internal JsClassList(ScriptHost host, IElement element)
		{
			_host = host;
			_element = element;
		}

		public bool Contains(string name)
		{
			return _element.ClassList.Contains(name);
		}

		public void Add(string name)
		{
			_element.ClassList.Add(new string[1] { name });
			_host.MarkDirty();
		}

		public void Remove(string name)
		{
			_element.ClassList.Remove(new string[1] { name });
			_host.MarkDirty();
		}

		public bool Toggle(string name)
		{
			bool flag = !_element.ClassList.Contains(name);
			if (flag)
			{
				_element.ClassList.Add(new string[1] { name });
			}
			else
			{
				_element.ClassList.Remove(new string[1] { name });
			}
			_host.MarkDirty();
			return flag;
		}
	}
	public sealed class JsStyle : ObjectInstance
	{
		private const string Attribute = "style";

		private readonly ScriptHost _host;

		private readonly IElement _element;

		internal JsStyle(ScriptHost host, IElement element)
			: base(host.Engine)
		{
			_host = host;
			_element = element;
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			string text = (JsValueExtensions.IsString(property) ? JsValueExtensions.AsString(property) : null);
			if (text == null)
			{
				return JsValue.Undefined;
			}
			if (text == "cssText")
			{
				return JsValue.op_Implicit(_element.GetAttribute("style") ?? "");
			}
			string text2 = Read(Kebab(text));
			if (text2 == null)
			{
				return JsValue.op_Implicit("");
			}
			return JsValue.op_Implicit(text2);
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			if (!JsValueExtensions.IsString(property))
			{
				return false;
			}
			string text = JsValueExtensions.AsString(property);
			string text2 = ((JsValueExtensions.IsNull(value) || JsValueExtensions.IsUndefined(value)) ? "" : ((object)value).ToString());
			string text3 = ((text == "cssText") ? null : Kebab(text));
			if (string.Equals(((text3 == null) ? _element.GetAttribute("style") : Read(text3)) ?? "", text2, StringComparison.Ordinal))
			{
				return true;
			}
			Write(text3, text2);
			_host.MarkDirty();
			return true;
		}

		public override bool HasProperty(JsValue property)
		{
			if (JsValueExtensions.IsString(property))
			{
				if (!(JsValueExtensions.AsString(property) == "cssText"))
				{
					return Read(Kebab(JsValueExtensions.AsString(property))) != null;
				}
				return true;
			}
			return false;
		}

		private string Read(string property)
		{
			foreach (Declaration item in CssParser.ParseDeclarations(_element.GetAttribute("style") ?? ""))
			{
				if (string.Equals(item.Property, property, StringComparison.OrdinalIgnoreCase))
				{
					return item.Value;
				}
			}
			return null;
		}

		private void Write(string property, string value)
		{
			if (property == null)
			{
				_element.SetAttribute("style", value);
				return;
			}
			List<string> list = new List<string>();
			foreach (Declaration item in CssParser.ParseDeclarations(_element.GetAttribute("style") ?? ""))
			{
				if (!string.Equals(item.Property, property, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(item.Property + ": " + item.Value);
				}
			}
			if (!string.IsNullOrEmpty(value))
			{
				list.Add(property + ": " + value);
			}
			_element.SetAttribute("style", string.Join("; ", list));
		}

		private static string Kebab(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return name;
			}
			StringBuilder stringBuilder = new StringBuilder(name.Length + 4);
			foreach (char c in name)
			{
				if (char.IsUpper(c))
				{
					stringBuilder.Append('-');
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}
	}
	public sealed class JsDocument
	{
		private readonly ScriptHost _host;

		private readonly IDocument _document;

		public JsElement Body
		{
			get
			{
				ScriptHost host = _host;
				IElement body = (IElement)(object)_document.Body;
				return host.Wrap(body ?? _document.DocumentElement);
			}
		}

		internal JsDocument(ScriptHost host, IDocument document)
		{
			_host = host;
			_document = document;
		}

		public JsElement GetElementById(string id)
		{
			return _host.Wrap(((INonElementParentNode)_document).GetElementById(id));
		}

		public JsElement QuerySelector(string selector)
		{
			return _host.Wrap(((IParentNode)_document).QuerySelector(selector));
		}

		public JsValue QuerySelectorAll(string selector)
		{
			return _host.WrapAll((IEnumerable<IElement>)((IParentNode)_document).QuerySelectorAll(selector));
		}

		public JsElement CreateElement(string tag)
		{
			return _host.Wrap(_document.CreateElement(tag));
		}

		public void AddEventListener(string type, JsValue handler)
		{
			ScriptHost host = _host;
			IElement body = (IElement)(object)_document.Body;
			host.AddListener(body ?? _document.DocumentElement, type, handler);
		}
	}
	public sealed class JsEvent
	{
		public string Type { get; }

		public JsElement Target { get; }

		public JsElement CurrentTarget { get; internal set; }

		public string Value { get; internal set; } = "";

		public string Key { get; internal set; } = "";

		public string Source { get; internal set; } = "";

		public bool DefaultPrevented { get; private set; }

		internal bool PropagationStopped { get; private set; }

		internal JsEvent(string type, JsElement target)
		{
			Type = type;
			Target = target;
			CurrentTarget = target;
		}

		public void PreventDefault()
		{
			DefaultPrevented = true;
		}

		public void StopPropagation()
		{
			PropagationStopped = true;
		}
	}
	internal sealed class FetchApi
	{
		private const int MaxInFlight = 8;

		private const string ResponseFactory = "(function (status, statusText, url, headerLines, body, redirected) {\n  var map = {};\n  var lines = headerLines ? headerLines.split('\\n') : [];\n  for (var i = 0; i < lines.length; i++) {\n    var at = lines[i].indexOf(':');\n    if (at > 0) map[lines[i].substring(0, at).trim().toLowerCase()] = lines[i].substring(at + 1).trim();\n  }\n\n  return {\n    ok: status >= 200 && status < 300,\n    status: status,\n    statusText: statusText,\n    url: url,\n    redirected: redirected,\n    headers: {\n      get: function (name) { var k = String(name).toLowerCase(); return k in map ? map[k] : null; },\n      has: function (name) { return String(name).toLowerCase() in map; }\n    },\n    // Already-settled promises: the body was read before the page was handed the response, so these match the web's\n    // shape without ever being pending.\n    text: function () { return Promise.resolve(body); },\n    json: function () {\n      try { return Promise.resolve(JSON.parse(body)); }\n      catch (e) { return Promise.reject(e); }\n    }\n  };\n})";

		private const string Wrapper = "(function (call) {\n  return function fetch(url, init) {\n    return call(url === undefined || url === null ? '' : String(url), init);\n  };\n})";

		private readonly ConcurrentQueue<Action> _finished = new ConcurrentQueue<Action>();

		private readonly Engine _engine;

		private readonly Promises _promises;

		private readonly Action<string> _onError;

		private readonly string _appId;

		private JsValue _responseFactory;

		private int _inFlight;

		internal int Ready => _finished.Count;

		internal FetchApi(Engine engine, string appId, Promises promises, Action<string> onError)
		{
			_engine = engine;
			_appId = appId ?? "";
			_promises = promises;
			_onError = onError;
		}

		internal void Install()
		{
			_responseFactory = _engine.Evaluate("(function (status, statusText, url, headerLines, body, redirected) {\n  var map = {};\n  var lines = headerLines ? headerLines.split('\\n') : [];\n  for (var i = 0; i < lines.length; i++) {\n    var at = lines[i].indexOf(':');\n    if (at > 0) map[lines[i].substring(0, at).trim().toLowerCase()] = lines[i].substring(at + 1).trim();\n  }\n\n  return {\n    ok: status >= 200 && status < 300,\n    status: status,\n    statusText: statusText,\n    url: url,\n    redirected: redirected,\n    headers: {\n      get: function (name) { var k = String(name).toLowerCase(); return k in map ? map[k] : null; },\n      has: function (name) { return String(name).toLowerCase() in map; }\n    },\n    // Already-settled promises: the body was read before the page was handed the response, so these match the web's\n    // shape without ever being pending.\n    text: function () { return Promise.resolve(body); },\n    json: function () {\n      try { return Promise.resolve(JSON.parse(body)); }\n      catch (e) { return Promise.reject(e); }\n    }\n  };\n})", (string)null);
			JsValue val = JsValue.FromObject(_engine, (object)new Func<string, JsValue, JsValue>(Call));
			_engine.SetValue("fetch", _engine.Invoke(_engine.Evaluate("(function (call) {\n  return function fetch(url, init) {\n    return call(url === undefined || url === null ? '' : String(url), init);\n  };\n})", (string)null), new object[1] { val }));
		}

		internal void Settle()
		{
			Action result;
			while (_finished.TryDequeue(out result))
			{
				try
				{
					result();
				}
				catch (Exception ex)
				{
					_onError?.Invoke("settling a fetch failed: " + ex.Message);
				}
			}
		}

		private JsValue Call(string url, JsValue init)
		{
			Deferred deferred = _promises.Create();
			FetchCall fetchCall = new FetchCall
			{
				AppId = _appId
			};
			if (!Uri.TryCreate(url, UriKind.Absolute, out Uri result))
			{
				Later(delegate
				{
					deferred.Reject("fetch needs an absolute http(s) URL - got '" + Trim(url) + "'.");
				});
				return deferred.Promise;
			}
			fetchCall.Url = result;
			try
			{
				ReadInit(init, fetchCall);
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Exception e = ex2;
				Later(delegate
				{
					deferred.Reject("the second argument to fetch is not usable: " + e.Message);
				});
				return deferred.Promise;
			}
			if (!HostAllowlist.Allows(_appId, result, out var reason))
			{
				HostAllowlist.ReportOnce(_appId, result, reason);
				Later(delegate
				{
					deferred.Reject(reason);
				});
				return deferred.Promise;
			}
			if (_inFlight >= 8)
			{
				Later(delegate
				{
					deferred.Reject($"too many requests at once - this app already has {8} " + "fetches in flight. Wait for one to settle before starting another.");
				});
				return deferred.Promise;
			}
			_inFlight++;
			Fetcher.Send(fetchCall, delegate(FetchOutcome outcome)
			{
				_finished.Enqueue(delegate
				{
					_inFlight--;
					if (outcome.Failed)
					{
						deferred.Reject(outcome.Error);
					}
					else
					{
						deferred.Resolve(Response(outcome));
					}
				});
			});
			return deferred.Promise;
		}

		private void Later(Action settle)
		{
			_finished.Enqueue(settle);
		}

		private JsValue Response(FetchOutcome outcome)
		{
			return _engine.Invoke(_responseFactory, new object[6] { outcome.Status, outcome.StatusText, outcome.Url, outcome.HeaderLines, outcome.Body, outcome.Redirected });
		}

		private static void ReadInit(JsValue init, FetchCall call)
		{
			if (init == (JsValue)null || JsValueExtensions.IsUndefined(init) || JsValueExtensions.IsNull(init) || !JsValueExtensions.IsObject(init))
			{
				return;
			}
			ObjectInstance obj = JsValueExtensions.AsObject(init);
			JsValue val = ((JsValue)obj).Get(JsValue.op_Implicit("method"));
			if (!JsValueExtensions.IsUndefined(val) && !JsValueExtensions.IsNull(val))
			{
				call.Method = ((object)val).ToString();
			}
			JsValue val2 = ((JsValue)obj).Get(JsValue.op_Implicit("body"));
			if (!JsValueExtensions.IsUndefined(val2) && !JsValueExtensions.IsNull(val2))
			{
				call.Body = ((object)val2).ToString();
			}
			JsValue val3 = ((JsValue)obj).Get(JsValue.op_Implicit("timeout"));
			if (JsValueExtensions.IsNumber(val3))
			{
				call.TimeoutMs = (int)JsValueExtensions.AsNumber(val3);
			}
			JsValue val4 = ((JsValue)obj).Get(JsValue.op_Implicit("headers"));
			if (!JsValueExtensions.IsObject(val4))
			{
				return;
			}
			ObjectInstance val5 = JsValueExtensions.AsObject(val4);
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in val5.GetOwnProperties())
			{
				JsValue val6 = ((JsValue)val5).Get(ownProperty.Key);
				if (!JsValueExtensions.IsUndefined(val6) && !JsValueExtensions.IsNull(val6))
				{
					call.Headers.Add(new KeyValuePair<string, string>(((object)ownProperty.Key).ToString(), ((object)val6).ToString()));
				}
			}
		}

		private static string Trim(string url)
		{
			string text;
			if (url == null || url.Length <= 80)
			{
				text = url;
				if (text == null)
				{
					return "";
				}
			}
			else
			{
				text = url.Substring(0, 80) + "...";
			}
			return text;
		}
	}
	internal static class MiniJson
	{
		internal static string WriteObject(Dictionary<string, string> values)
		{
			if (values == null || values.Count == 0)
			{
				return "{}";
			}
			StringBuilder stringBuilder = new StringBuilder("{");
			bool flag = true;
			foreach (KeyValuePair<string, string> value in values)
			{
				if (!flag)
				{
					stringBuilder.Append(',');
				}
				flag = false;
				stringBuilder.Append('\n').Append("  ");
				Escape(stringBuilder, value.Key);
				stringBuilder.Append(": ");
				Escape(stringBuilder, value.Value);
			}
			return stringBuilder.Append("\n}").ToString();
		}

		internal static Dictionary<string, string> ParseObject(string json)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			if (string.IsNullOrWhiteSpace(json))
			{
				return dictionary;
			}
			int i = 0;
			SkipWhitespace(json, ref i);
			if (i >= json.Length || json[i] != '{')
			{
				return dictionary;
			}
			i++;
			while (true)
			{
				SkipWhitespace(json, ref i);
				if (i >= json.Length || json[i] == '}')
				{
					break;
				}
				if (json[i] == ',')
				{
					i++;
					continue;
				}
				if (json[i] != '"')
				{
					break;
				}
				string key = ReadString(json, ref i);
				SkipWhitespace(json, ref i);
				if (i >= json.Length || json[i] != ':')
				{
					break;
				}
				i++;
				SkipWhitespace(json, ref i);
				if (i >= json.Length)
				{
					break;
				}
				dictionary[key] = ((json[i] == '"') ? ReadString(json, ref i) : ReadBareValue(json, ref i));
			}
			return dictionary;
		}

		private static void Escape(StringBuilder sb, string value)
		{
			sb.Append('"');
			string text = value ?? "";
			foreach (char c in text)
			{
				switch (c)
				{
				case '"':
					sb.Append("\\\"");
					continue;
				case '\\':
					sb.Append("\\\\");
					continue;
				case '\n':
					sb.Append("\\n");
					continue;
				case '\r':
					sb.Append("\\r");
					continue;
				case '\t':
					sb.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder = sb.Append("\\u");
					int num = c;
					stringBuilder.Append(num.ToString("x4"));
				}
				else
				{
					sb.Append(c);
				}
			}
			sb.Append('"');
		}

		private static string ReadString(string json, ref int i)
		{
			StringBuilder stringBuilder = new StringBuilder();
			i++;
			while (i < json.Length)
			{
				char c = json[i++];
				switch (c)
				{
				default:
					stringBuilder.Append(c);
					continue;
				case '\\':
				{
					if (i >= json.Length)
					{
						break;
					}
					char c2 = json[i++];
					switch (c2)
					{
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'u':
					{
						if (i + 4 <= json.Length && int.TryParse(json.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
						{
							stringBuilder.Append((char)result);
							i += 4;
						}
						break;
					}
					default:
						stringBuilder.Append(c2);
						break;
					}
					continue;
				}
				case '"':
					break;
				}
				break;
			}
			return stringBuilder.ToString();
		}

		private static string ReadBareValue(string json, ref int i)
		{
			int num = i;
			while (i < json.Length && json[i] != ',' && json[i] != '}')
			{
				i++;
			}
			return json.Substring(num, i - num).Trim();
		}

		private static void SkipWhitespace(string json, ref int i)
		{
			while (i < json.Length && char.IsWhiteSpace(json[i]))
			{
				i++;
			}
		}
	}
	internal sealed class Promises
	{
		private const string Factory = "(function (report) {\n  var settle, fail;\n  var root = new Promise(function (ok, no) { settle = ok; fail = no; });\n\n  function watch(p) {\n    var chained = false;\n    var then = p.then.bind(p);\n\n    p.then    = function (ok, no) { chained = true; return watch(then(ok, no)); };\n    p.catch   = function (no)     { chained = true; return watch(then(undefined, no)); };\n    p.finally = function (fn)     { chained = true; return watch(then(\n                                      function (v) { fn(); return v; },\n                                      function (e) { fn(); throw e; })); };\n\n    then(undefined, function (err) {\n      if (!chained) report(String(err && err.message ? err.message : err));\n    });\n    return p;\n  }\n\n  return {\n    promise: watch(root),\n    resolve: settle,\n    reject: function (message) { fail(new Error(message)); }\n  };\n})";

		private readonly Engine _engine;

		private readonly JsValue _factory;

		private readonly JsValue _report;

		internal Promises(Engine engine, Action<string> onUnhandledRejection)
		{
			_engine = engine;
			_factory = engine.Evaluate("(function (report) {\n  var settle, fail;\n  var root = new Promise(function (ok, no) { settle = ok; fail = no; });\n\n  function watch(p) {\n    var chained = false;\n    var then = p.then.bind(p);\n\n    p.then    = function (ok, no) { chained = true; return watch(then(ok, no)); };\n    p.catch   = function (no)     { chained = true; return watch(then(undefined, no)); };\n    p.finally = function (fn)     { chained = true; return watch(then(\n                                      function (v) { fn(); return v; },\n                                      function (e) { fn(); throw e; })); };\n\n    then(undefined, function (err) {\n      if (!chained) report(String(err && err.message ? err.message : err));\n    });\n    return p;\n  }\n\n  return {\n    promise: watch(root),\n    resolve: settle,\n    reject: function (message) { fail(new Error(message)); }\n  };\n})", (string)null);
			_report = JsValue.FromObject(engine, (object)(Action<string>)delegate(string m)
			{
				onUnhandledRejection?.Invoke(m);
			});
		}

		internal Deferred Create()
		{
			ObjectInstance val = JsValueExtensions.AsObject(_engine.Invoke(_factory, new object[1] { _report }));
			return new Deferred(_engine, ((JsValue)val).Get(JsValue.op_Implicit("promise")), ((JsValue)val).Get(JsValue.op_Implicit("resolve")), ((JsValue)val).Get(JsValue.op_Implicit("reject")));
		}

		internal void Pump()
		{
			_engine.Constraints.Reset();
			_engine.Advanced.ProcessTasks();
		}
	}
	internal sealed class Deferred
	{
		private readonly Engine _engine;

		private readonly JsValue _resolve;

		private readonly JsValue _reject;

		internal JsValue Promise { get; }

		internal Deferred(Engine engine, JsValue promise, JsValue resolve, JsValue reject)
		{
			_engine = engine;
			Promise = promise;
			_resolve = resolve;
			_reject = reject;
		}

		internal void Resolve(JsValue value)
		{
			_engine.Invoke(_resolve, new object[1] { value ?? JsValue.Undefined });
		}

		internal void Reject(string message)
		{
			_engine.Invoke(_reject, new object[1] { message ?? "" });
		}
	}
	internal sealed class ScriptHost
	{
		private sealed class Timer
		{
			internal int Id;

			internal JsValue Callback;

			internal double Remaining;

			internal double Interval;

			internal bool Cancelled;
		}

		public sealed class Console
		{
			private readonly string _appId;

			internal Console(string appId)
			{
				_appId = appId;
			}

			public void Log(params object[] args)
			{
				Emit("log", args);
			}

			public void Info(params object[] args)
			{
				Emit("info", args);
			}

			public void Warn(params object[] args)
			{
				Emit("warn", args);
			}

			public void Error(params object[] args)
			{
				Emit("error", args);
			}

			private void Emit(string level, object[] args)
			{
				string text = Format(args);
				if (!(level == "warn"))
				{
					if (level == "error")
					{
						Instance log = Core.Log;
						if (log != null)
						{
							log.Error(text);
						}
					}
					else
					{
						Instance log2 = Core.Log;
						if (log2 != null)
						{
							log2.Msg(text);
						}
					}
				}
				else
				{
					Instance log3 = Core.Log;
					if (log3 != null)
					{
						log3.Warning(text);
					}
				}
				Diagnostics?.Invoke(_appId, level, args, text);
			}

			private string Format(object[] args)
			{
				if (args == null || args.Length == 0)
				{
					return "[" + _appId + "]";
				}
				return "[" + _appId + "] " + string.Join(" ", Array.ConvertAll(args, (object a) => a?.ToString() ?? "null"));
			}
		}

		private static readonly TimeSpan Budget = TimeSpan.FromMilliseconds(250.0);

		internal static Action<string, string, object[], string> Diagnostics;

		private readonly Dictionary<IElement, Dictionary<string, List<JsValue>>> _listeners = new Dictionary<IElement, Dictionary<string, List<JsValue>>>();

		private readonly Dictionary<IElement, JsElement> _wrappers = new Dictionary<IElement, JsElement>();

		private readonly List<Timer> _timers = new List<Timer>();

		private readonly string _appId;

		private Promises _promises;

		private FetchApi _fetch;

		private IDocument _document;

		private Bridge _bridge;

		private int _nextTimerId = 1;

		private bool _failed;

		internal Engine Engine { get; }

		internal Action OnDomChanged { get; }

		internal Action<IElement> OnFocusRequested { get; }

		internal Action<IElement> OnScrollToEnd { get; }

		internal bool Failed => _failed;

		internal string LastError { get; private set; } = "";

		internal ScriptHost(string appId, IDocument document, Action onDomChanged, Action<IElement> onFocusRequested, Action<IElement> onScrollToEnd)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			_appId = appId;
			_document = document;
			OnDomChanged = onDomChanged;
			OnFocusRequested = onFocusRequested;
			OnScrollToEnd = onScrollToEnd;
			Engine = new Engine((Action<Options>)delegate(Options options)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				ConstraintsOptionsExtensions.TimeoutInterval(options, Budget);
				ConstraintsOptionsExtensions.MaxStatements(options, 2000000);
				OptionsExtensions.LimitRecursion(options, 256);
				options.Strict = false;
				options.ExperimentalFeatures = (ExperimentalFeature)3;
				OptionsExtensions.SetTypeResolver(options, new TypeResolver
				{
					MemberNameCreator = BothCasings
				});
			});
			Bind();
		}

		internal void Rebound(IDocument document)
		{
			_document = document;
			_wrappers.Clear();
			Engine.SetValue<JsDocument>("document", new JsDocument(this, _document));
		}

		internal void Dispose()
		{
			_bridge?.Dispose();
			_listeners.Clear();
			_wrappers.Clear();
			_timers.Clear();
		}

		internal void Forget(IElement element)
		{
			if (element == null)
			{
				return;
			}
			_wrappers.Remove(element);
			_listeners.Remove(element);
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)element).Children)
			{
				Forget(item);
			}
		}

		internal void MarkDirty()
		{
			OnDomChanged?.Invoke();
		}

		internal void RequestFocus(IElement element)
		{
			OnFocusRequested?.Invoke(element);
		}

		internal void RequestScrollToEnd(IElement element)
		{
			OnScrollToEnd?.Invoke(element);
		}

		internal JsElement Wrap(IElement element)
		{
			if (element == null)
			{
				return null;
			}
			if (_wrappers.TryGetValue(element, out var value))
			{
				return value;
			}
			JsElement jsElement = new JsElement(this, element);
			_wrappers[element] = jsElement;
			return jsElement;
		}

		internal JsValue WrapAll(IEnumerable<IElement> elements)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<JsValue> list = new List<JsValue>();
			if (elements != null)
			{
				foreach (IElement element in elements)
				{
					list.Add(JsValue.FromObject(Engine, (object)Wrap(element)));
				}
			}
			return (JsValue)new JsArray(Engine, list.ToArray());
		}

		internal void Run(string source, string fileName)
		{
			if (string.IsNullOrWhiteSpace(source))
			{
				return;
			}
			WarnAboutAwaitedFetch(source, fileName);
			try
			{
				Engine.Execute(source, fileName);
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg($"[Sideload] {fileName} executed ({source.Length} chars).");
				}
			}
			catch (Exception e)
			{
				_failed = true;
				LastError = Describe(e);
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Error("[Sideload] " + fileName + " failed: " + LastError);
				}
				Diagnostics?.Invoke(_appId, "exception", null, fileName + ": " + LastError);
			}
		}

		private static void WarnAboutAwaitedFetch(string source, string fileName)
		{
			if (source.IndexOf("fetch(", StringComparison.Ordinal) >= 0 && Regex.IsMatch(source, "\bawait\b"))
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] " + fileName + " uses both `await` and `fetch(`. Awaiting a PENDING promise freezes the game on this engine - it blocks the main thread that would settle it. Use `fetch(url).then(res => ...)` instead. Awaiting an already-settled promise, such as `res.text()`, is safe.");
				}
			}
		}

		internal string Evaluate(string source, out bool failed)
		{
			failed = false;
			if (string.IsNullOrWhiteSpace(source))
			{
				return "";
			}
			try
			{
				JsValue val = Engine.Evaluate(source, (string)null);
				return JsValueExtensions.IsUndefined(val) ? "undefined" : Describe(val);
			}
			catch (Exception e)
			{
				failed = true;
				LastError = Describe(e);
				return LastError;
			}
		}

		private string Describe(JsValue value)
		{
			try
			{
				if (JsValueExtensions.IsNull(value))
				{
					return "null";
				}
				if (JsValueExtensions.IsString(value) || JsValueExtensions.IsNumber(value) || JsValueExtensions.IsBoolean(value))
				{
					return ((object)value).ToString();
				}
				JsValue val = JsValueExtensions.Call(Engine.Evaluate("JSON.stringify", (string)null), JsValue.Undefined, value);
				return JsValueExtensions.IsUndefined(val) ? ((object)value).ToString() : JsValueExtensions.AsString(val);
			}
			catch
			{
				return ((object)value).ToString();
			}
		}

		internal void AddListener(IElement element, string type, JsValue handler)
		{
			if (element != null && !string.IsNullOrEmpty(type) && !(handler == (JsValue)null) && JsValueExtensions.IsObject(handler))
			{
				if (!_listeners.TryGetValue(element, out var value))
				{
					value = (_listeners[element] = new Dictionary<string, List<JsValue>>(StringComparer.OrdinalIgnoreCase));
				}
				if (!value.TryGetValue(type, out var value2))
				{
					value2 = (value[type] = new List<JsValue>());
				}
				value2.Add(handler);
			}
		}

		internal void RemoveListener(IElement element, string type, JsValue handler)
		{
			if (element != null && !(handler == (JsValue)null) && _listeners.TryGetValue(element, out var value) && value.TryGetValue(type, out var value2))
			{
				value2.RemoveAll((JsValue h) => h == handler || object.Equals(h, handler));
			}
		}

		internal IEnumerable<IElement> ElementsListeningFor(string type)
		{
			foreach (KeyValuePair<IElement, Dictionary<string, List<JsValue>>> listener in _listeners)
			{
				if (listener.Value.TryGetValue(type, out var value) && value.Count > 0)
				{
					yield return listener.Key;
				}
			}
		}

		internal JsEvent Dispatch(IElement target, string type, string value = "", string key = "", string source = "")
		{
			JsEvent jsEvent = new JsEvent(type, Wrap(target))
			{
				Value = (value ?? ""),
				Key = (key ?? ""),
				Source = (source ?? "")
			};
			if (_failed || target == null)
			{
				return jsEvent;
			}
			for (IElement val = target; val != null; val = ((INode)val).ParentElement)
			{
				if (_listeners.TryGetValue(val, out var value2) && value2.TryGetValue(type, out var value3) && value3.Count > 0)
				{
					jsEvent.CurrentTarget = Wrap(val);
					JsValue[] array = value3.ToArray();
					foreach (JsValue callback in array)
					{
						Invoke(callback, type + " handler on <" + val.LocalName + ">", JsValue.FromObject(Engine, (object)jsEvent));
						if (jsEvent.PropagationStopped)
						{
							return jsEvent;
						}
					}
				}
			}
			return jsEvent;
		}

		internal void Tick(float deltaSeconds)
		{
			if (_failed)
			{
				return;
			}
			try
			{
				_fetch?.Settle();
			}
			catch (Exception e)
			{
				Report("settling a fetch", e);
			}
			try
			{
				_promises?.Pump();
			}
			catch (Exception e2)
			{
				Report("a pending promise", e2);
			}
			if (_timers.Count == 0)
			{
				return;
			}
			double num = (double)deltaSeconds * 1000.0;
			Timer[] array = _timers.ToArray();
			foreach (Timer timer in array)
			{
				if (timer.Cancelled)
				{
					continue;
				}
				timer.Remaining -= num;
				if (!(timer.Remaining > 0.0))
				{
					if (timer.Interval > 0.0)
					{
						timer.Remaining += timer.Interval;
					}
					else
					{
						timer.Cancelled = true;
					}
					Invoke(timer.Callback, $"timer {timer.Id}");
				}
			}
			_timers.RemoveAll((Timer t) => t.Cancelled);
		}

		private int AddTimer(JsValue callback, double delayMs, bool repeating)
		{
			if (callback == (JsValue)null || !JsValueExtensions.IsObject(callback))
			{
				return 0;
			}
			Timer timer = new Timer
			{
				Id = _nextTimerId++,
				Callback = callback,
				Remaining = Math.Max(delayMs, 0.0),
				Interval = (repeating ? Math.Max(delayMs, 16.0) : 0.0)
			};
			_timers.Add(timer);
			return timer.Id;
		}

		private void ClearTimer(double id)
		{
			foreach (Timer timer in _timers)
			{
				if (timer.Id == (int)id)
				{
					timer.Cancelled = true;
				}
			}
		}

		private void Invoke(JsValue callback, string what, params JsValue[] args)
		{
			try
			{
				Engine.Invoke(callback, (object[])args);
			}
			catch (Exception e)
			{
				LastError = Describe(e);
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] " + what + " failed: " + LastError);
				}
				Diagnostics?.Invoke(_appId, "exception", null, what + " failed: " + LastError);
			}
		}

		private void Report(string what, Exception e)
		{
			LastError = Describe(e);
			Fault(what + " failed: " + LastError);
		}

		private void Fault(string line)
		{
			Instance log = Core.Log;
			if (log != null)
			{
				log.Error("[Sideload] [" + _appId + "] " + line);
			}
			Diagnostics?.Invoke(_appId, "error", null, "[" + _appId + "] " + line);
		}

		private void Bind()
		{
			Engine.SetValue<JsDocument>("document", new JsDocument(this, _document));
			_bridge = new Bridge(this, _appId);
			Engine.SetValue<Bridge>("s1", _bridge);
			Engine.SetValue<Console>("console", new Console(_appId));
			_promises = new Promises(Engine, delegate(string message)
			{
				Fault("unhandled promise rejection: " + message);
			});
			_fetch = new FetchApi(Engine, _appId, _promises, delegate(string line)
			{
				Fault(line);
			});
			_fetch.Install();
			Engine.SetValue<Func<JsValue, double, int>>("setTimeout", (Func<JsValue, double, int>)((JsValue fn, double ms) => AddTimer(fn, ms, repeating: false)));
			Engine.SetValue<Func<JsValue, double, int>>("setInterval", (Func<JsValue, double, int>)((JsValue fn, double ms) => AddTimer(fn, ms, repeating: true)));
			Engine.SetValue<Action<double>>("clearTimeout", (Action<double>)ClearTimer);
			Engine.SetValue<Action<double>>("clearInterval", (Action<double>)ClearTimer);
		}

		private static IEnumerable<string> BothCasings(MemberInfo member)
		{
			string name = member.Name;
			if (!string.IsNullOrEmpty(name))
			{
				string camel = (char.IsUpper(name[0]) ? (char.ToLowerInvariant(name[0]) + name.Substring(1)) : name);
				yield return camel;
				if (camel != name)
				{
					yield return name;
				}
			}
		}

		private static string Describe(Exception e)
		{
			JavaScriptException ex = (JavaScriptException)(object)((e is JavaScriptException) ? e : null);
			if (ex != null)
			{
				return $"{((Exception)(object)ex).Message} ({((Location)ex.Location).Source}:{((Location)ex.Location).Start.Line}:{((Location)ex.Location).Start.Column})";
			}
			ParserException ex2 = (ParserException)(object)((e is ParserException) ? e : null);
			if (ex2 != null)
			{
				return "syntax error: " + ((Exception)(object)ex2).Message;
			}
			return e.ToString();
		}
	}
}
namespace Sideload.Phone
{
	internal static class AppIconSprite
	{
		private const int Fallback = 128;

		internal static Sprite For(AppRegistration reg)
		{
			if ((Object)(object)reg.IconSprite != (Object)null)
			{
				return reg.IconSprite;
			}
			reg.IconSprite = FromBundle(reg) ?? Generated(reg.Id);
			return reg.IconSprite;
		}

		private static Sprite FromBundle(AppRegistration reg)
		{
			//IL_0026: 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_0033: Expected O, but got Unknown
			byte[] array = reg.Bundle?.ReadBytes("icon.png");
			if (array == null || array.Length == 0)
			{
				return null;
			}
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					filterMode = (FilterMode)1
				};
				if (!ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(array)))
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] '" + reg.Id + "' has an icon.png that is not a readable PNG.");
					}
					return null;
				}
				return Finish(val);
			}
			catch (Exception ex)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload] loading icon.png for '" + reg.Id + "' failed: " + ex.Message);
				}
				return null;
			}
		}

		private static Sprite Generated(string id)
		{
			//IL_0013: 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_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_0032: Expected O, but got Unknown
			//IL_006a: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			Color32 val = FromHue((float)(Hash(id) % 360) / 360f);
			Texture2D val2 = new Texture2D(128, 128, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1
			};
			Color32 val3 = default(Color32);
			((Color32)(ref val3))..ctor((byte)0, (byte)0, (byte)0, (byte)0);
			for (int i = 0; i < 128; i++)
			{
				for (int j = 0; j < 128; j++)
				{
					val2.SetPixel(j, i, Color32.op_Implicit(Inside((float)j + 0.5f, (float)i + 0.5f, 26f) ? val : val3));
				}
			}
			val2.Apply();
			return Finish(val2);
		}

		private static bool Inside(float x, float y, float r)
		{
			float num = Mathf.Clamp(x, r, 128f - r);
			float num2 = Mathf.Clamp(y, r, 128f - r);
			float num3 = x - num;
			float num4 = y - num2;
			return num3 * num3 + num4 * num4 <= r * r;
		}

		private static Sprite Finish(Texture2D tex)
		{
			//IL_0021: 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)
			((Object)tex).hideFlags = (HideFlags)32;
			Sprite val = Sprite.Create(tex, new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), new Vector2(0.5f, 0.5f), 100f);
			if ((Object)(object)val != (Object)null)
			{
				((Object)val).hideFlags = (HideFlags)32;
			}
			return val;
		}

		private static int Hash(string s)
		{
			int num = 17;
			string text = s ?? "";
			foreach (char c in text)
			{
				num = (num * 31 + c) & 0x7FFFFFF;
			}
			return num;
		}

		private static Color32 FromHue(float h)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return Color32.op_Implicit(Color.HSVToRGB(h, 0.62f, 0.86f));
		}
	}
	[HarmonyPatch(typeof(HomeScreen), "Start")]
	internal static class HomeScreenPatch
	{
		private static readonly List<PhoneAppHost> _hosts = new List<PhoneAppHost>();

		private static HomeScreen _home;

		internal static IReadOnlyList<PhoneAppHost> Hosts => _hosts;

		internal static void LogIconRow()
		{
			if ((Object)(object)_home == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/probe] no HomeScreen to inspect.");
				}
				return;
			}
			Transform appIconContainer = (Transform)(object)_home.appIconContainer;
			if ((Object)(object)appIconContainer == (Object)null)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload/probe] HomeScreen exposes no icon container.");
				}
				return;
			}
			List<string> list = new List<string>();
			for (int i = 0; i < appIconContainer.childCount; i++)
			{
				list.Add(((Object)appIconContainer.GetChild(i)).name);
			}
			Instance log3 = Core.Log;
			if (log3 != null)
			{
				log3.Msg($"[Sideload/probe] real AppIcons: {appIconContainer.childCount} child(ren) -> {string.Join(", ", list)}");
			}
		}

		private static void Postfix(HomeScreen __instance)
		{
			//IL_0010: 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)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			_home = __instance;
			Scene activeScene = SceneManager.GetActiveScene();
			if (!string.Equals(((Scene)(ref activeScene)).name, "Main", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			if (_hosts.Count > 0 && _hosts[0].IsAlive)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg("[Sideload] apps are already live on a phone - skipping this second HomeScreen.");
				}
				return;
			}
			_hosts.Clear();
			if (Registry.Apps.Count == 0)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Msg("[Sideload] no apps registered - nothing to put on the phone.");
				}
				return;
			}
			foreach (AppRegistration app in Registry.Apps)
			{
				try
				{
					PhoneAppHost phoneAppHost = PhoneAppHost.Spawn(__instance, app);
					if (phoneAppHost != null)
					{
						_hosts.Add(phoneAppHost);
					}
				}
				catch (Exception value)
				{
					Instance log3 = Core.Log;
					if (log3 != null)
					{
						log3.Error($"[Sideload] spawning '{app.Id}' failed: {value}");
					}
				}
			}
			Instance log4 = Core.Log;
			if (log4 != null)
			{
				log4.Msg($"[Sideload] {_hosts.Count}/{Registry.Apps.Count} app(s) live on the phone.");
			}
		}
	}
	internal static class OrientationStore
	{
		private static readonly Dictionary<string, bool> _portraitById = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

		private static bool _loaded;

		private static string Path => System.IO.Path.Combine(MelonEnvironment.UserDataDirectory, "Sideload", "orientation.json");

		internal static bool? Remembered(AppRegistration reg)
		{
			if (reg == null)
			{
				return null;
			}
			Load();
			if (!_portraitById.TryGetValue(reg.Id, out var value))
			{
				return null;
			}
			if (!reg.Supports(value))
			{
				return null;
			}
			return value;
		}

		internal static void Remember(string appId, bool portrait)
		{
			if (!string.IsNullOrWhiteSpace(appId))
			{
				Load();
				if (!_portraitById.TryGetValue(appId, out var value) || value != portrait)
				{
					_portraitById[appId] = portrait;
					Save();
				}
			}
		}

		private static void Load()
		{
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			try
			{
				if (!File.Exists(Path))
				{
					return;
				}
				foreach (KeyValuePair<string, string> item in MiniJson.ParseObject(File.ReadAllText(Path)))
				{
					_portraitById[item.Key] = string.Equals(item.Value, "portrait", StringComparison.OrdinalIgnoreCase);
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] remembered orientations unreadable (" + Path + "): " + ex.Message);
				}
			}
		}

		private static void Save()
		{
			try
			{
				Directory.CreateDirectory(System.IO.Path.GetDirectoryName(Path) ?? ".");
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
				foreach (KeyValuePair<string, bool> item in _portraitById)
				{
					dictionary[item.Key] = (item.Value ? "portrait" : "landscape");
				}
				File.WriteAllText(Path, MiniJson.WriteObject(dictionary));
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] could not write remembered orientations: " + ex.Message);
				}
			}
		}
	}
	internal sealed class PhoneAppHost
	{
		private readonly AppRegistration _reg;

		private GameObject _panel;

		private GameObject _container;

		private GameObject _icon;

		private WebView _view;

		private Transform _appsCanvas;

		private Transform _badge;

		private Text _badgeText;

		private Action _closeAppsHandler;

		private ExitDelegate _exitHandler;

		internal string Id => _reg.Id;

		internal bool IsOpen
		{
			get
			{
				if ((Object)(object)_panel != (Object)null && _panel.activeInHierarchy)
				{
					return (Object)(object)Phone.ActiveApp == (Object)(object)_panel;
				}
				return false;
			}
		}

		internal bool IsShowing
		{
			get
			{
				if (IsOpen && PlayerSingleton<Phone>.InstanceExists)
				{
					return PlayerSingleton<Phone>.Instance.IsOpen;
				}
				return false;
			}
		}

		internal bool IsAlive => (Object)(object)_panel != (Object)null;

		internal bool CanTurn => _reg.CanTurn;

		private PhoneAppHost(AppRegistration reg)
		{
			_reg = reg;
		}

		internal static PhoneAppHost Spawn(HomeScreen home, AppRegistration reg)
		{
			PhoneAppHost phoneAppHost = new PhoneAppHost(reg);
			if (!phoneAppHost.Build(home))
			{
				return null;
			}
			return phoneAppHost;
		}

		private bool Build(HomeScreen home)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_0173: 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)
			Transform val = (((Object)(object)((Component)home).transform.parent != (Object)null) ? ((Component)home).transform.parent.Find("AppsCanvas") : null);
			if ((Object)(object)val == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] AppsCanvas not found - '" + _reg.Id + "' not spawned.");
				}
				return false;
			}
			string text = "Sideload_" + _reg.Id;
			Transform val2 = val.Find(text);
			if ((Object)(object)val2 != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)val2).gameObject);
			}
			_appsCanvas = val;
			bool? flag = OrientationStore.Remembered(_reg);
			if (flag.HasValue)
			{
				_reg.Portrait = flag.Value;
			}
			_panel = new GameObject(text);
			((Transform)_panel.AddComponent<RectTransform>()).SetParent(val, false);
			if (!ApplyOrientation())
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Error("[Sideload] no vanilla app panel to measure - '" + _reg.Id + "' not spawned.");
				}
				return false;
			}
			_container = new GameObject("Container");
			RectTransform val3 = _container.AddComponent<RectTransform>();
			((Transform)val3).SetParent(_panel.transform, false);
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.pivot = new Vector2(0.5f, 0.5f);
			val3.anchoredPosition = Vector2.zero;
			val3.sizeDelta = Vector2.zero;
			_view = WebView.Mount(val3, _reg.Bundle, _reg.Id);
			_reg.OrientationChanged = OnOrientationChanged;
			_panel.SetActive(true);
			_container.SetActive(false);
			SpawnIcon(home);
			SubscribeShellEvents();
			Instance log3 = Core.Log;
			if (log3 != null)
			{
				log3.Msg("[Sideload] '" + _reg.Id + "' spawned on the phone.");
			}
			return true;
		}

		private bool ApplyOrientation()
		{
			if ((Object)(object)_panel == (Object)null || (Object)(object)_appsCanvas == (Object)null)
			{
				return false;
			}
			Transform val = FindPanelTemplate(_appsCanvas, _reg.Portrait) ?? FindPanelTemplate(_appsCanvas, !_reg.Portrait);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			CopyRect(((Component)val).GetComponent<RectTransform>(), _panel.GetComponent<RectTransform>());
			return true;
		}

		private static Transform FindPanelTemplate(Transform appsCanvas, bool portrait)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < appsCanvas.childCount; i++)
			{
				Transform child = appsCanvas.GetChild(i);
				if (((Object)child).name.StartsWith("Sideload_", StringComparison.Ordinal))
				{
					continue;
				}
				RectTransform component = ((Component)child).GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					Rect rect = component.rect;
					if (!(((Rect)(ref rect)).width < 1f) && !(((Rect)(ref rect)).height < 1f) && ((Rect)(ref rect)).height > ((Rect)(ref rect)).width == portrait)
					{
						return child;
					}
				}
			}
			return null;
		}

		private void OnOrientationChanged()
		{
			try
			{
				if (ApplyOrientation())
				{
					OrientationStore.Remember(_reg.Id, _reg.Portrait);
					if (IsOpen && PlayerSingleton<Phone>.InstanceExists)
					{
						PlayerSingleton<Phone>.Instance.SetIsHorizontal(!_reg.Portrait);
						PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(_reg.Portrait ? 1f : 0.6f);
					}
					Canvas.ForceUpdateCanvases();
					_view?.QueueResize();
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] turning '" + _reg.Id + "' failed: " + ex.Message);
				}
			}
		}

		private static void CopyRect(RectTransform from, RectTransform to)
		{
			//IL_0015: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)from == (Object)null) && !((Object)(object)to == (Object)null))
			{
				to.anchorMin = from.anchorMin;
				to.anchorMax = from.anchorMax;
				to.pivot = from.pivot;
				to.anchoredPosition3D = from.anchoredPosition3D;
				to.sizeDelta = from.sizeDelta;
				((Transform)to).localScale = ((Transform)from).localScale;
				((Transform)to).localRotation = ((Transform)from).localRotation;
			}
		}

		private void SpawnIcon(HomeScreen home)
		{
			Transform appIconContainer = (Transform)(object)home.appIconContainer;
			GameObject appIconPrefab = home.appIconPrefab;
			if ((Object)(object)appIconContainer == (Object)null || (Object)(object)appIconPrefab == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] HomeScreen exposes no icon prefab or container - '" + _reg.Id + "' has no home-screen icon.");
				}
				return;
			}
			string text = "SideloadIcon_" + _reg.Id;
			Transform val = appIconContainer.Find(text);
			if ((Object)(object)val != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
			}
			_icon = Object.Instantiate<GameObject>(appIconPrefab, appIconContainer);
			((Object)_icon).name = text;
			_icon.transform.SetAsLastSibling();
			_icon.SetActive(true);
			Dress(_icon.transform, AppIconSprite.For(_reg), _reg.IconLabel, _reg.Id);
			Button component = _icon.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((UnityEvent)component.onClick).AddListener(UnityAction.op_Implicit((Action)Open));
			}
			else
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload] the icon prefab has no Button component - '" + _reg.Id + "' cannot be opened from the home screen.");
				}
			}
			UISelectable component2 = _icon.GetComponent<UISelectable>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)home.uiPanel != (Object)null)
			{
				home.uiPanel.AddSelectable(component2);
			}
			_badge = _icon.transform.Find("Notifications");
			object badgeText;
			if (!((Object)(object)_badge != (Object)null))
			{
				badgeText = null;
			}
			else
			{
				Transform obj = _badge.Find("Text");
				badgeText = ((obj != null) ? ((Component)obj).GetComponent<Text>() : null);
			}
			_badgeText = (Text)badgeText;
			if ((Object)(object)_badge == (Object)null)
			{
				Instance log3 = Core.Log;
				if (log3 != null)
				{
					log3.Warning("[Sideload] the icon prefab has no Notifications badge - '" + _reg.Id + "' cannot show a count.");
				}
			}
			ApplyBadge();
		}

		internal void SetBadge(int count)
		{
			_reg.Badge = Math.Max(0, count);
			ApplyBadge();
		}

		private void ApplyBadge()
		{
			if (!((Object)(object)_badge == (Object)null))
			{
				if ((Object)(object)_badgeText != (Object)null)
				{
					_badgeText.text = ((_reg.Badge > 99) ? "99+" : _reg.Badge.ToString());
				}
				((Component)_badge).gameObject.SetActive(_reg.Badge > 0);
			}
		}

		internal void Notify(string title, string subtitle)
		{
			try
			{
				if (Singleton<NotificationsManager>.InstanceExists)
				{
					Singleton<NotificationsManager>.Instance.SendNotification(title ?? "", subtitle ?? "", AppIconSprite.For(_reg), 5f, true);
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] notification from '" + _reg.Id + "' failed: " + ex.Message);
				}
			}
		}

		private static void Dress(Transform icon, Sprite sprite, string caption, string appId)
		{
			Transform val = icon.Find("Mask/Image");
			Image val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Image>() : ((Component)icon).GetComponentInChildren<Image>(true));
			if ((Object)(object)val2 != (Object)null && (Object)(object)sprite != (Object)null)
			{
				val2.sprite = sprite;
			}
			else if ((Object)(object)val2 == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] no Image under the icon for '" + appId + "' - it keeps the prefab's picture.");
				}
			}
			if (!SetIconLabel(((Component)icon).gameObject, caption))
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload] no label found on the icon for '" + appId + "' - it stays unnamed.");
				}
			}
		}

		private static bool SetIconLabel(GameObject icon, string caption)
		{
			Transform val = icon.transform.Find("Label");
			if ((Object)(object)val != (Object)null)
			{
				Text component = ((Component)val).GetComponent<Text>();
				if ((Object)(object)component != (Object)null)
				{
					component.text = caption;
					return true;
				}
				TextMeshProUGUI component2 = ((Component)val).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component2 != (Object)null)
				{
					((TMP_Text)component2).text = caption;
					return true;
				}
			}
			foreach (Text componentsInChild in icon.GetComponentsInChildren<Text>(true))
			{
				if (!((Object)(object)((Component)componentsInChild).transform.parent != (Object)null) || !(((Object)((Component)componentsInChild).transform.parent).name == "Notifications"))
				{
					componentsInChild.text = caption;
					return true;
				}
			}
			using (IEnumerator<TextMeshProUGUI> enumerator2 = icon.GetComponentsInChildren<TextMeshProUGUI>(true).GetEnumerator())
			{
				if (enumerator2.MoveNext())
				{
					((TMP_Text)enumerator2.Current).text = caption;
					return true;
				}
			}
			return false;
		}

		private void SubscribeShellEvents()
		{
			if (PlayerSingleton<Phone>.InstanceExists)
			{
				_closeAppsHandler = Close;
				Phone instance = PlayerSingleton<Phone>.Instance;
				instance.closeApps += Action.op_Implicit(_closeAppsHandler);
				_exitHandler = DelegateSupport.ConvertDelegate<ExitDelegate>((Delegate)new Action<ExitAction>(OnExit));
				GameInput.RegisterExitListener(_exitHandler, 1);
			}
		}

		private void OnExit(ExitAction exit)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (exit.Used || !IsShowing)
			{
				return;
			}
			exit.Used = true;
			try
			{
				if (_view != null && _view.DispatchBack(((int)exit.exitType == 0) ? "rightClick" : "escape"))
				{
					return;
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] the back handler of '" + _reg.Id + "' threw: " + ex.Message);
				}
			}
			Close();
		}

		internal void Turn()
		{
			Registry.SetOrientation(_reg.Id, _reg.Portrait ? "landscape" : "portrait");
		}

		internal void Open()
		{
			try
			{
				Phone instance = PlayerSingleton<Phone>.Instance;
				if ((Object)(object)Phone.ActiveApp != (Object)null && (Object)(object)Phone.ActiveApp != (Object)(object)_panel)
				{
					instance.RequestCloseApp();
				}
				SetOpen(open: true);
				Canvas.ForceUpdateCanvases();
				_view?.EnsureBuilt();
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] opening '" + _reg.Id + "' failed: " + ex.Message);
				}
			}
		}

		internal void Close()
		{
			try
			{
				if (IsOpen)
				{
					SetOpen(open: false);
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] closing '" + _reg.Id + "' failed: " + ex.Message);
				}
			}
		}

		private void SetOpen(bool open)
		{
			if (!open || !((Object)(object)Phone.ActiveApp != (Object)null) || !((Object)(object)Phone.ActiveApp != (Object)(object)_panel))
			{
				if (PlayerSingleton<AppsCanvas>.InstanceExists)
				{
					PlayerSingleton<AppsCanvas>.Instance.SetIsOpen(open);
				}
				if (PlayerSingleton<HomeScreen>.InstanceExists)
				{
					PlayerSingleton<HomeScreen>.Instance.SetIsOpen(!open);
				}
				if (PlayerSingleton<Phone>.InstanceExists)
				{
					bool flag = open && !_reg.Portrait;
					PlayerSingleton<Phone>.Instance.SetIsHorizontal(flag);
					PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(flag ? 0.6f : 1f);
				}
				Phone.ActiveApp = (open ? _panel : null);
				if ((Object)(object)_container != (Object)null)
				{
					_container.SetActive(open);
				}
			}
		}
	}
	internal static class TurnInput
	{
		internal static void Tick()
		{
			PhoneAppHost phoneAppHost = OpenTurnableApp();
			TurnPrompt.Show(phoneAppHost != null);
			if (phoneAppHost != null && !GameInput.IsTyping && Singleton<GameInput>.InstanceExists && (GameInput.GetButtonDown((ButtonCode)17) || GameInput.GetButtonDown((ButtonCode)18)))
			{
				phoneAppHost.Turn();
			}
		}

		private static PhoneAppHost OpenTurnableApp()
		{
			IReadOnlyList<PhoneAppHost> hosts = HomeScreenPatch.Hosts;
			for (int i = 0; i < hosts.Count; i++)
			{
				if (hosts[i].IsOpen && hosts[i].CanTurn)
				{
					return hosts[i];
				}
			}
			return null;
		}
	}
	internal static class TurnPrompt
	{
		private const string RowName = "SideloadTurnPrompt";

		private static GameObject _row;

		private static RectTransform _hostModule;

		private static bool _warned;

		internal static void Show(bool wanted)
		{
			RectTransform val = CurrentModule();
			if ((Object)(object)_row != (Object)null && (!wanted || (Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)_hostModule))
			{
				Remove();
			}
			if (!wanted || (Object)(object)val == (Object)null || (Object)(object)_row != (Object)null)
			{
				return;
			}
			try
			{
				Build(val);
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] could not add the turn hint to the input prompts: " + ex.Message);
				}
				Remove();
			}
		}

		private static RectTransform CurrentModule()
		{
			if (!Singleton<InputPromptsCanvas>.InstanceExists)
			{
				return null;
			}
			InputPromptsCanvas instance = Singleton<InputPromptsCanvas>.Instance;
			if (!((Object)(object)instance.currentModule != (Object)null))
			{
				return instance.InputPromptsContainer;
			}
			return instance.currentModule;
		}

		private static void Remove()
		{
			if ((Object)(object)_row != (Object)null)
			{
				Object.Destroy((Object)(object)_row);
			}
			_row = null;
			_hostModule = null;
		}

		private static void Build(RectTransform module)
		{
			InputPrompt val = Template(module);
			if ((Object)(object)val == (Object)null)
			{
				WarnOnce("the input prompt strip has no line to copy");
				return;
			}
			InputActionReference val2 = FindAction("RotateLeft");
			InputActionReference val3 = FindAction("RotateRight");
			if ((Object)(object)val2 == (Object)null && (Object)(object)val3 == (Object)null)
			{
				WarnOnce("the rotate actions are not loaded");
				return;
			}
			_row = Object.Instantiate<GameObject>(((Component)val).gameObject, (Transform)(object)module);
			((Object)_row).name = "SideloadTurnPrompt";
			_row.transform.SetAsLastSibling();
			InputPrompt component = _row.GetComponent<InputPrompt>();
			if ((Object)(object)component == (Object)null)
			{
				WarnOnce("the copied line lost its InputPrompt component");
				Remove();
				return;
			}
			component.Actions.Clear();
			if ((Object)(object)val2 != (Object)null)
			{
				component.Actions.Add(val2);
			}
			if ((Object)(object)val3 != (Object)null)
			{
				component.Actions.Add(val3);
			}
			component.Label = "Rotate Phone";
			_row.SetActive(false);
			_row.SetActive(true);
			PlaceBelowTheRest(module, _row.GetComponent<RectTransform>());
			_hostModule = module;
		}

		private static void PlaceBelowTheRest(RectTransform module, RectTransform row)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00cd: 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)row == (Object)null)
			{
				return;
			}
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			for (int i = 0; i < ((Transform)module).childCount; i++)
			{
				Transform child = ((Transform)module).GetChild(i);
				if ((Object)(object)((Component)child).gameObject == (Object)(object)((Component)row).gameObject)
				{
					continue;
				}
				RectTransform component = ((Component)child).GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					float y = component.anchoredPosition.y;
					if (y < num)
					{
						num2 = num;
						num = y;
					}
					else if (y < num2)
					{
						num2 = y;
					}
				}
			}
			if (num == float.MaxValue)
			{
				return;
			}
			Rect rect;
			float num3;
			if (!(num2 < float.MaxValue))
			{
				rect = row.rect;
				num3 = Math.Abs(((Rect)(ref rect)).height);
			}
			else
			{
				num3 = Math.Abs(num2 - num);
			}
			float num4 = num3;
			if (num4 < 1f)
			{
				rect = row.rect;
				float num5;
				if (!(Math.Abs(((Rect)(ref rect)).height) < 1f))
				{
					rect = row.rect;
					num5 = Math.Abs(((Rect)(ref rect)).height);
				}
				else
				{
					num5 = 30f;
				}
				num4 = num5;
			}
			row.anchoredPosition = new Vector2(row.anchoredPosition.x, num - num4);
		}

		private static InputPrompt Template(RectTransform module)
		{
			foreach (InputPrompt componentsInChild in ((Component)module).GetComponentsInChildren<InputPrompt>(true))
			{
				if (((Object)((Component)componentsInChild).gameObject).name != "SideloadTurnPrompt")
				{
					return componentsInChild;
				}
			}
			return null;
		}

		private static InputActionReference FindAction(string actionName)
		{
			string value = "/" + actionName;
			foreach (InputActionReference item in Resources.FindObjectsOfTypeAll<InputActionReference>())
			{
				if (!((Object)(object)item == (Object)null))
				{
					string text = ((Object)item).name ?? "";
					if (text.EndsWith(value, StringComparison.OrdinalIgnoreCase) || text.Equals(actionName, StringComparison.OrdinalIgnoreCase))
					{
						return item;
					}
				}
			}
			return null;
		}

		private static void WarnOnce(string reason)
		{
			if (!_warned)
			{
				_warned = true;
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] no turn hint in the key strip - " + reason + ". Turning still works.");
				}
			}
		}
	}
}
namespace Sideload.Paint
{
	internal static class BoxMaterial
	{
		private const string ResourceName = "Sideload.Assets.Bundles.sideload-ui";

		private static bool _tried;

		private static Material _material;

		internal static bool Available => (Object)(object)Get() != (Object)null;

		internal static Material Get()
		{
			//IL_011d: 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: Expected O, but got Unknown
			if (_tried)
			{
				return _material;
			}
			_tried = true;
			try
			{
				byte[] array = ReadEmbedded("Sideload.Assets.Bundles.sideload-ui");
				if (array == null)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] UI shader bundle not embedded - boxes will be flat fills.");
					}
					return null;
				}
				Il2CppAssetBundle val = Il2CppAssetBundleManager.LoadFromMemory(Il2CppStructArray<byte>.op_Implicit(array));
				if (val == null)
				{
					Instance log2 = Core.Log;
					if (log2 != null)
					{
						log2.Warning("[Sideload] UI shader bundle failed to load - boxes will be flat fills.");
					}
					return null;
				}
				Shader val2 = val.LoadAsset<Shader>("Assets/SideloadBox.shader");
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val.LoadAsset<Shader>("SideloadBox");
				}
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val.LoadAsset<Shader>("Sideload/Box");
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Il2CppReferenceArray<Shader> val3 = val.LoadAllAssets<Shader>();
					if (val3 != null && ((Il2CppArrayBase<Shader>)(object)val3).Length > 0)
					{
						val2 = ((Il2CppArrayBase<Shader>)(object)val3)[0];
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Instance log3 = Core.Log;
					if (log3 != null)
					{
						log3.Warning("[Sideload] UI shader not found in bundle - boxes will be flat fills.");
					}
					return null;
				}
				if (!val2.isSupported)
				{
					Instance log4 = Core.Log;
					if (log4 != null)
					{
						log4.Warning("[Sideload] UI shader '" + ((Object)val2).name + "' is not supported here - boxes will be flat fills.");
					}
					return null;
				}
				_material = new Material(val2)
				{
					name = "SideloadBox"
				};
				Instance log5 = Core.Log;
				if (log5 != null)
				{
					log5.Msg("[Sideload] UI shader loaded: " + ((Object)val2).name);
				}
			}
			catch (Exception ex)
			{
				Instance log6 = Core.Log;
				if (log6 != null)
				{
					log6.Warning("[Sideload] UI shader load failed: " + ex.Message);
				}
				_material = null;
			}
			return _material;
		}

		internal static Material CreateClipped(Vector4 clipRect)
		{
			//IL_0012: 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_0023: Expected O, but got Unknown
			//IL_0034: 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)
			Material val = Get();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Material val2 = new Material(val)
			{
				name = "SideloadBox (clipped)"
			};
			val2.EnableKeyword("UNITY_UI_CLIP_RECT");
			val2.SetVector("_ClipRect", clipRect);
			Instance log = Core.Log;
			if (log != null)
			{
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(54, 4);
				defaultInterpolatedStringHandler.AppendLiteral("[Sideload/clip] material '");
				defaultInterpolatedStringHandler.AppendFormatted(((Object)val2).name);
				defaultInterpolatedStringHandler.AppendLiteral("' shader='");
				Shader shader = val2.shader;
				defaultInterpolatedStringHandler.AppendFormatted((shader != null) ? ((Object)shader).name : null);
				defaultInterpolatedStringHandler.AppendLiteral("' ");
				defaultInterpolatedStringHandler.AppendLiteral("supported=");
				Shader shader2 = val2.shader;
				defaultInterpolatedStringHandler.AppendFormatted((shader2 != null) ? new bool?(shader2.isSupported) : ((bool?)null));
				defaultInterpolatedStringHandler.AppendLiteral(" rect=");
				defaultInterpolatedStringHandler.AppendFormatted<Vector4>(clipRect);
				log.Msg(defaultInterpolatedStringHandler.ToStringAndClear());
			}
			return val2;
		}

		private static byte[] ReadEmbedded(string name)
		{
			try
			{
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name);
				if (stream == null)
				{
					return null;
				}
				byte[] array = new byte[stream.Length];
				int num;
				for (int i = 0; i < array.Length; i += num)
				{
					num = stream.Read(array, i, array.Length - i);
					if (num <= 0)
					{
						break;
					}
				}
				return array;
			}
			catch
			{
				return null;
			}
		}
	}
	internal struct BoxVisual
	{
		internal Color FillTL;

		internal Color FillTR;

		internal Color FillBR;

		internal Color FillBL;

		internal float RadiusTL;

		internal float RadiusTR;

		internal float RadiusBR;

		internal float RadiusBL;

		internal float BorderWidth;

		internal float EdgeTop;

		internal float EdgeRight;

		internal float EdgeBottom;

		internal float EdgeLeft;

		internal Color BorderColor;

		internal bool HasShadow;

		internal float ShadowOffsetX;

		internal float ShadowOffsetY;

		internal float ShadowBlur;

		internal Color ShadowColor;

		internal static BoxVisual Solid(Color color)
		{
			//IL_000a: 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_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_001a: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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)
			return new BoxVisual
			{
				FillTL = color,
				FillTR = color,
				FillBR = color,
				FillBL = color,
				BorderColor = new Color(0f, 0f, 0f, 0f),
				ShadowColor = new Color(0f, 0f, 0f, 0f)
			};
		}
	}
	internal static class BoxRenderer
	{
		private const AdditionalCanvasShaderChannels RequiredChannels = (AdditionalCanvasShaderChannels)31;

		private static readonly Dictionary<int, (int Owner, Mesh Mesh)> _meshes = new Dictionary<int, (int, Mesh)>();

		private static readonly HashSet<int> _touched = new HashSet<int>();

		private static bool _collecting;

		private static int _owner;

		internal static Rect? ActiveClip;

		internal static void EnsureCanvasChannels(Transform anyChild)
		{
			//IL_0034: 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_003e: Invalid comparison between Unknown and I4
			//IL_0043: 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)
			if ((Object)(object)anyChild == (Object)null)
			{
				return;
			}
			Canvas componentInParent = ((Component)anyChild).GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return;
			}
			Canvas val = (((Object)(object)componentInParent.rootCanvas != (Object)null) ? componentInParent.rootCanvas : componentInParent);
			if ((val.additionalShaderChannels & 0x1F) != 31)
			{
				val.additionalShaderChannels = (AdditionalCanvasShaderChannels)(val.additionalShaderChannels | 0x1F);
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg("[Sideload] enabled extra vertex channels on canvas '" + ((Object)val).name + "'.");
				}
			}
		}

		internal static void Paint(RectTransform rt, BoxVisual visual, float width, float height)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: 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)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: 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_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: 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_0471: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rt == (Object)null)
			{
				return;
			}
			Material val = BoxMaterial.Get();
			if ((Object)(object)val == (Object)null)
			{
				PaintFlat(rt, visual);
				return;
			}
			EnsureCanvasChannels((Transform)(object)rt);
			CanvasRenderer val2 = ((Component)rt).GetComponent<CanvasRenderer>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)rt).gameObject.AddComponent<CanvasRenderer>();
			}
			int num = ((!visual.HasShadow) ? 1 : 2);
			if (visual.EdgeTop > 0f)
			{
				num++;
			}
			if (visual.EdgeBottom > 0f)
			{
				num++;
			}
			if (visual.EdgeLeft > 0f)
			{
				num++;
			}
			if (visual.EdgeRight > 0f)
			{
				num++;
			}
			int num2 = num * 4;
			Vector3[] array = (Vector3[])(object)new Vector3[num2];
			Color32[] array2 = (Color32[])(object)new Color32[num2];
			Vector2[] array3 = (Vector2[])(object)new Vector2[num2];
			Vector2[] array4 = (Vector2[])(object)new Vector2[num2];
			Vector2[] array5 = (Vector2[])(object)new Vector2[num2];
			Vector2[] array6 = (Vector2[])(object)new Vector2[num2];
			Vector3[] array7 = (Vector3[])(object)new Vector3[num2];
			Vector4[] array8 = (Vector4[])(object)new Vector4[num2];
			int[] array9 = new int[num * 6];
			Vector2 pivot = rt.pivot;
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor((0.5f - pivot.x) * width, (0.5f - pivot.y) * height);
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(width * 0.5f, height * 0.5f);
			Vector4 radii = default(Vector4);
			((Vector4)(ref radii))..ctor(visual.RadiusTL, visual.RadiusTR, visual.RadiusBR, visual.RadiusBL);
			int v = 0;
			int t = 0;
			if (visual.HasShadow)
			{
				float num3 = visual.ShadowBlur + 2f;
				Vector2 centre = val3 + new Vector2(visual.ShadowOffsetX, 0f - visual.ShadowOffsetY);
				Color shadowColor = visual.ShadowColor;
				EmitQuad(array, array2, array3, array4, array5, array6, array7, array8, array9, ref v, ref t, centre, val4 + new Vector2(num3, num3), val4, radii, shadowColor, shadowColor, shadowColor, shadowColor, 0f, Mathf.Max(visual.ShadowBlur, 0.5f), new Color(0f, 0f, 0f, 0f));
			}
			EmitQuad(array, array2, array3, array4, array5, array6, array7, array8, array9, ref v, ref t, val3, val4, val4, radii, visual.FillTL, visual.FillTR, visual.FillBR, visual.FillBL, visual.BorderWidth, 0f, visual.BorderColor);
			Color borderColor = visual.BorderColor;
			EmitEdge(array, array2, array3, array4, array5, array6, array7, array8, array9, ref v, ref t, val3 + new Vector2(0f, val4.y - visual.EdgeTop * 0.5f), new Vector2(val4.x, visual.EdgeTop * 0.5f), visual.EdgeTop, borderColor);
			EmitEdge(array, array2, array3, array4, array5, array6, array7, array8, array9, ref v, ref t, val3 - new Vector2(0f, val4.y - visual.EdgeBottom * 0.5f), new Vector2(val4.x, visual.EdgeBottom * 0.5f), visual.EdgeBottom, borderColor);
			EmitEdge(array, array2, array3, array4, array5, array6, array7, array8, array9, ref v, ref t, val3 - new Vector2(val4.x - visual.EdgeLeft * 0.5f, 0f), new Vector2(visual.EdgeLeft * 0.5f, val4.y), visual.EdgeLeft, borderColor);
			EmitEdge(array, array2, array3, array4, array5, array6, array7, array8, array9, ref v, ref t, val3 + new Vector2(val4.x - visual.EdgeRight * 0.5f, 0f), new Vector2(visual.EdgeRight * 0.5f, val4.y), visual.EdgeRight, borderColor);
			Mesh val5 = MeshFor(((Component)rt).gameObject);
			val5.Clear();
			val5.vertices = Il2CppStructArray<Vector3>.op_Implicit(array);
			val5.colors32 = Il2CppStructArray<Color32>.op_Implicit(array2);
			val5.uv = Il2CppStructArray<Vector2>.op_Implicit(array3);
			val5.uv2 = Il2CppStructArray<Vector2>.op_Implicit(array4);
			val5.uv3 = Il2CppStructArray<Vector2>.op_Implicit(array5);
			val5.uv4 = Il2CppStructArray<Vector2>.op_Implicit(array6);
			val5.normals = Il2CppStructArray<Vector3>.op_Implicit(array7);
			val5.tangents = Il2CppStructArray<Vector4>.op_Implicit(array8);
			val5.triangles = Il2CppStructArray<int>.op_Implicit(array9);
			val2.SetMesh(val5);
			val2.materialCount = 1;
			val2.SetMaterial(val, 0);
			if (ActiveClip.HasValue)
			{
				val2.EnableRectClipping(ActiveClip.Value);
			}
			else
			{
				val2.DisableRectClipping();
			}
		}

		private static void EmitEdge(Vector3[] vertices, Color32[] colors, Vector2[] uv0, Vector2[] uv1, Vector2[] uv2, Vector2[] uv3, Vector3[] normals, Vector4[] tangents, int[] triangles, ref int v, ref int t, Vector2 centre, Vector2 half, float width, Color color)
		{
			//IL_0009: 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_002e: 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_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)
			//IL_0039: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!(width <= 0f) && !(color.a <= 0f))
			{
				EmitQuad(vertices, colors, uv0, uv1, uv2, uv3, normals, tangents, triangles, ref v, ref t, centre, half, half, Vector4.zero, color, color, color, color, 0f, 0f, new Color(0f, 0f, 0f, 0f));
			}
		}

		private static void EmitQuad(Vector3[] vertices, Color32[] colors, Vector2[] uv0, Vector2[] uv1, Vector2[] uv2, Vector2[] uv3, Vector3[] normals, Vector4[] tangents, int[] triangles, ref int v, ref int t, Vector2 centre, Vector2 quadHalf, Vector2 shapeHalf, Vector4 radii, Color cTL, Color cTR, Color cBR, Color cBL, float borderWidth, float blur, Color borderColor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_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_0022: 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_0026: 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_0035: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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)
			//IL_0057: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_007e: 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_008d: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			cTL = ToVertex(cTL);
			cTR = ToVertex(cTR);
			cBR = ToVertex(cBR);
			cBL = ToVertex(cBL);
			borderColor = ToVertex(borderColor);
			Vector2[] array = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(0f - quadHalf.x, quadHalf.y),
				new Vector2(quadHalf.x, quadHalf.y),
				new Vector2(quadHalf.x, 0f - quadHalf.y),
				new Vector2(0f - quadHalf.x, 0f - quadHalf.y)
			};
			Color[] array2 = (Color[])(object)new Color[4] { cTL, cTR, cBR, cBL };
			int num = v;
			for (int i = 0; i < 4; i++)
			{
				Vector2 val = array[i];
				vertices[v] = new Vector3(centre.x + val.x, centre.y + val.y, 0f);
				colors[v] = Color32.op_Implicit(array2[i]);
				uv0[v] = val;
				uv1[v] = shapeHalf;
				uv2[v] = new Vector2(radii.x, radii.y);
				uv3[v] = new Vector2(radii.z, radii.w);
				normals[v] = new Vector3(borderWidth, blur, 0f);
				tangents[v] = new Vector4(borderColor.r, borderColor.g, borderColor.b, borderColor.a);
				v++;
			}
			triangles[t++] = num;
			triangles[t++] = num + 1;
			triangles[t++] = num + 2;
			triangles[t++] = num + 2;
			triangles[t++] = num + 3;
			triangles[t++] = num;
		}

		private static Color ToVertex(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_000c: 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_0014: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			if ((int)QualitySettings.activeColorSpace != 1)
			{
				return c;
			}
			Color linear = ((Color)(ref c)).linear;
			linear.a = c.a;
			return linear;
		}

		private static Mesh MeshFor(GameObject go)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			int instanceID = ((Object)go).GetInstanceID();
			if (_collecting)
			{
				_touched.Add(instanceID);
			}
			if (_meshes.TryGetValue(instanceID, out (int, Mesh) value) && (Object)(object)value.Item2 != (Object)null)
			{
				if (value.Item1 != _owner)
				{
					_meshes[instanceID] = (_owner, value.Item2);
				}
				return value.Item2;
			}
			Mesh val = new Mesh
			{
				name = "sideload-box"
			};
			val.MarkDynamic();
			_meshes[instanceID] = (_owner, val);
			return val;
		}

		private static void PaintFlat(RectTransform rt, BoxVisual visual)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Image val = ((Component)rt).GetComponent<Image>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)rt).gameObject.AddComponent<Image>();
			}
			((Graphic)val).color = visual.FillTL;
			((Graphic)val).raycastTarget = false;
		}

		internal static void BeginPass(int owner)
		{
			_collecting = true;
			_owner = owner;
			_touched.Clear();
		}

		internal static void EndPass()
		{
			if (!_collecting)
			{
				return;
			}
			_collecting = false;
			List<int> list = null;
			foreach (KeyValuePair<int, (int, Mesh)> mesh in _meshes)
			{
				if (mesh.Value.Item1 == _owner && !_touched.Contains(mesh.Key))
				{
					(list ?? (list = new List<int>())).Add(mesh.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				if (_meshes.TryGetValue(item, out (int, Mesh) value) && (Object)(object)value.Item2 != (Object)null)
				{
					Object.Destroy((Object)(object)value.Item2);
				}
				_meshes.Remove(item);
			}
		}

		internal static void Release(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)go).GetInstanceID();
			if (_meshes.TryGetValue(instanceID, out (int, Mesh) value))
			{
				_meshes.Remove(instanceID);
				if ((Object)(object)value.Item2 != (Object)null)
				{
					Object.Destroy((Object)(object)value.Item2);
				}
			}
		}
	}
	internal static class ImageCache
	{
		private const string RuntimeScheme = "s1://";

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

		private static readonly Dictionary<string, byte[]> _supplied = new Dictionary<string, byte[]>(StringComparer.Ordinal);

		internal static void Supply(string appId, string name, byte[] png)
		{
			if (!string.IsNullOrWhiteSpace(name))
			{
				string key = Key(appId, "s1://" + name.Trim());
				if (png == null || png.Length == 0)
				{
					_supplied.Remove(key);
					_byKey.Remove(key);
				}
				else
				{
					_supplied[key] = png;
					_byKey.Remove(key);
				}
			}
		}

		internal static Sprite Get(AppBundle bundle, string appId, string src)
		{
			if (string.IsNullOrWhiteSpace(src))
			{
				return null;
			}
			string text = src.Trim().Replace('\\', '/');
			bool flag = text.StartsWith("s1://", StringComparison.OrdinalIgnoreCase);
			if (!flag)
			{
				text = text.TrimStart('/');
			}
			string key = Key(appId, text);
			if (_byKey.TryGetValue(key, out var value))
			{
				return value;
			}
			byte[] value2;
			Sprite val = (flag ? Decode(_supplied.TryGetValue(key, out value2) ? value2 : null, appId, text) : Load(bundle, appId, text));
			_byKey[key] = val;
			return val;
		}

		private static string Key(string appId, string path)
		{
			return appId + " " + path;
		}

		internal static void Forget(string appId)
		{
			string value = appId + "\0";
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Sprite> item in _byKey)
			{
				if (item.Key.StartsWith(value, StringComparison.Ordinal))
				{
					list.Add(item.Key);
				}
			}
			foreach (string item2 in list)
			{
				_byKey.Remove(item2);
			}
		}

		private static Sprite Load(AppBundle bundle, string appId, string path)
		{
			byte[] array = bundle?.ReadBytes(path);
			if (array == null || array.Length == 0)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning($"[Sideload] {appId}: <img src=\"{path}\"> is not in the bundle or the override folder.");
				}
				return null;
			}
			return Decode(array, appId, path);
		}

		private static Sprite Decode(byte[] bytes, string appId, string path)
		{
			//IL_000e: 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: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (bytes == null || bytes.Length == 0)
			{
				return null;
			}
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					filterMode = (FilterMode)1
				};
				if (!ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(bytes)))
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning($"[Sideload] {appId}: <img src=\"{path}\"> is not a readable PNG or JPG.");
					}
					return null;
				}
				((Object)val).hideFlags = (HideFlags)32;
				Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				if ((Object)(object)val2 != (Object)null)
				{
					((Object)val2).hideFlags = (HideFlags)32;
				}
				return val2;
			}
			catch (Exception ex)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning($"[Sideload] {appId}: loading <img src=\"{path}\"> failed: {ex.Message}");
				}
				return null;
			}
		}
	}
	internal static class Painter
	{
		internal readonly struct PaintedBox
		{
			internal readonly LayoutNode Node;

			internal readonly RectTransform Rect;

			internal readonly TextMeshProUGUI Text;

			internal PaintedBox(LayoutNode node, RectTransform rect, TextMeshProUGUI text = null)
			{
				Node = node;
				Rect = rect;
				Text = text;
			}
		}

		private static Dictionary<IElement, TMP_InputField> _inputs;

		private static Action<IElement, string> _inputChanged;

		private static Action<IElement, string> _inputSubmitted;

		private static Vector2 _viewSize;

		private static RectTransform _viewRoot;

		private static AppBundle _bundle;

		private static string _appId;

		private static Dictionary<IElement, RectTransform> _reuse;

		private static readonly Dictionary<int, Vector2> _placement = new Dictionary<int, Vector2>();

		internal static Dictionary<IElement, PaintedBox> Paint(LayoutNode root, RectTransform host, Vector2 viewSize, Dictionary<IElement, TMP_InputField> inputs, Action<IElement, string> inputChanged, Action<IElement, string> inputSubmitted, Dictionary<IElement, RectTransform> reuse = null, AppBundle bundle = null, string appId = null)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<IElement, PaintedBox> dictionary = new Dictionary<IElement, PaintedBox>();
			if (root == null || (Object)(object)host == (Object)null)
			{
				return dictionary;
			}
			_inputs = inputs;
			_inputChanged = inputChanged;
			_inputSubmitted = inputSubmitted;
			_inputs?.Clear();
			_placement.Clear();
			_viewSize = viewSize;
			_viewRoot = host;
			_reuse = reuse;
			_bundle = bundle;
			_appId = appId ?? "";
			BoxRenderer.ActiveClip = null;
			BoxRenderer.BeginPass(((Object)host).GetInstanceID());
			try
			{
				PaintNode(root, (Transform)(object)host, 0, dictionary, 0f, 0f);
				return dictionary;
			}
			finally
			{
				BoxRenderer.EndPass();
				_reuse = null;
				_inputs = null;
				_inputChanged = null;
				_inputSubmitted = null;
				_bundle = null;
			}
		}

		private static void PaintNode(LayoutNode node, Transform parent, int depth, Dictionary<IElement, PaintedBox> painted, float absX, float absY)
		{
			if (node.Style.Display == DisplayKind.None)
			{
				return;
			}
			absX += node.X;
			absY += node.Y;
			object tag = node.Tag;
			IElement val = (IElement)((tag is IElement) ? tag : null);
			if (val != null && _reuse != null && _reuse.TryGetValue(val, out var value) && (Object)(object)value != (Object)null)
			{
				painted[val] = new PaintedBox(node, ReuseControl(node, value, parent, val, absX, absY));
				return;
			}
			RectTransform val2 = UiFactory.Rect(NameOf(node, depth), parent);
			UiFactory.PlaceFromTopLeft(val2, node.X, node.Y, node.Width, node.Height);
			ApplyTransform(val2, node.Style);
			object tag2 = node.Tag;
			IElement val3 = (IElement)((tag2 is IElement) ? tag2 : null);
			if (val3 != null && !painted.ContainsKey(val3))
			{
				painted[val3] = new PaintedBox(node, val2);
			}
			if (Paints(node.Style))
			{
				BoxRenderer.Paint(val2, ToVisual(node.Style, node.Width, node.Height), node.Width, node.Height);
			}
			if (IsFormControl(node, out var multiline))
			{
				PaintInput(node, val2, multiline, absX, absY);
				return;
			}
			if (IsImage(node))
			{
				PaintImage(node, val2);
				return;
			}
			if (node.IsTextLeaf)
			{
				TextMeshProUGUI text = PaintText(node, val2);
				object tag3 = node.Tag;
				IElement val4 = (IElement)((tag3 is IElement) ? tag3 : null);
				if (val4 != null)
				{
					painted[val4] = new PaintedBox(node, val2, text);
				}
				return;
			}
			if (!NeedsScrolling(node))
			{
				foreach (LayoutNode child in node.Children)
				{
					PaintNode(child, (Transform)(object)val2, depth + 1, painted, absX, absY);
				}
				return;
			}
			Rect? clip;
			Transform parent2 = BuildScrollArea(node, val2, absX, absY, out clip);
			Rect? activeClip = BoxRenderer.ActiveClip;
			BoxRenderer.ActiveClip = clip ?? activeClip;
			try
			{
				foreach (LayoutNode child2 in node.Children)
				{
					PaintNode(child2, parent2, depth + 1, painted, absX, absY);
				}
			}
			finally
			{
				BoxRenderer.ActiveClip = activeClip;
			}
		}

		private static Rect? ClipRectInCanvasSpace(float absX, float absY, float width, float height)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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)
			//IL_00ce: 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_00d4: 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_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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_viewRoot == (Object)null)
			{
				return null;
			}
			Canvas componentInParent = ((Component)_viewRoot).GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return null;
			}
			Transform transform = ((Component)(((Object)(object)componentInParent.rootCanvas != (Object)null) ? componentInParent.rootCanvas : componentInParent)).transform;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(absX - _viewSize.x * 0.5f, _viewSize.y * 0.5f - absY, 0f);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(absX + width - _viewSize.x * 0.5f, _viewSize.y * 0.5f - (absY + height), 0f);
			Vector3 val3 = transform.InverseTransformPoint(((Transform)_viewRoot).TransformPoint(val));
			Vector3 val4 = transform.InverseTransformPoint(((Transform)_viewRoot).TransformPoint(val2));
			float num = Math.Min(val3.x, val4.x);
			float num2 = Math.Max(val3.x, val4.x);
			float num3 = Math.Min(val3.y, val4.y);
			float num4 = Math.Max(val3.y, val4.y);
			return new Rect(num, num3, num2 - num, num4 - num3);
		}

		private static bool NeedsScrolling(LayoutNode node)
		{
			OverflowKind overflowY = node.Style.OverflowY;
			if (overflowY != OverflowKind.Auto && overflowY != OverflowKind.Scroll)
			{
				return false;
			}
			return ContentBottom(node) > node.Height + 0.5f;
		}

		private static float ContentBottom(LayoutNode node)
		{
			float num = 0f;
			foreach (LayoutNode child in node.Children)
			{
				if (child.Style.Display != DisplayKind.None)
				{
					num = Math.Max(num, child.Y + child.Height);
				}
			}
			return num + node.Style.Padding.Bottom.Resolve(node.Width);
		}

		private static Transform BuildScrollArea(LayoutNode node, RectTransform box, float absX, float absY, out Rect? clip)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = UiFactory.Rect("scroll-viewport", (Transform)(object)box);
			UiFactory.Stretch(val);
			Image obj = ((Component)val).gameObject.AddComponent<Image>();
			((Graphic)obj).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)obj).raycastTarget = true;
			RectTransform val2 = UiFactory.Rect("scroll-content", (Transform)(object)val);
			UiFactory.PlaceFromTopLeft(val2, 0f, 0f, node.Width, ContentBottom(node));
			ScrollRect obj2 = ((Component)val).gameObject.AddComponent<ScrollRect>();
			obj2.content = val2;
			obj2.viewport = val;
			obj2.horizontal = false;
			obj2.vertical = true;
			obj2.movementType = (MovementType)1;
			obj2.elasticity = 0.1f;
			obj2.scrollSensitivity = 24f;
			obj2.inertia = true;
			obj2.decelerationRate = 0.135f;
			clip = ClipRectInCanvasSpace(absX, absY, node.Width, node.Height);
			Instance log = Core.Log;
			if (log != null)
			{
				log.Msg($"[Sideload] scroll area at ({absX:0.#},{absY:0.#}) size {node.Width:0.#}x{node.Height:0.#}, content {ContentBottom(node):0.#}, clip={clip}");
			}
			return (Transform)(object)val2;
		}

		internal static void Repaint(PaintedBox box, ComputedStyle style)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)box.Rect == (Object)null) && style != null)
			{
				BoxRenderer.Paint(box.Rect, ToVisual(style, box.Node.Width, box.Node.Height), box.Node.Width, box.Node.Height);
				ApplyTransform(box.Rect, style);
				if ((Object)(object)box.Text != (Object)null)
				{
					((Graphic)box.Text).color = new Color(style.Color.R, style.Color.G, style.Color.B, style.Color.A);
				}
			}
		}

		internal static void RepaintBetween(PaintedBox box, ComputedStyle from, ComputedStyle to, float t)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0067: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)box.Rect == (Object)null) && from != null && to != null)
			{
				float width = box.Node.Width;
				float height = box.Node.Height;
				BoxVisual visual = ToVisual(to, width, height);
				BoxVisual boxVisual = ToVisual(from, width, height);
				visual.FillTL = Color.Lerp(boxVisual.FillTL, visual.FillTL, t);
				visual.FillTR = Color.Lerp(boxVisual.FillTR, visual.FillTR, t);
				visual.FillBR = Color.Lerp(boxVisual.FillBR, visual.FillBR, t);
				visual.FillBL = Color.Lerp(boxVisual.FillBL, visual.FillBL, t);
				visual.BorderColor = Color.Lerp(boxVisual.BorderColor, visual.BorderColor, t);
				visual.ShadowColor = Color.Lerp(boxVisual.ShadowColor, visual.ShadowColor, t);
				BoxRenderer.Paint(box.Rect, visual, width, height);
				ApplyTransform(box.Rect, from, to, t);
				if ((Object)(object)box.Text != (Object)null)
				{
					((Graphic)box.Text).color = Color.Lerp(new Color(from.Color.R, from.Color.G, from.Color.B, from.Color.A), new Color(to.Color.R, to.Color.G, to.Color.B, to.Color.A), t);
				}
			}
		}

		private static void ApplyTransform(RectTransform rt, ComputedStyle style)
		{
			if (!((Object)(object)rt == (Object)null) && style != null)
			{
				Place(rt, style.TranslateX, style.TranslateY, style.ScaleX, style.ScaleY, style.RotateDeg);
			}
		}

		private static void ApplyTransform(RectTransform rt, ComputedStyle from, ComputedStyle to, float t)
		{
			if (!((Object)(object)rt == (Object)null))
			{
				Place(rt, Mathf.Lerp(from.TranslateX, to.TranslateX, t), Mathf.Lerp(from.TranslateY, to.TranslateY, t), Mathf.Lerp(from.ScaleX, to.ScaleX, t), Mathf.Lerp(from.ScaleY, to.ScaleY, t), Mathf.Lerp(from.RotateDeg, to.RotateDeg, t));
			}
		}

		private static void Place(RectTransform rt, float tx, float ty, float sx, float sy, float rotation)
		{
			//IL_002d: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!_placement.TryGetValue(((Object)rt).GetInstanceID(), out var value))
			{
				value = (_placement[((Object)rt).GetInstanceID()] = rt.anchoredPosition);
			}
			rt.anchoredPosition = value + new Vector2(tx, 0f - ty);
			((Transform)rt).localScale = new Vector3(sx, sy, 1f);
			((Transform)rt).localRotation = Quaternion.Euler(0f, 0f, 0f - rotation);
		}

		private static bool IsFormControl(LayoutNode node, out bool multiline)
		{
			multiline = false;
			object tag = node.Tag;
			IElement val = (IElement)((tag is IElement) ? tag : null);
			if (val == null)
			{
				return false;
			}
			string localName = val.LocalName;
			if (string.Equals(localName, "textarea", StringComparison.OrdinalIgnoreCase))
			{
				multiline = true;
				return true;
			}
			return string.Equals(localName, "input", StringComparison.OrdinalIgnoreCase);
		}

		private static RectTransform ReuseControl(LayoutNode node, RectTransform kept, Transform parent, IElement element, float absX, float absY)
		{
			((Transform)kept).SetParent(parent, false);
			UiFactory.PlaceFromTopLeft(kept, node.X, node.Y, node.Width, node.Height);
			if (Paints(node.Style))
			{
				BoxRenderer.Paint(kept, ToVisual(node.Style, node.Width, node.Height), node.Width, node.Height);
			}
			foreach (EventTrigger component2 in ((Component)kept).GetComponents<EventTrigger>())
			{
				Object.Destroy((Object)(object)component2);
			}
			TMP_InputField component = ((Component)kept).GetComponent<TMP_InputField>();
			if ((Object)(object)component != (Object)null)
			{
				if (_inputs != null)
				{
					_inputs[element] = component;
				}
				string text = element.GetAttribute("value") ?? "";
				if (!string.Equals(component.text, text, StringComparison.Ordinal))
				{
					component.text = text;
				}
				((Selectable)component).interactable = !element.HasAttribute("disabled");
				if ((Object)(object)component.placeholder != (Object)null)
				{
					TextMeshProUGUI val = ((Il2CppObjectBase)component.placeholder).TryCast<TextMeshProUGUI>();
					string text2 = element.GetAttribute("placeholder") ?? "";
					if ((Object)(object)val != (Object)null && !string.Equals(((TMP_Text)val).text, text2, StringComparison.Ordinal))
					{
						((TMP_Text)val).text = text2;
					}
				}
				component.characterLimit = ((int.TryParse(element.GetAttribute("maxlength"), out var result) && result > 0) ? result : 0);
				ComputedStyle style = node.Style;
				Rect? clip = InputClip(node, absX, absY, style.Padding.Left.Resolve(node.Width) + style.BorderWidth.Left.Resolve(node.Width), style.Padding.Right.Resolve(node.Width) + style.BorderWidth.Right.Resolve(node.Width), style.Padding.Top.Resolve(node.Width) + style.BorderWidth.Top.Resolve(node.Width), style.Padding.Bottom.Resolve(node.Width) + style.BorderWidth.Bottom.Resolve(node.Width));
				ClipTo((Graphic)(object)(((Object)(object)component.textComponent != (Object)null) ? ((Il2CppObjectBase)component.textComponent).TryCast<TextMeshProUGUI>() : null), clip);
				ClipTo((Graphic)(object)(((Object)(object)component.placeholder != (Object)null) ? ((Il2CppObjectBase)component.placeholder).TryCast<TextMeshProUGUI>() : null), clip);
			}
			return kept;
		}

		private static void PaintInput(LayoutNode node, RectTransform box, bool multiline, float absX, float absY)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0208: 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_032e: Unknown result type (might be due to invalid IL or missing references)
			ComputedStyle style = node.Style;
			IElement element = (IElement)node.Tag;
			float num = style.Padding.Left.Resolve(node.Width) + style.BorderWidth.Left.Resolve(node.Width);
			float num2 = style.Padding.Right.Resolve(node.Width) + style.BorderWidth.Right.Resolve(node.Width);
			float num3 = style.Padding.Top.Resolve(node.Width) + style.BorderWidth.Top.Resolve(node.Width);
			float num4 = style.Padding.Bottom.Resolve(node.Width) + style.BorderWidth.Bottom.Resolve(node.Width);
			RectTransform val = UiFactory.Rect("input-viewport", (Transform)(object)box);
			UiFactory.Stretch(val, num3, num2, num4, num);
			Rect? clip = InputClip(node, absX, absY, num, num2, num3, num4);
			RectTransform obj = UiFactory.Rect("input-text", (Transform)(object)val);
			UiFactory.Stretch(obj);
			TextMeshProUGUI val2 = ((Component)obj).gameObject.AddComponent<TextMeshProUGUI>();
			TmpMeasure.Apply((TMP_Text)(object)val2, style);
			((TMP_Text)val2).text = "";
			ClipTo((Graphic)(object)val2, clip);
			RectTransform obj2 = UiFactory.Rect("input-placeholder", (Transform)(object)val);
			UiFactory.Stretch(obj2);
			TextMeshProUGUI val3 = ((Component)obj2).gameObject.AddComponent<TextMeshProUGUI>();
			TmpMeasure.Apply((TMP_Text)(object)val3, style);
			((TMP_Text)val3).text = element.GetAttribute("placeholder") ?? "";
			((Graphic)val3).color = new Color(style.Color.R, style.Color.G, style.Color.B, style.Color.A * 0.45f);
			ClipTo((Graphic)(object)val3, clip);
			TMP_InputField val4 = ((Component)box).gameObject.AddComponent<TMP_InputField>();
			val4.textViewport = val;
			val4.textComponent = (TMP_Text)(object)val2;
			val4.placeholder = (Graphic)(object)val3;
			val4.lineType = (LineType)(multiline ? 2 : 0);
			val4.text = element.GetAttribute("value") ?? "";
			((Selectable)val4).interactable = !element.HasAttribute("disabled");
			val4.richText = false;
			if (int.TryParse(element.GetAttribute("maxlength"), out var result) && result > 0)
			{
				val4.characterLimit = result;
			}
			val4.onFocusSelectAll = false;
			val4.resetOnDeActivation = false;
			val4.customCaretColor = true;
			val4.caretColor = new Color(style.Color.R, style.Color.G, style.Color.B, 1f);
			val4.caretWidth = 2;
			val4.caretBlinkRate = 1.5f;
			val4.selectionColor = new Color(0.369f, 0.416f, 0.824f, 0.5f);
			((Behaviour)val4).enabled = false;
			((Behaviour)val4).enabled = true;
			Action<IElement, string> changed = _inputChanged;
			Action<IElement, string> submitted = _inputSubmitted;
			((UnityEvent<string>)(object)val4.onSubmit).AddListener(UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				try
				{
					submitted?.Invoke(element, v);
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] submit handler failed: " + ex.Message);
					}
				}
			}));
			((UnityEvent<string>)(object)val4.onSelect).AddListener(UnityAction<string>.op_Implicit((Action<string>)delegate
			{
				SetTyping(typing: true);
			}));
			((UnityEvent<string>)(object)val4.onDeselect).AddListener(UnityAction<string>.op_Implicit((Action<string>)delegate
			{
				SetTyping(typing: false);
			}));
			((UnityEvent<string>)(object)val4.onValueChanged).AddListener(UnityAction<string>.op_Implicit((Action<string>)delegate(string v)
			{
				try
				{
					changed?.Invoke(element, v);
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] input handler failed: " + ex.Message);
					}
				}
			}));
			if (_inputs != null)
			{
				_inputs[element] = val4;
			}
		}

		private static void SetTyping(bool typing)
		{
			try
			{
				GameInput.IsTyping = typing;
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] IsTyping toggle failed: " + ex.Message);
				}
			}
		}

		private static bool IsImage(LayoutNode node)
		{
			object tag = node.Tag;
			IElement val = (IElement)((tag is IElement) ? tag : null);
			if (val != null)
			{
				return val.LocalName.Equals("img", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static void PaintImage(LayoutNode node, RectTransform box)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			string src = ((IElement)node.Tag).GetAttribute("src") ?? "";
			Sprite val = ImageCache.Get(_bundle, _appId, src);
			if (!((Object)(object)val == (Object)null))
			{
				ComputedStyle style = node.Style;
				float left = style.Padding.Left.Resolve(node.Width) + style.BorderWidth.Left.Resolve(node.Width);
				float right = style.Padding.Right.Resolve(node.Width) + style.BorderWidth.Right.Resolve(node.Width);
				float top = style.Padding.Top.Resolve(node.Width) + style.BorderWidth.Top.Resolve(node.Width);
				float bottom = style.Padding.Bottom.Resolve(node.Width) + style.BorderWidth.Bottom.Resolve(node.Width);
				RectTransform obj = UiFactory.Rect("img", (Transform)(object)box);
				UiFactory.Stretch(obj, top, right, bottom, left);
				Image obj2 = ((Component)obj).gameObject.AddComponent<Image>();
				obj2.sprite = val;
				obj2.preserveAspect = true;
				((Graphic)obj2).raycastTarget = false;
				((Graphic)obj2).color = new Color(style.Color.R, style.Color.G, style.Color.B, style.Color.A * style.Opacity);
				ClipTo((Graphic)(object)obj2, BoxRenderer.ActiveClip);
			}
		}

		private static TextMeshProUGUI PaintText(LayoutNode node, RectTransform box)
		{
			ComputedStyle style = node.Style;
			float left = style.Padding.Left.Resolve(node.Width) + style.BorderWidth.Left.Resolve(node.Width);
			float right = style.Padding.Right.Resolve(node.Width) + style.BorderWidth.Right.Resolve(node.Width);
			float top = style.Padding.Top.Resolve(node.Width) + style.BorderWidth.Top.Resolve(node.Width);
			float bottom = style.Padding.Bottom.Resolve(node.Width) + style.BorderWidth.Bottom.Resolve(node.Width);
			RectTransform obj = UiFactory.Rect("text", (Transform)(object)box);
			UiFactory.Stretch(obj, top, right, bottom, left);
			TextMeshProUGUI obj2 = ((Component)obj).gameObject.AddComponent<TextMeshProUGUI>();
			TmpMeasure.Apply((TMP_Text)(object)obj2, style);
			((TMP_Text)obj2).text = node.Text;
			((Graphic)obj2).raycastTarget = false;
			ClipTo((Graphic)(object)obj2, BoxRenderer.ActiveClip);
			return obj2;
		}

		private static Rect? InputClip(LayoutNode node, float absX, float absY, float padLeft, float padRight, float padTop, float padBottom)
		{
			//IL_0056: 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_005e: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			Rect? result = ClipRectInCanvasSpace(absX + padLeft, absY + padTop, Math.Max(0f, node.Width - padLeft - padRight), Math.Max(0f, node.Height - padTop - padBottom));
			Rect? activeClip = BoxRenderer.ActiveClip;
			if (!result.HasValue)
			{
				return activeClip;
			}
			if (!activeClip.HasValue)
			{
				return result;
			}
			Rect value = result.Value;
			Rect value2 = activeClip.Value;
			float num = Math.Max(((Rect)(ref value)).xMin, ((Rect)(ref value2)).xMin);
			float num2 = Math.Min(((Rect)(ref value)).xMax, ((Rect)(ref value2)).xMax);
			float num3 = Math.Max(((Rect)(ref value)).yMin, ((Rect)(ref value2)).yMin);
			float num4 = Math.Min(((Rect)(ref value)).yMax, ((Rect)(ref value2)).yMax);
			return new Rect(num, num3, Math.Max(0f, num2 - num), Math.Max(0f, num4 - num3));
		}

		private static void ClipTo(Graphic graphic, Rect? clip)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)graphic == (Object)null)
			{
				return;
			}
			CanvasRenderer canvasRenderer = graphic.canvasRenderer;
			if (!((Object)(object)canvasRenderer == (Object)null))
			{
				if (clip.HasValue)
				{
					canvasRenderer.EnableRectClipping(clip.Value);
				}
				else
				{
					canvasRenderer.DisableRectClipping();
				}
			}
		}

		private static bool Paints(ComputedStyle s)
		{
			if (s.BackgroundColor.IsTransparent && !s.HasGradient && (!s.HasShadow || s.ShadowColor.IsTransparent))
			{
				if (!s.BorderColor.IsTransparent)
				{
					return MaxBorder(s) > 0f;
				}
				return false;
			}
			return true;
		}

		private static float MaxBorder(ComputedStyle s)
		{
			return Math.Max(Math.Max(s.BorderWidth.Top.Resolve(0f), s.BorderWidth.Right.Resolve(0f)), Math.Max(s.BorderWidth.Bottom.Resolve(0f), s.BorderWidth.Left.Resolve(0f)));
		}

		internal static BoxVisual ToVisual(ComputedStyle s, float width, float height)
		{
			//IL_0006: 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_0016: 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)
			//IL_001f: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: 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)
			Color val = ToColor(s.BackgroundColor);
			BoxVisual visual = new BoxVisual
			{
				FillTL = val,
				FillTR = val,
				FillBR = val,
				FillBL = val,
				RadiusTL = s.BorderRadius.TopLeft,
				RadiusTR = s.BorderRadius.TopRight,
				RadiusBR = s.BorderRadius.BottomRight,
				RadiusBL = s.BorderRadius.BottomLeft,
				BorderColor = ToColor(s.BorderColor),
				HasShadow = (s.HasShadow && !s.ShadowColor.IsTransparent),
				ShadowOffsetX = s.ShadowOffsetX,
				ShadowOffsetY = s.ShadowOffsetY,
				ShadowBlur = s.ShadowBlur,
				ShadowColor = ToColor(s.ShadowColor)
			};
			float num = s.BorderWidth.Top.Resolve(width);
			float num2 = s.BorderWidth.Right.Resolve(width);
			float num3 = s.BorderWidth.Bottom.Resolve(width);
			float num4 = s.BorderWidth.Left.Resolve(width);
			if (num == num2 && num2 == num3 && num3 == num4)
			{
				visual.BorderWidth = num;
			}
			else
			{
				visual.EdgeTop = num;
				visual.EdgeRight = num2;
				visual.EdgeBottom = num3;
				visual.EdgeLeft = num4;
			}
			if (s.HasGradient)
			{
				ApplyGradient(ref visual, s, width, height);
			}
			if (s.Opacity < 1f)
			{
				visual.FillTL = Fade(visual.FillTL, s.Opacity);
				visual.FillTR = Fade(visual.FillTR, s.Opacity);
				visual.FillBR = Fade(visual.FillBR, s.Opacity);
				visual.FillBL = Fade(visual.FillBL, s.Opacity);
				visual.BorderColor = Fade(visual.BorderColor, s.Opacity);
				visual.ShadowColor = Fade(visual.ShadowColor, s.Opacity);
			}
			return visual;
		}

		private static void ApplyGradient(ref BoxVisual visual, ComputedStyle s, float width, float height)
		{
			//IL_0026: 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_0034: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_009a: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			float num = s.GradientAngleDeg * (float)Math.PI / 180f;
			Vector2 dir = new Vector2((float)Math.Sin(num), 0f - (float)Math.Cos(num));
			float halfSpan = (Math.Abs(width * dir.x) + Math.Abs(height * dir.y)) * 0.5f;
			if (halfSpan < 0.001f)
			{
				halfSpan = 0.001f;
			}
			Color from = ToColor(s.GradientFrom);
			Color to = ToColor(s.GradientTo);
			float num2 = width * 0.5f;
			float num3 = height * 0.5f;
			visual.FillTL = At(0f - num2, 0f - num3);
			visual.FillTR = At(num2, 0f - num3);
			visual.FillBR = At(num2, num3);
			visual.FillBL = At(0f - num2, num3);
			Color At(float x, float y)
			{
				//IL_0040: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				float num4 = Math.Clamp((x * dir.x + y * dir.y + halfSpan) / (2f * halfSpan), 0f, 1f);
				return Color.Lerp(from, to, num4);
			}
		}

		private static Color ToColor(RgbaColor c)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Color(c.R, c.G, c.B, c.A);
		}

		private static Color Fade(Color c, float factor)
		{
			//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_000c: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			return new Color(c.r, c.g, c.b, c.a * factor);
		}

		private static string NameOf(LayoutNode node, int depth)
		{
			object tag = node.Tag;
			IElement val = (IElement)((tag is IElement) ? tag : null);
			if (val != null)
			{
				string attribute = val.GetAttribute("id");
				if (!string.IsNullOrEmpty(attribute))
				{
					return val.LocalName + "#" + attribute;
				}
				return val.LocalName;
			}
			return "node" + depth;
		}
	}
	internal static class FontRegistry
	{
		private static bool _scanned;

		private static readonly Dictionary<string, TMP_FontAsset> _byName = new Dictionary<string, TMP_FontAsset>(StringComparer.OrdinalIgnoreCase);

		private static TMP_FontAsset _fallback;

		internal static TMP_FontAsset Resolve(string family, int weight, FontStyleKind style)
		{
			Scan();
			bool flag = style == FontStyleKind.Italic;
			switch ((family ?? "game-ui").Trim().ToLowerInvariant())
			{
			case "game-hand":
				return Find("Caveat-Regular") ?? Find("Handlee-Regular") ?? _fallback;
			case "game-comic":
				return Find(flag ? "ComicNeue-BoldItalic" : "ComicNeue-Bold") ?? _fallback;
			case "game-pixel":
				return Find("VPPixel-Simplified") ?? _fallback;
			case "game-segment":
				return Find("fs-sevegment") ?? _fallback;
			default:
			{
				string text = ((weight >= 700) ? "Bold" : ((weight >= 600) ? "SemiBold" : ((weight >= 500) ? "Medium" : ((weight <= 300) ? "Light" : "Regular"))));
				TMP_FontAsset val = null;
				if (flag)
				{
					val = Find("OpenSans-" + text + "Italic");
				}
				if (val == null)
				{
					val = Find("OpenSans-" + text);
				}
				if (val == null)
				{
					val = Find("OpenSans-Regular");
				}
				return val ?? _fallback;
			}
			}
		}

		private static TMP_FontAsset Find(string name)
		{
			if (_byName.TryGetValue(name + " SDF", out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if (_byName.TryGetValue(name, out value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			foreach (KeyValuePair<string, TMP_FontAsset> item in _byName)
			{
				if (!((Object)(object)item.Value == (Object)null) && item.Key.StartsWith(name, StringComparison.OrdinalIgnoreCase))
				{
					return item.Value;
				}
			}
			return null;
		}

		private static void Scan()
		{
			if (_scanned)
			{
				return;
			}
			_scanned = true;
			try
			{
				TMP_FontAsset[] array = Il2CppArrayBase<TMP_FontAsset>.op_Implicit(Resources.FindObjectsOfTypeAll<TMP_FontAsset>());
				if (array == null)
				{
					return;
				}
				TMP_FontAsset[] array2 = array;
				foreach (TMP_FontAsset val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name))
					{
						_byName[((Object)val).name] = val;
						if ((Object)(object)_fallback == (Object)null && ((Object)val).name.StartsWith("LiberationSans", StringComparison.OrdinalIgnoreCase))
						{
							_fallback = val;
						}
					}
				}
				if ((Object)(object)_fallback == (Object)null && array.Length != 0)
				{
					_fallback = array[0];
				}
				Instance log = Core.Log;
				if (log != null)
				{
					DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(49, 2);
					defaultInterpolatedStringHandler.AppendLiteral("[Sideload] font registry: ");
					defaultInterpolatedStringHandler.AppendFormatted(_byName.Count);
					defaultInterpolatedStringHandler.AppendLiteral(" asset(s), fallback '");
					TMP_FontAsset fallback = _fallback;
					defaultInterpolatedStringHandler.AppendFormatted((fallback != null) ? ((Object)fallback).name : null);
					defaultInterpolatedStringHandler.AppendLiteral("'.");
					log.Msg(defaultInterpolatedStringHandler.ToStringAndClear());
				}
			}
			catch (Exception ex)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload] font scan failed: " + ex.Message);
				}
			}
		}
	}
	internal sealed class TmpMeasure : IMeasureText
	{
		private const float Unbounded = 100000f;

		private readonly TextMeshProUGUI _probe;

		internal TmpMeasure(Transform parent)
		{
			//IL_0025: 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_003c: 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)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = UiFactory.Rect("sideload-measure", parent);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0f, 1f);
			val.anchorMax = val2;
			val.anchorMin = val2;
			val.pivot = new Vector2(0f, 1f);
			val.sizeDelta = new Vector2(10f, 10f);
			val.anchoredPosition = new Vector2(-100000f, 100000f);
			_probe = ((Component)val).gameObject.AddComponent<TextMeshProUGUI>();
			((Graphic)_probe).raycastTarget = false;
		}

		public Size Measure(string text, ComputedStyle style, float availableWidth)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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)
			if ((Object)(object)_probe == (Object)null || string.IsNullOrEmpty(text))
			{
				return new Size(0f, style?.ResolvedLineHeight ?? 0f);
			}
			try
			{
				Apply((TMP_Text)(object)_probe, style);
				float num = ((float.IsPositiveInfinity(availableWidth) || availableWidth <= 0f) ? 100000f : availableWidth);
				((TMP_Text)_probe).rectTransform.sizeDelta = new Vector2(num, 100000f);
				((TMP_Text)_probe).text = text;
				Vector2 preferredValues = ((TMP_Text)_probe).GetPreferredValues(text, num, 100000f);
				float y = preferredValues.y;
				float x = preferredValues.x;
				return new Size(float.IsPositiveInfinity(availableWidth) ? x : Math.Min(x, availableWidth), y);
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] text measure failed: " + ex.Message);
				}
				return new Size(0f, style.ResolvedLineHeight);
			}
		}

		internal static void Apply(TMP_Text tmp, ComputedStyle s)
		{
			//IL_006e: 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)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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)
			if (!((Object)(object)tmp == (Object)null) && s != null)
			{
				TMP_FontAsset val = FontRegistry.Resolve(s.FontFamily, s.FontWeight, s.FontStyle);
				if ((Object)(object)val != (Object)null)
				{
					tmp.font = val;
				}
				tmp.fontSize = s.FontSize;
				((Graphic)tmp).color = new Color(s.Color.R, s.Color.G, s.Color.B, s.Color.A);
				tmp.characterSpacing = s.LetterSpacing;
				tmp.lineSpacing = 0f;
				tmp.richText = true;
				tmp.enableWordWrapping = s.WhiteSpace != WhiteSpaceKind.NoWrap;
				tmp.overflowMode = (TextOverflowModes)(s.TextOverflowEllipsis ? 1 : 0);
				bool flag = s.AlignItems == AlignKind.Center;
				tmp.alignment = (TextAlignmentOptions)(s.TextAlign switch
				{
					TextAlignKind.Center => flag ? 514 : 258, 
					TextAlignKind.Right => flag ? 516 : 260, 
					_ => flag ? 513 : 257, 
				});
				tmp.fontStyle = (FontStyles)0;
			}
		}
	}
	internal static class Transitions
	{
		private sealed class Tween
		{
			internal Painter.PaintedBox Box;

			internal ComputedStyle From;

			internal ComputedStyle To;

			internal float Elapsed;

			internal float Duration;

			internal float Delay;

			internal EasingKind Easing;
		}

		private static readonly Dictionary<int, Tween> _active = new Dictionary<int, Tween>();

		internal static bool Idle => _active.Count == 0;

		internal static void To(Painter.PaintedBox box, ComputedStyle from, ComputedStyle to)
		{
			if ((Object)(object)box.Rect == (Object)null || to == null)
			{
				return;
			}
			if (to.TransitionSeconds <= 0f || from == null)
			{
				Cancel(box);
				Painter.Repaint(box, to);
				return;
			}
			int instanceID = ((Object)box.Rect).GetInstanceID();
			ComputedStyle computedStyle = from;
			if (_active.TryGetValue(instanceID, out var value))
			{
				computedStyle = Blend(value.From, value.To, Progress(value));
			}
			_active[instanceID] = new Tween
			{
				Box = box,
				From = computedStyle,
				To = to,
				Duration = to.TransitionSeconds,
				Delay = to.TransitionDelaySeconds,
				Easing = to.TransitionEasing
			};
		}

		internal static void Cancel(Painter.PaintedBox box)
		{
			if ((Object)(object)box.Rect != (Object)null)
			{
				_active.Remove(((Object)box.Rect).GetInstanceID());
			}
		}

		internal static void Clear()
		{
			_active.Clear();
		}

		internal static void Tick(float deltaSeconds)
		{
			if (_active.Count == 0)
			{
				return;
			}
			List<int> list = null;
			foreach (KeyValuePair<int, Tween> item in _active)
			{
				Tween value = item.Value;
				value.Elapsed += deltaSeconds;
				if ((Object)(object)value.Box.Rect == (Object)null)
				{
					(list ?? (list = new List<int>())).Add(item.Key);
					continue;
				}
				float num = Progress(value);
				Painter.RepaintBetween(value.Box, value.From, value.To, Ease(num, value.Easing));
				if (num >= 1f)
				{
					(list ?? (list = new List<int>())).Add(item.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item2 in list)
			{
				_active.Remove(item2);
			}
		}

		private static float Progress(Tween tween)
		{
			return Math.Clamp((tween.Elapsed - tween.Delay) / Math.Max(tween.Duration, 0.0001f), 0f, 1f);
		}

		private static float Ease(float t, EasingKind kind)
		{
			return kind switch
			{
				EasingKind.Linear => t, 
				EasingKind.EaseIn => t * t, 
				EasingKind.EaseInOut => (t < 0.5f) ? (2f * t * t) : (1f - 2f * (1f - t) * (1f - t)), 
				_ => 1f - (1f - t) * (1f - t), 
			};
		}

		private static ComputedStyle Blend(ComputedStyle from, ComputedStyle to, float t)
		{
			ComputedStyle computedStyle = to.Clone();
			computedStyle.BackgroundColor = Lerp(from.BackgroundColor, to.BackgroundColor, t);
			computedStyle.BorderColor = Lerp(from.BorderColor, to.BorderColor, t);
			computedStyle.Color = Lerp(from.Color, to.Color, t);
			computedStyle.ShadowColor = Lerp(from.ShadowColor, to.ShadowColor, t);
			computedStyle.Opacity = from.Opacity + (to.Opacity - from.Opacity) * t;
			computedStyle.TranslateX = from.TranslateX + (to.TranslateX - from.TranslateX) * t;
			computedStyle.TranslateY = from.TranslateY + (to.TranslateY - from.TranslateY) * t;
			computedStyle.ScaleX = from.ScaleX + (to.ScaleX - from.ScaleX) * t;
			computedStyle.ScaleY = from.ScaleY + (to.ScaleY - from.ScaleY) * t;
			computedStyle.RotateDeg = from.RotateDeg + (to.RotateDeg - from.RotateDeg) * t;
			return computedStyle;
		}

		private static RgbaColor Lerp(RgbaColor a, RgbaColor b, float t)
		{
			return new RgbaColor(a.R + (b.R - a.R) * t, a.G + (b.G - a.G) * t, a.B + (b.B - a.B) * t, a.A + (b.A - a.A) * t);
		}
	}
	internal static class UiFactory
	{
		internal static RectTransform Rect(string name, Transform parent)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0030: 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)
			GameObject val = new GameObject(name);
			if ((Object)(object)parent != (Object)null)
			{
				val.layer = ((Component)parent).gameObject.layer;
			}
			RectTransform obj = val.AddComponent<RectTransform>();
			((Transform)obj).SetParent(parent, false);
			((Transform)obj).localScale = Vector3.one;
			((Transform)obj).localRotation = Quaternion.identity;
			((Transform)obj).localPosition = Vector3.zero;
			return obj;
		}

		internal static void Stretch(RectTransform rt, float top = 0f, float right = 0f, float bottom = 0f, float left = 0f)
		{
			//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_0021: 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)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.pivot = new Vector2(0.5f, 0.5f);
			rt.offsetMin = new Vector2(left, bottom);
			rt.offsetMax = new Vector2(0f - right, 0f - top);
		}

		internal static void PlaceFromTopLeft(RectTransform rt, float x, float y, float width, float height)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(0f, 1f);
			rt.pivot = new Vector2(0f, 1f);
			rt.sizeDelta = new Vector2(width, height);
			rt.anchoredPosition = new Vector2(x, 0f - y);
		}

		internal static Image Fill(RectTransform rt, Color color, bool raycastTarget = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Image obj = ((Component)rt).gameObject.AddComponent<Image>();
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = raycastTarget;
			return obj;
		}

		internal static void ClearChildren(Transform t)
		{
			if (!((Object)(object)t == (Object)null))
			{
				for (int num = t.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)t.GetChild(num)).gameObject);
				}
			}
		}
	}
}
namespace Sideload.Net
{
	internal sealed class FetchCall
	{
		internal string AppId = "";

		internal Uri Url;

		internal string Method = "GET";

		internal List<KeyValuePair<string, string>> Headers = new List<KeyValuePair<string, string>>();

		internal string Body;

		internal int TimeoutMs = 10000;

		internal int MaxBytes = 4194304;
	}
	internal sealed class FetchOutcome
	{
		internal string Error;

		internal int Status;

		internal string StatusText = "";

		internal string Url = "";

		internal bool Redirected;

		internal string HeaderLines = "";

		internal string Body = "";

		internal bool Failed => Error != null;
	}
	internal static class Fetcher
	{
		internal const int DefaultTimeoutMs = 10000;

		internal const int DefaultMaxBytes = 4194304;

		internal const int MaxRedirects = 5;

		private static readonly Lazy<HttpClient> _client = new Lazy<HttpClient>(CreateClient);

		internal static void Send(FetchCall call, Action<FetchOutcome> done)
		{
			if (done == null)
			{
				return;
			}
			if (call?.Url == null)
			{
				done(Fail("fetch was given no URL."));
				return;
			}
			Task.Run(async delegate
			{
				FetchOutcome obj;
				try
				{
					obj = await Run(call).ConfigureAwait(continueOnCapturedContext: false);
				}
				catch (Exception e)
				{
					obj = Fail($"fetch to '{call.Url}' failed: {Describe(e)}");
				}
				try
				{
					done(obj);
				}
				catch
				{
				}
			});
		}

		private static async Task<FetchOutcome> Run(FetchCall call)
		{
			using CancellationTokenSource budget = new CancellationTokenSource();
			budget.CancelAfter(Math.Clamp(call.TimeoutMs, 100, 120000));
			Uri target = call.Url;
			string method = (string.IsNullOrWhiteSpace(call.Method) ? "GET" : call.Method.Trim().ToUpperInvariant());
			string body = call.Body;
			bool redirected = false;
			int hop = 0;
			string reason;
			while (HostAllowlist.Allows(call.AppId, target, out reason))
			{
				HttpResponseMessage httpResponseMessage;
				try
				{
					using HttpRequestMessage request = Build(method, target, body, call.Headers);
					httpResponseMessage = await _client.Value.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, budget.Token).ConfigureAwait(continueOnCapturedContext: false);
				}
				catch (OperationCanceledException) when (budget.IsCancellationRequested)
				{
					return Fail($"fetch to '{call.Url}' timed out after {call.TimeoutMs} ms.");
				}
				catch (Exception e)
				{
					return Fail($"fetch to '{target}' failed: {Describe(e)}");
				}
				using (httpResponseMessage)
				{
					Uri uri = RedirectTarget(httpResponseMessage, target);
					if (!(uri != null) || hop >= 5)
					{
						if (uri != null)
						{
							return Fail($"fetch to '{call.Url}' failed: more than {5} redirects.");
						}
						return await ReadBody(httpResponseMessage, call, target, redirected, budget.Token).ConfigureAwait(continueOnCapturedContext: false);
					}
					int statusCode = (int)httpResponseMessage.StatusCode;
					bool flag = statusCode == 303;
					if (!flag)
					{
						bool flag2 = (uint)(statusCode - 301) <= 1u;
						flag = flag2 && method != "GET" && method != "HEAD";
					}
					if (flag)
					{
						method = "GET";
						body = null;
					}
					target = uri;
					redirected = true;
				}
				hop++;
			}
			HostAllowlist.ReportOnce(call.AppId, target, reason);
			return Fail(redirected ? ("a redirect led somewhere blocked - " + reason) : reason);
		}

		private static async Task<FetchOutcome> ReadBody(HttpResponseMessage response, FetchCall call, Uri target, bool redirected, CancellationToken token)
		{
			int cap = Math.Max(call.MaxBytes, 1024);
			MemoryStream buffer = new MemoryStream();
			try
			{
				using Stream stream = await response.Content.ReadAsStreamAsync(token).ConfigureAwait(continueOnCapturedContext: false);
				byte[] chunk = new byte[65536];
				while (true)
				{
					int num = await stream.ReadAsync(chunk, 0, chunk.Length, token).ConfigureAwait(continueOnCapturedContext: false);
					if (num > 0)
					{
						if (buffer.Length + num > cap)
						{
							return Fail($"the response from '{target.IdnHost}' is larger than the {Megabytes(cap)} cap " + "that Sideload puts on a fetch body.");
						}
						buffer.Write(chunk, 0, num);
						continue;
					}
					break;
				}
			}
			catch (OperationCanceledException)
			{
				return Fail($"fetch to '{call.Url}' timed out after {call.TimeoutMs} ms.");
			}
			catch (Exception e)
			{
				return Fail("reading the response from '" + target.IdnHost + "' failed: " + Describe(e));
			}
			return new FetchOutcome
			{
				Status = (int)response.StatusCode,
				StatusText = (response.ReasonPhrase ?? response.StatusCode.ToString()),
				Url = target.ToString(),
				Redirected = redirected,
				HeaderLines = HeaderLines(response),
				Body = Decode(buffer.ToArray(), response)
			};
		}

		private static HttpRequestMessage Build(string method, Uri target, string body, List<KeyValuePair<string, string>> headers)
		{
			HttpRequestMessage httpRequestMessage = new HttpRequestMessage(new HttpMethod(method), target);
			if (body != null && method != "GET" && method != "HEAD")
			{
				httpRequestMessage.Content = new StringContent(body, Encoding.UTF8);
			}
			int num = 0;
			while (headers != null && num < headers.Count)
			{
				KeyValuePair<string, string> keyValuePair = headers[num];
				if (!string.IsNullOrWhiteSpace(keyValuePair.Key) && !httpRequestMessage.Headers.TryAddWithoutValidation(keyValuePair.Key, keyValuePair.Value))
				{
					httpRequestMessage.Content?.Headers.Remove(keyValuePair.Key);
					httpRequestMessage.Content?.Headers.TryAddWithoutValidation(keyValuePair.Key, keyValuePair.Value);
				}
				num++;
			}
			return httpRequestMessage;
		}

		private static Uri RedirectTarget(HttpResponseMessage response, Uri from)
		{
			int statusCode = (int)response.StatusCode;
			if (((uint)(statusCode - 301) > 2u && (uint)(statusCode - 307) > 1u) || 1 == 0)
			{
				return null;
			}
			Uri location = response.Headers.Location;
			if (location == null)
			{
				return null;
			}
			if (!location.IsAbsoluteUri)
			{
				return new Uri(from, location);
			}
			return location;
		}

		private static string HeaderLines(HttpResponseMessage response)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<string, IEnumerable<string>> header in response.Headers)
			{
				stringBuilder.Append(header.Key).Append(':').Append(string.Join(", ", header.Value))
					.Append('\n');
			}
			foreach (KeyValuePair<string, IEnumerable<string>> header2 in response.Content.Headers)
			{
				stringBuilder.Append(header2.Key).Append(':').Append(string.Join(", ", header2.Value))
					.Append('\n');
			}
			return stringBuilder.ToString();
		}

		private static string Decode(byte[] bytes, HttpResponseMessage response)
		{
			string text = response.Content.Headers.ContentType?.CharSet?.Trim().Trim('"');
			if (!string.IsNullOrEmpty(text))
			{
				try
				{
					return Encoding.GetEncoding(text).GetString(bytes);
				}
				catch
				{
				}
			}
			return Encoding.UTF8.GetString(bytes);
		}

		private static HttpClient CreateClient()
		{
			return new HttpClient(new HttpClientHandler
			{
				AllowAutoRedirect = false,
				UseCookies = false,
				AutomaticDecompression = (DecompressionMethods.GZip | DecompressionMethods.Deflate)
			})
			{
				Timeout = Timeout.InfiniteTimeSpan
			};
		}

		private static FetchOutcome Fail(string message)
		{
			return new FetchOutcome
			{
				Error = message
			};
		}

		private static string Megabytes(int bytes)
		{
			return ((double)bytes / 1048576.0).ToString("0.#", CultureInfo.InvariantCulture) + " MB";
		}

		private static string Describe(Exception e)
		{
			Exception ex = e;
			while (ex.InnerException != null)
			{
				ex = ex.InnerException;
			}
			return ex.Message;
		}
	}
	internal static class HostAllowlist
	{
		private static readonly string[] Loopback = new string[4] { "127.0.0.1", "localhost", "::1", "[::1]" };

		private static readonly Dictionary<string, List<string>> _byApp = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> _reported = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly object _gate = new object();

		internal static Action<string> Log;

		internal static void Allow(string appId, string host)
		{
			string text = Normalise(host);
			if (string.IsNullOrEmpty(appId) || text == null)
			{
				return;
			}
			lock (_gate)
			{
				if (!_byApp.TryGetValue(appId, out var value))
				{
					value = (_byApp[appId] = new List<string>());
				}
				if (!value.Contains<string>(text, StringComparer.OrdinalIgnoreCase))
				{
					value.Add(text);
				}
			}
		}

		internal static IReadOnlyList<string> For(string appId)
		{
			lock (_gate)
			{
				List<string> value;
				return (appId != null && _byApp.TryGetValue(appId, out value)) ? value.ToArray() : Array.Empty<string>();
			}
		}

		internal static bool Allows(string appId, Uri uri, out string reason)
		{
			reason = "";
			if (uri == null || !uri.IsAbsoluteUri)
			{
				reason = "fetch needs an absolute http(s) URL.";
				return false;
			}
			bool num = string.Equals(uri.Scheme, "https", StringComparison.OrdinalIgnoreCase);
			bool flag = string.Equals(uri.Scheme, "http", StringComparison.OrdinalIgnoreCase);
			if (!num && !flag)
			{
				reason = $"fetch to '{uri}' is blocked: only http and https are supported, not '{uri.Scheme}'.";
				return false;
			}
			string text = HostOf(uri);
			bool flag2 = Array.IndexOf(Loopback, text) >= 0;
			if (flag && !flag2)
			{
				reason = $"fetch to '{uri}' is blocked: plain http is only allowed for {string.Join(" and ", Loopback)}. " + "Use https.";
				return false;
			}
			IReadOnlyList<string> readOnlyList = For(appId);
			foreach (string item in readOnlyList)
			{
				if (Matches(text, item))
				{
					return true;
				}
			}
			reason = $"fetch to '{uri}' is blocked: app '{appId}' is not allowed to reach '{text}'. The mod that registers this app must call .AllowHost(\"{text}\") on its AppHandle" + ((readOnlyList.Count == 0) ? "." : (" (it currently allows: " + string.Join(", ", readOnlyList) + ")."));
			return false;
		}

		internal static void ReportOnce(string appId, Uri uri, string reason)
		{
			string item = appId + "\0" + ((uri == null) ? "?" : HostOf(uri));
			lock (_gate)
			{
				if (!_reported.Add(item))
				{
					return;
				}
			}
			Log?.Invoke("[Sideload] " + reason);
		}

		private static string HostOf(Uri uri)
		{
			return uri.IdnHost.TrimEnd('.').ToLowerInvariant();
		}

		private static bool Matches(string host, string pattern)
		{
			if (pattern.StartsWith("*.", StringComparison.Ordinal))
			{
				string text = pattern.Substring(1);
				if (host.Length > text.Length)
				{
					return host.EndsWith(text, StringComparison.Ordinal);
				}
				return false;
			}
			return string.Equals(host, pattern, StringComparison.Ordinal);
		}

		private static string Normalise(string host)
		{
			string text = host?.Trim();
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			int num = text.IndexOf("://", StringComparison.Ordinal);
			if (num >= 0)
			{
				text = text.Substring(num + 3);
			}
			int num2 = text.IndexOfAny(new char[3] { '/', '?', '#' });
			if (num2 >= 0)
			{
				text = text.Substring(0, num2);
			}
			int num3 = text.LastIndexOf('@');
			if (num3 >= 0)
			{
				text = text.Substring(num3 + 1);
			}
			bool flag = text.StartsWith("*.", StringComparison.Ordinal);
			if (flag)
			{
				text = text.Substring(2);
			}
			if (!text.StartsWith("[", StringComparison.Ordinal))
			{
				int num4 = text.IndexOf(':');
				if (num4 >= 0)
				{
					text = text.Substring(0, num4);
				}
			}
			else
			{
				int num5 = text.IndexOf(']');
				if (num5 >= 0)
				{
					text = text.Substring(0, num5 + 1);
				}
			}
			text = text.TrimEnd('.').ToLowerInvariant();
			if (text.Length == 0)
			{
				return null;
			}
			try
			{
				text = new Uri("https://" + text + "/").IdnHost.TrimEnd('.').ToLowerInvariant();
			}
			catch
			{
			}
			if (!flag)
			{
				return text;
			}
			return "*." + text;
		}

		internal static void ResetForTests()
		{
			lock (_gate)
			{
				_byApp.Clear();
				_reported.Clear();
			}
		}
	}
}
namespace Sideload.Model
{
	internal readonly struct OrientationSet
	{
		internal bool Declared { get; }

		internal bool Portrait { get; }

		internal bool CanTurn { get; }

		internal IReadOnlyList<string> Ignored { get; }

		private OrientationSet(bool declared, bool portrait, bool canTurn, IReadOnlyList<string> ignored)
		{
			Declared = declared;
			Portrait = portrait;
			CanTurn = canTurn;
			Ignored = ignored;
		}

		internal static OrientationSet Parse(string list)
		{
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			List<string> list2 = null;
			string[] array = (list ?? "").Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				bool flag5 = string.Equals(text, "portrait", StringComparison.OrdinalIgnoreCase);
				bool flag6 = string.Equals(text, "landscape", StringComparison.OrdinalIgnoreCase);
				if (!flag5 && !flag6)
				{
					(list2 ?? (list2 = new List<string>())).Add(text);
					continue;
				}
				if (!flag4)
				{
					flag3 = flag5;
					flag4 = true;
				}
				flag = flag || flag5;
				flag2 = flag2 || flag6;
			}
			bool declared = flag4;
			bool portrait = flag3;
			bool canTurn = flag && flag2;
			IReadOnlyList<string> readOnlyList = list2;
			return new OrientationSet(declared, portrait, canTurn, readOnlyList ?? Array.Empty<string>());
		}
	}
}
namespace Sideload.Layout
{
	internal static class FlexLayout
	{
		private sealed class Item
		{
			internal LayoutNode Node;

			internal float BaseSize;

			internal float MainSize;

			internal float CrossSize;

			internal float MainMarginStart;

			internal float MainMarginEnd;

			internal float CrossMarginStart;

			internal float CrossMarginEnd;

			internal float MinMain;

			internal float MaxMain;
		}

		internal static void Compute(LayoutNode root, float availableWidth, float availableHeight, IMeasureText measure)
		{
			if (root != null)
			{
				float forcedWidth = (root.Style.Width.IsDefinite ? float.NaN : availableWidth);
				LayoutBox(root, availableWidth, availableHeight, measure, forcedWidth);
				root.X = 0f;
				root.Y = 0f;
			}
		}

		private static void LayoutBox(LayoutNode node, float availWidth, float availHeight, IMeasureText measure, float forcedWidth = float.NaN, float forcedHeight = float.NaN)
		{
			ComputedStyle style = node.Style;
			if (style.Display == DisplayKind.None)
			{
				node.Width = 0f;
				node.Height = 0f;
				return;
			}
			float num = ((!float.IsNaN(forcedWidth)) ? forcedWidth : ResolveOrNaN(style.Width, availWidth));
			float num2 = ((!float.IsNaN(forcedHeight)) ? forcedHeight : ResolveOrNaN(style.Height, availHeight));
			float num3 = Horizontal(style.Padding, availWidth) + Horizontal(style.BorderWidth, availWidth);
			float num4 = Vertical(style.Padding, availWidth) + Vertical(style.BorderWidth, availWidth);
			if (float.IsNaN(num))
			{
				float val = availWidth - Horizontal(style.Margin, availWidth);
				num = (node.IsTextLeaf ? Math.Min(measure.Measure(node.Text, style, float.PositiveInfinity).Width + num3, Math.Max(val, 0f)) : (IntrinsicWidth(node, measure, availWidth) + num3));
			}
			num = Clamp(num, style.MinWidth, style.MaxWidth, availWidth);
			num = Math.Max(num, 0f);
			float num5 = Math.Max(num - num3, 0f);
			float contentH = (float.IsNaN(num2) ? float.NaN : Math.Max(num2 - num4, 0f));
			float num6 = ((!node.IsTextLeaf) ? LayoutChildren(node, num5, contentH, availWidth, measure) : measure.Measure(node.Text, style, num5).Height);
			if (float.IsNaN(num2))
			{
				num2 = num6 + num4;
			}
			num2 = Clamp(num2, style.MinHeight, style.MaxHeight, availHeight);
			num2 = Math.Max(num2, 0f);
			float num7 = Math.Max(num2 - num4, 0f);
			if (!node.IsTextLeaf && Math.Abs(num7 - num6) > 0.01f)
			{
				LayoutChildren(node, num5, num7, availWidth, measure);
			}
			node.Width = num;
			node.Height = num2;
		}

		private static float LayoutChildren(LayoutNode node, float contentW, float contentH, float percentBasis, IMeasureText measure)
		{
			ComputedStyle style = node.Style;
			bool flag = style.FlexDirection == FlexDirection.Row || style.FlexDirection == FlexDirection.RowReverse;
			bool reverse = style.FlexDirection == FlexDirection.RowReverse || style.FlexDirection == FlexDirection.ColumnReverse;
			List<LayoutNode> list = new List<LayoutNode>();
			List<LayoutNode> list2 = new List<LayoutNode>();
			foreach (LayoutNode child in node.Children)
			{
				if (child.Style.Display == DisplayKind.None)
				{
					child.Width = 0f;
					child.Height = 0f;
				}
				else if (child.Style.Position == PositionKind.Absolute)
				{
					list2.Add(child);
				}
				else
				{
					list.Add(child);
				}
			}
			float mainGap = (flag ? style.ColumnGap : style.RowGap).Resolve(contentW);
			float num = (flag ? style.RowGap : style.ColumnGap).Resolve(contentW);
			float mainAvail = (flag ? contentW : contentH);
			float num2 = (flag ? contentH : contentW);
			List<Item> list3 = new List<Item>(list.Count);
			foreach (LayoutNode item in list)
			{
				list3.Add(BuildItem(item, flag, mainAvail, num2, contentW, style.AlignItems, measure));
			}
			List<List<Item>> list4 = BreakIntoLines(list3, style.FlexWrap, mainAvail, mainGap);
			float num3 = 0f;
			float val = 0f;
			foreach (List<Item> item2 in list4)
			{
				ResolveFlexibleLengths(item2, mainAvail, mainGap);
				foreach (Item item3 in item2)
				{
					float forcedWidth = (flag ? item3.MainSize : float.NaN);
					float forcedHeight = (flag ? float.NaN : item3.MainSize);
					LayoutBox(item3.Node, contentW, contentH, measure, forcedWidth, forcedHeight);
					item3.CrossSize = (flag ? item3.Node.Height : item3.Node.Width);
				}
				float num4 = 0f;
				foreach (Item item4 in item2)
				{
					num4 = Math.Max(num4, item4.CrossSize + item4.CrossMarginStart + item4.CrossMarginEnd);
				}
				if (list4.Count == 1 && !float.IsNaN(num2))
				{
					num4 = num2;
				}
				foreach (Item item5 in item2)
				{
					if (((item5.Node.Style.AlignSelf != AlignKind.Auto) ? item5.Node.Style.AlignSelf : style.AlignItems) != AlignKind.Stretch || (flag ? item5.Node.Style.Height : item5.Node.Style.Width).IsDefinite)
					{
						continue;
					}
					float num5 = Math.Max(num4 - item5.CrossMarginStart - item5.CrossMarginEnd, 0f);
					if (!(Math.Abs(num5 - item5.CrossSize) < 0.01f))
					{
						float num6 = (((flag ? item5.Node.Style.Width : item5.Node.Style.Height).IsDefinite || item5.Node.Style.FlexBasis.IsDefinite || Math.Abs(item5.MainSize - item5.BaseSize) > 0.01f) ? item5.MainSize : float.NaN);
						LayoutBox(item5.Node, contentW, contentH, measure, flag ? num6 : num5, flag ? num5 : num6);
						item5.CrossSize = (flag ? item5.Node.Height : item5.Node.Width);
						if (float.IsNaN(num6))
						{
							item5.MainSize = (flag ? item5.Node.Width : item5.Node.Height);
						}
					}
				}
				PlaceLine(item2, style, flag, reverse, mainAvail, mainGap, num3, num4);
				float num7 = 0f;
				foreach (Item item6 in item2)
				{
					num7 = Math.Max(num7, flag ? (item6.Node.Y + item6.Node.Height) : (item6.Node.X + item6.Node.Width));
				}
				val = Math.Max(val, num7);
				num3 += num4 + num;
			}
			float result = ((list4.Count == 0) ? 0f : Math.Max(val, num3 - num));
			float num8 = 0f;
			foreach (LayoutNode item7 in list)
			{
				num8 = Math.Max(num8, item7.Y + item7.Height);
			}
			float num9 = style.BorderWidth.Left.Resolve(percentBasis);
			float num10 = style.BorderWidth.Top.Resolve(percentBasis);
			float num11 = style.Padding.Left.Resolve(percentBasis);
			float num12 = style.Padding.Top.Resolve(percentBasis);
			foreach (LayoutNode item8 in list)
			{
				item8.X += num9 + num11;
				item8.Y += num10 + num12;
			}
			float contentW2 = contentW + num11 + style.Padding.Right.Resolve(percentBasis);
			float contentH2 = (float.IsNaN(contentH) ? float.NaN : (contentH + num12 + style.Padding.Bottom.Resolve(percentBasis)));
			foreach (LayoutNode item9 in list2)
			{
				LayoutAbsolute(item9, contentW2, contentH2, measure);
				item9.X += num9;
				item9.Y += num10;
			}
			if (!flag)
			{
				return num8;
			}
			return result;
		}

		private static Item BuildItem(LayoutNode child, bool row, float mainAvail, float crossAvail, float percentBasis, AlignKind parentAlign, IMeasureText measure)
		{
			ComputedStyle style = child.Style;
			Item item = new Item
			{
				Node = child,
				MainMarginStart = (row ? style.Margin.Left : style.Margin.Top).Resolve(percentBasis),
				MainMarginEnd = (row ? style.Margin.Right : style.Margin.Bottom).Resolve(percentBasis),
				CrossMarginStart = (row ? style.Margin.Top : style.Margin.Left).Resolve(percentBasis),
				CrossMarginEnd = (row ? style.Margin.Bottom : style.Margin.Right).Resolve(percentBasis)
			};
			Len len = (row ? style.Width : style.Height);
			Len minProperty = (row ? style.MinWidth : style.MinHeight);
			Len len2 = (row ? style.MaxWidth : style.MaxHeight);
			float num = ResolveOrNaN(style.FlexBasis, mainAvail);
			if (float.IsNaN(num))
			{
				num = ResolveOrNaN(len, mainAvail);
			}
			if (float.IsNaN(num))
			{
				AlignKind alignKind = ((style.AlignSelf != AlignKind.Auto) ? style.AlignSelf : parentAlign);
				bool flag = !row && alignKind == AlignKind.Stretch && !style.Width.IsDefinite && !float.IsNaN(crossAvail);
				LayoutBox(child, row ? mainAvail : crossAvail, row ? crossAvail : mainAvail, measure, flag ? crossAvail : float.NaN);
				num = (row ? child.Width : child.Height);
			}
			item.BaseSize = Math.Max(num, 0f);
			item.MinMain = AutomaticMinimum(item, minProperty, row, mainAvail);
			item.MaxMain = (len2.IsDefinite ? len2.Resolve(mainAvail) : float.PositiveInfinity);
			item.MainSize = Math.Clamp(item.BaseSize, item.MinMain, item.MaxMain);
			return item;
		}

		private static float AutomaticMinimum(Item item, Len minProperty, bool row, float mainAvail)
		{
			if (minProperty.IsDefinite)
			{
				return minProperty.Resolve(mainAvail);
			}
			if (row)
			{
				return 0f;
			}
			ComputedStyle style = item.Node.Style;
			if (style.OverflowY != OverflowKind.Visible || style.OverflowX != OverflowKind.Visible)
			{
				return 0f;
			}
			return item.BaseSize;
		}

		private static List<List<Item>> BreakIntoLines(List<Item> items, FlexWrap wrap, float mainAvail, float mainGap)
		{
			List<List<Item>> list = new List<List<Item>>();
			if (items.Count == 0)
			{
				return list;
			}
			if (wrap == FlexWrap.NoWrap || float.IsNaN(mainAvail))
			{
				list.Add(items);
				return list;
			}
			List<Item> list2 = new List<Item>();
			float num = 0f;
			foreach (Item item in items)
			{
				float num2 = item.MainSize + item.MainMarginStart + item.MainMarginEnd;
				float num3 = ((list2.Count > 0) ? (num + mainGap + num2) : num2);
				if (list2.Count > 0 && num3 > mainAvail + 0.01f)
				{
					list.Add(list2);
					list2 = new List<Item>();
					num = num2;
				}
				else
				{
					num = num3;
				}
				list2.Add(item);
			}
			if (list2.Count > 0)
			{
				list.Add(list2);
			}
			if (wrap == FlexWrap.WrapReverse)
			{
				list.Reverse();
			}
			return list;
		}

		private static void ResolveFlexibleLengths(List<Item> line, float mainAvail, float mainGap)
		{
			if (line.Count == 0 || float.IsNaN(mainAvail))
			{
				return;
			}
			int count = line.Count;
			float num = mainGap * (float)(count - 1);
			foreach (Item item4 in line)
			{
				num += item4.MainMarginStart + item4.MainMarginEnd;
			}
			float num2 = 0f;
			foreach (Item item5 in line)
			{
				num2 += item5.BaseSize;
			}
			bool flag = num2 + num < mainAvail;
			bool[] array = new bool[count];
			float[] array2 = new float[count];
			for (int i = 0; i < count; i++)
			{
				Item item = line[i];
				item.MainSize = Math.Clamp(item.BaseSize, item.MinMain, item.MaxMain);
				if ((flag ? item.Node.Style.FlexGrow : item.Node.Style.FlexShrink) <= 0f)
				{
					array[i] = true;
				}
			}
			for (int j = 0; j <= count; j++)
			{
				float num3 = num;
				float num4 = 0f;
				int num5 = 0;
				for (int k = 0; k < count; k++)
				{
					Item item2 = line[k];
					if (array[k])
					{
						num3 += item2.MainSize;
						continue;
					}
					num3 += item2.BaseSize;
					num5++;
					num4 += Weight(item2, flag);
				}
				if (num5 == 0 || num4 <= 0f)
				{
					break;
				}
				float num6 = mainAvail - num3;
				if (Math.Abs(num6) < 0.01f)
				{
					break;
				}
				float num7 = 0f;
				for (int l = 0; l < count; l++)
				{
					if (!array[l])
					{
						Item item3 = line[l];
						array2[l] = item3.BaseSize + Weight(item3, flag) / num4 * num6;
						item3.MainSize = Math.Clamp(array2[l], item3.MinMain, item3.MaxMain);
						num7 += item3.MainSize - array2[l];
					}
				}
				if (Math.Abs(num7) < 0.01f)
				{
					break;
				}
				for (int m = 0; m < count; m++)
				{
					if (!array[m])
					{
						if (num7 > 0f && line[m].MainSize > array2[m] + 0.001f)
						{
							array[m] = true;
						}
						else if (num7 < 0f && line[m].MainSize < array2[m] - 0.001f)
						{
							array[m] = true;
						}
					}
				}
			}
		}

		private static float Weight(Item item, bool growing)
		{
			if (!growing)
			{
				return item.Node.Style.FlexShrink * item.BaseSize;
			}
			return item.Node.Style.FlexGrow;
		}

		private static void PlaceLine(List<Item> line, ComputedStyle parent, bool row, bool reverse, float mainAvail, float mainGap, float crossOffset, float lineCross)
		{
			float num = 0f;
			foreach (Item item in line)
			{
				num += item.MainSize + item.MainMarginStart + item.MainMarginEnd;
			}
			num += mainGap * (float)(line.Count - 1);
			float num2 = (float.IsNaN(mainAvail) ? 0f : Math.Max(mainAvail - num, 0f));
			int count = line.Count;
			float num3 = 0f;
			float num4 = mainGap;
			switch (parent.JustifyContent)
			{
			case Justify.FlexEnd:
				num3 = num2;
				break;
			case Justify.Center:
				num3 = num2 * 0.5f;
				break;
			case Justify.SpaceBetween:
				if (count > 1)
				{
					num4 += num2 / (float)(count - 1);
				}
				break;
			case Justify.SpaceAround:
				if (count > 0)
				{
					num4 += num2 / (float)count;
					num3 = num2 / (float)count * 0.5f;
				}
				break;
			case Justify.SpaceEvenly:
				if (count > 0)
				{
					num4 += num2 / (float)(count + 1);
					num3 = num2 / (float)(count + 1);
				}
				break;
			}
			List<Item> list = new List<Item>(line);
			if (reverse)
			{
				list.Reverse();
			}
			foreach (Item item2 in list)
			{
				num3 += item2.MainMarginStart;
				AlignKind alignKind = ((item2.Node.Style.AlignSelf != AlignKind.Auto) ? item2.Node.Style.AlignSelf : parent.AlignItems);
				float num5 = Math.Max(lineCross - item2.CrossSize - item2.CrossMarginStart - item2.CrossMarginEnd, 0f);
				float num6 = crossOffset + item2.CrossMarginStart;
				switch (alignKind)
				{
				case AlignKind.FlexEnd:
					num6 += num5;
					break;
				case AlignKind.Center:
					num6 += num5 * 0.5f;
					break;
				}
				if (row)
				{
					item2.Node.X = num3;
					item2.Node.Y = num6;
				}
				else
				{
					item2.Node.Y = num3;
					item2.Node.X = num6;
				}
				num3 += item2.MainSize + item2.MainMarginEnd + num4;
			}
		}

		private static void LayoutAbsolute(LayoutNode child, float contentW, float contentH, IMeasureText measure)
		{
			ComputedStyle style = child.Style;
			float num = ResolveOrNaN(style.Inset.Left, contentW);
			float num2 = ResolveOrNaN(style.Inset.Right, contentW);
			float num3 = ResolveOrNaN(style.Inset.Top, contentH);
			float num4 = ResolveOrNaN(style.Inset.Bottom, contentH);
			float num5 = ResolveOrNaN(style.Width, contentW);
			float num6 = ResolveOrNaN(style.Height, contentH);
			if (float.IsNaN(num5) && !float.IsNaN(num) && !float.IsNaN(num2))
			{
				num5 = Math.Max(contentW - num - num2, 0f);
			}
			if (float.IsNaN(num6) && !float.IsNaN(num3) && !float.IsNaN(num4))
			{
				num6 = Math.Max(contentH - num3 - num4, 0f);
			}
			LayoutBox(child, contentW, contentH, measure, num5, num6);
			child.X = ((!float.IsNaN(num)) ? num : ((!float.IsNaN(num2)) ? (contentW - num2 - child.Width) : 0f));
			child.Y = ((!float.IsNaN(num3)) ? num3 : ((!float.IsNaN(num4) && !float.IsNaN(contentH)) ? (contentH - num4 - child.Height) : 0f));
		}

		private static float IntrinsicWidth(LayoutNode node, IMeasureText measure, float availWidth)
		{
			ComputedStyle style = node.Style;
			bool flag = style.FlexDirection == FlexDirection.Row || style.FlexDirection == FlexDirection.RowReverse;
			float num = 0f;
			float num2 = 0f;
			int num3 = 0;
			foreach (LayoutNode child in node.Children)
			{
				if (child.Style.Display != DisplayKind.None && child.Style.Position != PositionKind.Absolute)
				{
					LayoutBox(child, availWidth, float.NaN, measure);
					float num4 = child.Width + Horizontal(child.Style.Margin, availWidth);
					num2 = Math.Max(num2, num4);
					num += num4;
					num3++;
				}
			}
			if (num3 == 0)
			{
				return 0f;
			}
			if (!flag)
			{
				return num2;
			}
			float num5 = style.ColumnGap.Resolve(availWidth) * (float)(num3 - 1);
			return num + num5;
		}

		private static float ResolveOrNaN(Len len, float basis)
		{
			if (!len.IsDefinite)
			{
				return float.NaN;
			}
			if (len.Unit == LenUnit.Percent && float.IsNaN(basis))
			{
				return float.NaN;
			}
			return len.Resolve(basis);
		}

		private static float Clamp(float value, Len min, Len max, float basis)
		{
			if (min.IsDefinite)
			{
				float num = min.Resolve(basis);
				if (!float.IsNaN(num))
				{
					value = Math.Max(value, num);
				}
			}
			if (max.IsDefinite)
			{
				float num2 = max.Resolve(basis);
				if (!float.IsNaN(num2))
				{
					value = Math.Min(value, num2);
				}
			}
			return value;
		}

		private static float Horizontal(Edges e, float basis)
		{
			return e.Left.Resolve(basis) + e.Right.Resolve(basis);
		}

		private static float Vertical(Edges e, float basis)
		{
			return e.Top.Resolve(basis) + e.Bottom.Resolve(basis);
		}
	}
	internal readonly struct Size
	{
		internal readonly float Width;

		internal readonly float Height;

		internal Size(float width, float height)
		{
			Width = width;
			Height = height;
		}

		public override string ToString()
		{
			return $"{Width:0.##} x {Height:0.##}";
		}
	}
	internal interface IMeasureText
	{
		Size Measure(string text, ComputedStyle style, float availableWidth);
	}
	internal sealed class LayoutNode
	{
		internal ComputedStyle Style = new ComputedStyle();

		internal string Text;

		internal readonly List<LayoutNode> Children = new List<LayoutNode>();

		internal object Tag;

		internal float X;

		internal float Y;

		internal float Width;

		internal float Height;

		internal bool IsTextLeaf
		{
			get
			{
				if (Text != null)
				{
					return Children.Count == 0;
				}
				return false;
			}
		}

		internal LayoutNode()
		{
		}

		internal LayoutNode(ComputedStyle style, string text = null)
		{
			Style = style ?? new ComputedStyle();
			Text = text;
		}

		internal LayoutNode Add(LayoutNode child)
		{
			Children.Add(child);
			return this;
		}

		public override string ToString()
		{
			return $"({X:0.##},{Y:0.##}) {Width:0.##}x{Height:0.##}";
		}
	}
}
namespace Sideload.Input
{
	internal sealed class Interaction
	{
		private readonly Dictionary<IElement, StateFlags> _states = new Dictionary<IElement, StateFlags>();

		private readonly Dictionary<IElement, StateFlags> _forced = new Dictionary<IElement, StateFlags>();

		private readonly Action<IElement> _onStateChanged;

		private readonly Action<IElement> _onClicked;

		internal Interaction(Action<IElement> onStateChanged, Action<IElement> onClicked)
		{
			_onStateChanged = onStateChanged;
			_onClicked = onClicked;
		}

		internal StateFlags StateOf(IElement element)
		{
			if (element == null)
			{
				return StateFlags.None;
			}
			StateFlags value;
			StateFlags stateFlags = (_states.TryGetValue(element, out value) ? value : StateFlags.None);
			if (!_forced.TryGetValue(element, out var value2))
			{
				return stateFlags;
			}
			return stateFlags | value2;
		}

		internal void Force(IElement element, StateFlags flags)
		{
			if (element != null)
			{
				if (flags == StateFlags.None)
				{
					_forced.Remove(element);
				}
				else
				{
					_forced[element] = flags;
				}
				_onStateChanged?.Invoke(element);
			}
		}

		internal StateFlags ForcedOn(IElement element)
		{
			if (element == null || !_forced.TryGetValue(element, out var value))
			{
				return StateFlags.None;
			}
			return value;
		}

		internal void Clear()
		{
			_states.Clear();
		}

		internal void ResetForRender(IDocument document)
		{
			foreach (IElement item in new List<IElement>(_states.Keys))
			{
				_states[item] &= ~(StateFlags.Hover | StateFlags.Active);
			}
			foreach (IElement item2 in new List<IElement>(_states.Keys))
			{
				_states[item2] &= ~StateFlags.Disabled;
			}
			SeedDisabled(document);
		}

		internal void SeedDisabled(IDocument document)
		{
			if (document == null)
			{
				return;
			}
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)document).QuerySelectorAll("[disabled]"))
			{
				_states[item] = StateOf(item) | StateFlags.Disabled;
			}
		}

		internal void Attach(RectTransform rect, IElement element, bool disabled, bool ownGameObject = false)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null || element == null)
			{
				return;
			}
			if (disabled)
			{
				Set(element, StateFlags.Disabled, on: true, notify: false);
				return;
			}
			GameObject gameObject = ((Component)rect).gameObject;
			if (!ownGameObject)
			{
				RectTransform obj = UiFactory.Rect("hit", (Transform)(object)rect);
				UiFactory.Stretch(obj);
				Image obj2 = ((Component)obj).gameObject.AddComponent<Image>();
				((Graphic)obj2).color = new Color(0f, 0f, 0f, 0f);
				((Graphic)obj2).raycastTarget = true;
				gameObject = ((Component)obj).gameObject;
			}
			EventTrigger trigger = gameObject.AddComponent<EventTrigger>();
			Add(trigger, (EventTriggerType)0, delegate
			{
				Set(element, StateFlags.Hover, on: true);
			});
			Add(trigger, (EventTriggerType)1, delegate
			{
				Set(element, StateFlags.Hover, on: false);
				Set(element, StateFlags.Active, on: false);
			});
			Add(trigger, (EventTriggerType)2, delegate
			{
				Set(element, StateFlags.Active, on: true);
			});
			Add(trigger, (EventTriggerType)3, delegate
			{
				Set(element, StateFlags.Active, on: false);
			});
			Add(trigger, (EventTriggerType)4, delegate
			{
				_onClicked?.Invoke(element);
			});
		}

		private static void Add(EventTrigger trigger, EventTriggerType type, Action run)
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			Entry val = new Entry
			{
				eventID = type
			};
			val.callback = new TriggerEvent();
			((UnityEvent<BaseEventData>)(object)val.callback).AddListener(UnityAction<BaseEventData>.op_Implicit((Action<BaseEventData>)delegate
			{
				try
				{
					run();
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] pointer handler failed: " + ex.Message);
					}
				}
			}));
			trigger.triggers.Add(val);
		}

		private void Set(IElement element, StateFlags flag, bool on, bool notify = true)
		{
			StateFlags stateFlags = StateOf(element);
			StateFlags stateFlags2 = (on ? (stateFlags | flag) : (stateFlags & ~flag));
			if (stateFlags2 != stateFlags)
			{
				_states[element] = stateFlags2;
				if (notify)
				{
					_onStateChanged?.Invoke(element);
				}
			}
		}
	}
}
namespace Sideload.Host
{
	public sealed class WebView
	{
		private const float ReferenceShortSide = 400f;

		private static readonly List<WebView> _live = new List<WebView>();

		private readonly AppBundle _bundle;

		private readonly RectTransform _host;

		private readonly RectTransform _root;

		private readonly string _appId;

		private bool _built;

		private bool _rebuildQueued;

		private bool _resizeQueued;

		private IDocument _document;

		private Stylesheet _sheet;

		private StyleContext _context;

		private Interaction _interaction;

		private ScriptHost _script;

		private Dictionary<IElement, Painter.PaintedBox> _painted;

		private Dictionary<IElement, RectTransform> _survivors;

		private LayoutNode _tree;

		private IElement _focused;

		private IElement _pinToEnd;

		private readonly Dictionary<IElement, ComputedStyle> _styleWas = new Dictionary<IElement, ComputedStyle>();

		private readonly Dictionary<IElement, TMP_InputField> _inputs = new Dictionary<IElement, TMP_InputField>();

		private int _renders;

		private int _reloads;

		private float _lastRenderMs;

		private int _boxes;

		internal static bool RenderingDisabled;

		private const int MaxElements = 20000;

		private const int MaxDepth = 200;

		public RectTransform Root => _root;

		internal static IReadOnlyList<WebView> Live => _live;

		internal string AppId => _appId;

		internal int BoxCount => _boxes;

		internal int RenderCount => _renders;

		internal int ReloadCount => _reloads;

		internal float LastRenderMs => _lastRenderMs;

		internal string Stats => $"{_appId}  {_root.sizeDelta.x:0}x{_root.sizeDelta.y:0}css @{((Transform)_root).localScale.x:0.00}x\n  {_boxes} boxes, {_sheet?.Rules.Count ?? 0} rules, {_painted?.Count ?? 0} wired\n  renders {_renders} ({_lastRenderMs:0.0} ms)   reloads {_reloads}\n  script: {((_script == null) ? "none" : (_script.Failed ? ("FAILED - " + _script.LastError) : "ok"))}";

		internal IDocument Document => _document;

		internal ScriptHost Script => _script;

		internal Stylesheet Sheet => _sheet;

		internal StyleContext StyleContext => _context;

		private WebView(RectTransform host, RectTransform root, AppBundle bundle, string appId)
		{
			_host = host;
			_root = root;
			_bundle = bundle;
			_appId = appId;
		}

		internal static WebView Mount(RectTransform host, AppBundle bundle, string appId)
		{
			if ((Object)(object)host == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] mount target is null - nothing will render.");
				}
				return null;
			}
			RectTransform root = UiFactory.Rect("sideload-view", (Transform)(object)host);
			WebView webView = new WebView(host, root, bundle, appId);
			_live.Add(webView);
			return webView;
		}

		internal static void TickAll(float deltaSeconds)
		{
			for (int num = _live.Count - 1; num >= 0; num--)
			{
				WebView webView = _live[num];
				if ((Object)(object)webView._root == (Object)null)
				{
					webView._script?.Dispose();
					webView._script = null;
					_live.RemoveAt(num);
				}
				else
				{
					try
					{
						webView.Tick(deltaSeconds);
					}
					catch (Exception ex)
					{
						Instance log = Core.Log;
						if (log != null)
						{
							log.Error("[Sideload] view tick failed: " + ex);
						}
					}
				}
			}
		}

		internal void EnsureBuilt()
		{
			if (_built)
			{
				return;
			}
			if ((Object)(object)_root == (Object)null || !((Component)_root).gameObject.activeInHierarchy)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] " + _appId + ": asked to build while off screen - deferred until it is shown.");
				}
				return;
			}
			_built = true;
			try
			{
				Build();
			}
			catch (Exception ex)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Error("[Sideload] building the page failed: " + ex);
				}
				ShowError(ex.Message);
			}
		}

		private void Tick(float deltaSeconds)
		{
			if (RenderingDisabled)
			{
				return;
			}
			Transitions.Tick(deltaSeconds);
			_script?.Tick(deltaSeconds);
			if (((Component)_root).gameObject.activeInHierarchy)
			{
				if (_resizeQueued)
				{
					_resizeQueued = false;
					_rebuildQueued = false;
					Resize();
				}
				else if (_rebuildQueued)
				{
					_rebuildQueued = false;
					Rebuild();
				}
			}
		}

		internal void Reload()
		{
			Instance log = Core.Log;
			if (log != null)
			{
				log.Msg("[Sideload] reloading the page from disk.");
			}
			ImageCache.Forget(_appId);
			for (int num = ((Transform)_root).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)_root).GetChild(num)).gameObject);
			}
			_script?.Dispose();
			_built = false;
			_reloads++;
			_rebuildQueued = false;
			_script = null;
			_painted = null;
			_focused = null;
			EnsureBuilt();
		}

		internal void MarkDirty()
		{
			QueueRebuild();
		}

		internal void QueueResize()
		{
			_resizeQueued = true;
		}

		private void Resize()
		{
			//IL_002d: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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)
			if (!_built || (Object)(object)_root == (Object)null || _document == null || _context == null)
			{
				return;
			}
			Rect rect = _host.rect;
			float width = ((Rect)(ref rect)).width;
			float height = ((Rect)(ref rect)).height;
			if (width < 1f || height < 1f)
			{
				return;
			}
			float num = Math.Min(width, height) / 400f;
			float num2 = width / num;
			float num3 = height / num;
			if (Mathf.Approximately(num2, _root.sizeDelta.x) && Mathf.Approximately(num3, _root.sizeDelta.y))
			{
				return;
			}
			Orientation orientation = _context.Orientation;
			_root.sizeDelta = new Vector2(num2, num3);
			((Transform)_root).localScale = new Vector3(num, num, 1f);
			_context.Orientation = ((num2 >= num3) ? Orientation.Landscape : Orientation.Portrait);
			Rebuild();
			Instance log = Core.Log;
			if (log != null)
			{
				log.Msg($"[Sideload] {_appId}: viewport is now {num2:0.#}x{num3:0.#} css px ({_context.Orientation}).");
			}
			if (orientation == _context.Orientation)
			{
				return;
			}
			ScriptHost script = _script;
			if (script != null)
			{
				IDocument document = _document;
				IElement val = (IElement)(object)((document != null) ? document.Body : null);
				object obj = val;
				if (obj == null)
				{
					IDocument document2 = _document;
					obj = ((document2 != null) ? document2.DocumentElement : null);
				}
				script.Dispatch((IElement)obj, "orientationchange", (_context.Orientation == Orientation.Portrait) ? "portrait" : "landscape");
			}
		}

		private void Build()
		{
			//IL_0006: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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)
			Rect rect = _host.rect;
			float width = ((Rect)(ref rect)).width;
			float height = ((Rect)(ref rect)).height;
			if (width < 1f || height < 1f)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning($"[Sideload] host rect is {width}x{height} - the page cannot be sized yet.");
				}
				return;
			}
			float num = Math.Min(width, height) / 400f;
			float num2 = width / num;
			float num3 = height / num;
			RectTransform root = _root;
			RectTransform root2 = _root;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			root2.anchorMax = val;
			root.anchorMin = val;
			_root.pivot = new Vector2(0.5f, 0.5f);
			_root.anchoredPosition = Vector2.zero;
			_root.sizeDelta = new Vector2(num2, num3);
			((Transform)_root).localScale = new Vector3(num, num, 1f);
			string text = _bundle?.ReadText("index.html");
			if (string.IsNullOrEmpty(text))
			{
				ShowError("index.html not found in bundle or override");
				return;
			}
			_document = (IDocument)(object)new HtmlParser().ParseDocument(text);
			string text2 = TooLargeToRender(_document);
			if (text2 != null)
			{
				ShowError(text2);
				return;
			}
			_sheet = CssParser.Parse(CollectCss(_document));
			_interaction = new Interaction(OnStateChanged, OnClicked);
			_context = new StyleContext
			{
				Orientation = ((num2 >= num3) ? Orientation.Landscape : Orientation.Portrait),
				StateOf = _interaction.StateOf
			};
			_script = new ScriptHost(_appId, _document, QueueRebuild, Focus, PinToEnd);
			RunScripts(_document);
			Render(num2, num3, width, height, num);
			_rebuildQueued = false;
			Instance log2 = Core.Log;
			if (log2 != null)
			{
				log2.Msg($"[Sideload] page built: viewport {num2:0.#}x{num3:0.#} css px at {num:0.###}x, {_sheet.Rules.Count} rule(s).");
			}
		}

		private static string TooLargeToRender(IDocument document)
		{
			IElement val = (IElement)(object)((document != null) ? document.Body : null);
			IElement val2 = val ?? ((document != null) ? document.DocumentElement : null);
			if (val2 == null)
			{
				return null;
			}
			int num = 0;
			Stack<(IElement, int)> stack = new Stack<(IElement, int)>();
			stack.Push((val2, 1));
			while (stack.Count > 0)
			{
				var (val3, num2) = stack.Pop();
				if (++num > 20000)
				{
					return $"the page has more than {20000} elements - refusing to render it";
				}
				if (num2 > 200)
				{
					return $"the page nests deeper than {200} elements - refusing to render it";
				}
				foreach (IElement item in (IEnumerable<IElement>)((IParentNode)val3).Children)
				{
					stack.Push((item, num2 + 1));
				}
			}
			return null;
		}

		private void Render(float cssW, float cssH, float hostW, float hostH, float scale)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			long timestamp = Stopwatch.GetTimestamp();
			_interaction.ResetForRender(_document);
			Transitions.Clear();
			_styleWas.Clear();
			Dictionary<IElement, ComputedStyle> dictionary = StyleResolver.Resolve(_document, _sheet, _context);
			IElement body = (IElement)(object)_document.Body;
			LayoutNode layoutNode = DomBuilder.Build(body ?? _document.DocumentElement, dictionary);
			if (layoutNode == null)
			{
				ShowError("the document has no renderable content");
				return;
			}
			TmpMeasure measure = new TmpMeasure((Transform)(object)_root);
			FlexLayout.Compute(layoutNode, cssW, cssH, measure);
			_painted = Painter.Paint(layoutNode, _root, new Vector2(cssW, cssH), _inputs, OnInputChanged, OnInputSubmitted, _survivors, _bundle, _appId);
			_survivors = null;
			WireInteraction(dictionary);
			ApplyPin();
			foreach (KeyValuePair<IElement, Painter.PaintedBox> item in _painted)
			{
				if (dictionary.TryGetValue(item.Key, out var value))
				{
					_styleWas[item.Key] = value;
				}
			}
			_tree = layoutNode;
			_renders++;
			_boxes = CountNodes(layoutNode);
			_lastRenderMs = (float)(Stopwatch.GetTimestamp() - timestamp) * 1000f / (float)Stopwatch.Frequency;
		}

		private void QueueRebuild()
		{
			_rebuildQueued = true;
		}

		private void Rebuild()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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)
			if ((Object)(object)_root == (Object)null || _document == null)
			{
				return;
			}
			try
			{
				Dictionary<IElement, float> offsets = CaptureScroll();
				_survivors = RescueControls();
				for (int num = ((Transform)_root).childCount - 1; num >= 0; num--)
				{
					GameObject gameObject = ((Component)((Transform)_root).GetChild(num)).gameObject;
					if (!IsRescued(gameObject))
					{
						Object.Destroy((Object)(object)gameObject);
					}
				}
				float x = ((Transform)_root).localScale.x;
				Render(_root.sizeDelta.x, _root.sizeDelta.y, _root.sizeDelta.x * x, _root.sizeDelta.y * x, x);
				RestoreScroll(offsets);
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Error("[Sideload] rebuilding the page failed: " + ex);
				}
			}
		}

		private Dictionary<IElement, RectTransform> RescueControls()
		{
			Dictionary<IElement, RectTransform> dictionary = new Dictionary<IElement, RectTransform>();
			if (_painted == null)
			{
				return dictionary;
			}
			foreach (KeyValuePair<IElement, Painter.PaintedBox> item in _painted)
			{
				if (_inputs.ContainsKey(item.Key) && !((Object)(object)item.Value.Rect == (Object)null))
				{
					((Transform)item.Value.Rect).SetParent((Transform)(object)_root, false);
					dictionary[item.Key] = item.Value.Rect;
				}
			}
			return dictionary;
		}

		private bool IsRescued(GameObject candidate)
		{
			if (_survivors == null)
			{
				return false;
			}
			foreach (KeyValuePair<IElement, RectTransform> survivor in _survivors)
			{
				if ((Object)(object)survivor.Value != (Object)null && (Object)(object)((Component)survivor.Value).gameObject == (Object)(object)candidate)
				{
					return true;
				}
			}
			return false;
		}

		private Dictionary<IElement, float> CaptureScroll()
		{
			Dictionary<IElement, float> dictionary = new Dictionary<IElement, float>();
			if (_painted == null)
			{
				return dictionary;
			}
			foreach (KeyValuePair<IElement, Painter.PaintedBox> item in _painted)
			{
				if (!((Object)(object)item.Value.Rect == (Object)null))
				{
					ScrollRect componentInChildren = ((Component)item.Value.Rect).GetComponentInChildren<ScrollRect>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						dictionary[item.Key] = componentInChildren.verticalNormalizedPosition;
					}
				}
			}
			return dictionary;
		}

		private void RestoreScroll(Dictionary<IElement, float> offsets)
		{
			if (offsets == null || _painted == null)
			{
				return;
			}
			foreach (KeyValuePair<IElement, float> offset in offsets)
			{
				if (_painted.TryGetValue(offset.Key, out var value) && !((Object)(object)value.Rect == (Object)null))
				{
					ScrollRect componentInChildren = ((Component)value.Rect).GetComponentInChildren<ScrollRect>();
					if (!((Object)(object)componentInChildren == (Object)null))
					{
						componentInChildren.verticalNormalizedPosition = ((offset.Key == _pinToEnd) ? 0f : offset.Value);
					}
				}
			}
		}

		private void ApplyPin()
		{
			if (_pinToEnd == null || _painted == null)
			{
				return;
			}
			if (_painted.TryGetValue(_pinToEnd, out var value) && (Object)(object)value.Rect != (Object)null)
			{
				ScrollRect componentInChildren = ((Component)value.Rect).GetComponentInChildren<ScrollRect>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.verticalNormalizedPosition = 0f;
				}
			}
			_pinToEnd = null;
		}

		internal void ForcePseudoState(IElement element, IEnumerable<string> pseudoClasses)
		{
			if (element == null || _interaction == null)
			{
				return;
			}
			StateFlags stateFlags = StateFlags.None;
			using (IEnumerator<string> enumerator = (pseudoClasses ?? Array.Empty<string>()).GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch ((enumerator.Current ?? "").Trim().ToLowerInvariant())
					{
					case "hover":
						stateFlags |= StateFlags.Hover;
						break;
					case "active":
						stateFlags |= StateFlags.Active;
						break;
					case "focus":
					case "focus-visible":
					case "focus-within":
						stateFlags |= StateFlags.Focus;
						break;
					}
				}
			}
			_interaction.Force(element, stateFlags);
		}

		private void PinToEnd(IElement element)
		{
			_pinToEnd = element;
		}

		private void Focus(IElement element)
		{
			if (element != null && _inputs.TryGetValue(element, out var value) && !((Object)(object)value == (Object)null))
			{
				_focused = element;
				value.ActivateInputField();
			}
		}

		private void WireInteraction(Dictionary<IElement, ComputedStyle> styles)
		{
			HashSet<IElement> hashSet = StyleResolver.StatefulElements(_document, _sheet, _context.Orientation);
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)_document).QuerySelectorAll("button, a, input, textarea"))
			{
				hashSet.Add(item);
			}
			if (_script != null)
			{
				foreach (IElement item2 in _script.ElementsListeningFor("click"))
				{
					hashSet.Add(item2);
				}
			}
			int num = 0;
			foreach (IElement item3 in hashSet)
			{
				if (_painted.TryGetValue(item3, out var value))
				{
					bool disabled = item3.HasAttribute("disabled");
					bool ownGameObject = item3.LocalName.Equals("input", StringComparison.OrdinalIgnoreCase) || item3.LocalName.Equals("textarea", StringComparison.OrdinalIgnoreCase);
					_interaction.Attach(value.Rect, item3, disabled, ownGameObject);
					num++;
				}
			}
			Instance log = Core.Log;
			if (log != null)
			{
				log.Msg($"[Sideload] interaction wired on {num} element(s).");
			}
		}

		private void OnStateChanged(IElement element)
		{
			try
			{
				if (StyleResolver.Resolve(_document, _sheet, _context).TryGetValue(element, out var value) && _painted.TryGetValue(element, out var value2))
				{
					_styleWas.TryGetValue(element, out var value3);
					Transitions.To(value2, value3, value);
					_styleWas[element] = value;
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload] restyle failed: " + ex.Message);
				}
			}
		}

		private void OnClicked(IElement element)
		{
			if (element != null)
			{
				if (_inputs.ContainsKey(element))
				{
					_focused = element;
				}
				_script?.Dispatch(element, "click");
			}
		}

		private void OnInputChanged(IElement element, string value)
		{
			if (element != null)
			{
				element.SetAttribute("value", value ?? "");
				_focused = element;
				_script?.Dispatch(element, "input", value);
			}
		}

		private void RunScripts(IDocument document)
		{
			bool flag = false;
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)document).QuerySelectorAll("script"))
			{
				string attribute = item.GetAttribute("src");
				if (string.IsNullOrEmpty(attribute))
				{
					if (!string.IsNullOrWhiteSpace(((INode)item).TextContent))
					{
						_script.Run(((INode)item).TextContent, "<inline script>");
						flag = true;
					}
					continue;
				}
				string text = _bundle?.ReadText(attribute.TrimStart('/'));
				if (text == null)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] script not found: " + attribute);
					}
				}
				else
				{
					_script.Run(text, attribute);
					flag = true;
				}
			}
			if (!flag)
			{
				string text2 = _bundle?.ReadText("app.js");
				if (text2 != null)
				{
					_script.Run(text2, "app.js");
				}
			}
		}

		private void OnInputSubmitted(IElement element, string value)
		{
			if (element != null)
			{
				element.SetAttribute("value", value ?? "");
				_script?.Dispatch(element, "keydown", value, "Enter");
				_focused = element;
				Focus(element);
			}
		}

		internal bool DispatchBack(string source)
		{
			IDocument document = _document;
			IElement val = (IElement)(object)((document != null) ? document.Body : null);
			object obj = val;
			if (obj == null)
			{
				IDocument document2 = _document;
				obj = ((document2 != null) ? document2.DocumentElement : null);
			}
			IElement val2 = (IElement)obj;
			if (val2 == null || _script == null)
			{
				return false;
			}
			return _script.Dispatch(val2, "back", "", "", source ?? "").DefaultPrevented;
		}

		private string CollectCss(IDocument document)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)document).QuerySelectorAll("link"))
			{
				string attribute = item.GetAttribute("rel");
				if (attribute == null || !attribute.Contains("stylesheet", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string attribute2 = item.GetAttribute("href");
				if (string.IsNullOrEmpty(attribute2))
				{
					continue;
				}
				string path = attribute2.TrimStart('/');
				string text = _bundle?.ReadText(path) ?? Framework(path);
				if (text == null)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] stylesheet not found: " + attribute2);
					}
				}
				else
				{
					stringBuilder.AppendLine(text);
				}
			}
			foreach (IElement item2 in (IEnumerable<IElement>)((IParentNode)document).QuerySelectorAll("style"))
			{
				stringBuilder.AppendLine(((INode)item2).TextContent);
			}
			return stringBuilder.ToString();
		}

		private static int CountNodes(LayoutNode node)
		{
			int num = 1;
			foreach (LayoutNode child in node.Children)
			{
				num += CountNodes(child);
			}
			return num;
		}

		private static string Framework(string path)
		{
			string name = "Sideload.Assets." + path.Replace('/', '.');
			using Stream stream = typeof(WebView).Assembly.GetManifestResourceStream(name);
			if (stream == null)
			{
				return null;
			}
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		private void ShowError(string message)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			Instance log = Core.Log;
			if (log != null)
			{
				log.Warning("[Sideload] " + message);
			}
			for (int num = ((Transform)_root).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)_root).GetChild(num)).gameObject);
			}
			RectTransform val = UiFactory.Rect("sideload-error", (Transform)(object)_root);
			UiFactory.Stretch(val);
			UiFactory.Fill(val, new Color(0.165f, 0.082f, 0.094f, 1f));
			RectTransform obj = UiFactory.Rect("message", (Transform)(object)val);
			UiFactory.Stretch(obj, 24f, 24f, 24f, 24f);
			TextMeshProUGUI obj2 = ((Component)obj).gameObject.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = "Sideload\n\n" + message;
			((TMP_Text)obj2).fontSize = 18f;
			((Graphic)obj2).color = new Color(0.945f, 0.439f, 0.478f, 1f);
			((Graphic)obj2).raycastTarget = false;
		}
	}
}
namespace Sideload.Dom
{
	internal static class DomBuilder
	{
		private static readonly HashSet<string> InlineTags = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "b", "strong", "i", "em", "u", "span", "br", "small", "code", "a" };

		private static readonly HashSet<string> SkippedTags = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "head", "script", "style", "title", "meta", "link" };

		internal static LayoutNode Build(IElement element, Dictionary<IElement, ComputedStyle> styles)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			if (element == null)
			{
				return null;
			}
			if (SkippedTags.Contains(element.LocalName))
			{
				return null;
			}
			ComputedStyle computedStyle = Style(element, styles);
			if (computedStyle.Display == DisplayKind.None)
			{
				return null;
			}
			if (IsInlineOnly(element))
			{
				string text = CompileInline(element, styles, computedStyle);
				if (!string.IsNullOrEmpty(text))
				{
					return new LayoutNode(computedStyle, text)
					{
						Tag = element
					};
				}
				return null;
			}
			LayoutNode layoutNode = new LayoutNode(computedStyle)
			{
				Tag = element
			};
			foreach (INode item in (IEnumerable<INode>)((INode)element).ChildNodes)
			{
				if ((int)item.NodeType == 3)
				{
					string text2 = Normalise(item.TextContent).Trim();
					if (text2.Length != 0)
					{
						layoutNode.Add(new LayoutNode(computedStyle, text2)
						{
							Tag = element
						});
					}
					continue;
				}
				IElement val = (IElement)(object)((item is IElement) ? item : null);
				if (val != null)
				{
					LayoutNode layoutNode2 = Build(val, styles);
					if (layoutNode2 != null)
					{
						layoutNode.Add(layoutNode2);
					}
				}
			}
			return layoutNode;
		}

		private static bool IsInlineOnly(IElement element)
		{
			//IL_0018: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_004e: 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_0024: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			bool result = false;
			foreach (INode item in (IEnumerable<INode>)((INode)element).ChildNodes)
			{
				NodeType nodeType = item.NodeType;
				if ((int)nodeType != 1)
				{
					if ((int)nodeType != 3)
					{
						if ((int)nodeType != 8)
						{
							return false;
						}
					}
					else if (Normalise(item.TextContent).Trim().Length > 0)
					{
						result = true;
					}
				}
				else if (!InlineTags.Contains(((IElement)item).LocalName))
				{
					return false;
				}
			}
			return result;
		}

		private static string CompileInline(IElement element, Dictionary<IElement, ComputedStyle> styles, ComputedStyle inherited)
		{
			StringBuilder stringBuilder = new StringBuilder();
			AppendInline(element, styles, inherited, stringBuilder);
			return stringBuilder.ToString().Trim();
		}

		private static void AppendInline(IElement element, Dictionary<IElement, ComputedStyle> styles, ComputedStyle inherited, StringBuilder sb)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			foreach (INode item in (IEnumerable<INode>)((INode)element).ChildNodes)
			{
				if ((int)item.NodeType == 3)
				{
					sb.Append(Escape(Normalise(item.TextContent)));
					continue;
				}
				IElement val = (IElement)(object)((item is IElement) ? item : null);
				if (val == null)
				{
					continue;
				}
				string text = val.LocalName.ToLowerInvariant();
				if (text == "br")
				{
					sb.Append('\n');
					continue;
				}
				ComputedStyle computedStyle = Style(val, styles);
				string text2 = "";
				string text3 = "";
				if (text == "b" || text == "strong" || computedStyle.FontWeight >= 600)
				{
					text2 += "<b>";
					text3 = "</b>" + text3;
				}
				if (text == "i" || text == "em" || computedStyle.FontStyle == FontStyleKind.Italic)
				{
					text2 += "<i>";
					text3 = "</i>" + text3;
				}
				if (text == "u")
				{
					text2 += "<u>";
					text3 = "</u>" + text3;
				}
				if (!computedStyle.Color.Equals(inherited.Color))
				{
					text2 = text2 + "<color=#" + Hex(computedStyle.Color) + ">";
					text3 = "</color>" + text3;
				}
				sb.Append(text2);
				AppendInline(val, styles, computedStyle, sb);
				sb.Append(text3);
			}
		}

		private static ComputedStyle Style(IElement element, Dictionary<IElement, ComputedStyle> styles)
		{
			if (styles == null || !styles.TryGetValue(element, out var value))
			{
				return new ComputedStyle();
			}
			return value;
		}

		internal static string Normalise(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			bool flag = false;
			foreach (char c in text)
			{
				if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
				{
					if (!flag)
					{
						stringBuilder.Append(' ');
					}
					flag = true;
				}
				else
				{
					stringBuilder.Append(c);
					flag = false;
				}
			}
			return stringBuilder.ToString();
		}

		private static string Escape(string text)
		{
			return text.Replace("<", "<noparse><</noparse>");
		}

		private static string Hex(RgbaColor c)
		{
			int num = (int)Math.Round(Math.Clamp(c.R, 0f, 1f) * 255f);
			int num2 = (int)Math.Round(Math.Clamp(c.G, 0f, 1f) * 255f);
			int num3 = (int)Math.Round(Math.Clamp(c.B, 0f, 1f) * 255f);
			return num.ToString("X2") + num2.ToString("X2") + num3.ToString("X2");
		}
	}
}
namespace Sideload.Devtools
{
	internal static class ClickProbe
	{
		internal static GameObject ClickAt(Vector2 screenPosition, string what)
		{
			//IL_0027: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/probe] no EventSystem - nothing can be clicked.");
				}
				return null;
			}
			PointerEventData val = new PointerEventData(current)
			{
				position = screenPosition,
				button = (InputButton)0
			};
			List<RaycastResult> val2 = new List<RaycastResult>();
			current.RaycastAll(val, val2);
			if (val2.Count == 0)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning($"[Sideload/probe] {what}: raycast at {screenPosition} hit nothing.");
				}
				return null;
			}
			RaycastResult val3 = (val.pointerPressRaycast = (val.pointerCurrentRaycast = val2[0]));
			ExecuteEvents.ExecuteHierarchy<IPointerDownHandler>(val3.gameObject, (BaseEventData)(object)val, ExecuteEvents.pointerDownHandler);
			ExecuteEvents.ExecuteHierarchy<IPointerUpHandler>(val3.gameObject, (BaseEventData)(object)val, ExecuteEvents.pointerUpHandler);
			GameObject val6 = ExecuteEvents.ExecuteHierarchy<IPointerClickHandler>(val3.gameObject, (BaseEventData)(object)val, ExecuteEvents.pointerClickHandler);
			Instance log3 = Core.Log;
			if (log3 != null)
			{
				log3.Msg($"[Sideload/probe] {what}: raycast hit '{Path(val3.gameObject)}' ({val2.Count} candidate(s)), click handled by '{Path(val6)}'.");
			}
			return val6;
		}

		private static string Path(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return "<none>";
			}
			string text = ((Object)go).name;
			Transform parent = go.transform.parent;
			int num = 0;
			while ((Object)(object)parent != (Object)null && num < 4)
			{
				text = ((Object)parent).name + "/" + text;
				num++;
				parent = parent.parent;
			}
			return text;
		}
	}
	internal static class LayoutOverlay
	{
		internal static bool Outlines;

		internal static bool DumpTree = true;

		internal static bool ClipProbe = false;

		internal static void Dump(LayoutNode root, float viewportWidth, float viewportHeight, float hostWidth, float hostHeight, float scale)
		{
			if (DumpTree && root != null)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("[Sideload/layout] --- computed tree ---");
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder3 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(49, 2, stringBuilder2);
				handler.AppendLiteral("[Sideload/layout] host rect    : ");
				handler.AppendFormatted(hostWidth, "0.##");
				handler.AppendLiteral(" x ");
				handler.AppendFormatted(hostHeight, "0.##");
				handler.AppendLiteral(" device units");
				stringBuilder3.AppendLine(ref handler);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(41, 3, stringBuilder2);
				handler.AppendLiteral("[Sideload/layout] css viewport : ");
				handler.AppendFormatted(viewportWidth, "0.##");
				handler.AppendLiteral(" x ");
				handler.AppendFormatted(viewportHeight, "0.##");
				handler.AppendLiteral(" at ");
				handler.AppendFormatted(scale, "0.####");
				handler.AppendLiteral("x");
				stringBuilder4.AppendLine(ref handler);
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder5 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(49, 2, stringBuilder2);
				handler.AppendLiteral("[Sideload/layout] back-check   : ");
				handler.AppendFormatted(viewportWidth * scale, "0.##");
				handler.AppendLiteral(" x ");
				handler.AppendFormatted(viewportHeight * scale, "0.##");
				handler.AppendLiteral(" device units");
				stringBuilder5.AppendLine(ref handler);
				Walk(root, 0, stringBuilder);
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg(stringBuilder.ToString().TrimEnd());
				}
			}
		}

		private static void Walk(LayoutNode node, int depth, StringBuilder sb)
		{
			if (depth > 8)
			{
				return;
			}
			string value = new string(' ', depth * 2);
			string value2 = Describe(node);
			StringBuilder stringBuilder = sb;
			StringBuilder stringBuilder2 = stringBuilder;
			StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(47, 8, stringBuilder);
			handler.AppendLiteral("[Sideload/layout] ");
			handler.AppendFormatted(value);
			handler.AppendFormatted(value2);
			handler.AppendLiteral("  x=");
			handler.AppendFormatted(node.X, "0.##");
			handler.AppendLiteral(" y=");
			handler.AppendFormatted(node.Y, "0.##");
			handler.AppendLiteral(" w=");
			handler.AppendFormatted(node.Width, "0.##");
			handler.AppendLiteral(" h=");
			handler.AppendFormatted(node.Height, "0.##");
			handler.AppendLiteral("  right=");
			handler.AppendFormatted(node.X + node.Width, "0.##");
			handler.AppendLiteral(" bottom=");
			handler.AppendFormatted(node.Y + node.Height, "0.##");
			stringBuilder2.AppendLine(ref handler);
			if (node.IsTextLeaf)
			{
				string text = node.Text.Replace("\n", "\\n");
				if (text.Length > 120)
				{
					text = text.Substring(0, 120) + "...";
				}
				stringBuilder = sb;
				StringBuilder stringBuilder3 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(27, 2, stringBuilder);
				handler.AppendLiteral("[Sideload/layout] ");
				handler.AppendFormatted(value);
				handler.AppendLiteral("  text=\"");
				handler.AppendFormatted(text);
				handler.AppendLiteral("\"");
				stringBuilder3.AppendLine(ref handler);
			}
			foreach (LayoutNode child in node.Children)
			{
				Walk(child, depth + 1, sb);
			}
		}

		private static string Describe(LayoutNode node)
		{
			object tag = node.Tag;
			IElement val = (IElement)((tag is IElement) ? tag : null);
			if (val != null)
			{
				string attribute = val.GetAttribute("class");
				string text = val.LocalName;
				if (node.IsTextLeaf)
				{
					text += "(text)";
				}
				if (!string.IsNullOrEmpty(attribute))
				{
					return text + "." + attribute.Replace(' ', '.');
				}
				return text;
			}
			if (!node.IsTextLeaf)
			{
				return "(box)";
			}
			return "(text)";
		}
	}
	internal static class Probe
	{
		private static bool _fontsLogged;

		internal static void LogRect(RectTransform rt, string label)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_003c: 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)
			//IL_00c6: 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)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rt == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/probe] " + label + ": rect is null");
				}
				return;
			}
			try
			{
				Canvas.ForceUpdateCanvases();
				Rect rect = rt.rect;
				Vector2 val = Vector2.op_Implicit(((Transform)rt).lossyScale);
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Msg($"[Sideload/probe] {label}: {((Rect)(ref rect)).width:0.##} x {((Rect)(ref rect)).height:0.##} (pivot {rt.pivot.x:0.##},{rt.pivot.y:0.##}  lossyScale {val.x:0.###},{val.y:0.###})");
				}
			}
			catch (Exception ex)
			{
				Instance log3 = Core.Log;
				if (log3 != null)
				{
					log3.Warning("[Sideload/probe] " + label + ": rect read failed: " + ex.Message);
				}
			}
		}

		internal static void LogAppPanels(Transform appsCanvas)
		{
			//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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)appsCanvas == (Object)null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/probe] no AppsCanvas to inspect.");
				}
				return;
			}
			try
			{
				Canvas.ForceUpdateCanvases();
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Msg($"[Sideload/probe] AppsCanvas: {appsCanvas.childCount} panel(s)");
				}
				for (int i = 0; i < appsCanvas.childCount; i++)
				{
					Transform child = appsCanvas.GetChild(i);
					RectTransform component = ((Component)child).GetComponent<RectTransform>();
					if ((Object)(object)component == (Object)null)
					{
						Instance log3 = Core.Log;
						if (log3 != null)
						{
							log3.Msg("[Sideload/probe]   " + ((Object)child).name + ": no RectTransform");
						}
						continue;
					}
					Vector3 localEulerAngles = ((Transform)component).localEulerAngles;
					Instance log4 = Core.Log;
					if (log4 != null)
					{
						DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(66, 11);
						defaultInterpolatedStringHandler.AppendLiteral("[Sideload/probe]   ");
						defaultInterpolatedStringHandler.AppendFormatted(((Object)child).name);
						defaultInterpolatedStringHandler.AppendLiteral(": ");
						Rect rect = component.rect;
						defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).width, "0.#");
						defaultInterpolatedStringHandler.AppendLiteral(" x ");
						rect = component.rect;
						defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).height, "0.#");
						defaultInterpolatedStringHandler.AppendLiteral("  ");
						defaultInterpolatedStringHandler.AppendLiteral("anchors ");
						defaultInterpolatedStringHandler.AppendFormatted(component.anchorMin.x, "0.##");
						defaultInterpolatedStringHandler.AppendLiteral(",");
						defaultInterpolatedStringHandler.AppendFormatted(component.anchorMin.y, "0.##");
						defaultInterpolatedStringHandler.AppendLiteral("-");
						defaultInterpolatedStringHandler.AppendFormatted(component.anchorMax.x, "0.##");
						defaultInterpolatedStringHandler.AppendLiteral(",");
						defaultInterpolatedStringHandler.AppendFormatted(component.anchorMax.y, "0.##");
						defaultInterpolatedStringHandler.AppendLiteral("  ");
						defaultInterpolatedStringHandler.AppendLiteral("sizeDelta ");
						defaultInterpolatedStringHandler.AppendFormatted(component.sizeDelta.x, "0.#");
						defaultInterpolatedStringHandler.AppendLiteral(",");
						defaultInterpolatedStringHandler.AppendFormatted(component.sizeDelta.y, "0.#");
						defaultInterpolatedStringHandler.AppendLiteral("  rotZ ");
						defaultInterpolatedStringHandler.AppendFormatted(localEulerAngles.z, "0.#");
						defaultInterpolatedStringHandler.AppendLiteral("  active ");
						defaultInterpolatedStringHandler.AppendFormatted(((Component)child).gameObject.activeSelf);
						log4.Msg(defaultInterpolatedStringHandler.ToStringAndClear());
					}
				}
			}
			catch (Exception ex)
			{
				Instance log5 = Core.Log;
				if (log5 != null)
				{
					log5.Warning("[Sideload/probe] AppsCanvas read failed: " + ex.Message);
				}
			}
		}

		internal static void LogFonts()
		{
			if (_fontsLogged)
			{
				return;
			}
			_fontsLogged = true;
			try
			{
				TMP_FontAsset[] array = Il2CppArrayBase<TMP_FontAsset>.op_Implicit(Resources.FindObjectsOfTypeAll<TMP_FontAsset>());
				if (array == null || array.Length == 0)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Msg("[Sideload/probe] no TMP font assets found");
					}
					return;
				}
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Msg($"[Sideload/probe] {array.Length} TMP font asset(s):");
				}
				TMP_FontAsset[] array2 = array;
				foreach (TMP_FontAsset val in array2)
				{
					if (!((Object)(object)val == (Object)null))
					{
						string value = "?";
						try
						{
							value = ((TMP_Asset)val).faceInfo.familyName + " / " + ((TMP_Asset)val).faceInfo.styleName;
						}
						catch
						{
						}
						Instance log3 = Core.Log;
						if (log3 != null)
						{
							log3.Msg($"[Sideload/probe]   {((Object)val).name}  [{value}]  pointSize={SafePointSize(val)}");
						}
					}
				}
			}
			catch (Exception ex)
			{
				Instance log4 = Core.Log;
				if (log4 != null)
				{
					log4.Warning("[Sideload/probe] font scan failed: " + ex.Message);
				}
			}
		}

		private static string SafePointSize(TMP_FontAsset font)
		{
			try
			{
				return ((TMP_Asset)font).faceInfo.pointSize.ToString();
			}
			catch
			{
				return "?";
			}
		}
	}
	internal static class SelfTestApp
	{
		internal const string Id = "sideload-selftest";

		internal static void Register()
		{
			Registry.RegisterApp("sideload-selftest", "Sideload Self-Test", "Sideload", "Sideload.Assets.selftest", typeof(Core).Assembly);
			Sideload.Script.Bridge.Handle("sideload-selftest", "host.clock", (string app, string arg) => DateTime.Now.ToString("HH:mm:ss", CultureInfo.InvariantCulture));
			Sideload.Script.Bridge.Handle("sideload-selftest", "host.info", (string app, string arg) => $"{app} on Unity {Application.unityVersion}, frame {Time.frameCount}");
		}
	}
}
namespace Sideload.Devtools.Cdp
{
	internal static class CdpServer
	{
		private sealed class Snapshot
		{
			internal object Document;

			internal object Script;
		}

		private const int MaxSessions = 4;

		private static readonly List<CdpSession> _sessions = new List<CdpSession>();

		private static readonly object _lock = new object();

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

		private static HttpListener _listener;

		private static Thread _accept;

		private static CancellationTokenSource _cancel;

		private static volatile bool _running;

		private static int _port;

		private static bool _announced;

		internal static bool Running => _running;

		internal static int Port => _port;

		internal static void Start(int port)
		{
			if (_running)
			{
				return;
			}
			_port = port;
			try
			{
				_listener = new HttpListener();
				_listener.Prefixes.Add($"http://127.0.0.1:{port}/");
				_listener.Start();
				_running = true;
				_cancel = new CancellationTokenSource();
				_accept = new Thread(AcceptLoop)
				{
					IsBackground = true,
					Name = "Sideload-DevTools"
				};
				_accept.Start();
				ScriptHost.Diagnostics = OnDiagnostic;
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg($"[Sideload/cdp] devtools protocol server on http://127.0.0.1:{port}/ " + "- open that page and click a target, or add it under chrome://inspect > Configure.");
				}
				FrontendCache.Resolve();
			}
			catch (Exception ex)
			{
				_running = false;
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Error($"[Sideload/cdp] the devtools server could not start on {port}: {ex.Message} " + "(port already in use? change Sideload's DevToolsPort)");
				}
			}
		}

		internal static void Stop()
		{
			if (!_running && _listener == null)
			{
				return;
			}
			_running = false;
			ScriptHost.Diagnostics = null;
			try
			{
				_cancel?.Cancel();
			}
			catch
			{
			}
			lock (_lock)
			{
				foreach (CdpSession session in _sessions)
				{
					session.Dispose();
				}
				_sessions.Clear();
			}
			try
			{
				_listener?.Stop();
				_listener?.Close();
			}
			catch
			{
			}
			try
			{
				_cancel?.Dispose();
			}
			catch
			{
			}
			_listener = null;
			_cancel = null;
			_seen.Clear();
			LogDomain.Clear();
			MainThread.Clear();
		}

		internal static void Pump()
		{
			if (_running)
			{
				MainThread.Pump();
				Announce();
				NoticeReloads();
			}
		}

		private static List<CdpSession> SessionsFor(string targetId)
		{
			List<CdpSession> list = new List<CdpSession>();
			lock (_lock)
			{
				foreach (CdpSession session in _sessions)
				{
					if (session.Alive && string.Equals(session.TargetId, targetId, StringComparison.Ordinal))
					{
						list.Add(session);
					}
				}
				return list;
			}
		}

		private static void NoticeReloads()
		{
			lock (_lock)
			{
				if (_sessions.Count == 0)
				{
					return;
				}
			}
			foreach (WebView item in WebView.Live)
			{
				string text = Targets.IdOf(item);
				object document = item.Document;
				object script = item.Script;
				if (!_seen.TryGetValue(text, out var value))
				{
					_seen[text] = new Snapshot
					{
						Document = document,
						Script = script
					};
					continue;
				}
				bool flag = value.Document != document;
				bool flag2 = value.Script != script;
				if (!flag && !flag2)
				{
					continue;
				}
				value.Document = document;
				value.Script = script;
				foreach (CdpSession item2 in SessionsFor(text))
				{
					if (flag)
					{
						item2.Nodes.Clear();
						if (item2.DomEnabled)
						{
							item2.Emit("DOM.documentUpdated", "{}");
						}
						CssDomain.Forget(item2);
						if (item2.CssEnabled)
						{
							string text2 = CssDomain.HeaderJson(item2);
							if (text2 != null)
							{
								item2.Emit("CSS.styleSheetAdded", text2);
							}
						}
					}
					if (flag2 && item2.RuntimeEnabled)
					{
						item2.Objects.Clear();
						item2.Emit("Runtime.executionContextsCleared", "{}");
						item2.Emit("Runtime.executionContextCreated", RuntimeDomain.ContextJson(item2));
					}
				}
			}
		}

		private static void Announce()
		{
			if (_announced)
			{
				return;
			}
			WebView webView = null;
			foreach (WebView item in WebView.Live)
			{
				if (item.BoxCount > 0)
				{
					webView = item;
					break;
				}
			}
			if (webView != null)
			{
				_announced = true;
				string text = Targets.IdOf(webView);
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg($"[Sideload/cdp] open http://127.0.0.1:{_port}/ and click '{text}' to inspect it.");
				}
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Msg("[Sideload/cdp] direct: " + Targets.FrontendUrl(_port, text));
				}
				if (Preferences.DevToolsAutoOpen)
				{
					ChromeLauncher.Open(_port, text);
				}
			}
		}

		private static void OnDiagnostic(string appId, string level, object[] args, string text)
		{
			if (!_running)
			{
				return;
			}
			string targetId = Targets.IdFor(appId);
			LogDomain.Record(targetId, level, text);
			List<CdpSession> list = SessionsFor(targetId);
			if (list.Count == 0)
			{
				return;
			}
			Engine engine = null;
			try
			{
				engine = Targets.Find(targetId)?.Script?.Engine;
			}
			catch
			{
			}
			foreach (CdpSession item in list)
			{
				try
				{
					LogDomain.Console(item, engine, level, args, text);
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload/cdp] forwarding a console line failed: " + ex.Message);
					}
				}
			}
		}

		private static void AcceptLoop()
		{
			while (_running)
			{
				HttpListenerContext context;
				try
				{
					context = _listener.GetContext();
				}
				catch
				{
					if (!_running)
					{
						break;
					}
					continue;
				}
				Task.Run(() => HandleAsync(context));
			}
		}

		private static async Task HandleAsync(HttpListenerContext context)
		{
			try
			{
				HttpListenerRequest request = context.Request;
				if (!IsLocalHost(request))
				{
					context.Response.StatusCode = 403;
					context.Response.Close();
					return;
				}
				string absolutePath = request.Url.AbsolutePath;
				if (request.IsWebSocketRequest)
				{
					await HandleSocketAsync(context, absolutePath).ConfigureAwait(continueOnCapturedContext: false);
					return;
				}
				switch (absolutePath)
				{
				case "/json/version":
					WriteJson(context.Response, VersionJson());
					return;
				case "/json":
				case "/json/list":
					WriteJson(context.Response, MainThread.Run(ListJson));
					return;
				case "/":
				case "/index.html":
					WriteHtml(context.Response, MainThread.Run(LandingPage));
					return;
				}
				if (absolutePath.StartsWith("/frontend/", StringComparison.Ordinal))
				{
					ServeFrontend(context.Response, absolutePath);
					return;
				}
				if (absolutePath.StartsWith("/json/activate/", StringComparison.Ordinal))
				{
					WriteText(context.Response, "Target activated");
					return;
				}
				if (absolutePath.StartsWith("/json/close/", StringComparison.Ordinal))
				{
					WriteText(context.Response, "Target is closed");
					return;
				}
				context.Response.StatusCode = 404;
				context.Response.Close();
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/cdp] request failed: " + ex.Message);
				}
				try
				{
					context.Response.Abort();
				}
				catch
				{
				}
			}
		}

		private static async Task HandleSocketAsync(HttpListenerContext context, string path)
		{
			if (!path.StartsWith("/devtools/page/", StringComparison.Ordinal))
			{
				context.Response.StatusCode = 404;
				context.Response.Close();
				return;
			}
			string targetId = path.Substring("/devtools/page/".Length).Trim('/');
			lock (_lock)
			{
				if (_sessions.Count >= 4)
				{
					try
					{
						context.Response.StatusCode = 503;
						context.Response.Close();
						return;
					}
					catch
					{
						return;
					}
				}
			}
			WebSocket webSocket;
			try
			{
				webSocket = (await context.AcceptWebSocketAsync(null).ConfigureAwait(continueOnCapturedContext: false)).WebSocket;
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/cdp] the websocket upgrade failed: " + ex.Message);
				}
				return;
			}
			CdpSession session = new CdpSession(webSocket, targetId);
			lock (_lock)
			{
				_sessions.Add(session);
			}
			Instance log2 = Core.Log;
			if (log2 != null)
			{
				log2.Msg("[Sideload/cdp] devtools attached to '" + targetId + "'.");
			}
			try
			{
				await session.RunAsync(_cancel?.Token ?? CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				lock (_lock)
				{
					_sessions.Remove(session);
				}
				session.Dispose();
				Instance log3 = Core.Log;
				if (log3 != null)
				{
					log3.Msg("[Sideload/cdp] devtools detached from '" + targetId + "'.");
				}
			}
		}

		private static string VersionJson()
		{
			return new Json.Obj().Str("Browser", "Sideload/" + typeof(Core).Assembly.GetName().Version).Str("Protocol-Version", "1.3").Str("User-Agent", "Sideload (Schedule I; MelonLoader; uGUI renderer)")
				.Str("V8-Version", "0.0.0.0")
				.Str("WebKit-Version", "0.0.0.0")
				.Str("webSocketDebuggerUrl", $"ws://127.0.0.1:{_port}/devtools/browser/sideload")
				.Done();
		}

		private static string ListJson()
		{
			List<string> list = new List<string>();
			foreach (WebView item in Targets.All())
			{
				list.Add(Targets.DescribeJson(item, _port));
			}
			return Json.Array(list);
		}

		private static void ServeFrontend(HttpListenerResponse response, string path)
		{
			string root = FrontendCache.Root;
			if (string.IsNullOrEmpty(root) || !Directory.Exists(root))
			{
				response.StatusCode = 404;
				response.Close();
				return;
			}
			string path2 = Uri.UnescapeDataString(path.Substring("/frontend/".Length)).Replace('/', Path.DirectorySeparatorChar);
			string fullPath = Path.GetFullPath(Path.Combine(root, path2));
			if (!fullPath.StartsWith(Path.GetFullPath(root), StringComparison.OrdinalIgnoreCase) || !File.Exists(fullPath))
			{
				response.StatusCode = 404;
				response.Close();
				return;
			}
			try
			{
				byte[] array = File.ReadAllBytes(fullPath);
				response.ContentType = ContentTypeOf(fullPath);
				response.ContentLength64 = array.Length;
				response.OutputStream.Write(array, 0, array.Length);
				response.Close();
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/cdp] serving " + path + " failed: " + ex.Message);
				}
				try
				{
					response.Abort();
				}
				catch
				{
				}
			}
		}

		private static string ContentTypeOf(string file)
		{
			switch (Path.GetExtension(file).ToLowerInvariant())
			{
			case ".html":
			case ".htm":
				return "text/html; charset=utf-8";
			case ".mjs":
			case ".js":
				return "text/javascript; charset=utf-8";
			case ".css":
				return "text/css; charset=utf-8";
			case ".json":
			case ".map":
				return "application/json; charset=utf-8";
			case ".svg":
				return "image/svg+xml";
			case ".png":
				return "image/png";
			case ".avif":
				return "image/avif";
			case ".ico":
				return "image/x-icon";
			case ".jpeg":
			case ".jpg":
				return "image/jpeg";
			case ".woff2":
				return "font/woff2";
			case ".woff":
				return "font/woff";
			case ".wasm":
				return "application/wasm";
			default:
				return "application/octet-stream";
			}
		}

		private static string LandingPage()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<!doctype html><html><head><meta charset=\"utf-8\"><title>Sideload DevTools</title><style>").Append("body{background:#0b0d12;color:#e7e9ee;font:14px/1.6 system-ui,Segoe UI,sans-serif;margin:0;padding:40px}").Append("h1{font-size:18px;margin:0 0 4px}p{color:#8a8f9e;margin:0 0 24px;max-width:60ch}")
				.Append("a{color:#7cc0ff}li{margin:0 0 16px;list-style:none}")
				.Append("code{color:#8a8f9e;font-size:12px}ul{padding:0;margin:0 0 32px}")
				.Append("h2{font-size:14px;margin:0 0 4px}</style></head><body>")
				.Append("<h1>Sideload DevTools</h1><p>Click a page to inspect it. That opens the real Chrome DevTools, ")
				.Append("attached to the page running in the game - console, evaluate, Elements.</p><ul>");
			List<WebView> list = Targets.All();
			if (list.Count == 0)
			{
				stringBuilder.Append("<li>No page is mounted yet. Open a Sideload app on the in-game phone, then reload this page.</li>");
			}
			foreach (WebView item in list)
			{
				string targetId = Targets.IdOf(item);
				stringBuilder.Append("<li><a href=\"").Append(Targets.FrontendUrl(_port, targetId)).Append("\">")
					.Append(WebUtility.HtmlEncode(item.AppId))
					.Append("</a><br><code>")
					.Append(WebUtility.HtmlEncode(Targets.WebSocketUrl(_port, targetId)))
					.Append("</code></li>");
			}
			if (FrontendCache.Root != null)
			{
				stringBuilder.Append("<h2>Offline</h2><p>Those links load the DevTools frontend from this machine, out of ").Append("<code>").Append(WebUtility.HtmlEncode(FrontendCache.Root))
					.Append("</code>. No internet needed.</p>");
			}
			else
			{
				stringBuilder.Append("<h2>No internet?</h2><p>Those links load the DevTools frontend from Google's servers. ").Append("Switch on <code>DevToolsFetchFrontend</code> to have Sideload download its own copy once, ").Append("or use Chrome's built-in copy right now: open <code>chrome://inspect</code>, click ")
					.Append("<b>Configure</b> next to \"Discover network targets\", add <code>127.0.0.1:")
					.Append(_port)
					.Append("</code>, and this page appears in the list with an <b>inspect</b> link. That setting is ")
					.Append("remembered, so it is a one-time step per machine.</p>");
			}
			return stringBuilder.Append("</body></html>").ToString();
		}

		private static bool IsLocalHost(HttpListenerRequest request)
		{
			string text = request.UserHostName ?? "";
			int num = text.LastIndexOf(':');
			if (num > 0 && text.IndexOf(']') < num)
			{
				text = text.Substring(0, num);
			}
			switch (text)
			{
			case "127.0.0.1":
			case "localhost":
			case "[::1]":
			case "::1":
				return true;
			default:
				return false;
			}
		}

		private static void WriteJson(HttpListenerResponse response, string json)
		{
			Write(response, "application/json; charset=utf-8", json);
		}

		private static void WriteHtml(HttpListenerResponse response, string html)
		{
			Write(response, "text/html; charset=utf-8", html);
		}

		private static void WriteText(HttpListenerResponse response, string text)
		{
			Write(response, "text/plain; charset=utf-8", text);
		}

		private static void Write(HttpListenerResponse response, string contentType, string body)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(body ?? "");
			response.StatusCode = 200;
			response.ContentType = contentType;
			response.ContentLength64 = bytes.Length;
			response.OutputStream.Write(bytes, 0, bytes.Length);
			response.OutputStream.Close();
		}
	}
	internal sealed class CdpSession
	{
		private const int MaxMessageBytes = 8388608;

		private readonly WebSocket _ws;

		private readonly ConcurrentQueue<string> _outbox = new ConcurrentQueue<string>();

		private readonly SemaphoreSlim _sendGate = new SemaphoreSlim(1, 1);

		private readonly List<string> _deferred = new List<string>();

		internal string TargetId { get; }

		internal ObjectStore Objects { get; } = new ObjectStore();

		internal NodeStore Nodes { get; } = new NodeStore();

		internal bool RuntimeEnabled { get; set; }

		internal bool LogEnabled { get; set; }

		internal bool DomEnabled { get; set; }

		internal bool PageEnabled { get; set; }

		internal bool CssEnabled { get; set; }

		internal SheetModel Sheet { get; set; }

		internal int SheetGeneration { get; set; }

		internal bool Alive
		{
			get
			{
				if (_ws != null)
				{
					return _ws.State == WebSocketState.Open;
				}
				return false;
			}
		}

		internal CdpSession(WebSocket socket, string targetId)
		{
			_ws = socket;
			TargetId = targetId;
		}

		internal async Task RunAsync(CancellationToken cancel)
		{
			byte[] buffer = new byte[16384];
			MemoryStream message = new MemoryStream();
			try
			{
				while (!cancel.IsCancellationRequested && _ws.State == WebSocketState.Open)
				{
					WebSocketReceiveResult webSocketReceiveResult = await _ws.ReceiveAsync(new ArraySegment<byte>(buffer), cancel).ConfigureAwait(continueOnCapturedContext: false);
					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close)
					{
						break;
					}
					message.Write(buffer, 0, webSocketReceiveResult.Count);
					if (message.Length > 8388608)
					{
						Instance log = Core.Log;
						if (log != null)
						{
							log.Warning("[Sideload/cdp] a message exceeded the size limit - dropping the connection.");
						}
						break;
					}
					if (webSocketReceiveResult.EndOfMessage)
					{
						string raw = Encoding.UTF8.GetString(message.ToArray());
						message.SetLength(0L);
						Handle(raw);
					}
				}
			}
			catch (OperationCanceledException)
			{
			}
			catch (Exception ex2)
			{
				if (!cancel.IsCancellationRequested)
				{
					Instance log2 = Core.Log;
					if (log2 != null)
					{
						log2.Msg("[Sideload/cdp] devtools disconnected: " + ex2.Message);
					}
				}
			}
		}

		private void Handle(string raw)
		{
			JsonValue jsonValue = JsonValue.Parse(raw);
			string method = jsonValue["method"].AsString();
			int num = jsonValue["id"].AsInt(-1);
			if (string.IsNullOrEmpty(method))
			{
				if (num >= 0)
				{
					SendError(num, -32600, "the message has no method");
				}
				return;
			}
			JsonValue args = jsonValue["params"];
			string text;
			try
			{
				text = MainThread.Run(() => Domains.Invoke(this, method, args));
			}
			catch (CdpException ex)
			{
				if (num >= 0)
				{
					SendError(num, ex.Code, ex.Message);
				}
				FlushDeferred();
				return;
			}
			catch (TimeoutException ex2)
			{
				if (num >= 0)
				{
					SendError(num, -32000, ex2.Message);
				}
				return;
			}
			catch (Exception ex3)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/cdp] " + method + " failed: " + ex3.Message);
				}
				if (num >= 0)
				{
					SendError(num, -32000, ex3.Message);
				}
				FlushDeferred();
				return;
			}
			if (num >= 0)
			{
				Send(new Json.Obj().Num("id", num).Raw("result", text ?? "{}").Done());
			}
			FlushDeferred();
		}

		internal void Emit(string method, string parameters)
		{
			Send(new Json.Obj().Str("method", method).Raw("params", parameters ?? "{}").Done());
		}

		internal void EmitAfterReply(string method, string parameters)
		{
			_deferred.Add(new Json.Obj().Str("method", method).Raw("params", parameters ?? "{}").Done());
		}

		private void FlushDeferred()
		{
			if (_deferred.Count == 0)
			{
				return;
			}
			foreach (string item in _deferred)
			{
				Send(item);
			}
			_deferred.Clear();
		}

		private void SendError(int id, int code, string message)
		{
			Send(new Json.Obj().Num("id", id).Raw("error", new Json.Obj().Num("code", code).Str("message", message ?? "").Done()).Done());
		}

		internal void Send(string message)
		{
			if (!string.IsNullOrEmpty(message) && Alive)
			{
				_outbox.Enqueue(message);
				DrainAsync();
			}
		}

		private async Task DrainAsync()
		{
			if (!(await _sendGate.WaitAsync(0).ConfigureAwait(continueOnCapturedContext: false)))
			{
				return;
			}
			try
			{
				string result;
				while (_outbox.TryDequeue(out result))
				{
					if (_ws.State != WebSocketState.Open)
					{
						return;
					}
					byte[] bytes = Encoding.UTF8.GetBytes(result);
					await _ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, endOfMessage: true, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg("[Sideload/cdp] send failed, closing the session: " + ex.Message);
				}
				Close();
			}
			finally
			{
				try
				{
					_sendGate.Release();
				}
				catch
				{
				}
			}
			if (!_outbox.IsEmpty)
			{
				DrainAsync();
			}
		}

		internal void Close()
		{
			try
			{
				_ws?.Abort();
			}
			catch
			{
			}
		}

		internal void Dispose()
		{
			Close();
			try
			{
				_sendGate.Dispose();
			}
			catch
			{
			}
			Objects.Clear();
			Nodes.Clear();
		}
	}
	internal sealed class CdpException : Exception
	{
		internal const int MethodNotFound = -32601;

		internal const int InvalidParams = -32602;

		internal const int ServerError = -32000;

		internal int Code { get; }

		internal CdpException(int code, string message)
			: base(message)
		{
			Code = code;
		}
	}
	internal static class ChromeLauncher
	{
		private static readonly string[] Candidates = new string[6] { "%ProgramFiles%\\Google\\Chrome\\Application\\chrome.exe", "%ProgramFiles(x86)%\\Google\\Chrome\\Application\\chrome.exe", "%LocalAppData%\\Google\\Chrome\\Application\\chrome.exe", "%ProgramFiles%\\Google\\Chrome Beta\\Application\\chrome.exe", "%ProgramFiles%\\Microsoft\\Edge\\Application\\msedge.exe", "%ProgramFiles(x86)%\\Microsoft\\Edge\\Application\\msedge.exe" };

		private static Process _window;

		internal static void Open(int port, string targetId)
		{
			string value = ((targetId == null) ? $"http://127.0.0.1:{port}/" : Targets.FrontendUrl(port, targetId));
			string text = Find();
			if (text == null)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning($"[Sideload/cdp] no Chrome or Edge found - open http://127.0.0.1:{port}/ yourself.");
				}
				return;
			}
			if (_window != null && !_window.HasExited)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Msg("[Sideload/cdp] devtools window is already open.");
				}
				return;
			}
			try
			{
				_window = Process.Start(new ProcessStartInfo
				{
					FileName = text,
					Arguments = $"--app=\"{value}\" --user-data-dir=\"{ProfileDirectory()}\" " + "--no-first-run --no-default-browser-check --disable-features=Translate --window-size=1500,950",
					UseShellExecute = false
				});
				Instance log3 = Core.Log;
				if (log3 != null)
				{
					log3.Msg($"[Sideload/cdp] devtools opened in {Path.GetFileNameWithoutExtension(text)} (own window, own profile) on '{targetId ?? "the target list"}'.");
				}
			}
			catch (Exception ex)
			{
				Instance log4 = Core.Log;
				if (log4 != null)
				{
					log4.Warning($"[Sideload/cdp] launching the browser failed ({ex.Message}) - open http://127.0.0.1:{port}/ yourself.");
				}
			}
		}

		internal static void Close()
		{
			try
			{
				if (_window != null && !_window.HasExited)
				{
					_window.Kill(entireProcessTree: true);
				}
			}
			catch
			{
			}
			finally
			{
				_window = null;
			}
		}

		private static string ProfileDirectory()
		{
			string text = Path.Combine(MelonEnvironment.UserDataDirectory, "Sideload", "devtools-profile");
			Directory.CreateDirectory(text);
			return text;
		}

		private static string Find()
		{
			string[] candidates = Candidates;
			for (int i = 0; i < candidates.Length; i++)
			{
				string text = Environment.ExpandEnvironmentVariables(candidates[i]);
				if (!text.Contains('%') && File.Exists(text))
				{
					return text;
				}
			}
			return null;
		}
	}
	internal static class ComputedCss
	{
		internal static List<KeyValuePair<string, string>> Describe(ComputedStyle style)
		{
			List<KeyValuePair<string, string>> css = new List<KeyValuePair<string, string>>();
			if (style == null)
			{
				return css;
			}
			Put("display", (style.Display == DisplayKind.None) ? "none" : "flex");
			Put("flex-direction", style.FlexDirection switch
			{
				FlexDirection.Row => "row", 
				FlexDirection.RowReverse => "row-reverse", 
				FlexDirection.ColumnReverse => "column-reverse", 
				_ => "column", 
			});
			Put("flex-wrap", style.FlexWrap switch
			{
				FlexWrap.Wrap => "wrap", 
				FlexWrap.WrapReverse => "wrap-reverse", 
				_ => "nowrap", 
			});
			Put("flex-grow", Number(style.FlexGrow));
			Put("flex-shrink", Number(style.FlexShrink));
			Put("flex-basis", style.FlexBasis.ToString());
			Put("justify-content", style.JustifyContent switch
			{
				Justify.FlexEnd => "flex-end", 
				Justify.Center => "center", 
				Justify.SpaceBetween => "space-between", 
				Justify.SpaceAround => "space-around", 
				Justify.SpaceEvenly => "space-evenly", 
				_ => "flex-start", 
			});
			Put("align-items", Align(style.AlignItems));
			Put("align-self", Align(style.AlignSelf));
			Put("row-gap", style.RowGap.ToString());
			Put("column-gap", style.ColumnGap.ToString());
			Edges(css, "padding", style.Padding);
			Edges(css, "margin", style.Margin);
			Put("width", style.Width.ToString());
			Put("height", style.Height.ToString());
			Put("min-width", style.MinWidth.ToString());
			Put("min-height", style.MinHeight.ToString());
			Put("max-width", style.MaxWidth.ToString());
			Put("max-height", style.MaxHeight.ToString());
			Put("position", (style.Position == PositionKind.Absolute) ? "absolute" : "static");
			Put("top", style.Inset.Top.ToString());
			Put("right", style.Inset.Right.ToString());
			Put("bottom", style.Inset.Bottom.ToString());
			Put("left", style.Inset.Left.ToString());
			Put("overflow-x", Overflow(style.OverflowX));
			Put("overflow-y", Overflow(style.OverflowY));
			Put("background-color", Color(style.BackgroundColor));
			Put("background-image", style.HasGradient ? string.Format(CultureInfo.InvariantCulture, "linear-gradient({0}deg, {1}, {2})", Number(style.GradientAngleDeg), Color(style.GradientFrom), Color(style.GradientTo)) : "none");
			Put("border-top-width", style.BorderWidth.Top.ToString());
			Put("border-right-width", style.BorderWidth.Right.ToString());
			Put("border-bottom-width", style.BorderWidth.Bottom.ToString());
			Put("border-left-width", style.BorderWidth.Left.ToString());
			Put("border-color", Color(style.BorderColor));
			Put("border-radius", Radius(style.BorderRadius));
			Put("box-shadow", style.HasShadow ? string.Format(CultureInfo.InvariantCulture, "{0} {1} {2} {3}", Pixels(style.ShadowOffsetX), Pixels(style.ShadowOffsetY), Pixels(style.ShadowBlur), Color(style.ShadowColor)) : "none");
			Put("opacity", Number(style.Opacity));
			Put("font-family", style.FontFamily ?? "");
			Put("font-size", Pixels(style.FontSize));
			Put("font-weight", style.FontWeight.ToString(CultureInfo.InvariantCulture));
			Put("font-style", (style.FontStyle == FontStyleKind.Italic) ? "italic" : "normal");
			Put("line-height", Pixels(style.ResolvedLineHeight));
			Put("letter-spacing", Pixels(style.LetterSpacing));
			Put("text-align", style.TextAlign switch
			{
				TextAlignKind.Center => "center", 
				TextAlignKind.Right => "right", 
				_ => "left", 
			});
			Put("white-space", (style.WhiteSpace == WhiteSpaceKind.NoWrap) ? "nowrap" : "normal");
			Put("color", Color(style.Color));
			Put("text-overflow", style.TextOverflowEllipsis ? "ellipsis" : "clip");
			if (style.Variables != null)
			{
				foreach (KeyValuePair<string, string> variable in style.Variables)
				{
					Put(variable.Key, variable.Value ?? "");
				}
			}
			return css;
			void Put(string name, string value)
			{
				css.Add(new KeyValuePair<string, string>(name, value));
			}
		}

		private static void Edges(List<KeyValuePair<string, string>> css, string prefix, Edges edges)
		{
			css.Add(new KeyValuePair<string, string>(prefix + "-top", edges.Top.ToString()));
			css.Add(new KeyValuePair<string, string>(prefix + "-right", edges.Right.ToString()));
			css.Add(new KeyValuePair<string, string>(prefix + "-bottom", edges.Bottom.ToString()));
			css.Add(new KeyValuePair<string, string>(prefix + "-left", edges.Left.ToString()));
		}

		private static string Align(AlignKind align)
		{
			return align switch
			{
				AlignKind.FlexStart => "flex-start", 
				AlignKind.FlexEnd => "flex-end", 
				AlignKind.Center => "center", 
				AlignKind.Baseline => "baseline", 
				AlignKind.Auto => "auto", 
				_ => "stretch", 
			};
		}

		private static string Overflow(OverflowKind overflow)
		{
			return overflow switch
			{
				OverflowKind.Hidden => "hidden", 
				OverflowKind.Scroll => "scroll", 
				OverflowKind.Auto => "auto", 
				_ => "visible", 
			};
		}

		private static string Radius(Corners corners)
		{
			if (corners.IsZero)
			{
				return "0px";
			}
			if (corners.TopLeft != corners.TopRight || corners.TopRight != corners.BottomRight || corners.BottomRight != corners.BottomLeft)
			{
				return $"{Pixels(corners.TopLeft)} {Pixels(corners.TopRight)} {Pixels(corners.BottomRight)} {Pixels(corners.BottomLeft)}";
			}
			return Pixels(corners.TopLeft);
		}

		internal static string Color(RgbaColor color)
		{
			int num = Channel(color.R);
			int num2 = Channel(color.G);
			int num3 = Channel(color.B);
			if (!(color.A >= 0.999f))
			{
				return string.Format(CultureInfo.InvariantCulture, "rgba({0}, {1}, {2}, {3})", num, num2, num3, Number(color.A));
			}
			return string.Format(CultureInfo.InvariantCulture, "rgb({0}, {1}, {2})", num, num2, num3);
		}

		private static int Channel(float value)
		{
			return (int)Math.Round(Math.Clamp(value, 0f, 1f) * 255f);
		}

		private static string Number(float value)
		{
			return value.ToString("0.###", CultureInfo.InvariantCulture);
		}

		private static string Pixels(float value)
		{
			return Number(value) + "px";
		}
	}
	internal static class CssDomain
	{
		private sealed class Match
		{
			internal SourceRule Rule;

			internal List<int> Selectors;

			internal int A;

			internal int B;

			internal int C;

			internal int Order = int.MaxValue;
		}

		internal static string Enable(CdpSession session)
		{
			session.CssEnabled = true;
			string text = HeaderJson(session);
			if (text != null)
			{
				session.EmitAfterReply("CSS.styleSheetAdded", text);
			}
			return "{}";
		}

		internal static string GetMatchedStylesForNode(CdpSession session, JsonValue args)
		{
			IElement element = DomDomain.ElementOf(session, args);
			WebView view = DomDomain.ViewOf(session);
			SheetModel model = ModelOf(session);
			return new Json.Obj().Raw("inlineStyle", InlineJson(element)).Raw("matchedCSSRules", MatchedJson(model, view, element)).Raw("pseudoElements", "[]")
				.Raw("inherited", InheritedJson(model, view, element))
				.Raw("cssKeyframesRules", "[]")
				.Done();
		}

		internal static string GetInlineStylesForNode(CdpSession session, JsonValue args)
		{
			IElement element = DomDomain.ElementOf(session, args);
			return new Json.Obj().Raw("inlineStyle", InlineJson(element)).Done();
		}

		internal static string ForcePseudoState(CdpSession session, JsonValue args)
		{
			IElement element = DomDomain.ElementOf(session, args);
			WebView webView = DomDomain.ViewOf(session);
			List<string> list = new List<string>();
			JsonValue jsonValue = args?["forcedPseudoClasses"];
			if (jsonValue != null)
			{
				for (int i = 0; i < jsonValue.Count; i++)
				{
					list.Add(jsonValue[i]?.AsString() ?? "");
				}
			}
			webView.ForcePseudoState(element, list);
			return "{}";
		}

		internal static string GetComputedStyleForNode(CdpSession session, JsonValue args)
		{
			IElement key = DomDomain.ElementOf(session, args);
			WebView webView = DomDomain.ViewOf(session);
			Dictionary<IElement, ComputedStyle> dictionary = StyleResolver.Resolve(webView.Document, webView.Sheet, webView.StyleContext);
			List<string> list = new List<string>();
			if (dictionary.TryGetValue(key, out var value))
			{
				foreach (KeyValuePair<string, string> item in ComputedCss.Describe(value))
				{
					list.Add(new Json.Obj().Str("name", item.Key).Str("value", item.Value).Done());
				}
			}
			return new Json.Obj().Raw("computedStyle", Json.Array(list)).Done();
		}

		internal static string GetStyleSheetText(CdpSession session, JsonValue args)
		{
			SheetModel sheetModel = ModelOf(session);
			string text = args["styleSheetId"].AsString();
			if (sheetModel == null || !string.Equals(sheetModel.Id, text, StringComparison.Ordinal))
			{
				throw new CdpException(-32602, "no stylesheet with id " + text + " - the page may have been reloaded");
			}
			return new Json.Obj().Str("text", sheetModel.Text).Done();
		}

		internal static string HeaderJson(CdpSession session)
		{
			SheetModel sheetModel = ModelOf(session);
			if (sheetModel == null)
			{
				return null;
			}
			WebView view = Targets.Find(session.TargetId);
			return new Json.Obj().Raw("header", new Json.Obj().Str("styleSheetId", sheetModel.Id).Str("frameId", Targets.FrameOf(session.TargetId)).Str("sourceURL", Targets.OriginOf(view) + "/styles.css")
				.Str("origin", "regular")
				.Str("title", "")
				.Bool("disabled", value: false)
				.Bool("isInline", value: false)
				.Bool("isMutable", value: true)
				.Bool("isConstructed", value: false)
				.Num("startLine", 0.0)
				.Num("startColumn", 0.0)
				.Num("length", sheetModel.Text.Length)
				.Num("endLine", sheetModel.LineCount)
				.Num("endColumn", 0.0)
				.Done()).Done();
		}

		internal static string SetStyleTexts(CdpSession session, JsonValue args)
		{
			SheetModel sheetModel = ModelOf(session) ?? throw new CdpException(-32000, "the page has no stylesheet yet");
			JsonValue jsonValue = args["edits"];
			List<SourceRule> list = new List<SourceRule>();
			List<List<Declaration>> list2 = new List<List<Declaration>>();
			for (int i = 0; i < jsonValue.Count; i++)
			{
				JsonValue jsonValue2 = jsonValue[i];
				if (!string.Equals(jsonValue2["styleSheetId"].AsString(), sheetModel.Id, StringComparison.Ordinal))
				{
					throw new CdpException(-32602, "that edit is for a stylesheet this page no longer has");
				}
				SourceRule item = RuleAt(sheetModel, jsonValue2["range"]) ?? throw new CdpException(-32602, "no rule at that range - the stylesheet has moved on");
				string text = jsonValue2["text"].AsString();
				List<Declaration> list3 = CssParser.ParseDeclarations(text);
				if (list3.Count == 0 && !string.IsNullOrWhiteSpace(text))
				{
					throw new CdpException(-32602, "that declaration could not be parsed");
				}
				list.Add(item);
				list2.Add(list3);
			}
			for (int j = 0; j < list.Count; j++)
			{
				list[j].Declarations.Clear();
				list[j].Declarations.AddRange(list2[j]);
			}
			DomDomain.ViewOf(session).MarkDirty();
			SheetModel sheetModel2 = Rebuild(session, sheetModel.Id);
			session.EmitAfterReply("CSS.styleSheetChanged", new Json.Obj().Str("styleSheetId", sheetModel2.Id).Done());
			List<string> list4 = new List<string>();
			foreach (SourceRule rule in list)
			{
				SourceRule sourceRule = sheetModel2.Rules.Find((SourceRule r) => r.Declarations == rule.Declarations);
				list4.Add((sourceRule == null) ? "{}" : StyleJson(sheetModel2, sourceRule));
			}
			return new Json.Obj().Raw("styles", Json.Array(list4)).Done();
		}

		private static SourceRule RuleAt(SheetModel model, JsonValue range)
		{
			int num = range["startLine"].AsInt(-1);
			int num2 = range["startColumn"].AsInt(-1);
			foreach (SourceRule rule in model.Rules)
			{
				if (rule.BodySpan.StartLine == num && rule.BodySpan.StartColumn == num2)
				{
					return rule;
				}
			}
			return null;
		}

		internal static void Forget(CdpSession session)
		{
			session.Sheet = null;
		}

		private static SheetModel Rebuild(CdpSession session, string id)
		{
			session.Sheet = SheetModel.Build(Targets.Find(session.TargetId)?.Sheet, id);
			return session.Sheet;
		}

		private static string MatchedJson(SheetModel model, WebView view, IElement element)
		{
			List<Match> list = new List<Match>();
			if (model == null || element == null)
			{
				return Json.Array(new List<string>());
			}
			StyleContext styleContext = view.StyleContext;
			Orientation orientation = styleContext?.Orientation ?? Orientation.Landscape;
			StateFlags state = ((styleContext != null && styleContext.StateOf != null) ? styleContext.StateOf(element) : StateFlags.None);
			foreach (SourceRule rule in model.Rules)
			{
				Match match = null;
				for (int i = 0; i < rule.Variants.Count; i++)
				{
					StyleRule styleRule = rule.Variants[i];
					if (Applies(element, styleRule, orientation, state))
					{
						if (match == null)
						{
							match = new Match
							{
								Rule = rule,
								Selectors = new List<int>()
							};
						}
						match.Selectors.Add(i);
						if (Weaker(match.A, match.B, match.C, styleRule))
						{
							match.A = styleRule.SpecificityA;
							match.B = styleRule.SpecificityB;
							match.C = styleRule.SpecificityC;
						}
						if (styleRule.Order < match.Order)
						{
							match.Order = styleRule.Order;
						}
					}
				}
				if (match != null)
				{
					list.Add(match);
				}
			}
			list.Sort(Compare);
			List<string> list2 = new List<string>();
			foreach (Match item in list)
			{
				List<string> list3 = new List<string>();
				foreach (int selector in item.Selectors)
				{
					list3.Add(Json.Number(selector));
				}
				list2.Add(new Json.Obj().Raw("rule", RuleJson(model, item.Rule)).Raw("matchingSelectors", Json.Array(list3)).Done());
			}
			return Json.Array(list2);
		}

		private static string InheritedJson(SheetModel model, WebView view, IElement element)
		{
			List<string> list = new List<string>();
			for (IElement val = ((element != null) ? ((INode)element).ParentElement : null); val != null; val = ((INode)val).ParentElement)
			{
				list.Add(new Json.Obj().Raw("inlineStyle", InlineJson(val)).Raw("matchedCSSRules", MatchedJson(model, view, val)).Done());
			}
			return Json.Array(list);
		}

		private static bool Applies(IElement element, StyleRule rule, Orientation orientation, StateFlags state)
		{
			if (rule.Media.HasValue && rule.Media.Value != orientation)
			{
				return false;
			}
			if ((rule.RequiredStates & state) != rule.RequiredStates)
			{
				return false;
			}
			try
			{
				return element.Matches(rule.BaseSelector);
			}
			catch
			{
				return false;
			}
		}

		private static bool Weaker(int a, int b, int c, StyleRule candidate)
		{
			if (candidate.SpecificityA != a)
			{
				return candidate.SpecificityA > a;
			}
			if (candidate.SpecificityB != b)
			{
				return candidate.SpecificityB > b;
			}
			return candidate.SpecificityC > c;
		}

		private static int Compare(Match x, Match y)
		{
			if (x.A != y.A)
			{
				return x.A - y.A;
			}
			if (x.B != y.B)
			{
				return x.B - y.B;
			}
			if (x.C != y.C)
			{
				return x.C - y.C;
			}
			return x.Order.CompareTo(y.Order);
		}

		private static string RuleJson(SheetModel model, SourceRule rule)
		{
			List<string> list = new List<string>();
			for (int i = 0; i < rule.Variants.Count; i++)
			{
				list.Add(new Json.Obj().Str("text", rule.Variants[i].Selector ?? "").Raw("range", (i < rule.SelectorSpans.Count) ? rule.SelectorSpans[i].ToJson() : null).Done());
			}
			Json.Obj obj = new Json.Obj().Str("styleSheetId", model.Id).Raw("selectorList", new Json.Obj().Raw("selectors", Json.Array(list)).Str("text", rule.SelectorText).Done()).Str("origin", "regular")
				.Raw("style", StyleJson(model, rule));
			if (rule.Media.HasValue)
			{
				string text = new Json.Obj().Str("text", "(orientation: " + ((rule.Media.Value == Orientation.Portrait) ? "portrait" : "landscape") + ")").Str("source", "mediaRule").Done();
				obj.Raw("media", Json.Array(new string[1] { text }));
			}
			return obj.Done();
		}

		private static string StyleJson(SheetModel model, SourceRule rule)
		{
			List<string> list = new List<string>();
			List<Declaration> list2 = rule.Declarations ?? new List<Declaration>();
			for (int i = 0; i < list2.Count; i++)
			{
				SourceSpan? span = ((i < rule.DeclarationSpans.Count) ? new SourceSpan?(rule.DeclarationSpans[i]) : ((SourceSpan?)null));
				list.Add(PropertyJson(list2[i], span));
			}
			return new Json.Obj().Str("styleSheetId", model.Id).Raw("cssProperties", Json.Array(list)).Raw("shorthandEntries", "[]")
				.Str("cssText", model.Slice(rule.BodySpan))
				.Raw("range", rule.BodySpan.ToJson())
				.Done();
		}

		private static string PropertyJson(Declaration declaration, SourceSpan? span)
		{
			Json.Obj obj = new Json.Obj().Str("name", declaration.Property).Str("value", declaration.Value).Bool("implicit", value: false)
				.Str("text", SheetModel.DeclarationText(declaration))
				.Bool("parsedOk", value: true)
				.Bool("disabled", value: false);
			if (declaration.Important)
			{
				obj.Bool("important", value: true);
			}
			if (span.HasValue)
			{
				obj.Raw("range", span.Value.ToJson());
			}
			return obj.Done();
		}

		private static string InlineJson(IElement element)
		{
			string text = ((element != null) ? element.GetAttribute("style") : null);
			List<string> list = new List<string>();
			if (!string.IsNullOrWhiteSpace(text))
			{
				foreach (Declaration item in CssParser.ParseDeclarations(text))
				{
					list.Add(PropertyJson(item, null));
				}
			}
			return new Json.Obj().Raw("cssProperties", Json.Array(list)).Raw("shorthandEntries", "[]").Str("cssText", text ?? "")
				.Done();
		}

		private static SheetModel ModelOf(CdpSession session)
		{
			Stylesheet stylesheet = Targets.Find(session.TargetId)?.Sheet;
			if (stylesheet == null)
			{
				return null;
			}
			if (session.Sheet == null || session.Sheet.Sheet != stylesheet)
			{
				session.Sheet = SheetModel.Build(stylesheet, session.TargetId + "-sheet-" + ++session.SheetGeneration);
			}
			return session.Sheet;
		}
	}
	internal readonly struct SourceSpan
	{
		internal int StartLine { get; }

		internal int StartColumn { get; }

		internal int EndLine { get; }

		internal int EndColumn { get; }

		internal SourceSpan(int startLine, int startColumn, int endLine, int endColumn)
		{
			StartLine = startLine;
			StartColumn = startColumn;
			EndLine = endLine;
			EndColumn = endColumn;
		}

		internal string ToJson()
		{
			return new Json.Obj().Num("startLine", StartLine).Num("startColumn", StartColumn).Num("endLine", EndLine)
				.Num("endColumn", EndColumn)
				.Done();
		}
	}
	internal sealed class SourceRule
	{
		internal readonly List<StyleRule> Variants = new List<StyleRule>();

		internal readonly List<SourceSpan> SelectorSpans = new List<SourceSpan>();

		internal readonly List<SourceSpan> DeclarationSpans = new List<SourceSpan>();

		internal List<Declaration> Declarations;

		internal Orientation? Media;

		internal SourceSpan BodySpan;

		internal string SelectorText = "";
	}
	internal sealed class SheetModel
	{
		private sealed class Writer
		{
			private readonly StringBuilder _sb = new StringBuilder();

			internal int Line { get; private set; }

			internal int Column { get; private set; }

			internal string Text => _sb.ToString();

			internal void Write(string text)
			{
				if (string.IsNullOrEmpty(text))
				{
					return;
				}
				for (int i = 0; i < text.Length; i++)
				{
					if (text[i] == '\n')
					{
						Line++;
						Column = 0;
					}
					else
					{
						Column++;
					}
				}
				_sb.Append(text);
			}
		}

		internal string Id { get; private set; }

		internal Stylesheet Sheet { get; private set; }

		internal string Text { get; private set; } = "";

		internal List<SourceRule> Rules { get; } = new List<SourceRule>();

		internal int LineCount { get; private set; }

		internal static SheetModel Build(Stylesheet sheet, string id)
		{
			SheetModel sheetModel = new SheetModel
			{
				Id = id,
				Sheet = sheet
			};
			if (sheet == null)
			{
				return sheetModel;
			}
			Writer writer = new Writer();
			foreach (SourceRule item in Group(sheet))
			{
				sheetModel.Rules.Add(item);
				Emit(writer, item);
			}
			sheetModel.Text = writer.Text;
			sheetModel.LineCount = writer.Line;
			return sheetModel;
		}

		private static List<SourceRule> Group(Stylesheet sheet)
		{
			List<SourceRule> list = new List<SourceRule>();
			SourceRule sourceRule = null;
			foreach (StyleRule rule in sheet.Rules)
			{
				if (sourceRule == null || sourceRule.Declarations != rule.Declarations || !Nullable.Equals(sourceRule.Media, rule.Media))
				{
					sourceRule = new SourceRule
					{
						Declarations = rule.Declarations,
						Media = rule.Media
					};
					list.Add(sourceRule);
				}
				sourceRule.Variants.Add(rule);
			}
			return list;
		}

		private static void Emit(Writer writer, SourceRule rule)
		{
			string text = "";
			if (rule.Media.HasValue)
			{
				writer.Write("@media (orientation: " + ((rule.Media.Value == Orientation.Portrait) ? "portrait" : "landscape") + ") {\n");
				text = "  ";
			}
			writer.Write(text);
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < rule.Variants.Count; i++)
			{
				if (i > 0)
				{
					writer.Write(", ");
					stringBuilder.Append(", ");
				}
				string text2 = rule.Variants[i].Selector ?? "";
				int line = writer.Line;
				int column = writer.Column;
				writer.Write(text2);
				rule.SelectorSpans.Add(new SourceSpan(line, column, writer.Line, writer.Column));
				stringBuilder.Append(text2);
			}
			rule.SelectorText = stringBuilder.ToString();
			writer.Write(" {\n");
			int line2 = writer.Line;
			int column2 = writer.Column;
			foreach (Declaration item in rule.Declarations ?? new List<Declaration>())
			{
				writer.Write(text + "  ");
				int line3 = writer.Line;
				int column3 = writer.Column;
				writer.Write(DeclarationText(item));
				rule.DeclarationSpans.Add(new SourceSpan(line3, column3, writer.Line, writer.Column));
				writer.Write("\n");
			}
			rule.BodySpan = new SourceSpan(line2, column2, writer.Line, writer.Column);
			writer.Write(text + "}\n");
			if (rule.Media.HasValue)
			{
				writer.Write("}\n");
			}
			writer.Write("\n");
		}

		internal string Slice(SourceSpan span)
		{
			int num = Offset(span.StartLine, span.StartColumn);
			int num2 = Offset(span.EndLine, span.EndColumn);
			if (num < 0 || num2 < num || num2 > Text.Length)
			{
				return "";
			}
			return Text.Substring(num, num2 - num);
		}

		private int Offset(int line, int column)
		{
			int num = 0;
			for (int i = 0; i < line; i++)
			{
				int num2 = Text.IndexOf('\n', num);
				if (num2 < 0)
				{
					return -1;
				}
				num = num2 + 1;
			}
			return Math.Min(num + column, Text.Length);
		}

		internal static string DeclarationText(Declaration declaration)
		{
			return declaration.Property + ": " + declaration.Value + (declaration.Important ? " !important" : "") + ";";
		}
	}
	internal static class Domains
	{
		private static readonly HashSet<string> Accepted = new HashSet<string>(StringComparer.Ordinal)
		{
			"Autofill.setAddresses", "Debugger.setAsyncCallStackDepth", "Debugger.setBlackboxPatterns", "Debugger.setBlackboxExecutionContexts", "Debugger.setPauseOnExceptions", "DOM.hideHighlight", "DOM.markUndoableState", "DOM.setInspectedNode", "DOMDebugger.setBreakOnCSPViolation", "Emulation.setAutoDarkModeOverride",
			"Emulation.setEmulatedMedia", "Emulation.setEmulatedVisionDeficiency", "Emulation.setFocusEmulationEnabled", "Log.clear", "Log.startViolationsReport", "Log.stopViolationsReport", "Network.clearAcceptedEncodingsOverride", "Network.setAttachDebugStack", "Network.setBlockedURLs", "Network.setCacheDisabled",
			"Overlay.hideHighlight", "Overlay.highlightNode", "Overlay.setInspectMode", "Overlay.setShowContainerQueryOverlays", "Overlay.setShowFlexOverlays", "Overlay.setShowGridOverlays", "Overlay.setShowIsolatedElements", "Overlay.setShowScrollSnapOverlays", "Overlay.setShowViewportSizeOnResize", "Page.bringToFront",
			"Page.setAdBlockingEnabled", "Page.setBypassCSP", "Page.setInterceptFileChooserDialog", "Page.setLifecycleEventsEnabled", "Profiler.setSamplingInterval", "Runtime.discardConsoleEntries", "Runtime.runIfWaitingForDebugger", "Runtime.setAsyncCallStackDepth", "Runtime.setCustomObjectFormatterEnabled", "Runtime.setMaxCallStackSizeToCapture",
			"Target.setAutoAttach", "Target.setDiscoverTargets", "Target.setRemoteLocations"
		};

		internal static string Invoke(CdpSession session, string method, JsonValue args)
		{
			switch (method)
			{
			case "Runtime.enable":
				return RuntimeDomain.Enable(session);
			case "Runtime.evaluate":
				return RuntimeDomain.Evaluate(session, args);
			case "Runtime.callFunctionOn":
				return RuntimeDomain.CallFunctionOn(session, args);
			case "Runtime.getProperties":
				return RuntimeDomain.GetProperties(session, args);
			case "Runtime.releaseObject":
				return RuntimeDomain.ReleaseObject(session, args);
			case "Runtime.releaseObjectGroup":
				return RuntimeDomain.ReleaseObjectGroup(session, args);
			case "Runtime.globalLexicalScopeNames":
				return RuntimeDomain.GlobalLexicalScopeNames();
			case "Runtime.disable":
				session.RuntimeEnabled = false;
				return "{}";
			case "Log.enable":
				session.LogEnabled = true;
				return "{}";
			case "Log.disable":
				session.LogEnabled = false;
				return "{}";
			case "Page.enable":
				return PageDomain.Enable(session);
			case "Page.disable":
				session.PageEnabled = false;
				return "{}";
			case "Page.getResourceTree":
				return PageDomain.GetResourceTree(session);
			case "Page.getFrameTree":
				return PageDomain.GetFrameTree(session);
			case "Page.getNavigationHistory":
				return PageDomain.GetNavigationHistory(session);
			case "Page.getLayoutMetrics":
				return PageDomain.GetLayoutMetrics(session);
			case "Page.reload":
				return PageDomain.Reload(session);
			case "CSS.enable":
				return CssDomain.Enable(session);
			case "CSS.disable":
				session.CssEnabled = false;
				return "{}";
			case "CSS.getMatchedStylesForNode":
				return CssDomain.GetMatchedStylesForNode(session, args);
			case "CSS.getInlineStylesForNode":
				return CssDomain.GetInlineStylesForNode(session, args);
			case "CSS.getComputedStyleForNode":
				return CssDomain.GetComputedStyleForNode(session, args);
			case "CSS.forcePseudoState":
				return CssDomain.ForcePseudoState(session, args);
			case "CSS.getStyleSheetText":
				return CssDomain.GetStyleSheetText(session, args);
			case "CSS.setStyleTexts":
				return CssDomain.SetStyleTexts(session, args);
			case "DOM.enable":
				session.DomEnabled = true;
				return "{}";
			case "DOM.disable":
				session.DomEnabled = false;
				return "{}";
			case "DOM.getDocument":
				return DomDomain.GetDocument(session, args);
			case "DOM.requestChildNodes":
				return DomDomain.RequestChildNodes(session, args);
			case "DOM.getOuterHTML":
				return DomDomain.GetOuterHtml(session, args);
			case "DOM.setOuterHTML":
				return DomDomain.SetOuterHtml(session, args);
			case "DOM.setAttributeValue":
				return DomDomain.SetAttributeValue(session, args);
			case "DOM.setAttributesAsText":
				return DomDomain.SetAttributesAsText(session, args);
			case "DOM.removeNode":
				return DomDomain.RemoveNode(session, args);
			case "DOM.setNodeValue":
				return DomDomain.SetNodeValue(session, args);
			case "DOM.describeNode":
				return DomDomain.DescribeNode(session, args);
			case "DOM.resolveNode":
				return DomDomain.ResolveNode(session, args);
			default:
				if (Accepted.Contains(method))
				{
					return "{}";
				}
				if (method.EndsWith(".enable", StringComparison.Ordinal) || method.EndsWith(".disable", StringComparison.Ordinal))
				{
					return "{}";
				}
				throw new CdpException(-32601, "'" + method + "' is not implemented by Sideload (Runtime, Log, Page and DOM are).");
			}
		}
	}
	internal sealed class NodeStore
	{
		private readonly Dictionary<int, INode> _byId = new Dictionary<int, INode>();

		private readonly Dictionary<INode, int> _byNode = new Dictionary<INode, int>();

		private int _next = 1;

		internal int IdOf(INode node)
		{
			if (node == null)
			{
				return 0;
			}
			if (_byNode.TryGetValue(node, out var value))
			{
				return value;
			}
			int num = _next++;
			_byNode[node] = num;
			_byId[num] = node;
			return num;
		}

		internal bool Knows(INode node)
		{
			if (node != null)
			{
				return _byNode.ContainsKey(node);
			}
			return false;
		}

		internal INode Get(int id)
		{
			if (!_byId.TryGetValue(id, out var value))
			{
				return null;
			}
			return value;
		}

		internal void Clear()
		{
			_byId.Clear();
			_byNode.Clear();
			_next = 1;
		}
	}
	internal static class DomDomain
	{
		private const int MaxDepth = 32;

		internal static string GetDocument(CdpSession session, JsonValue args)
		{
			IDocument node = DocumentOf(session);
			session.Nodes.Clear();
			int depth = Depth(args, 32);
			return new Json.Obj().Raw("root", NodeJson(session, (INode)(object)node, depth)).Done();
		}

		internal static string RequestChildNodes(CdpSession session, JsonValue args)
		{
			INode node = NodeOf(session, args);
			int num = Depth(args, 1);
			List<string> list = new List<string>();
			foreach (INode item in Visible(node))
			{
				list.Add(NodeJson(session, item, num - 1));
			}
			session.EmitAfterReply("DOM.setChildNodes", new Json.Obj().Num("parentId", session.Nodes.IdOf(node)).Raw("nodes", Json.Array(list)).Done());
			return "{}";
		}

		internal static string GetOuterHtml(CdpSession session, JsonValue args)
		{
			INode val = NodeOf(session, args);
			IElement val2 = (IElement)(object)((val is IElement) ? val : null);
			string text;
			if (val2 == null)
			{
				IDocument val3 = (IDocument)(object)((val is IDocument) ? val : null);
				if (val3 != null)
				{
					IElement documentElement = val3.DocumentElement;
					text = ((documentElement != null) ? documentElement.OuterHtml : null) ?? "";
				}
				else
				{
					text = val.TextContent ?? "";
				}
			}
			else
			{
				text = val2.OuterHtml;
			}
			string value = text;
			return new Json.Obj().Str("outerHTML", value).Done();
		}

		internal static string SetOuterHtml(CdpSession session, JsonValue args)
		{
			INode obj = NodeOf(session, args);
			string outerHtml = args["outerHTML"].AsString();
			((IElement)(((obj is IElement) ? obj : null) ?? throw new CdpException(-32602, "only an element can have its outer HTML replaced"))).OuterHtml = outerHtml;
			session.Nodes.Clear();
			Dirty(session);
			session.EmitAfterReply("DOM.documentUpdated", "{}");
			return "{}";
		}

		internal static string SetAttributeValue(CdpSession session, JsonValue args)
		{
			IElement val = ElementOf(session, args);
			string text = args["name"].AsString();
			if (string.IsNullOrEmpty(text))
			{
				throw new CdpException(-32602, "name is empty");
			}
			val.SetAttribute(text, args["value"].AsString());
			Dirty(session);
			session.EmitAfterReply("DOM.attributeModified", new Json.Obj().Num("nodeId", session.Nodes.IdOf((INode)(object)val)).Str("name", text).Str("value", args["value"].AsString())
				.Done());
			return "{}";
		}

		internal static string SetAttributesAsText(CdpSession session, JsonValue args)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			IElement val = ElementOf(session, args);
			string text = args["text"].AsString();
			string text2 = args["name"].AsString();
			IElement obj = ((IParentNode)new HtmlParser().ParseDocument("<span " + text + "></span>")).QuerySelector("span") ?? throw new CdpException(-32602, "the attribute text could not be parsed");
			if (!string.IsNullOrEmpty(text2))
			{
				val.RemoveAttribute(text2);
			}
			foreach (IAttr item in (IEnumerable<IAttr>)obj.Attributes)
			{
				val.SetAttribute(item.Name, item.Value);
			}
			Dirty(session);
			session.EmitAfterReply("DOM.documentUpdated", "{}");
			return "{}";
		}

		internal static string RemoveNode(CdpSession session, JsonValue args)
		{
			INode val = NodeOf(session, args);
			INode val2 = val.Parent ?? throw new CdpException(-32602, "the document itself cannot be removed");
			int num = session.Nodes.IdOf(val);
			int num2 = session.Nodes.IdOf(val2);
			val2.RemoveChild(val);
			Dirty(session);
			session.EmitAfterReply("DOM.childNodeRemoved", new Json.Obj().Num("parentNodeId", num2).Num("nodeId", num).Done());
			return "{}";
		}

		internal static string SetNodeValue(CdpSession session, JsonValue args)
		{
			INode val = NodeOf(session, args);
			string value = (val.NodeValue = args["value"].AsString());
			Dirty(session);
			session.EmitAfterReply("DOM.characterDataModified", new Json.Obj().Num("nodeId", session.Nodes.IdOf(val)).Str("characterData", value).Done());
			return "{}";
		}

		internal static string DescribeNode(CdpSession session, JsonValue args)
		{
			return new Json.Obj().Raw("node", NodeJson(session, NodeOf(session, args), 0)).Done();
		}

		internal static string ResolveNode(CdpSession session, JsonValue args)
		{
			INode obj = NodeOf(session, args);
			IElement val = (IElement)(object)((obj is IElement) ? obj : null);
			if (val == null)
			{
				throw new CdpException(-32602, "only an element can be resolved to a value");
			}
			ScriptHost scriptHost = RuntimeDomain.ScriptOf(session);
			JsValue value = JsValue.FromObject(scriptHost.Engine, (object)scriptHost.Wrap(val));
			return new Json.Obj().Raw("object", Remote.Describe(value, session.Objects, args["objectGroup"].AsString("console"))).Done();
		}

		private static string NodeJson(CdpSession session, INode node, int depth)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			int num = session.Nodes.IdOf(node);
			Json.Obj obj = new Json.Obj().Num("nodeId", num).Num("backendNodeId", num).Num("nodeType", (double)node.NodeType)
				.Str("nodeName", node.NodeName ?? "");
			IElement val = (IElement)(object)((node is IElement) ? node : null);
			Json.Obj obj2 = obj.Str("localName", (val != null) ? val.LocalName : "").Str("nodeValue", node.NodeValue ?? "");
			if (node.Parent != null && session.Nodes.Knows(node.Parent))
			{
				obj2.Num("parentId", session.Nodes.IdOf(node.Parent));
			}
			List<INode> list = new List<INode>(Visible(node));
			obj2.Num("childNodeCount", list.Count);
			IElement val2 = (IElement)(object)((node is IElement) ? node : null);
			if (val2 != null)
			{
				obj2.Raw("attributes", AttributesJson(val2));
			}
			if (node is IDocument)
			{
				string value = Targets.UrlOf(Targets.Find(session.TargetId));
				obj2.Str("documentURL", value).Str("baseURL", value).Str("xmlVersion", "")
					.Str("frameId", Targets.FrameOf(session.TargetId));
			}
			IDocumentType val3 = (IDocumentType)(object)((node is IDocumentType) ? node : null);
			if (val3 != null)
			{
				obj2.Str("publicId", val3.PublicIdentifier ?? "").Str("systemId", val3.SystemIdentifier ?? "");
			}
			if (depth != 0 && list.Count > 0)
			{
				List<string> list2 = new List<string>();
				foreach (INode item in list)
				{
					list2.Add(NodeJson(session, item, depth - 1));
				}
				obj2.Raw("children", Json.Array(list2));
			}
			return obj2.Done();
		}

		private static string AttributesJson(IElement element)
		{
			List<string> list = new List<string>();
			foreach (IAttr item in (IEnumerable<IAttr>)element.Attributes)
			{
				list.Add(Json.Quote(item.Name));
				list.Add(Json.Quote(item.Value ?? ""));
			}
			return Json.Array(list);
		}

		private static IEnumerable<INode> Visible(INode node)
		{
			foreach (INode item in (IEnumerable<INode>)node.ChildNodes)
			{
				if ((int)item.NodeType != 3 || !string.IsNullOrWhiteSpace(item.TextContent))
				{
					yield return item;
				}
			}
		}

		private static int Depth(JsonValue args, int fallback)
		{
			int num = args["depth"].AsInt(fallback);
			if (num >= 0 && num <= 32)
			{
				return num;
			}
			return 32;
		}

		internal static IDocument DocumentOf(CdpSession session)
		{
			return ViewOf(session).Document ?? throw new CdpException(-32000, "the page has not been built yet - open the app on the phone first");
		}

		internal static WebView ViewOf(CdpSession session)
		{
			return Targets.Find(session.TargetId) ?? throw new CdpException(-32000, "the page '" + session.TargetId + "' is no longer mounted");
		}

		internal static INode NodeOf(CdpSession session, JsonValue args)
		{
			int num = args["nodeId"].AsInt(args["backendNodeId"].AsInt());
			if (num <= 0)
			{
				throw new CdpException(-32602, "nodeId is missing");
			}
			return session.Nodes.Get(num) ?? throw new CdpException(-32602, $"node {num} is not known to this session - the document may have been reloaded");
		}

		internal static IElement ElementOf(CdpSession session, JsonValue args)
		{
			INode obj = NodeOf(session, args);
			return (IElement)(object)(((obj is IElement) ? obj : null) ?? throw new CdpException(-32602, "that node is not an element"));
		}

		private static void Dirty(CdpSession session)
		{
			ViewOf(session).MarkDirty();
		}
	}
	internal static class FrontendCache
	{
		private const string Package = "@react-native/debugger-frontend";

		private const string Version = "0.86.1";

		private const string Sha512 = "DRl6ctuVNcY1CtiAKFstWMDlJhXQ4tM96XVib3tTOH2zIoJPgeiGQdXUUa4tsPgqR4RkXsd5adDYwcFkE5QvVg==";

		private const int MaxDownloadBytes = 25165824;

		private const long MaxUnpackedBytes = 100663296L;

		private const int TimeoutMs = 180000;

		private const int MaxEntries = 20000;

		private const int MaxSearchDepth = 8;

		private const int MaxFoldersScanned = 512;

		private static readonly Lazy<HttpClient> _client = new Lazy<HttpClient>(CreateClient);

		private static volatile string _root;

		private static int _fetching;

		private static string TarballUrl => "https://registry.npmjs.org/@react-native/debugger-frontend/-/debugger-frontend-0.86.1.tgz";

		internal static string Root => _root;

		internal static string CacheDirectory => Path.Combine(MelonEnvironment.UserDataDirectory, "Sideload", "devtools-frontend");

		private static string MarkerFile => CacheDirectory + ".version";

		internal static void Resolve()
		{
			try
			{
				Decide();
			}
			catch (Exception e)
			{
				_root = null;
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/cdp] devtools frontend: working out where it lives failed (" + Describe(e) + ") - Google's hosted copy is used, which needs internet.");
				}
			}
		}

		private static void Decide()
		{
			string devToolsFrontend = Preferences.DevToolsFrontend;
			if (!string.IsNullOrEmpty(devToolsFrontend))
			{
				string text = FindInspectorRoot(devToolsFrontend);
				if (text != null)
				{
					_root = text;
					Instance log = Core.Log;
					if (log != null)
					{
						log.Msg("[Sideload/cdp] devtools frontend: your DevToolsFrontend folder, " + text + " - works offline.");
					}
					return;
				}
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload/cdp] devtools frontend: DevToolsFrontend is set to '" + devToolsFrontend + "' but no inspector.html was found under it - ignoring that setting.");
				}
			}
			string text2 = FindInspectorRoot(CacheDirectory);
			string text3 = InstalledVersion();
			bool flag = text2 != null && text3 != null && text3 != "0.86.1";
			if (text2 != null)
			{
				_root = text2;
				Instance log3 = Core.Log;
				if (log3 != null)
				{
					log3.Msg("[Sideload/cdp] devtools frontend: the local copy at " + text2 + " - works offline." + (flag ? " Pinned version is now 0.86.1, refreshing in the background." : ""));
				}
				if (!flag)
				{
					return;
				}
			}
			if (!Preferences.DevToolsFetchFrontend)
			{
				if (text2 == null)
				{
					Instance log4 = Core.Log;
					if (log4 != null)
					{
						log4.Msg("[Sideload/cdp] devtools frontend: Google's hosted copy, which needs internet. For offline use switch DevToolsFetchFrontend on, or run Workspace/tools/install-devtools-frontend.ps1.");
					}
				}
				return;
			}
			if (text2 == null)
			{
				Instance log5 = Core.Log;
				if (log5 != null)
				{
					log5.Msg("[Sideload/cdp] devtools frontend: none on disk - downloading @react-native/debugger-frontend@0.86.1 (about 4.5 MB) once, in the background, to " + CacheDirectory + ". Google's hosted copy is used until it lands.");
				}
			}
			Begin();
		}

		private static string FindInspectorRoot(string start)
		{
			if (string.IsNullOrEmpty(start))
			{
				return null;
			}
			string fullPath;
			try
			{
				fullPath = Path.GetFullPath(start);
			}
			catch
			{
				return null;
			}
			if (!Directory.Exists(fullPath))
			{
				return null;
			}
			Queue<KeyValuePair<string, int>> queue = new Queue<KeyValuePair<string, int>>();
			queue.Enqueue(new KeyValuePair<string, int>(fullPath, 0));
			int num = 0;
			while (queue.Count > 0 && num < 512)
			{
				KeyValuePair<string, int> keyValuePair = queue.Dequeue();
				if (File.Exists(Path.Combine(keyValuePair.Key, "inspector.html")))
				{
					return keyValuePair.Key;
				}
				if (keyValuePair.Value < 8)
				{
					try
					{
						foreach (string item in Directory.EnumerateDirectories(keyValuePair.Key))
						{
							queue.Enqueue(new KeyValuePair<string, int>(item, keyValuePair.Value + 1));
						}
					}
					catch
					{
					}
				}
				num++;
			}
			return null;
		}

		private static string InstalledVersion()
		{
			try
			{
				if (!File.Exists(MarkerFile))
				{
					return null;
				}
				string text = File.ReadAllText(MarkerFile).Trim();
				int num = text.LastIndexOf('@');
				return (num > 0 && num < text.Length - 1) ? text.Substring(num + 1) : null;
			}
			catch
			{
				return null;
			}
		}

		private static void Begin()
		{
			if (Interlocked.Exchange(ref _fetching, 1) != 0)
			{
				return;
			}
			Task.Run(async delegate
			{
				try
				{
					await Fetch().ConfigureAwait(continueOnCapturedContext: false);
				}
				catch (OperationCanceledException)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload/cdp] devtools frontend: the download gave up after " + 180 + "s - Google's hosted copy is used instead.");
					}
				}
				catch (Exception e)
				{
					Instance log2 = Core.Log;
					if (log2 != null)
					{
						log2.Warning("[Sideload/cdp] devtools frontend: the download failed (" + Describe(e) + ") - Google's hosted copy is used instead.");
					}
				}
				finally
				{
					Interlocked.Exchange(ref _fetching, 0);
				}
			});
		}

		private static async Task Fetch()
		{
			Stopwatch clock = Stopwatch.StartNew();
			using CancellationTokenSource budget = new CancellationTokenSource(180000);
			byte[] array = await Download(budget.Token).ConfigureAwait(continueOnCapturedContext: false);
			if (!Authentic(array))
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/cdp] devtools frontend: the download did not match the checksum npm publishes for @react-native/debugger-frontend@0.86.1 - discarding it and using Google's hosted copy.");
				}
				return;
			}
			string text = CacheDirectory + ".download";
			Discard(text);
			using (MemoryStream stream = new MemoryStream(array, writable: false))
			{
				using GZipStream tar = new GZipStream(stream, CompressionMode.Decompress);
				Untar(tar, text);
			}
			string text2 = FindInspectorRoot(text);
			if (text2 == null)
			{
				Discard(text);
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload/cdp] devtools frontend: @react-native/debugger-frontend@0.86.1 unpacked with no inspector.html in it - has the package changed shape? Google's hosted copy is used instead.");
				}
				return;
			}
			string text3 = Publish(text2, text);
			clock.Stop();
			Instance log3 = Core.Log;
			if (log3 != null)
			{
				log3.Msg("[Sideload/cdp] devtools frontend: downloaded @react-native/debugger-frontend@0.86.1 (" + Megabytes(array.Length) + " in " + Seconds(clock.ElapsedMilliseconds) + ") to " + text3 + " - DevTools works offline from now on.");
			}
		}

		private static async Task<byte[]> Download(CancellationToken token)
		{
			using HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, TarballUrl);
			using HttpResponseMessage response = await _client.Value.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(continueOnCapturedContext: false);
			if (!response.IsSuccessStatusCode)
			{
				throw new InvalidDataException("the registry answered " + (int)response.StatusCode + " " + response.ReasonPhrase);
			}
			long? declared = response.Content.Headers.ContentLength;
			if (declared > 25165824)
			{
				throw new InvalidDataException("the tarball is " + Megabytes(declared.Value) + ", past the " + Megabytes(25165824L) + " cap");
			}
			using Stream stream = await response.Content.ReadAsStreamAsync(token).ConfigureAwait(continueOnCapturedContext: false);
			int capacity;
			if (declared.HasValue)
			{
				long valueOrDefault = declared.GetValueOrDefault();
				if (valueOrDefault > 0 && valueOrDefault <= 25165824)
				{
					capacity = (int)declared.Value;
					goto IL_0252;
				}
			}
			capacity = 4194304;
			goto IL_0252;
			IL_0252:
			MemoryStream buffer = new MemoryStream(capacity);
			byte[] chunk = new byte[81920];
			while (true)
			{
				int num = await stream.ReadAsync(chunk, 0, chunk.Length, token).ConfigureAwait(continueOnCapturedContext: false);
				if (num <= 0)
				{
					break;
				}
				if (buffer.Length + num > 25165824)
				{
					throw new InvalidDataException("the download went past the " + Megabytes(25165824L) + " cap");
				}
				buffer.Write(chunk, 0, num);
			}
			return buffer.ToArray();
		}

		private static bool Authentic(byte[] tarball)
		{
			using SHA512 sHA = SHA512.Create();
			return string.Equals(Convert.ToBase64String(sHA.ComputeHash(tarball)), "DRl6ctuVNcY1CtiAKFstWMDlJhXQ4tM96XVib3tTOH2zIoJPgeiGQdXUUa4tsPgqR4RkXsd5adDYwcFkE5QvVg==", StringComparison.Ordinal);
		}

		private static string Publish(string extracted, string staging)
		{
			string cacheDirectory = CacheDirectory;
			Discard(cacheDirectory);
			Directory.CreateDirectory(Path.GetDirectoryName(cacheDirectory));
			Directory.Move(extracted, cacheDirectory);
			Discard(staging);
			File.WriteAllText(MarkerFile, "@react-native/debugger-frontend@0.86.1");
			_root = cacheDirectory;
			return cacheDirectory;
		}

		private static void Discard(string directory)
		{
			try
			{
				if (Directory.Exists(directory))
				{
					Directory.Delete(directory, recursive: true);
				}
			}
			catch (Exception ex)
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Warning("[Sideload/cdp] devtools frontend: could not remove " + directory + " (" + ex.Message + ")");
				}
			}
		}

		private static void Untar(Stream tar, string destination)
		{
			string fullPath = Path.GetFullPath(destination);
			byte[] array = new byte[512];
			byte[] block = new byte[81920];
			long num = 0L;
			int num2 = 0;
			while (Fill(tar, array, 512) && !IsZero(array))
			{
				if (++num2 > 20000)
				{
					throw new InvalidDataException("the archive holds more than " + 20000 + " entries");
				}
				string text = Text(array, 0, 100);
				string text2 = Text(array, 345, 155);
				if (text2.Length > 0)
				{
					text = text2 + "/" + text;
				}
				long num3 = Octal(array, 124, 12);
				long num4 = (num3 + 511) / 512 * 512 - num3;
				char c = (char)array[156];
				num += num3;
				if (num > 100663296)
				{
					throw new InvalidDataException("the archive unpacks to more than " + Megabytes(100663296L) + ", past the cap");
				}
				bool flag = ((c == '\0' || c == '0') ? true : false);
				bool flag2 = flag;
				bool flag3 = c == '5' || (flag2 && text.EndsWith("/", StringComparison.Ordinal));
				if (flag3)
				{
					flag2 = false;
				}
				string text3 = ((flag2 || flag3) ? SafeRelativePath(text) : null);
				string text4 = ((text3 == null) ? null : Path.GetFullPath(Path.Combine(fullPath, text3)));
				if (text4 != null && !text4.StartsWith(fullPath + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
				{
					text4 = null;
				}
				if (text4 == null)
				{
					Skip(tar, block, num3 + num4);
					continue;
				}
				if (flag3)
				{
					Directory.CreateDirectory(text4);
					Skip(tar, block, num3 + num4);
					continue;
				}
				Directory.CreateDirectory(Path.GetDirectoryName(text4));
				using (FileStream destination2 = File.Create(text4))
				{
					Copy(tar, destination2, num3, block);
				}
				Skip(tar, block, num4);
			}
		}

		private static string SafeRelativePath(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (name[0] == '/' || name[0] == '\\')
			{
				return null;
			}
			if (name.Length > 1 && name[1] == ':')
			{
				return null;
			}
			List<string> list = new List<string>();
			string[] array = name.Replace('\\', '/').Split('/');
			foreach (string text in array)
			{
				if (text.Length != 0 && !(text == "."))
				{
					if (text == "..")
					{
						return null;
					}
					list.Add(text);
				}
			}
			if (list.Count != 0)
			{
				return string.Join(Path.DirectorySeparatorChar.ToString(), list);
			}
			return null;
		}

		private static bool Fill(Stream stream, byte[] buffer, int count)
		{
			int num;
			for (int i = 0; i < count; i += num)
			{
				num = stream.Read(buffer, i, count - i);
				if (num <= 0)
				{
					return false;
				}
			}
			return true;
		}

		private static void Copy(Stream source, Stream destination, long count, byte[] block)
		{
			while (count > 0)
			{
				int num = source.Read(block, 0, (int)Math.Min(count, block.Length));
				if (num <= 0)
				{
					throw new InvalidDataException("the archive ended in the middle of a file");
				}
				destination.Write(block, 0, num);
				count -= num;
			}
		}

		private static void Skip(Stream stream, byte[] block, long count)
		{
			while (count > 0)
			{
				int num = stream.Read(block, 0, (int)Math.Min(count, block.Length));
				if (num <= 0)
				{
					break;
				}
				count -= num;
			}
		}

		private static bool IsZero(byte[] block)
		{
			for (int i = 0; i < block.Length; i++)
			{
				if (block[i] != 0)
				{
					return false;
				}
			}
			return true;
		}

		private static string Text(byte[] header, int offset, int length)
		{
			int i;
			for (i = offset; i < offset + length && header[i] != 0; i++)
			{
			}
			return Encoding.UTF8.GetString(header, offset, i - offset).Trim();
		}

		private static long Octal(byte[] header, int offset, int length)
		{
			string text = Text(header, offset, length);
			if (text.Length == 0)
			{
				return 0L;
			}
			long num = 0L;
			string text2 = text;
			foreach (char c in text2)
			{
				if (c < '0' || c > '7')
				{
					throw new InvalidDataException("a tar header holds a size that is not octal");
				}
				num = num * 8 + (c - 48);
			}
			return num;
		}

		private static HttpClient CreateClient()
		{
			HttpClient httpClient = new HttpClient(new HttpClientHandler
			{
				AllowAutoRedirect = true,
				UseCookies = false,
				AutomaticDecompression = DecompressionMethods.None
			});
			httpClient.Timeout = Timeout.InfiniteTimeSpan;
			httpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", "Sideload/" + typeof(Core).Assembly.GetName().Version?.ToString() + " (Schedule I mod)");
			return httpClient;
		}

		private static string Megabytes(long bytes)
		{
			return ((double)bytes / 1048576.0).ToString("0.#", CultureInfo.InvariantCulture) + " MB";
		}

		private static string Seconds(long milliseconds)
		{
			return ((double)milliseconds / 1000.0).ToString("0.#", CultureInfo.InvariantCulture) + "s";
		}

		private static string Describe(Exception e)
		{
			Exception ex = e;
			while (ex.InnerException != null)
			{
				ex = ex.InnerException;
			}
			return ex.Message;
		}
	}
	internal enum JsonKind
	{
		Null,
		Bool,
		Number,
		String,
		Array,
		Object
	}
	internal sealed class JsonValue
	{
		internal static readonly JsonValue Nothing = new JsonValue
		{
			Kind = JsonKind.Null
		};

		private const int MaxDepth = 64;

		internal JsonKind Kind { get; private set; }

		internal string Text { get; private set; } = "";

		internal double Number { get; private set; }

		internal bool Flag { get; private set; }

		internal List<JsonValue> Items { get; private set; }

		internal Dictionary<string, JsonValue> Members { get; private set; }

		internal bool IsMissing => this == Nothing;

		internal int Count => Items?.Count ?? 0;

		internal JsonValue this[string name]
		{
			get
			{
				if (Members == null || name == null || !Members.TryGetValue(name, out var value))
				{
					return Nothing;
				}
				return value;
			}
		}

		internal JsonValue this[int index]
		{
			get
			{
				if (Items == null || index < 0 || index >= Items.Count)
				{
					return Nothing;
				}
				return Items[index];
			}
		}

		internal string AsString(string fallback = "")
		{
			return Kind switch
			{
				JsonKind.String => Text, 
				JsonKind.Number => Number.ToString(CultureInfo.InvariantCulture), 
				JsonKind.Bool => Flag ? "true" : "false", 
				_ => fallback, 
			};
		}

		internal double AsNumber(double fallback = 0.0)
		{
			if (Kind != JsonKind.Number)
			{
				return fallback;
			}
			return Number;
		}

		internal int AsInt(int fallback = 0)
		{
			if (Kind != JsonKind.Number)
			{
				return fallback;
			}
			return (int)Number;
		}

		internal bool AsBool(bool fallback = false)
		{
			if (Kind != JsonKind.Bool)
			{
				return fallback;
			}
			return Flag;
		}

		internal static JsonValue Parse(string text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return Nothing;
			}
			try
			{
				int i = 0;
				return ParseValue(text, ref i, 0) ?? Nothing;
			}
			catch
			{
				return Nothing;
			}
		}

		private static JsonValue ParseValue(string s, ref int i, int depth)
		{
			if (depth > 64)
			{
				throw new FormatException("json nested too deeply");
			}
			SkipWhitespace(s, ref i);
			if (i >= s.Length)
			{
				throw new FormatException("json ended early");
			}
			switch (s[i])
			{
			case '{':
				return ParseObject(s, ref i, depth);
			case '[':
				return ParseArray(s, ref i, depth);
			case '"':
				return new JsonValue
				{
					Kind = JsonKind.String,
					Text = ParseString(s, ref i)
				};
			case 't':
				Expect(s, ref i, "true");
				return new JsonValue
				{
					Kind = JsonKind.Bool,
					Flag = true
				};
			case 'f':
				Expect(s, ref i, "false");
				return new JsonValue
				{
					Kind = JsonKind.Bool,
					Flag = false
				};
			case 'n':
				Expect(s, ref i, "null");
				return new JsonValue
				{
					Kind = JsonKind.Null
				};
			default:
				return ParseNumber(s, ref i);
			}
		}

		private static JsonValue ParseObject(string s, ref int i, int depth)
		{
			JsonValue jsonValue = new JsonValue
			{
				Kind = JsonKind.Object,
				Members = new Dictionary<string, JsonValue>(StringComparer.Ordinal)
			};
			i++;
			while (true)
			{
				SkipWhitespace(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("unterminated object");
				}
				if (s[i] == '}')
				{
					i++;
					return jsonValue;
				}
				if (s[i] == ',')
				{
					i++;
					continue;
				}
				if (s[i] != '"')
				{
					throw new FormatException("expected a key");
				}
				string key = ParseString(s, ref i);
				SkipWhitespace(s, ref i);
				if (i >= s.Length || s[i] != ':')
				{
					break;
				}
				i++;
				jsonValue.Members[key] = ParseValue(s, ref i, depth + 1);
			}
			throw new FormatException("expected ':'");
		}

		private static JsonValue ParseArray(string s, ref int i, int depth)
		{
			JsonValue jsonValue = new JsonValue
			{
				Kind = JsonKind.Array,
				Items = new List<JsonValue>()
			};
			i++;
			while (true)
			{
				SkipWhitespace(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("unterminated array");
				}
				if (s[i] == ']')
				{
					break;
				}
				if (s[i] == ',')
				{
					i++;
				}
				else
				{
					jsonValue.Items.Add(ParseValue(s, ref i, depth + 1));
				}
			}
			i++;
			return jsonValue;
		}

		private static JsonValue ParseNumber(string s, ref int i)
		{
			int num = i;
			while (i < s.Length && (char.IsDigit(s[i]) || s[i] == '-' || s[i] == '+' || s[i] == '.' || s[i] == 'e' || s[i] == 'E'))
			{
				i++;
			}
			string text = s.Substring(num, i - num);
			if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				throw new FormatException("bad number '" + text + "'");
			}
			return new JsonValue
			{
				Kind = JsonKind.Number,
				Number = result
			};
		}

		private static string ParseString(string s, ref int i)
		{
			StringBuilder stringBuilder = new StringBuilder();
			i++;
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				default:
					stringBuilder.Append(c);
					continue;
				case '\\':
					break;
				}
				if (i >= s.Length)
				{
					break;
				}
				char c2 = s[i++];
				switch (c2)
				{
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'u':
					if (i + 4 > s.Length)
					{
						throw new FormatException("truncated \\u escape");
					}
					stringBuilder.Append((char)int.Parse(s.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture));
					i += 4;
					break;
				default:
					stringBuilder.Append(c2);
					break;
				}
			}
			throw new FormatException("unterminated string");
		}

		private static void Expect(string s, ref int i, string literal)
		{
			if (i + literal.Length > s.Length || string.CompareOrdinal(s, i, literal, 0, literal.Length) != 0)
			{
				throw new FormatException("expected '" + literal + "'");
			}
			i += literal.Length;
		}

		private static void SkipWhitespace(string s, ref int i)
		{
			while (i < s.Length && char.IsWhiteSpace(s[i]))
			{
				i++;
			}
		}
	}
	internal static class Json
	{
		internal sealed class Obj
		{
			private readonly StringBuilder _sb = new StringBuilder("{");

			private bool _any;

			internal Obj Raw(string name, string encoded)
			{
				if (encoded == null)
				{
					return this;
				}
				if (_any)
				{
					_sb.Append(',');
				}
				_any = true;
				Quote(_sb, name);
				_sb.Append(':').Append(encoded);
				return this;
			}

			internal Obj Str(string name, string value)
			{
				return Raw(name, Quote(value));
			}

			internal Obj Num(string name, double value)
			{
				return Raw(name, Number(value));
			}

			internal Obj Bool(string name, bool value)
			{
				return Raw(name, value ? "true" : "false");
			}

			internal Obj StrIf(string name, string value)
			{
				if (!string.IsNullOrEmpty(value))
				{
					return Str(name, value);
				}
				return this;
			}

			internal string Done()
			{
				return _sb.Append('}').ToString();
			}

			public override string ToString()
			{
				return Done();
			}
		}

		internal const string EmptyObject = "{}";

		internal static string Quote(string value)
		{
			StringBuilder stringBuilder = new StringBuilder((value == null) ? 2 : (value.Length + 2));
			Quote(stringBuilder, value);
			return stringBuilder.ToString();
		}

		internal static void Quote(StringBuilder sb, string value)
		{
			sb.Append('"');
			string text = value ?? "";
			foreach (char c in text)
			{
				switch (c)
				{
				case '"':
					sb.Append("\\\"");
					continue;
				case '\\':
					sb.Append("\\\\");
					continue;
				case '\n':
					sb.Append("\\n");
					continue;
				case '\r':
					sb.Append("\\r");
					continue;
				case '\t':
					sb.Append("\\t");
					continue;
				}
				if (c < ' ' || c == '\u2028' || c == '\u2029')
				{
					StringBuilder stringBuilder = sb.Append("\\u");
					int num = c;
					stringBuilder.Append(num.ToString("x4", CultureInfo.InvariantCulture));
				}
				else
				{
					sb.Append(c);
				}
			}
			sb.Append('"');
		}

		internal static string Number(double value)
		{
			if (double.IsNaN(value) || double.IsInfinity(value))
			{
				return "null";
			}
			return value.ToString("R", CultureInfo.InvariantCulture);
		}

		internal static string Array(IEnumerable<string> encoded)
		{
			StringBuilder stringBuilder = new StringBuilder("[");
			bool flag = true;
			foreach (string item in encoded)
			{
				if (!flag)
				{
					stringBuilder.Append(',');
				}
				flag = false;
				stringBuilder.Append(item);
			}
			return stringBuilder.Append(']').ToString();
		}
	}
	internal static class LogDomain
	{
		private readonly struct Entry
		{
			internal string Level { get; }

			internal string Text { get; }

			internal double At { get; }

			internal Entry(string level, string text, double at)
			{
				Level = level;
				Text = text;
				At = at;
			}
		}

		private const int HistorySize = 200;

		private static readonly Dictionary<string, List<Entry>> _history = new Dictionary<string, List<Entry>>(StringComparer.Ordinal);

		internal static double Now => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

		internal static void Record(string targetId, string level, string text)
		{
			if (!_history.TryGetValue(targetId, out var value))
			{
				value = (_history[targetId] = new List<Entry>());
			}
			value.Add(new Entry(level, text, Now));
			if (value.Count > 200)
			{
				value.RemoveRange(0, value.Count - 200);
			}
		}

		internal static void Replay(CdpSession session)
		{
			if (!_history.TryGetValue(session.TargetId, out var value))
			{
				return;
			}
			foreach (Entry item2 in value)
			{
				string item = new Json.Obj().Str("type", "string").Str("value", item2.Text).Done();
				session.EmitAfterReply((item2.Level == "exception") ? "Log.entryAdded" : "Runtime.consoleAPICalled", (item2.Level == "exception") ? EntryJson(session, "error", item2.Text, item2.At) : CallJson(TypeOf(item2.Level), new List<string> { item }, item2.At));
			}
		}

		internal static void Console(CdpSession session, Engine engine, string level, object[] args, string text)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			if (level == "exception")
			{
				if (session.LogEnabled)
				{
					session.Emit("Log.entryAdded", EntryJson(session, "error", text, Now));
				}
			}
			else
			{
				if (!session.RuntimeEnabled)
				{
					return;
				}
				List<string> list = new List<string>();
				if (args != null && args.Length != 0 && engine != null)
				{
					foreach (object obj in args)
					{
						JsValue value;
						try
						{
							value = JsValue.FromObject(engine, obj);
						}
						catch
						{
							value = (JsValue)new JsString(obj?.ToString() ?? "null");
						}
						list.Add(Remote.Describe(value, session.Objects));
					}
				}
				else
				{
					list.Add(new Json.Obj().Str("type", "string").Str("value", text).Done());
				}
				session.Emit("Runtime.consoleAPICalled", CallJson(TypeOf(level), list, Now));
			}
		}

		internal static void Forget(string targetId)
		{
			_history.Remove(targetId);
		}

		internal static void Clear()
		{
			_history.Clear();
		}

		private static string CallJson(string type, List<string> args, double at)
		{
			return new Json.Obj().Str("type", type).Raw("args", Json.Array(args)).Num("executionContextId", 1.0)
				.Num("timestamp", at)
				.Done();
		}

		private static string EntryJson(CdpSession session, string level, string text, double at)
		{
			return new Json.Obj().Raw("entry", new Json.Obj().Str("source", "javascript").Str("level", level).Str("text", text)
				.Num("timestamp", at)
				.Str("url", Targets.UrlOf(Targets.Find(session.TargetId)))
				.Done()).Done();
		}

		private static string TypeOf(string level)
		{
			return level switch
			{
				"warn" => "warning", 
				"warning" => "warning", 
				"error" => "error", 
				"info" => "info", 
				"debug" => "debug", 
				_ => "log", 
			};
		}
	}
	internal static class MainThread
	{
		internal const int DefaultTimeoutMs = 5000;

		private static readonly ConcurrentQueue<Action> _queue = new ConcurrentQueue<Action>();

		internal static T Run<T>(Func<T> work, int timeoutMs = 5000)
		{
			if (work == null)
			{
				return default(T);
			}
			T result = default(T);
			ExceptionDispatchInfo failure = null;
			ManualResetEventSlim done = new ManualResetEventSlim(initialState: false);
			try
			{
				_queue.Enqueue(delegate
				{
					try
					{
						result = work();
					}
					catch (Exception source)
					{
						failure = ExceptionDispatchInfo.Capture(source);
					}
					finally
					{
						try
						{
							done.Set();
						}
						catch
						{
						}
					}
				});
				if (!done.Wait(timeoutMs))
				{
					throw new TimeoutException($"the game did not run the command within {timeoutMs} ms - is it paused or still loading?");
				}
				failure?.Throw();
				return result;
			}
			finally
			{
				if (done != null)
				{
					((IDisposable)done).Dispose();
				}
			}
		}

		internal static void Post(Action work)
		{
			if (work != null)
			{
				_queue.Enqueue(work);
			}
		}

		internal static void Pump()
		{
			int count = _queue.Count;
			Action result;
			while (count-- > 0 && _queue.TryDequeue(out result))
			{
				try
				{
					result();
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload/cdp] a queued command failed: " + ex.Message);
					}
				}
			}
		}

		internal static void Clear()
		{
			Action result;
			while (_queue.TryDequeue(out result))
			{
			}
		}
	}
	internal static class PageDomain
	{
		internal static string Enable(CdpSession session)
		{
			session.PageEnabled = true;
			return "{}";
		}

		internal static string GetResourceTree(CdpSession session)
		{
			return new Json.Obj().Raw("frameTree", new Json.Obj().Raw("frame", FrameJson(session)).Raw("resources", "[]").Done()).Done();
		}

		internal static string GetFrameTree(CdpSession session)
		{
			return new Json.Obj().Raw("frameTree", new Json.Obj().Raw("frame", FrameJson(session)).Raw("childFrames", "[]").Done()).Done();
		}

		internal static string GetNavigationHistory(CdpSession session)
		{
			WebView webView = Targets.Find(session.TargetId);
			string value = Targets.UrlOf(webView);
			string text = new Json.Obj().Num("id", 1.0).Str("url", value).Str("userTypedURL", value)
				.Str("title", webView?.AppId ?? session.TargetId)
				.Str("transitionType", "typed")
				.Done();
			return new Json.Obj().Num("currentIndex", 0.0).Raw("entries", Json.Array(new string[1] { text })).Done();
		}

		internal static string GetLayoutMetrics(CdpSession session)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			float num2 = 0f;
			try
			{
				WebView webView = Targets.Find(session.TargetId);
				if (webView != null && (Object)(object)webView.Root != (Object)null)
				{
					num = webView.Root.sizeDelta.x;
					num2 = webView.Root.sizeDelta.y;
				}
			}
			catch
			{
			}
			string encoded = new Json.Obj().Num("pageX", 0.0).Num("pageY", 0.0).Num("clientWidth", num)
				.Num("clientHeight", num2)
				.Done();
			string encoded2 = new Json.Obj().Num("offsetX", 0.0).Num("offsetY", 0.0).Num("pageX", 0.0)
				.Num("pageY", 0.0)
				.Num("clientWidth", num)
				.Num("clientHeight", num2)
				.Num("scale", 1.0)
				.Num("zoom", 1.0)
				.Done();
			string encoded3 = new Json.Obj().Num("x", 0.0).Num("y", 0.0).Num("width", num)
				.Num("height", num2)
				.Done();
			return new Json.Obj().Raw("layoutViewport", encoded).Raw("visualViewport", encoded2).Raw("contentSize", encoded3)
				.Raw("cssLayoutViewport", encoded)
				.Raw("cssVisualViewport", encoded2)
				.Raw("cssContentSize", encoded3)
				.Done();
		}

		internal static string Reload(CdpSession session)
		{
			(Targets.Find(session.TargetId) ?? throw new CdpException(-32000, "the page '" + session.TargetId + "' is no longer mounted")).Reload();
			return "{}";
		}

		private static string FrameJson(CdpSession session)
		{
			WebView view = Targets.Find(session.TargetId);
			return new Json.Obj().Str("id", Targets.FrameOf(session.TargetId)).Str("loaderId", Targets.LoaderOf(session.TargetId)).Str("url", Targets.UrlOf(view))
				.Str("domainAndRegistry", "")
				.Str("securityOrigin", Targets.OriginOf(view))
				.Str("mimeType", "text/html")
				.Str("secureContextType", "Secure")
				.Str("crossOriginIsolatedContextType", "NotIsolated")
				.Raw("gatedAPIFeatures", "[]")
				.Done();
		}
	}
	internal sealed class ObjectStore
	{
		private readonly struct Entry
		{
			internal JsValue Value { get; }

			internal string Group { get; }

			internal Entry(JsValue value, string group)
			{
				Value = value;
				Group = group;
			}
		}

		private readonly Dictionary<string, Entry> _byId = new Dictionary<string, Entry>(StringComparer.Ordinal);

		private int _next = 1;

		internal string Add(JsValue value, string group)
		{
			string text = "sl:" + _next++;
			_byId[text] = new Entry(value, group ?? "");
			return text;
		}

		internal bool TryGet(string id, out JsValue value)
		{
			value = null;
			if (string.IsNullOrEmpty(id) || !_byId.TryGetValue(id, out var value2))
			{
				return false;
			}
			value = value2.Value;
			return true;
		}

		internal void Release(string id)
		{
			if (!string.IsNullOrEmpty(id))
			{
				_byId.Remove(id);
			}
		}

		internal void ReleaseGroup(string group)
		{
			if (string.IsNullOrEmpty(group))
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Entry> item in _byId)
			{
				if (string.Equals(item.Value.Group, group, StringComparison.Ordinal))
				{
					list.Add(item.Key);
				}
			}
			foreach (string item2 in list)
			{
				_byId.Remove(item2);
			}
		}

		internal void Clear()
		{
			_byId.Clear();
		}
	}
	internal static class Remote
	{
		private const int PreviewMembers = 5;

		private const int PreviewStringLength = 100;

		private const int ByValueDepth = 5;

		internal static string Describe(JsValue value, ObjectStore store, string group = "console", bool byValue = false, bool preview = true)
		{
			if (value == (JsValue)null || JsValueExtensions.IsUndefined(value))
			{
				return new Json.Obj().Str("type", "undefined").Done();
			}
			if (JsValueExtensions.IsNull(value))
			{
				return new Json.Obj().Str("type", "object").Str("subtype", "null").Raw("value", "null")
					.Done();
			}
			if (JsValueExtensions.IsBoolean(value))
			{
				return new Json.Obj().Str("type", "boolean").Bool("value", JsValueExtensions.AsBoolean(value)).Done();
			}
			if (JsValueExtensions.IsNumber(value))
			{
				double num = JsValueExtensions.AsNumber(value);
				if (double.IsNaN(num) || double.IsInfinity(num))
				{
					return new Json.Obj().Str("type", "number").Str("unserializableValue", double.IsNaN(num) ? "NaN" : ((num > 0.0) ? "Infinity" : "-Infinity")).Str("description", double.IsNaN(num) ? "NaN" : ((num > 0.0) ? "Infinity" : "-Infinity"))
						.Done();
				}
				return new Json.Obj().Str("type", "number").Num("value", num).Str("description", Json.Number(num))
					.Done();
			}
			if (JsValueExtensions.IsString(value))
			{
				return new Json.Obj().Str("type", "string").Str("value", JsValueExtensions.AsString(value)).Done();
			}
			if (JsValueExtensions.IsSymbol(value))
			{
				return new Json.Obj().Str("type", "symbol").Str("description", Text(value)).Str("objectId", store.Add(value, group))
					.Done();
			}
			if (byValue)
			{
				string encoded = ToJson(value, 0);
				return new Json.Obj().Str("type", "object").Raw("value", encoded).Done();
			}
			return DescribeObject(value, store, group, preview);
		}

		private static string DescribeObject(JsValue value, ObjectStore store, string group, bool preview)
		{
			bool flag = IsCallable(value);
			bool flag2 = IsArray(value);
			string text = ClassOf(value, flag, flag2);
			string text2 = DescribeText(value, flag, flag2, text);
			Json.Obj obj = new Json.Obj().Str("type", flag ? "function" : "object").StrIf("subtype", flag2 ? "array" : (IsError(value) ? "error" : null)).Str("className", text)
				.Str("description", text2)
				.Str("objectId", store.Add(value, group));
			if (preview && !flag)
			{
				obj.Raw("preview", Preview(value, flag2, text2));
			}
			return obj.Done();
		}

		private static string Preview(JsValue value, bool array, string description)
		{
			List<string> list = new List<string>();
			bool value2 = false;
			try
			{
				ObjectInstance val = JsValueExtensions.AsObject(value);
				int num = 0;
				foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in val.GetOwnProperties())
				{
					if (!JsValueExtensions.IsString(ownProperty.Key))
					{
						continue;
					}
					string text = JsValueExtensions.AsString(ownProperty.Key);
					if (!array || !(text == "length"))
					{
						if (num++ >= 5)
						{
							value2 = true;
							break;
						}
						JsValue val2 = Read(val, ownProperty.Key);
						list.Add(new Json.Obj().Str("name", text).Str("type", TypeOf(val2)).StrIf("subtype", IsArray(val2) ? "array" : ((val2 != (JsValue)null && JsValueExtensions.IsNull(val2)) ? "null" : null))
							.Str("value", Short(val2))
							.Done());
					}
				}
			}
			catch (Exception ex)
			{
				list.Add(new Json.Obj().Str("name", "<preview>").Str("type", "string").Str("value", ex.Message)
					.Done());
			}
			return new Json.Obj().Str("type", "object").StrIf("subtype", array ? "array" : null).Str("description", description)
				.Bool("overflow", value2)
				.Raw(array ? "properties" : "properties", Json.Array(list))
				.Done();
		}

		internal static string Properties(JsValue value, ObjectStore store, string group)
		{
			List<string> list = new List<string>();
			if (value == (JsValue)null || !JsValueExtensions.IsObject(value))
			{
				return Json.Array(list);
			}
			ObjectInstance val = JsValueExtensions.AsObject(value);
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in val.GetOwnProperties())
			{
				if (JsValueExtensions.IsString(ownProperty.Key))
				{
					JsValue value2 = Read(val, ownProperty.Key);
					list.Add(new Json.Obj().Str("name", JsValueExtensions.AsString(ownProperty.Key)).Raw("value", Describe(value2, store, group)).Bool("writable", value: true)
						.Bool("configurable", value: true)
						.Bool("enumerable", value: true)
						.Bool("isOwn", value: true)
						.Done());
				}
			}
			return Json.Array(list);
		}

		internal static string ExceptionDetails(Exception error, ObjectStore store, string group)
		{
			string text = "Uncaught";
			JavaScriptException ex = (JavaScriptException)(object)((error is JavaScriptException) ? error : null);
			string encoded;
			if (ex != null)
			{
				encoded = Describe(ex.Error, store, group);
				text = "Uncaught " + ErrorHead(ex.Error, ((Exception)(object)ex).Message);
			}
			else
			{
				encoded = new Json.Obj().Str("type", "object").Str("subtype", "error").Str("className", error.GetType().Name)
					.Str("description", error.Message)
					.Done();
				text = "Uncaught " + error.Message;
			}
			return new Json.Obj().Num("exceptionId", 1.0).Str("text", text).Num("lineNumber", LineOf(error))
				.Num("columnNumber", 0.0)
				.Raw("exception", encoded)
				.Done();
		}

		private static int LineOf(Exception error)
		{
			JavaScriptException ex = (JavaScriptException)(object)((error is JavaScriptException) ? error : null);
			if (ex == null)
			{
				return 0;
			}
			return Math.Max(((Location)ex.Location).Start.Line - 1, 0);
		}

		internal static string ToJson(JsValue value, int depth)
		{
			if (value == (JsValue)null || JsValueExtensions.IsUndefined(value) || JsValueExtensions.IsNull(value))
			{
				return "null";
			}
			if (JsValueExtensions.IsBoolean(value))
			{
				if (!JsValueExtensions.AsBoolean(value))
				{
					return "false";
				}
				return "true";
			}
			if (JsValueExtensions.IsNumber(value))
			{
				return Json.Number(JsValueExtensions.AsNumber(value));
			}
			if (JsValueExtensions.IsString(value))
			{
				return Json.Quote(JsValueExtensions.AsString(value));
			}
			if (depth >= 5 || !JsValueExtensions.IsObject(value))
			{
				return Json.Quote(Text(value));
			}
			try
			{
				ObjectInstance val = JsValueExtensions.AsObject(value);
				if (IsArray(value))
				{
					List<string> list = new List<string>();
					int num = (int)Math.Min(JsValueExtensions.AsNumber(((JsValue)val).Get(JsValue.op_Implicit("length"))), 1000.0);
					for (int i = 0; i < num; i++)
					{
						list.Add(ToJson(((JsValue)val).Get(JsValue.op_Implicit(i.ToString())), depth + 1));
					}
					return Json.Array(list);
				}
				Json.Obj obj = new Json.Obj();
				foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in val.GetOwnProperties())
				{
					if (JsValueExtensions.IsString(ownProperty.Key))
					{
						obj.Raw(JsValueExtensions.AsString(ownProperty.Key), ToJson(Read(val, ownProperty.Key), depth + 1));
					}
				}
				return obj.Done();
			}
			catch (Exception ex)
			{
				return Json.Quote("<" + ex.Message + ">");
			}
		}

		internal static JsValue FromJson(Engine engine, JsonValue json)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			switch (json.Kind)
			{
			case JsonKind.Bool:
				if (!json.Flag)
				{
					return (JsValue)(object)JsBoolean.False;
				}
				return (JsValue)(object)JsBoolean.True;
			case JsonKind.Number:
				return (JsValue)(object)JsNumber.Create(json.Number);
			case JsonKind.String:
				return (JsValue)new JsString(json.Text);
			case JsonKind.Array:
			{
				List<JsValue> list = new List<JsValue>();
				for (int i = 0; i < json.Count; i++)
				{
					list.Add(FromJson(engine, json[i]));
				}
				return (JsValue)new JsArray(engine, list.ToArray());
			}
			case JsonKind.Object:
			{
				ObjectInstance val = (ObjectInstance)new JsObject(engine);
				if (json.Members != null)
				{
					foreach (KeyValuePair<string, JsonValue> member in json.Members)
					{
						val.Set(JsValue.op_Implicit(member.Key), FromJson(engine, member.Value));
					}
				}
				return (JsValue)(object)val;
			}
			default:
				return JsValue.Null;
			}
		}

		private static JsValue Read(ObjectInstance instance, JsValue key)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			try
			{
				return ((JsValue)instance).Get(key);
			}
			catch (Exception ex)
			{
				return (JsValue)new JsString("<" + ex.Message + ">");
			}
		}

		private static string TypeOf(JsValue value)
		{
			if (value == (JsValue)null || JsValueExtensions.IsUndefined(value))
			{
				return "undefined";
			}
			if (JsValueExtensions.IsNull(value))
			{
				return "object";
			}
			if (JsValueExtensions.IsBoolean(value))
			{
				return "boolean";
			}
			if (JsValueExtensions.IsNumber(value))
			{
				return "number";
			}
			if (JsValueExtensions.IsString(value))
			{
				return "string";
			}
			if (JsValueExtensions.IsSymbol(value))
			{
				return "symbol";
			}
			if (!IsCallable(value))
			{
				return "object";
			}
			return "function";
		}

		private static string Short(JsValue value)
		{
			if (value == (JsValue)null || JsValueExtensions.IsUndefined(value))
			{
				return "undefined";
			}
			if (JsValueExtensions.IsNull(value))
			{
				return "null";
			}
			if (JsValueExtensions.IsNumber(value))
			{
				return Json.Number(JsValueExtensions.AsNumber(value));
			}
			if (JsValueExtensions.IsBoolean(value))
			{
				if (!JsValueExtensions.AsBoolean(value))
				{
					return "false";
				}
				return "true";
			}
			if (JsValueExtensions.IsString(value))
			{
				string text = JsValueExtensions.AsString(value);
				if (text.Length <= 100)
				{
					return text;
				}
				return text.Substring(0, 100) + "...";
			}
			bool callable = IsCallable(value);
			bool array = IsArray(value);
			return DescribeText(value, callable, array, ClassOf(value, callable, array));
		}

		private static string DescribeText(JsValue value, bool callable, bool array, string className)
		{
			if (array)
			{
				try
				{
					return "Array(" + (int)JsValueExtensions.AsNumber(((JsValue)JsValueExtensions.AsObject(value)).Get(JsValue.op_Implicit("length"))) + ")";
				}
				catch
				{
					return "Array";
				}
			}
			if (callable)
			{
				string text = Text(value);
				if (!string.IsNullOrEmpty(text))
				{
					if (text.Length <= 120)
					{
						return text;
					}
					return text.Substring(0, 120) + "...";
				}
				return "function";
			}
			if (IsError(value))
			{
				string text2 = ErrorHead(value, className);
				string text3 = Stack(value);
				if (!string.IsNullOrEmpty(text3))
				{
					return text2 + "\n" + text3;
				}
				return text2;
			}
			return className;
		}

		private static string ErrorHead(JsValue error, string fallback)
		{
			try
			{
				ObjectInstance obj = JsValueExtensions.AsObject(error);
				string text = Text(((JsValue)obj).Get(JsValue.op_Implicit("name")));
				string text2 = Text(((JsValue)obj).Get(JsValue.op_Implicit("message")));
				if (string.IsNullOrEmpty(text) || text == "undefined")
				{
					return string.IsNullOrEmpty(text2) ? fallback : text2;
				}
				return (string.IsNullOrEmpty(text2) || text2 == "undefined") ? text : (text + ": " + text2);
			}
			catch
			{
				return fallback;
			}
		}

		private static string Stack(JsValue error)
		{
			try
			{
				string text = Text(((JsValue)JsValueExtensions.AsObject(error)).Get(JsValue.op_Implicit("stack")));
				return (string.IsNullOrEmpty(text) || text == "undefined") ? "" : text.TrimEnd();
			}
			catch
			{
				return "";
			}
		}

		private static string ClassOf(JsValue value, bool callable, bool array)
		{
			if (array)
			{
				return "Array";
			}
			if (callable)
			{
				return "Function";
			}
			try
			{
				JsValue val = ((JsValue)JsValueExtensions.AsObject(value)).Get(JsValue.op_Implicit("constructor"));
				if (val != (JsValue)null && JsValueExtensions.IsObject(val))
				{
					string text = Text(((JsValue)JsValueExtensions.AsObject(val)).Get(JsValue.op_Implicit("name")));
					if (!string.IsNullOrEmpty(text) && text != "undefined")
					{
						return text;
					}
				}
			}
			catch
			{
			}
			return "Object";
		}

		private static bool IsError(JsValue value)
		{
			if (value == (JsValue)null || !JsValueExtensions.IsObject(value))
			{
				return false;
			}
			try
			{
				ObjectInstance val = JsValueExtensions.AsObject(value);
				return !JsValueExtensions.IsUndefined(((JsValue)val).Get(JsValue.op_Implicit("stack"))) && !JsValueExtensions.IsUndefined(((JsValue)val).Get(JsValue.op_Implicit("message")));
			}
			catch
			{
				return false;
			}
		}

		private static bool IsCallable(JsValue value)
		{
			try
			{
				return value != (JsValue)null && JsValueExtensions.IsObject(value) && value is Function;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsArray(JsValue value)
		{
			try
			{
				return value != (JsValue)null && JsValueExtensions.IsArray(value);
			}
			catch
			{
				return false;
			}
		}

		private static string Text(JsValue value)
		{
			try
			{
				return (value == (JsValue)null) ? "" : ((object)value).ToString();
			}
			catch
			{
				return "";
			}
		}
	}
	internal static class RuntimeDomain
	{
		internal const int ContextId = 1;

		internal static string Enable(CdpSession session)
		{
			session.RuntimeEnabled = true;
			session.EmitAfterReply("Runtime.executionContextCreated", ContextJson(session));
			LogDomain.Replay(session);
			return "{}";
		}

		internal static string Evaluate(CdpSession session, JsonValue args)
		{
			string text = args["expression"].AsString();
			if (string.IsNullOrEmpty(text))
			{
				throw new CdpException(-32602, "expression is empty");
			}
			string text2 = args["objectGroup"].AsString("console");
			bool byValue = args["returnByValue"].AsBool();
			bool preview = args["generatePreview"].AsBool(fallback: true);
			bool flag = args["awaitPromise"].AsBool();
			Engine engine = ScriptOf(session).Engine;
			try
			{
				JsValue val = engine.Evaluate(text, "<devtools>");
				if (flag)
				{
					engine.Advanced.ProcessTasks();
					val = JsValueExtensions.UnwrapIfPromise(val);
				}
				return new Json.Obj().Raw("result", Remote.Describe(val, session.Objects, text2, byValue, preview)).Done();
			}
			catch (Exception error)
			{
				return Threw(session, error, text2);
			}
		}

		internal static string CallFunctionOn(CdpSession session, JsonValue args)
		{
			string text = args["functionDeclaration"].AsString();
			if (string.IsNullOrEmpty(text))
			{
				throw new CdpException(-32602, "functionDeclaration is empty");
			}
			string text2 = args["objectGroup"].AsString("console");
			bool byValue = args["returnByValue"].AsBool();
			bool preview = args["generatePreview"].AsBool(fallback: true);
			string text3 = args["objectId"].AsString();
			Engine engine = ScriptOf(session).Engine;
			JsValue value = JsValue.Undefined;
			if (!string.IsNullOrEmpty(text3) && !session.Objects.TryGet(text3, out value))
			{
				throw new CdpException(-32602, "no object with id " + text3);
			}
			try
			{
				JsValue val = engine.Evaluate("(" + text + ")", "<devtools>");
				List<JsValue> list = new List<JsValue>();
				JsonValue jsonValue = args["arguments"];
				for (int i = 0; i < jsonValue.Count; i++)
				{
					JsonValue jsonValue2 = jsonValue[i];
					string text4 = jsonValue2["objectId"].AsString();
					if (!string.IsNullOrEmpty(text4))
					{
						list.Add(session.Objects.TryGet(text4, out var value2) ? value2 : JsValue.Undefined);
					}
					else
					{
						list.Add(jsonValue2["value"].IsMissing ? JsValue.Undefined : Remote.FromJson(engine, jsonValue2["value"]));
					}
				}
				JsValue obj = value;
				object[] array = list.ToArray();
				JsValue value3 = engine.Invoke(val, (object)obj, array);
				return new Json.Obj().Raw("result", Remote.Describe(value3, session.Objects, text2, byValue, preview)).Done();
			}
			catch (Exception error)
			{
				return Threw(session, error, text2);
			}
		}

		internal static string GetProperties(CdpSession session, JsonValue args)
		{
			string text = args["objectId"].AsString();
			if (!session.Objects.TryGet(text, out var value))
			{
				throw new CdpException(-32602, "no object with id " + text);
			}
			if (args["accessorPropertiesOnly"].AsBool())
			{
				return new Json.Obj().Raw("result", "[]").Done();
			}
			return new Json.Obj().Raw("result", Remote.Properties(value, session.Objects, args["objectGroup"].AsString("console"))).Done();
		}

		internal static string ReleaseObject(CdpSession session, JsonValue args)
		{
			session.Objects.Release(args["objectId"].AsString());
			return "{}";
		}

		internal static string ReleaseObjectGroup(CdpSession session, JsonValue args)
		{
			session.Objects.ReleaseGroup(args["objectGroup"].AsString());
			return "{}";
		}

		internal static string GlobalLexicalScopeNames()
		{
			return new Json.Obj().Raw("names", "[]").Done();
		}

		internal static string ContextJson(CdpSession session)
		{
			WebView webView = Targets.Find(session.TargetId);
			string encoded = new Json.Obj().Num("id", 1.0).Str("uniqueId", session.TargetId + "." + 1).Str("origin", Targets.OriginOf(webView))
				.Str("name", webView?.AppId ?? session.TargetId)
				.Raw("auxData", new Json.Obj().Bool("isDefault", value: true).Str("type", "default").Str("frameId", Targets.FrameOf(session.TargetId))
					.Done())
				.Done();
			return new Json.Obj().Raw("context", encoded).Done();
		}

		internal static ScriptHost ScriptOf(CdpSession session)
		{
			return (Targets.Find(session.TargetId) ?? throw new CdpException(-32000, "the page '" + session.TargetId + "' is no longer mounted")).Script ?? throw new CdpException(-32000, "the page has not been built yet - open the app on the phone first");
		}

		private static string Threw(CdpSession session, Exception error, string group)
		{
			string encoded = Remote.ExceptionDetails(error, session.Objects, group);
			return new Json.Obj().Raw("result", new Json.Obj().Str("type", "object").Str("subtype", "error").Str("className", error.GetType().Name)
				.Str("description", error.Message)
				.Done()).Raw("exceptionDetails", encoded).Done();
		}
	}
	internal static class Targets
	{
		private const string FrontendRevision = "0fcdce5f4fdec8d442d7df760cb541f1ca6e446d";

		internal static string IdFor(string appId)
		{
			StringBuilder stringBuilder = new StringBuilder(appId?.Length ?? 0);
			string text = appId ?? "";
			foreach (char c in text)
			{
				stringBuilder.Append((char.IsLetterOrDigit(c) || c == '-' || c == '_') ? c : '-');
			}
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString();
			}
			return "page";
		}

		internal static string IdOf(WebView view)
		{
			return IdFor(view?.AppId);
		}

		internal static WebView Find(string targetId)
		{
			if (string.IsNullOrEmpty(targetId))
			{
				return null;
			}
			foreach (WebView item in WebView.Live)
			{
				if (string.Equals(IdOf(item), targetId, StringComparison.OrdinalIgnoreCase))
				{
					return item;
				}
			}
			return null;
		}

		internal static List<WebView> All()
		{
			List<WebView> list = new List<WebView>();
			foreach (WebView item in WebView.Live)
			{
				list.Add(item);
			}
			return list;
		}

		internal static string UrlOf(WebView view)
		{
			return "sideload://" + (view?.AppId ?? "page") + "/index.html";
		}

		internal static string OriginOf(WebView view)
		{
			return "sideload://" + (view?.AppId ?? "page");
		}

		internal static string FrameOf(string targetId)
		{
			return "frame-" + targetId;
		}

		internal static string LoaderOf(string targetId)
		{
			return "loader-" + targetId;
		}

		internal static string WebSocketUrl(int port, string targetId)
		{
			return $"ws://127.0.0.1:{port}/devtools/page/{targetId}";
		}

		internal static string FrontendUrl(int port, string targetId)
		{
			string text = $"ws=127.0.0.1:{port}/devtools/page/{targetId}";
			if (FrontendCache.Root != null)
			{
				return $"http://127.0.0.1:{port}/frontend/inspector.html?{text}";
			}
			return "https://chrome-devtools-frontend.appspot.com/serve_rev/@0fcdce5f4fdec8d442d7df760cb541f1ca6e446d/inspector.html?" + text;
		}

		internal static string DescribeJson(WebView view, int port)
		{
			string text = IdOf(view);
			return new Json.Obj().Str("description", "Sideload page").Str("devtoolsFrontendUrl", FrontendUrl(port, text)).Str("id", text)
				.Str("title", view?.AppId ?? "page")
				.Str("type", "page")
				.Str("url", UrlOf(view))
				.Str("webSocketDebuggerUrl", WebSocketUrl(port, text))
				.Done();
		}
	}
}
namespace Sideload.Css
{
	internal sealed class ComputedStyle
	{
		internal DisplayKind Display;

		internal FlexDirection FlexDirection = FlexDirection.Column;

		internal FlexWrap FlexWrap;

		internal float FlexGrow;

		internal float FlexShrink = 1f;

		internal Len FlexBasis = Len.Auto;

		internal Justify JustifyContent;

		internal AlignKind AlignItems = AlignKind.Stretch;

		internal AlignKind AlignSelf;

		internal Len RowGap = Len.Zero;

		internal Len ColumnGap = Len.Zero;

		internal Edges Padding = Edges.Zero;

		internal Edges Margin = Edges.Zero;

		internal Len Width = Len.Auto;

		internal Len Height = Len.Auto;

		internal Len MinWidth = Len.None;

		internal Len MinHeight = Len.None;

		internal Len MaxWidth = Len.None;

		internal Len MaxHeight = Len.None;

		internal PositionKind Position;

		internal Edges Inset = new Edges
		{
			Top = Len.Auto,
			Right = Len.Auto,
			Bottom = Len.Auto,
			Left = Len.Auto
		};

		internal OverflowKind OverflowX;

		internal OverflowKind OverflowY;

		internal RgbaColor BackgroundColor = RgbaColor.Transparent;

		internal bool HasGradient;

		internal RgbaColor GradientFrom = RgbaColor.Transparent;

		internal RgbaColor GradientTo = RgbaColor.Transparent;

		internal float GradientAngleDeg = 180f;

		internal Edges BorderWidth = Edges.Zero;

		internal RgbaColor BorderColor = RgbaColor.Transparent;

		internal Corners BorderRadius;

		internal bool HasShadow;

		internal float ShadowOffsetX;

		internal float ShadowOffsetY;

		internal float ShadowBlur;

		internal RgbaColor ShadowColor = RgbaColor.Transparent;

		internal float Opacity = 1f;

		internal float TranslateX;

		internal float TranslateY;

		internal float ScaleX = 1f;

		internal float ScaleY = 1f;

		internal float RotateDeg;

		internal float TransitionSeconds;

		internal float TransitionDelaySeconds;

		internal EasingKind TransitionEasing = EasingKind.EaseOut;

		internal string FontFamily = "game-ui";

		internal float FontSize = 15f;

		internal int FontWeight = 400;

		internal FontStyleKind FontStyle;

		internal Len LineHeight = Len.None;

		internal float LetterSpacing;

		internal TextAlignKind TextAlign;

		internal WhiteSpaceKind WhiteSpace;

		internal RgbaColor Color = new RgbaColor(0.925f, 0.929f, 0.945f);

		internal bool TextOverflowEllipsis;

		internal Dictionary<string, string> Variables;

		private bool _sharedVariables = true;

		internal bool HasTransform
		{
			get
			{
				if (TranslateX == 0f && TranslateY == 0f && ScaleX == 1f && ScaleY == 1f)
				{
					return RotateDeg != 0f;
				}
				return true;
			}
		}

		internal float ResolvedLineHeight
		{
			get
			{
				if (!LineHeight.IsDefinite)
				{
					return FontSize * 1.2f;
				}
				return LineHeight.Resolve(FontSize);
			}
		}

		internal ComputedStyle Clone()
		{
			return (ComputedStyle)MemberwiseClone();
		}

		internal static ComputedStyle CreateFrom(ComputedStyle parent)
		{
			ComputedStyle computedStyle = new ComputedStyle();
			if (parent == null)
			{
				computedStyle.Variables = new Dictionary<string, string>(StringComparer.Ordinal);
				computedStyle._sharedVariables = false;
				return computedStyle;
			}
			computedStyle.FontFamily = parent.FontFamily;
			computedStyle.FontSize = parent.FontSize;
			computedStyle.FontWeight = parent.FontWeight;
			computedStyle.FontStyle = parent.FontStyle;
			computedStyle.LineHeight = parent.LineHeight;
			computedStyle.LetterSpacing = parent.LetterSpacing;
			computedStyle.TextAlign = parent.TextAlign;
			computedStyle.WhiteSpace = parent.WhiteSpace;
			computedStyle.Color = parent.Color;
			computedStyle.Variables = parent.Variables;
			return computedStyle;
		}

		internal void SetVariable(string name, string value)
		{
			if (Variables == null)
			{
				Variables = new Dictionary<string, string>(StringComparer.Ordinal);
			}
			else if (_sharedVariables)
			{
				Variables = new Dictionary<string, string>(Variables, StringComparer.Ordinal);
			}
			_sharedVariables = false;
			Variables[name] = value;
		}
	}
	[Flags]
	internal enum StateFlags
	{
		None = 0,
		Hover = 1,
		Active = 2,
		Focus = 4,
		Disabled = 8
	}
	internal sealed class Declaration
	{
		internal string Property;

		internal string Value;

		internal bool Important;
	}
	internal sealed class StyleRule
	{
		internal string Selector;

		internal string BaseSelector;

		internal StateFlags RequiredStates;

		internal int SpecificityA;

		internal int SpecificityB;

		internal int SpecificityC;

		internal int Order;

		internal Orientation? Media;

		internal List<Declaration> Declarations = new List<Declaration>();
	}
	internal sealed class Stylesheet
	{
		internal readonly List<StyleRule> Rules = new List<StyleRule>();
	}
	internal static class CssParser
	{
		internal static Stylesheet Parse(string css)
		{
			Stylesheet stylesheet = new Stylesheet();
			if (string.IsNullOrEmpty(css))
			{
				return stylesheet;
			}
			string text = StripComments(css);
			int order = 0;
			ParseRules(text, 0, text.Length, null, stylesheet, ref order);
			return stylesheet;
		}

		private static void ParseRules(string src, int start, int end, Orientation? media, Stylesheet sheet, ref int order)
		{
			int i = start;
			while (i < end)
			{
				for (; i < end && char.IsWhiteSpace(src[i]); i++)
				{
				}
				if (i >= end)
				{
					break;
				}
				if (src[i] == '@')
				{
					int j;
					for (j = i; j < end && src[j] != '{' && src[j] != ';'; j++)
					{
					}
					if (j >= end)
					{
						break;
					}
					if (src[j] == ';')
					{
						i = j + 1;
						continue;
					}
					int num = MatchingBrace(src, j, end);
					if (num >= 0)
					{
						string prelude = src.Substring(i, j - i);
						Orientation? orientation = ParseMediaOrientation(prelude);
						if (orientation.HasValue || IsAlwaysTrueMedia(prelude))
						{
							ParseRules(src, j + 1, num, orientation ?? media, sheet, ref order);
						}
						i = num + 1;
						continue;
					}
					break;
				}
				int k;
				for (k = i; k < end && src[k] != '{'; k++)
				{
				}
				if (k >= end)
				{
					break;
				}
				int num2 = MatchingBrace(src, k, end);
				if (num2 < 0)
				{
					break;
				}
				string text = src.Substring(i, k - i).Trim();
				string body = src.Substring(k + 1, num2 - k - 1);
				if (text.Length > 0)
				{
					List<Declaration> list = ParseDeclarations(body);
					if (list.Count > 0)
					{
						foreach (string item in SplitSelectorList(text))
						{
							StyleRule styleRule = new StyleRule
							{
								Selector = item,
								Media = media,
								Order = order++,
								Declarations = list
							};
							SplitStates(item, out styleRule.BaseSelector, out styleRule.RequiredStates);
							Specificity(styleRule.BaseSelector, styleRule.RequiredStates, out styleRule.SpecificityA, out styleRule.SpecificityB, out styleRule.SpecificityC);
							sheet.Rules.Add(styleRule);
						}
					}
				}
				i = num2 + 1;
			}
		}

		internal static List<Declaration> ParseDeclarations(string body)
		{
			List<Declaration> list = new List<Declaration>();
			if (string.IsNullOrEmpty(body))
			{
				return list;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i <= body.Length; i++)
			{
				if (i < body.Length)
				{
					char c = body[i];
					if (c == '(')
					{
						num++;
						continue;
					}
					if (c == ')')
					{
						num--;
						continue;
					}
					if (c != ';' || num != 0)
					{
						continue;
					}
				}
				string text = body.Substring(num2, i - num2).Trim();
				num2 = i + 1;
				if (text.Length == 0)
				{
					continue;
				}
				int num3 = IndexOfTopLevel(text, ':');
				if (num3 <= 0)
				{
					continue;
				}
				string text2 = text.Substring(0, num3).Trim();
				string text3 = text.Substring(num3 + 1).Trim();
				if (text2.Length != 0 && text3.Length != 0)
				{
					bool important = false;
					int num4 = text3.LastIndexOf('!');
					if (num4 >= 0 && text3.Substring(num4 + 1).Trim().Equals("important", StringComparison.OrdinalIgnoreCase))
					{
						important = true;
						text3 = text3.Substring(0, num4).Trim();
					}
					if (text3.Length > 0)
					{
						list.Add(new Declaration
						{
							Property = text2,
							Value = text3,
							Important = important
						});
					}
				}
			}
			return list;
		}

		internal static void SplitStates(string selector, out string baseSelector, out StateFlags states)
		{
			states = StateFlags.None;
			baseSelector = selector;
			if (string.IsNullOrEmpty(selector))
			{
				baseSelector = "*";
				return;
			}
			int num = LastCombinatorEnd(selector);
			string text = selector.Substring(0, num);
			string text2 = selector.Substring(num);
			StringBuilder stringBuilder = new StringBuilder();
			int num2 = 0;
			while (num2 < text2.Length)
			{
				if (text2[num2] == ':' && (num2 + 1 >= text2.Length || text2[num2 + 1] != ':'))
				{
					int num3 = num2 + 1;
					int i;
					for (i = num3; i < text2.Length && (char.IsLetterOrDigit(text2[i]) || text2[i] == '-'); i++)
					{
					}
					StateFlags stateFlags = text2.Substring(num3, i - num3).ToLowerInvariant() switch
					{
						"hover" => StateFlags.Hover, 
						"active" => StateFlags.Active, 
						"focus" => StateFlags.Focus, 
						"focus-visible" => StateFlags.Focus, 
						"focus-within" => StateFlags.Focus, 
						"disabled" => StateFlags.Disabled, 
						_ => StateFlags.None, 
					};
					if (stateFlags != StateFlags.None)
					{
						states |= stateFlags;
						num2 = i;
						continue;
					}
				}
				stringBuilder.Append(text2[num2]);
				num2++;
			}
			string text3 = stringBuilder.ToString();
			if (text3.Trim().Length == 0)
			{
				text3 = "*";
			}
			baseSelector = (text + text3).Trim();
			if (baseSelector.Length == 0)
			{
				baseSelector = "*";
			}
		}

		internal static void Specificity(string selector, StateFlags states, out int a, out int b, out int c)
		{
			a = 0;
			b = 0;
			c = 0;
			if (string.IsNullOrEmpty(selector))
			{
				return;
			}
			for (int i = 0; i < 4; i++)
			{
				if (((uint)states & (uint)(1 << i)) != 0)
				{
					b++;
				}
			}
			int j = 0;
			while (j < selector.Length)
			{
				char c2 = selector[j];
				switch (c2)
				{
				case '#':
					a++;
					j = SkipIdent(selector, j + 1);
					break;
				case '.':
					b++;
					j = SkipIdent(selector, j + 1);
					break;
				case '[':
					b++;
					for (; j < selector.Length && selector[j] != ']'; j++)
					{
					}
					j++;
					break;
				case ':':
					if (j + 1 < selector.Length && selector[j + 1] == ':')
					{
						c++;
						j = SkipIdent(selector, j + 2);
					}
					else
					{
						b++;
						j = SkipIdent(selector, j + 1);
					}
					break;
				default:
					if (char.IsLetter(c2))
					{
						c++;
						j = SkipIdent(selector, j);
					}
					else
					{
						j++;
					}
					break;
				}
			}
		}

		private static int SkipIdent(string s, int i)
		{
			while (i < s.Length && (char.IsLetterOrDigit(s[i]) || s[i] == '-' || s[i] == '_'))
			{
				i++;
			}
			return i;
		}

		private static int LastCombinatorEnd(string selector)
		{
			int num = 0;
			int result = 0;
			for (int i = 0; i < selector.Length; i++)
			{
				char c = selector[i];
				switch (c)
				{
				case '(':
				case '[':
					num++;
					continue;
				case ')':
				case ']':
					num--;
					continue;
				}
				if (num == 0 && (c == ' ' || c == '>' || c == '+' || c == '~' || c == '\t' || c == '\n' || c == '\r'))
				{
					result = i + 1;
				}
			}
			return result;
		}

		internal static List<string> SplitSelectorList(string list)
		{
			List<string> list2 = new List<string>();
			int num = 0;
			int num2 = 0;
			for (int i = 0; i <= list.Length; i++)
			{
				if (i < list.Length)
				{
					char c = list[i];
					if (c == '(' || c == '[')
					{
						num++;
					}
					else if (c == ')' || c == ']')
					{
						num--;
					}
					else if (c != ',' || num != 0)
					{
						continue;
					}
				}
				string text = list.Substring(num2, i - num2).Trim();
				num2 = i + 1;
				if (text.Length > 0)
				{
					list2.Add(text);
				}
			}
			return list2;
		}

		private static int IndexOfTopLevel(string s, char target)
		{
			int num = 0;
			for (int i = 0; i < s.Length; i++)
			{
				char c = s[i];
				switch (c)
				{
				case '(':
					num++;
					continue;
				case ')':
					num--;
					continue;
				}
				if (c == target && num == 0)
				{
					return i;
				}
			}
			return -1;
		}

		private static int MatchingBrace(string s, int open, int end)
		{
			int num = 0;
			for (int i = open; i < end; i++)
			{
				if (s[i] == '{')
				{
					num++;
				}
				else if (s[i] == '}')
				{
					num--;
					if (num == 0)
					{
						return i;
					}
				}
			}
			return -1;
		}

		private static Orientation? ParseMediaOrientation(string prelude)
		{
			if (prelude.IndexOf("orientation", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return null;
			}
			if (prelude.IndexOf("portrait", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return Orientation.Portrait;
			}
			if (prelude.IndexOf("landscape", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return Orientation.Landscape;
			}
			return null;
		}

		private static bool IsAlwaysTrueMedia(string prelude)
		{
			string text = prelude.Trim();
			if (!text.StartsWith("@media", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			string text2 = text.Substring(6).Trim().ToLowerInvariant();
			if (text2.Length != 0 && !(text2 == "all"))
			{
				return text2 == "screen";
			}
			return true;
		}

		internal static string StripComments(string css)
		{
			StringBuilder stringBuilder = new StringBuilder(css.Length);
			for (int i = 0; i < css.Length; i++)
			{
				if (css[i] == '/' && i + 1 < css.Length && css[i + 1] == '*')
				{
					int num = css.IndexOf("*/", i + 2, StringComparison.Ordinal);
					if (num < 0)
					{
						break;
					}
					i = num + 1;
				}
				else
				{
					stringBuilder.Append(css[i]);
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal static class StyleApplier
	{
		private enum Side
		{
			All,
			Top,
			Right,
			Bottom,
			Left
		}

		internal static void Apply(ComputedStyle s, string property, string value)
		{
			if (s == null || string.IsNullOrEmpty(property) || value == null)
			{
				return;
			}
			property = property.Trim().ToLowerInvariant();
			value = value.Trim();
			if (value.Length == 0 || property == null)
			{
				return;
			}
			switch (property.Length)
			{
			case 7:
				switch (property[0])
				{
				case 'd':
					if (property == "display")
					{
						if (Is(value, "none"))
						{
							s.Display = DisplayKind.None;
						}
						else if (Is(value, "flex") || Is(value, "block") || Is(value, "inline-block"))
						{
							s.Display = DisplayKind.Flex;
						}
					}
					break;
				case 'r':
				{
					if (property == "row-gap" && ValueParser.TryLength(value, out var len18))
					{
						s.RowGap = len18;
					}
					break;
				}
				case 'p':
				{
					if (property == "padding" && TryEdges(value, out var edges4))
					{
						s.Padding = edges4;
					}
					break;
				}
				case 'o':
				{
					if (property == "opacity" && ValueParser.TryNumber(value, out var value2))
					{
						s.Opacity = ((value2 < 0f) ? 0f : ((value2 > 1f) ? 1f : value2));
					}
					break;
				}
				}
				break;
			case 14:
				switch (property[0])
				{
				case 'f':
					if (property == "flex-direction")
					{
						s.FlexDirection = ParseDirection(value, s.FlexDirection);
					}
					break;
				case 'p':
				{
					if (property == "padding-bottom" && ValueParser.TryLength(value, out var len27))
					{
						s.Padding.Bottom = len27;
					}
					break;
				}
				case 'l':
					if (property == "letter-spacing")
					{
						float px6;
						if (Is(value, "normal"))
						{
							s.LetterSpacing = 0f;
						}
						else if (TryPx(value, out px6))
						{
							s.LetterSpacing = px6;
						}
					}
					break;
				}
				break;
			case 9:
				switch (property[1])
				{
				case 'l':
					switch (property)
					{
					case "flex-wrap":
						s.FlexWrap = ParseWrap(value, s.FlexWrap);
						break;
					case "flex-flow":
					{
						string[] array2 = ValueParser.SplitTopLevel(value);
						foreach (string v in array2)
						{
							s.FlexDirection = ParseDirection(v, s.FlexDirection);
							s.FlexWrap = ParseWrap(v, s.FlexWrap);
						}
						break;
					}
					case "flex-grow":
					{
						if (ValueParser.TryNumber(value, out var value4))
						{
							s.FlexGrow = value4;
						}
						break;
					}
					}
					break;
				case 'i':
				{
					if (property == "min-width" && ValueParser.TryLength(value, out var len24))
					{
						s.MinWidth = len24;
					}
					break;
				}
				case 'a':
				{
					if (property == "max-width" && ValueParser.TryLength(value, out var len23))
					{
						s.MaxWidth = len23;
					}
					break;
				}
				case 'r':
					if (property == "transform")
					{
						ApplyTransform(s, value);
					}
					break;
				case 'o':
				{
					if (property == "font-size" && TryPx(value, out var px4))
					{
						s.FontSize = px4;
					}
					break;
				}
				}
				break;
			case 4:
				switch (property[0])
				{
				case 'f':
					if (property == "flex")
					{
						ApplyFlex(s, value);
					}
					break;
				case 'l':
				{
					if (property == "left" && ValueParser.TryLength(value, out var len22))
					{
						s.Inset.Left = len22;
					}
					break;
				}
				}
				break;
			case 11:
				switch (property[0])
				{
				case 'f':
					switch (property)
					{
					case "flex-shrink":
					{
						if (ValueParser.TryNumber(value, out var value3))
						{
							s.FlexShrink = value3;
						}
						break;
					}
					case "font-family":
						s.FontFamily = FirstFamily(value);
						break;
					case "font-weight":
						s.FontWeight = ParseWeight(value, s.FontWeight);
						break;
					}
					break;
				case 'a':
					if (property == "align-items")
					{
						s.AlignItems = ParseAlign(value, s.AlignItems);
					}
					break;
				case 'p':
				{
					if (property == "padding-top" && ValueParser.TryLength(value, out var len21))
					{
						s.Padding.Top = len21;
					}
					break;
				}
				case 'm':
				{
					if (property == "margin-left" && ValueParser.TryLength(value, out var len20))
					{
						s.Margin.Left = len20;
					}
					break;
				}
				case 'b':
					if (property == "border-left")
					{
						ApplyBorder(s, value, Side.Left);
					}
					break;
				case 'l':
					if (property == "line-height")
					{
						ApplyLineHeight(s, value);
					}
					break;
				case 'w':
					if (property == "white-space")
					{
						s.WhiteSpace = (Is(value, "nowrap") ? WhiteSpaceKind.NoWrap : WhiteSpaceKind.Normal);
					}
					break;
				}
				break;
			case 10:
				switch (property[9])
				{
				case 's':
				{
					if (property == "flex-basis" && ValueParser.TryLength(value, out var len16))
					{
						s.FlexBasis = len16;
					}
					return;
				}
				case 'f':
					if (property == "align-self")
					{
						s.AlignSelf = ParseAlign(value, s.AlignSelf);
					}
					return;
				case 'p':
					switch (property)
					{
					case "column-gap":
					{
						if (ValueParser.TryLength(value, out var len15))
						{
							s.ColumnGap = len15;
						}
						break;
					}
					case "margin-top":
					{
						if (ValueParser.TryLength(value, out var len14))
						{
							s.Margin.Top = len14;
						}
						break;
					}
					case "border-top":
						ApplyBorder(s, value, Side.Top);
						break;
					}
					return;
				case 't':
				{
					Len len13;
					if (!(property == "min-height"))
					{
						if (property == "max-height" && ValueParser.TryLength(value, out var len12))
						{
							s.MaxHeight = len12;
						}
					}
					else if (ValueParser.TryLength(value, out len13))
					{
						s.MinHeight = len13;
					}
					return;
				}
				case 'x':
					if (property == "overflow-x")
					{
						s.OverflowX = ParseOverflow(value, s.OverflowX);
					}
					return;
				case 'y':
					if (property == "overflow-y")
					{
						s.OverflowY = ParseOverflow(value, s.OverflowY);
					}
					return;
				case 'd':
					break;
				case 'w':
					if (property == "box-shadow")
					{
						ApplyShadow(s, value);
					}
					return;
				case 'n':
					if (!(property == "transition"))
					{
						if (property == "text-align")
						{
							if (Is(value, "center"))
							{
								s.TextAlign = TextAlignKind.Center;
							}
							else if (Is(value, "right") || Is(value, "end"))
							{
								s.TextAlign = TextAlignKind.Right;
							}
							else if (Is(value, "left") || Is(value, "start"))
							{
								s.TextAlign = TextAlignKind.Left;
							}
						}
					}
					else
					{
						ApplyTransition(s, value);
					}
					return;
				case 'e':
					if (property == "font-style")
					{
						s.FontStyle = ((Is(value, "italic") || Is(value, "oblique")) ? FontStyleKind.Italic : FontStyleKind.Normal);
					}
					return;
				default:
					return;
				}
				if (!(property == "background"))
				{
					break;
				}
				goto IL_0cda;
			case 3:
				switch (property[0])
				{
				case 'g':
					if (property == "gap")
					{
						string[] array = ValueParser.SplitTopLevel(value);
						if (array.Length >= 1 && ValueParser.TryLength(array[0], out var len10))
						{
							s.RowGap = len10;
							s.ColumnGap = len10;
						}
						if (array.Length >= 2 && ValueParser.TryLength(array[1], out var len11))
						{
							s.ColumnGap = len11;
						}
					}
					break;
				case 't':
				{
					if (property == "top" && ValueParser.TryLength(value, out var len9))
					{
						s.Inset.Top = len9;
					}
					break;
				}
				}
				break;
			case 13:
				switch (property[0])
				{
				case 'p':
				{
					if (property == "padding-right" && ValueParser.TryLength(value, out var len7))
					{
						s.Padding.Right = len7;
					}
					break;
				}
				case 'm':
				{
					if (property == "margin-bottom" && ValueParser.TryLength(value, out var len8))
					{
						s.Margin.Bottom = len8;
					}
					break;
				}
				case 'b':
					if (!(property == "border-bottom"))
					{
						if (property == "border-radius")
						{
							ApplyRadius(s, value);
						}
					}
					else
					{
						ApplyBorder(s, value, Side.Bottom);
					}
					break;
				case 't':
					if (property == "text-overflow")
					{
						s.TextOverflowEllipsis = Is(value, "ellipsis");
					}
					break;
				}
				break;
			case 12:
				switch (property[7])
				{
				case '-':
				{
					if (property == "padding-left" && ValueParser.TryLength(value, out var len6))
					{
						s.Padding.Left = len6;
					}
					break;
				}
				case 'r':
				{
					Len len5;
					if (!(property == "margin-right"))
					{
						if (property == "border-right")
						{
							ApplyBorder(s, value, Side.Right);
						}
					}
					else if (ValueParser.TryLength(value, out len5))
					{
						s.Margin.Right = len5;
					}
					break;
				}
				case 'w':
				{
					if (property == "border-width" && TryEdges(value, out var edges3))
					{
						s.BorderWidth = edges3;
					}
					break;
				}
				case 'c':
				{
					if (property == "border-color" && ValueParser.TryColor(value, out var color2))
					{
						s.BorderColor = color2;
					}
					break;
				}
				case 's':
					_ = property == "border-style";
					break;
				}
				break;
			case 6:
				switch (property[4])
				{
				case 'i':
				{
					if (property == "margin" && TryEdges(value, out var edges2))
					{
						s.Margin = edges2;
					}
					break;
				}
				case 'h':
				{
					if (property == "height" && ValueParser.TryLength(value, out var len4))
					{
						s.Height = len4;
					}
					break;
				}
				case 'o':
				{
					if (property == "bottom" && ValueParser.TryLength(value, out var len3))
					{
						s.Inset.Bottom = len3;
					}
					break;
				}
				case 'e':
					if (property == "border")
					{
						ApplyBorder(s, value);
					}
					break;
				}
				break;
			case 5:
				switch (property[0])
				{
				case 'w':
				{
					if (property == "width" && ValueParser.TryLength(value, out var len))
					{
						s.Width = len;
					}
					break;
				}
				case 'i':
				{
					if (property == "inset" && TryEdges(value, out var edges))
					{
						s.Inset = edges;
					}
					break;
				}
				case 'r':
				{
					if (property == "right" && ValueParser.TryLength(value, out var len2))
					{
						s.Inset.Right = len2;
					}
					break;
				}
				case 'c':
				{
					if (property == "color" && ValueParser.TryColor(value, out var color))
					{
						s.Color = color;
					}
					break;
				}
				}
				break;
			case 8:
				switch (property[0])
				{
				case 'p':
					if (property == "position")
					{
						if (Is(value, "absolute") || Is(value, "fixed"))
						{
							s.Position = PositionKind.Absolute;
						}
						else if (Is(value, "static") || Is(value, "relative"))
						{
							s.Position = PositionKind.Static;
						}
					}
					break;
				case 'o':
					if (property == "overflow")
					{
						s.OverflowX = (s.OverflowY = ParseOverflow(value, s.OverflowX));
					}
					break;
				}
				break;
			case 16:
				switch (property[11])
				{
				default:
					return;
				case 'c':
					break;
				case 'i':
					if (property == "background-image")
					{
						ApplyBackground(s, value);
					}
					return;
				case 'w':
				{
					if (property == "border-top-width" && ValueParser.TryLength(value, out var len26))
					{
						s.BorderWidth.Top = len26;
					}
					return;
				}
				case 'd':
					if (property == "transition-delay")
					{
						s.TransitionDelaySeconds = Seconds(value);
					}
					return;
				}
				if (!(property == "background-color"))
				{
					break;
				}
				goto IL_0cda;
			case 19:
				switch (property[11])
				{
				case 'o':
				{
					if (property == "border-bottom-width" && ValueParser.TryLength(value, out var len25))
					{
						s.BorderWidth.Bottom = len25;
					}
					break;
				}
				case 'd':
					if (property == "transition-duration")
					{
						s.TransitionSeconds = Seconds(value);
					}
					break;
				case 'p':
					_ = property == "transition-property";
					break;
				}
				break;
			case 26:
				switch (property[0])
				{
				case 'b':
				{
					if (property == "border-bottom-right-radius" && TryPx(value, out var px5))
					{
						s.BorderRadius.BottomRight = px5;
					}
					break;
				}
				case 't':
					if (property == "transition-timing-function")
					{
						s.TransitionEasing = Easing(value);
					}
					break;
				}
				break;
			case 15:
				if (property == "justify-content")
				{
					s.JustifyContent = ParseJustify(value, s.JustifyContent);
				}
				break;
			case 18:
			{
				if (property == "border-right-width" && ValueParser.TryLength(value, out var len19))
				{
					s.BorderWidth.Right = len19;
				}
				break;
			}
			case 17:
			{
				if (property == "border-left-width" && ValueParser.TryLength(value, out var len17))
				{
					s.BorderWidth.Left = len17;
				}
				break;
			}
			case 22:
			{
				if (property == "border-top-left-radius" && TryPx(value, out var px3))
				{
					s.BorderRadius.TopLeft = px3;
				}
				break;
			}
			case 23:
			{
				if (property == "border-top-right-radius" && TryPx(value, out var px2))
				{
					s.BorderRadius.TopRight = px2;
				}
				break;
			}
			case 25:
			{
				if (property == "border-bottom-left-radius" && TryPx(value, out var px))
				{
					s.BorderRadius.BottomLeft = px;
				}
				break;
			}
			case 20:
			case 21:
			case 24:
				break;
				IL_0cda:
				ApplyBackground(s, value);
				break;
			}
		}

		private static void ApplyFlex(ComputedStyle s, string value)
		{
			if (Is(value, "none"))
			{
				s.FlexGrow = 0f;
				s.FlexShrink = 0f;
				s.FlexBasis = Len.Auto;
				return;
			}
			if (Is(value, "auto"))
			{
				s.FlexGrow = 1f;
				s.FlexShrink = 1f;
				s.FlexBasis = Len.Auto;
				return;
			}
			string[] array = ValueParser.SplitTopLevel(value);
			if (array.Length == 1 && ValueParser.TryNumber(array[0], out var value2))
			{
				s.FlexGrow = value2;
				s.FlexShrink = 1f;
				s.FlexBasis = Len.Percent(0f);
				return;
			}
			if (array.Length >= 1 && ValueParser.TryNumber(array[0], out var value3))
			{
				s.FlexGrow = value3;
			}
			if (array.Length >= 2 && ValueParser.TryNumber(array[1], out var value4))
			{
				s.FlexShrink = value4;
			}
			Len len2;
			if (array.Length >= 3 && ValueParser.TryLength(array[2], out var len))
			{
				s.FlexBasis = len;
			}
			else if (array.Length == 2 && ValueParser.TryLength(array[1], out len2))
			{
				s.FlexBasis = len2;
				s.FlexShrink = 1f;
			}
		}

		private static void ApplyBackground(ComputedStyle s, string value)
		{
			if (Is(value, "none"))
			{
				s.HasGradient = false;
				s.BackgroundColor = RgbaColor.Transparent;
				return;
			}
			int num = value.IndexOf("linear-gradient(", StringComparison.OrdinalIgnoreCase);
			if (num >= 0)
			{
				int num2 = value.IndexOf('(', num);
				int num3 = MatchingParen(value, num2);
				if (num3 > num2)
				{
					string[] array = ValueParser.SplitTopLevel(value.Substring(num2 + 1, num3 - num2 - 1), commaSeparated: true);
					int num4 = 0;
					float gradientAngleDeg = 180f;
					if (array.Length != 0 && array[0].EndsWith("deg", StringComparison.OrdinalIgnoreCase) && ValueParser.TryNumber(array[0].Substring(0, array[0].Length - 3), out var value2))
					{
						gradientAngleDeg = value2;
						num4 = 1;
					}
					if (array.Length >= num4 + 2 && ValueParser.TryColor(FirstToken(array[num4]), out var color) && ValueParser.TryColor(FirstToken(array[num4 + 1]), out var color2))
					{
						s.HasGradient = true;
						s.GradientAngleDeg = gradientAngleDeg;
						s.GradientFrom = color;
						s.GradientTo = color2;
						s.BackgroundColor = RgbaColor.Transparent;
						return;
					}
				}
			}
			string[] array2 = ValueParser.SplitTopLevel(value);
			for (int i = 0; i < array2.Length; i++)
			{
				if (ValueParser.TryColor(array2[i], out var color3))
				{
					s.BackgroundColor = color3;
					s.HasGradient = false;
					break;
				}
			}
		}

		private static void ApplyTransform(ComputedStyle s, string value)
		{
			if (Is(value, "none"))
			{
				s.TranslateX = (s.TranslateY = 0f);
				s.ScaleX = (s.ScaleY = 1f);
				s.RotateDeg = 0f;
				return;
			}
			string[] array = ValueParser.SplitTopLevel(value);
			foreach (string text in array)
			{
				int num = text.IndexOf('(');
				int num2 = text.LastIndexOf(')');
				if (num >= 0 && num2 > num)
				{
					string text2 = text.Substring(0, num).Trim().ToLowerInvariant();
					string[] array2 = text.Substring(num + 1, num2 - num - 1).Split(',');
					switch (text2)
					{
					case "translate":
						s.TranslateX = Px(array2, 0);
						s.TranslateY = ((array2.Length > 1) ? Px(array2, 1) : 0f);
						break;
					case "translatex":
						s.TranslateX = Px(array2, 0);
						break;
					case "translatey":
						s.TranslateY = Px(array2, 0);
						break;
					case "scale":
						s.ScaleX = Number(array2, 0, 1f);
						s.ScaleY = ((array2.Length > 1) ? Number(array2, 1, 1f) : s.ScaleX);
						break;
					case "scalex":
						s.ScaleX = Number(array2, 0, 1f);
						break;
					case "scaley":
						s.ScaleY = Number(array2, 0, 1f);
						break;
					case "rotate":
						s.RotateDeg = Degrees(array2, 0);
						break;
					}
				}
			}
		}

		private static void ApplyTransition(ComputedStyle s, string value)
		{
			if (Is(value, "none"))
			{
				s.TransitionSeconds = 0f;
				return;
			}
			bool flag = false;
			string[] array = ValueParser.SplitTopLevel(value);
			foreach (string value2 in array)
			{
				EasingKind easingKind = Easing(value2);
				if (easingKind != EasingKind.EaseOut || Is(value2, "ease-out"))
				{
					s.TransitionEasing = easingKind;
					continue;
				}
				float num = Seconds(value2);
				if (!(num <= 0f))
				{
					if (!flag)
					{
						s.TransitionSeconds = num;
						flag = true;
					}
					else
					{
						s.TransitionDelaySeconds = num;
					}
				}
			}
		}

		private static float Seconds(string value)
		{
			string text = (value ?? "").Trim().ToLowerInvariant();
			if (text.EndsWith("ms"))
			{
				string text2 = text;
				if (float.TryParse(text2.Substring(0, text2.Length - 2), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					return result / 1000f;
				}
			}
			if (text.EndsWith("s"))
			{
				string text2 = text;
				if (float.TryParse(text2.Substring(0, text2.Length - 1), NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
				{
					return result2;
				}
			}
			return 0f;
		}

		private static EasingKind Easing(string value)
		{
			switch ((value ?? "").Trim().ToLowerInvariant())
			{
			case "linear":
				return EasingKind.Linear;
			case "ease-in":
				return EasingKind.EaseIn;
			case "ease-in-out":
			case "ease":
				return EasingKind.EaseInOut;
			default:
				return EasingKind.EaseOut;
			}
		}

		private static float Px(string[] args, int index)
		{
			if (index >= args.Length || !ValueParser.TryLength(args[index].Trim(), out var len))
			{
				return 0f;
			}
			return len.Resolve(0f);
		}

		private static float Degrees(string[] args, int index)
		{
			if (index >= args.Length)
			{
				return 0f;
			}
			string text = args[index].Trim().ToLowerInvariant();
			float num = 1f;
			if (text.EndsWith("deg"))
			{
				string text2 = text;
				text = text2.Substring(0, text2.Length - 3);
			}
			else if (text.EndsWith("turn"))
			{
				string text2 = text;
				text = text2.Substring(0, text2.Length - 4);
				num = 360f;
			}
			else if (text.EndsWith("rad"))
			{
				string text2 = text;
				text = text2.Substring(0, text2.Length - 3);
				num = 180f / (float)Math.PI;
			}
			if (!float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return 0f;
			}
			return result * num;
		}

		private static float Number(string[] args, int index, float fallback)
		{
			if (index >= args.Length || !float.TryParse(args[index].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return fallback;
			}
			return result;
		}

		private static void ApplyBorder(ComputedStyle s, string value, Side side = Side.All)
		{
			if (Is(value, "none") || Is(value, "0"))
			{
				SetWidth(s, side, Len.Px(0f));
				if (side == Side.All)
				{
					s.BorderColor = RgbaColor.Transparent;
				}
				return;
			}
			string[] array = ValueParser.SplitTopLevel(value);
			foreach (string text in array)
			{
				if (!Is(text, "solid") && !Is(text, "none") && !Is(text, "hidden"))
				{
					RgbaColor color;
					if (ValueParser.TryLength(text, out var len) && len.IsDefinite)
					{
						SetWidth(s, side, len);
					}
					else if (ValueParser.TryColor(text, out color))
					{
						s.BorderColor = color;
					}
				}
			}
		}

		private static void SetWidth(ComputedStyle s, Side side, Len width)
		{
			switch (side)
			{
			case Side.Top:
				s.BorderWidth.Top = width;
				break;
			case Side.Right:
				s.BorderWidth.Right = width;
				break;
			case Side.Bottom:
				s.BorderWidth.Bottom = width;
				break;
			case Side.Left:
				s.BorderWidth.Left = width;
				break;
			default:
				s.BorderWidth = Edges.All(width);
				break;
			}
		}

		private static void ApplyRadius(ComputedStyle s, string value)
		{
			string[] array = ValueParser.SplitTopLevel(value);
			float[] array2 = new float[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				if (!TryPx(array[i], out array2[i]))
				{
					return;
				}
			}
			switch (array2.Length)
			{
			case 1:
				s.BorderRadius = Corners.All(array2[0]);
				break;
			case 2:
				s.BorderRadius = new Corners
				{
					TopLeft = array2[0],
					TopRight = array2[1],
					BottomRight = array2[0],
					BottomLeft = array2[1]
				};
				break;
			case 3:
				s.BorderRadius = new Corners
				{
					TopLeft = array2[0],
					TopRight = array2[1],
					BottomRight = array2[2],
					BottomLeft = array2[1]
				};
				break;
			case 4:
				s.BorderRadius = new Corners
				{
					TopLeft = array2[0],
					TopRight = array2[1],
					BottomRight = array2[2],
					BottomLeft = array2[3]
				};
				break;
			}
		}

		private static void ApplyShadow(ComputedStyle s, string value)
		{
			if (Is(value, "none"))
			{
				s.HasShadow = false;
				return;
			}
			string[] array = ValueParser.SplitTopLevel(value);
			float shadowOffsetX = 0f;
			float shadowOffsetY = 0f;
			float shadowBlur = 0f;
			RgbaColor shadowColor = new RgbaColor(0f, 0f, 0f, 0.5f);
			int num = 0;
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (Is(text, "inset"))
				{
					return;
				}
				RgbaColor color;
				if (num < 3 && ValueParser.TryLength(text, out var len) && len.Unit == LenUnit.Px)
				{
					switch (num)
					{
					case 0:
						shadowOffsetX = len.Value;
						break;
					case 1:
						shadowOffsetY = len.Value;
						break;
					default:
						shadowBlur = len.Value;
						break;
					}
					num++;
				}
				else if (ValueParser.TryColor(text, out color))
				{
					shadowColor = color;
				}
			}
			if (num >= 2)
			{
				s.HasShadow = true;
				s.ShadowOffsetX = shadowOffsetX;
				s.ShadowOffsetY = shadowOffsetY;
				s.ShadowBlur = shadowBlur;
				s.ShadowColor = shadowColor;
			}
		}

		private static void ApplyLineHeight(ComputedStyle s, string value)
		{
			Len len;
			float value2;
			if (Is(value, "normal"))
			{
				s.LineHeight = Len.None;
			}
			else if (ValueParser.TryLength(value, out len) && len.IsDefinite)
			{
				s.LineHeight = len;
			}
			else if (ValueParser.TryNumber(value, out value2))
			{
				s.LineHeight = Len.Percent(value2 * 100f);
			}
		}

		private static bool TryEdges(string value, out Edges edges)
		{
			edges = Edges.Zero;
			string[] array = ValueParser.SplitTopLevel(value);
			Len[] array2 = new Len[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				if (!ValueParser.TryLength(array[i], out array2[i]))
				{
					return false;
				}
			}
			switch (array2.Length)
			{
			case 1:
				edges = Edges.All(array2[0]);
				return true;
			case 2:
				edges = new Edges
				{
					Top = array2[0],
					Right = array2[1],
					Bottom = array2[0],
					Left = array2[1]
				};
				return true;
			case 3:
				edges = new Edges
				{
					Top = array2[0],
					Right = array2[1],
					Bottom = array2[2],
					Left = array2[1]
				};
				return true;
			case 4:
				edges = new Edges
				{
					Top = array2[0],
					Right = array2[1],
					Bottom = array2[2],
					Left = array2[3]
				};
				return true;
			default:
				return false;
			}
		}

		private static bool TryPx(string value, out float px)
		{
			px = 0f;
			if (!ValueParser.TryLength(value, out var len))
			{
				return false;
			}
			if (len.Unit != LenUnit.Px)
			{
				return false;
			}
			px = len.Value;
			return true;
		}

		private static string FirstFamily(string value)
		{
			string[] array = ValueParser.SplitTopLevel(value, commaSeparated: true);
			if (array.Length == 0)
			{
				return "game-ui";
			}
			return array[0].Trim().Trim('"', '\'');
		}

		private static string FirstToken(string s)
		{
			string[] array = ValueParser.SplitTopLevel(s);
			if (array.Length == 0)
			{
				return s;
			}
			return array[0];
		}

		private static int MatchingParen(string s, int open)
		{
			if (open < 0 || open >= s.Length)
			{
				return -1;
			}
			int num = 0;
			for (int i = open; i < s.Length; i++)
			{
				if (s[i] == '(')
				{
					num++;
				}
				else if (s[i] == ')')
				{
					num--;
					if (num == 0)
					{
						return i;
					}
				}
			}
			return -1;
		}

		private static bool Is(string value, string keyword)
		{
			return string.Equals(value, keyword, StringComparison.OrdinalIgnoreCase);
		}

		private static FlexDirection ParseDirection(string v, FlexDirection fallback)
		{
			if (!Is(v, "row"))
			{
				if (!Is(v, "row-reverse"))
				{
					if (!Is(v, "column"))
					{
						if (!Is(v, "column-reverse"))
						{
							return fallback;
						}
						return FlexDirection.ColumnReverse;
					}
					return FlexDirection.Column;
				}
				return FlexDirection.RowReverse;
			}
			return FlexDirection.Row;
		}

		private static FlexWrap ParseWrap(string v, FlexWrap fallback)
		{
			if (!Is(v, "nowrap"))
			{
				if (!Is(v, "wrap"))
				{
					if (!Is(v, "wrap-reverse"))
					{
						return fallback;
					}
					return FlexWrap.WrapReverse;
				}
				return FlexWrap.Wrap;
			}
			return FlexWrap.NoWrap;
		}

		private static Justify ParseJustify(string v, Justify fallback)
		{
			if (!Is(v, "flex-start") && !Is(v, "start"))
			{
				if (!Is(v, "flex-end") && !Is(v, "end"))
				{
					if (!Is(v, "center"))
					{
						if (!Is(v, "space-between"))
						{
							if (!Is(v, "space-around"))
							{
								if (!Is(v, "space-evenly"))
								{
									return fallback;
								}
								return Justify.SpaceEvenly;
							}
							return Justify.SpaceAround;
						}
						return Justify.SpaceBetween;
					}
					return Justify.Center;
				}
				return Justify.FlexEnd;
			}
			return Justify.FlexStart;
		}

		private static AlignKind ParseAlign(string v, AlignKind fallback)
		{
			if (!Is(v, "auto"))
			{
				if (!Is(v, "flex-start") && !Is(v, "start"))
				{
					if (!Is(v, "flex-end") && !Is(v, "end"))
					{
						if (!Is(v, "center"))
						{
							if (!Is(v, "stretch"))
							{
								if (!Is(v, "baseline"))
								{
									return fallback;
								}
								return AlignKind.Baseline;
							}
							return AlignKind.Stretch;
						}
						return AlignKind.Center;
					}
					return AlignKind.FlexEnd;
				}
				return AlignKind.FlexStart;
			}
			return AlignKind.Auto;
		}

		private static OverflowKind ParseOverflow(string v, OverflowKind fallback)
		{
			if (!Is(v, "visible"))
			{
				if (!Is(v, "hidden") && !Is(v, "clip"))
				{
					if (!Is(v, "scroll"))
					{
						if (!Is(v, "auto"))
						{
							return fallback;
						}
						return OverflowKind.Auto;
					}
					return OverflowKind.Scroll;
				}
				return OverflowKind.Hidden;
			}
			return OverflowKind.Visible;
		}

		private static int ParseWeight(string v, int fallback)
		{
			if (Is(v, "normal"))
			{
				return 400;
			}
			if (Is(v, "bold"))
			{
				return 700;
			}
			if (Is(v, "lighter"))
			{
				return 300;
			}
			if (Is(v, "bolder"))
			{
				return 700;
			}
			if (!ValueParser.TryNumber(v, out var value))
			{
				return fallback;
			}
			return (int)value;
		}
	}
	internal sealed class StyleContext
	{
		internal Orientation Orientation = Orientation.Landscape;

		internal Func<IElement, StateFlags> StateOf;
	}
	internal static class StyleResolver
	{
		private readonly struct Entry
		{
			internal readonly Declaration Declaration;

			internal readonly int A;

			internal readonly int B;

			internal readonly int C;

			internal readonly int Order;

			internal readonly bool Inline;

			internal Entry(Declaration declaration, int a, int b, int c, int order, bool inline)
			{
				Declaration = declaration;
				A = a;
				B = b;
				C = c;
				Order = order;
				Inline = inline;
			}
		}

		private const int MaxVarDepth = 8;

		internal static Dictionary<IElement, ComputedStyle> Resolve(IDocument document, Stylesheet sheet, StyleContext context)
		{
			Dictionary<IElement, ComputedStyle> result = new Dictionary<IElement, ComputedStyle>();
			if (((document != null) ? document.DocumentElement : null) == null)
			{
				return result;
			}
			if (context == null)
			{
				context = new StyleContext();
			}
			Dictionary<IElement, List<StyleRule>> matches = MatchRules(document, sheet, context.Orientation);
			Walk(document.DocumentElement, null, matches, context, result);
			return result;
		}

		internal static HashSet<IElement> StatefulElements(IDocument document, Stylesheet sheet, Orientation orientation)
		{
			HashSet<IElement> hashSet = new HashSet<IElement>();
			if (document == null || sheet == null)
			{
				return hashSet;
			}
			foreach (StyleRule rule in sheet.Rules)
			{
				if (rule.RequiredStates == StateFlags.None || (rule.Media.HasValue && rule.Media.Value != orientation))
				{
					continue;
				}
				try
				{
					foreach (IElement item in (IEnumerable<IElement>)((IParentNode)document).QuerySelectorAll(rule.BaseSelector))
					{
						hashSet.Add(item);
					}
				}
				catch
				{
				}
			}
			return hashSet;
		}

		private static Dictionary<IElement, List<StyleRule>> MatchRules(IDocument document, Stylesheet sheet, Orientation orientation)
		{
			Dictionary<IElement, List<StyleRule>> dictionary = new Dictionary<IElement, List<StyleRule>>();
			if (sheet == null)
			{
				return dictionary;
			}
			foreach (StyleRule rule in sheet.Rules)
			{
				if (rule.Media.HasValue && rule.Media.Value != orientation)
				{
					continue;
				}
				IHtmlCollection<IElement> val;
				try
				{
					val = ((IParentNode)document).QuerySelectorAll(rule.BaseSelector);
				}
				catch
				{
					continue;
				}
				foreach (IElement item in (IEnumerable<IElement>)val)
				{
					if (!dictionary.TryGetValue(item, out var value))
					{
						value = (dictionary[item] = new List<StyleRule>());
					}
					value.Add(rule);
				}
			}
			return dictionary;
		}

		private static void Walk(IElement element, ComputedStyle parentStyle, Dictionary<IElement, List<StyleRule>> matches, StyleContext context, Dictionary<IElement, ComputedStyle> result)
		{
			ComputedStyle parentStyle2 = (result[element] = ComputeFor(element, parentStyle, matches, context));
			foreach (IElement item in (IEnumerable<IElement>)((IParentNode)element).Children)
			{
				Walk(item, parentStyle2, matches, context, result);
			}
		}

		private static ComputedStyle ComputeFor(IElement element, ComputedStyle parentStyle, Dictionary<IElement, List<StyleRule>> matches, StyleContext context)
		{
			ComputedStyle computedStyle = ComputedStyle.CreateFrom(parentStyle);
			StateFlags stateFlags = ((context.StateOf != null) ? context.StateOf(element) : StateFlags.None);
			List<Entry> list = new List<Entry>();
			if (matches.TryGetValue(element, out var value))
			{
				foreach (StyleRule item in value)
				{
					if ((item.RequiredStates & stateFlags) != item.RequiredStates)
					{
						continue;
					}
					foreach (Declaration declaration2 in item.Declarations)
					{
						list.Add(new Entry(declaration2, item.SpecificityA, item.SpecificityB, item.SpecificityC, item.Order, inline: false));
					}
				}
			}
			string attribute = element.GetAttribute("style");
			if (!string.IsNullOrWhiteSpace(attribute))
			{
				foreach (Declaration item2 in CssParser.ParseDeclarations(attribute))
				{
					list.Add(new Entry(item2, 0, 0, 0, int.MaxValue, inline: true));
				}
			}
			list.Sort(Compare);
			foreach (Entry item3 in list)
			{
				if (IsCustomProperty(item3.Declaration.Property))
				{
					computedStyle.SetVariable(item3.Declaration.Property.Trim(), item3.Declaration.Value);
				}
			}
			foreach (Entry item4 in list)
			{
				Declaration declaration = item4.Declaration;
				if (IsCustomProperty(declaration.Property))
				{
					continue;
				}
				string text = declaration.Value;
				if (text.IndexOf("var(", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					text = SubstituteVariables(text, computedStyle.Variables, 0);
					if (text == null)
					{
						continue;
					}
				}
				StyleApplier.Apply(computedStyle, declaration.Property, text);
			}
			return computedStyle;
		}

		private static bool IsCustomProperty(string property)
		{
			return property?.TrimStart().StartsWith("--", StringComparison.Ordinal) ?? false;
		}

		internal static string SubstituteVariables(string value, Dictionary<string, string> variables, int depth)
		{
			if (depth > 8 || string.IsNullOrEmpty(value))
			{
				return null;
			}
			StringBuilder stringBuilder = new StringBuilder(value.Length);
			int num = 0;
			while (num < value.Length)
			{
				int num2 = value.IndexOf("var(", num, StringComparison.OrdinalIgnoreCase);
				if (num2 < 0)
				{
					stringBuilder.Append(value, num, value.Length - num);
					break;
				}
				stringBuilder.Append(value, num, num2 - num);
				int num3 = num2 + 3;
				int num4 = MatchingParen(value, num3);
				if (num4 < 0)
				{
					return null;
				}
				string text = value.Substring(num3 + 1, num4 - num3 - 1);
				int num5 = TopLevelComma(text);
				string text2 = ((num5 < 0) ? text : text.Substring(0, num5)).Trim();
				string text3 = ((num5 < 0) ? null : text.Substring(num5 + 1).Trim());
				string value2 = null;
				if (variables != null && text2.StartsWith("--", StringComparison.Ordinal))
				{
					variables.TryGetValue(text2, out value2);
				}
				if (value2 == null)
				{
					value2 = text3;
				}
				if (value2 == null)
				{
					return null;
				}
				if (value2.IndexOf("var(", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					value2 = SubstituteVariables(value2, variables, depth + 1);
					if (value2 == null)
					{
						return null;
					}
				}
				stringBuilder.Append(value2);
				num = num4 + 1;
			}
			return stringBuilder.ToString();
		}

		private static int MatchingParen(string s, int open)
		{
			int num = 0;
			for (int i = open; i < s.Length; i++)
			{
				if (s[i] == '(')
				{
					num++;
				}
				else if (s[i] == ')')
				{
					num--;
					if (num == 0)
					{
						return i;
					}
				}
			}
			return -1;
		}

		private static int TopLevelComma(string s)
		{
			int num = 0;
			for (int i = 0; i < s.Length; i++)
			{
				if (s[i] == '(')
				{
					num++;
				}
				else if (s[i] == ')')
				{
					num--;
				}
				else if (s[i] == ',' && num == 0)
				{
					return i;
				}
			}
			return -1;
		}

		private static int Compare(Entry x, Entry y)
		{
			int num = (x.Declaration.Important ? 1 : 0);
			int num2 = (y.Declaration.Important ? 1 : 0);
			if (num != num2)
			{
				return num - num2;
			}
			int num3 = (x.Inline ? 1 : 0);
			int num4 = (y.Inline ? 1 : 0);
			if (num3 != num4)
			{
				return num3 - num4;
			}
			if (x.A != y.A)
			{
				return x.A - y.A;
			}
			if (x.B != y.B)
			{
				return x.B - y.B;
			}
			if (x.C != y.C)
			{
				return x.C - y.C;
			}
			return x.Order.CompareTo(y.Order);
		}
	}
	internal static class ValueParser
	{
		internal static bool TryNumber(string s, out float value)
		{
			value = 0f;
			if (string.IsNullOrEmpty(s))
			{
				return false;
			}
			return float.TryParse(s.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out value);
		}

		internal static bool TryLength(string s, out Len len)
		{
			len = Len.None;
			if (string.IsNullOrEmpty(s))
			{
				return false;
			}
			s = s.Trim();
			if (s.Equals("auto", StringComparison.OrdinalIgnoreCase))
			{
				len = Len.Auto;
				return true;
			}
			if (s.Equals("none", StringComparison.OrdinalIgnoreCase))
			{
				len = Len.None;
				return true;
			}
			if (s.EndsWith("%", StringComparison.Ordinal))
			{
				if (!TryNumber(s.Substring(0, s.Length - 1), out var value))
				{
					return false;
				}
				len = Len.Percent(value);
				return true;
			}
			if (s.EndsWith("px", StringComparison.OrdinalIgnoreCase))
			{
				if (!TryNumber(s.Substring(0, s.Length - 2), out var value2))
				{
					return false;
				}
				len = Len.Px(value2);
				return true;
			}
			if (TryNumber(s, out var value3) && value3 == 0f)
			{
				len = Len.Zero;
				return true;
			}
			return false;
		}

		internal static bool TryColor(string s, out RgbaColor color)
		{
			color = RgbaColor.Transparent;
			if (string.IsNullOrEmpty(s))
			{
				return false;
			}
			s = s.Trim();
			if (s.StartsWith("#", StringComparison.Ordinal))
			{
				return TryHex(s.Substring(1), out color);
			}
			if (s.StartsWith("rgb", StringComparison.OrdinalIgnoreCase))
			{
				int num = s.IndexOf('(');
				int num2 = s.LastIndexOf(')');
				if (num < 0 || num2 <= num)
				{
					return false;
				}
				string[] array = SplitArgs(s.Substring(num + 1, num2 - num - 1));
				if (array.Length < 3)
				{
					return false;
				}
				if (!TryChannel(array[0], out var v) || !TryChannel(array[1], out var v2) || !TryChannel(array[2], out var v3))
				{
					return false;
				}
				float v4 = 1f;
				if (array.Length >= 4 && !TryAlpha(array[3], out v4))
				{
					return false;
				}
				color = new RgbaColor(v, v2, v3, v4);
				return true;
			}
			return TryNamed(s, out color);
		}

		private static bool TryHex(string hex, out RgbaColor color)
		{
			color = RgbaColor.Transparent;
			for (int i = 0; i < hex.Length; i++)
			{
				if (Hx(hex[i]) < 0)
				{
					return false;
				}
			}
			switch (hex.Length)
			{
			case 3:
			case 4:
			{
				float r2 = (float)(Hx(hex[0]) * 17) / 255f;
				float g2 = (float)(Hx(hex[1]) * 17) / 255f;
				float b2 = (float)(Hx(hex[2]) * 17) / 255f;
				float a2 = ((hex.Length == 4) ? ((float)(Hx(hex[3]) * 17) / 255f) : 1f);
				color = new RgbaColor(r2, g2, b2, a2);
				return true;
			}
			case 6:
			case 8:
			{
				float r = (float)(Hx(hex[0]) * 16 + Hx(hex[1])) / 255f;
				float g = (float)(Hx(hex[2]) * 16 + Hx(hex[3])) / 255f;
				float b = (float)(Hx(hex[4]) * 16 + Hx(hex[5])) / 255f;
				float a = ((hex.Length == 8) ? ((float)(Hx(hex[6]) * 16 + Hx(hex[7])) / 255f) : 1f);
				color = new RgbaColor(r, g, b, a);
				return true;
			}
			default:
				return false;
			}
			static int Hx(char c)
			{
				if (c < '0' || c > '9')
				{
					if (c < 'a' || c > 'f')
					{
						if (c < 'A' || c > 'F')
						{
							return -1;
						}
						return c - 65 + 10;
					}
					return c - 97 + 10;
				}
				return c - 48;
			}
		}

		private static bool TryChannel(string s, out float v)
		{
			v = 0f;
			s = s.Trim();
			if (s.EndsWith("%", StringComparison.Ordinal))
			{
				if (!TryNumber(s.Substring(0, s.Length - 1), out var value))
				{
					return false;
				}
				v = Clamp01(value / 100f);
				return true;
			}
			if (!TryNumber(s, out var value2))
			{
				return false;
			}
			v = Clamp01(value2 / 255f);
			return true;
		}

		private static bool TryAlpha(string s, out float v)
		{
			v = 1f;
			s = s.Trim();
			if (s.EndsWith("%", StringComparison.Ordinal))
			{
				if (!TryNumber(s.Substring(0, s.Length - 1), out var value))
				{
					return false;
				}
				v = Clamp01(value / 100f);
				return true;
			}
			if (!TryNumber(s, out var value2))
			{
				return false;
			}
			v = Clamp01(value2);
			return true;
		}

		private static float Clamp01(float v)
		{
			if (!(v < 0f))
			{
				if (!(v > 1f))
				{
					return v;
				}
				return 1f;
			}
			return 0f;
		}

		internal static string[] SplitArgs(string s)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (char c in s)
			{
				switch (c)
				{
				case '(':
					num++;
					break;
				case ')':
					num--;
					break;
				}
				if (num == 0 && (c == ',' || c == '/' || char.IsWhiteSpace(c)))
				{
					if (stringBuilder.Length > 0)
					{
						list.Add(stringBuilder.ToString());
						stringBuilder.Clear();
					}
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			if (stringBuilder.Length > 0)
			{
				list.Add(stringBuilder.ToString());
			}
			return list.ToArray();
		}

		internal static string[] SplitTopLevel(string s, bool commaSeparated = false)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (char c in s)
			{
				switch (c)
				{
				case '(':
					num++;
					break;
				case ')':
					num--;
					break;
				}
				if (num == 0)
				{
					bool num2;
					if (!commaSeparated)
					{
						if (char.IsWhiteSpace(c))
						{
							goto IL_005a;
						}
						num2 = c == ',';
					}
					else
					{
						num2 = c == ',';
					}
					if (num2)
					{
						goto IL_005a;
					}
				}
				stringBuilder.Append(c);
				continue;
				IL_005a:
				if (stringBuilder.Length > 0)
				{
					list.Add(stringBuilder.ToString().Trim());
					stringBuilder.Clear();
				}
			}
			if (stringBuilder.Length > 0)
			{
				list.Add(stringBuilder.ToString().Trim());
			}
			return list.ToArray();
		}

		private static bool TryNamed(string name, out RgbaColor color)
		{
			switch (name.ToLowerInvariant())
			{
			case "transparent":
				color = RgbaColor.Transparent;
				return true;
			case "black":
				color = new RgbaColor(0f, 0f, 0f);
				return true;
			case "white":
				color = new RgbaColor(1f, 1f, 1f);
				return true;
			case "red":
				color = new RgbaColor(1f, 0f, 0f);
				return true;
			case "lime":
				color = new RgbaColor(0f, 1f, 0f);
				return true;
			case "blue":
				color = new RgbaColor(0f, 0f, 1f);
				return true;
			case "yellow":
				color = new RgbaColor(1f, 1f, 0f);
				return true;
			case "cyan":
			case "aqua":
				color = new RgbaColor(0f, 1f, 1f);
				return true;
			case "fuchsia":
			case "magenta":
				color = new RgbaColor(1f, 0f, 1f);
				return true;
			case "gray":
			case "grey":
				color = new RgbaColor(0.502f, 0.502f, 0.502f);
				return true;
			case "silver":
				color = new RgbaColor(0.753f, 0.753f, 0.753f);
				return true;
			case "maroon":
				color = new RgbaColor(0.502f, 0f, 0f);
				return true;
			case "olive":
				color = new RgbaColor(0.502f, 0.502f, 0f);
				return true;
			case "green":
				color = new RgbaColor(0f, 0.502f, 0f);
				return true;
			case "purple":
				color = new RgbaColor(0.502f, 0f, 0.502f);
				return true;
			case "teal":
				color = new RgbaColor(0f, 0.502f, 0.502f);
				return true;
			case "navy":
				color = new RgbaColor(0f, 0f, 0.502f);
				return true;
			case "orange":
				color = new RgbaColor(1f, 0.647f, 0f);
				return true;
			default:
				color = RgbaColor.Transparent;
				return false;
			}
		}
	}
	internal enum LenUnit
	{
		None,
		Px,
		Percent,
		Auto
	}
	internal readonly struct Len
	{
		internal readonly float Value;

		internal readonly LenUnit Unit;

		internal static readonly Len None = new Len(0f, LenUnit.None);

		internal static readonly Len Auto = new Len(0f, LenUnit.Auto);

		internal static readonly Len Zero = new Len(0f, LenUnit.Px);

		internal bool IsNone => Unit == LenUnit.None;

		internal bool IsAuto => Unit == LenUnit.Auto;

		internal bool IsDefinite
		{
			get
			{
				if (Unit != LenUnit.Px)
				{
					return Unit == LenUnit.Percent;
				}
				return true;
			}
		}

		internal Len(float value, LenUnit unit)
		{
			Value = value;
			Unit = unit;
		}

		internal static Len Px(float v)
		{
			return new Len(v, LenUnit.Px);
		}

		internal static Len Percent(float v)
		{
			return new Len(v, LenUnit.Percent);
		}

		internal float Resolve(float basis, float fallback = 0f)
		{
			return Unit switch
			{
				LenUnit.Px => Value, 
				LenUnit.Percent => basis * Value * 0.01f, 
				_ => fallback, 
			};
		}

		public override string ToString()
		{
			return Unit switch
			{
				LenUnit.Px => Value.ToString("0.###", CultureInfo.InvariantCulture) + "px", 
				LenUnit.Percent => Value.ToString("0.###", CultureInfo.InvariantCulture) + "%", 
				LenUnit.Auto => "auto", 
				_ => "none", 
			};
		}
	}
	internal readonly struct RgbaColor
	{
		internal readonly float R;

		internal readonly float G;

		internal readonly float B;

		internal readonly float A;

		internal static readonly RgbaColor Transparent = new RgbaColor(0f, 0f, 0f, 0f);

		internal static readonly RgbaColor Black = new RgbaColor(0f, 0f, 0f);

		internal static readonly RgbaColor White = new RgbaColor(1f, 1f, 1f);

		internal bool IsTransparent => A <= 0.0001f;

		internal RgbaColor(float r, float g, float b, float a = 1f)
		{
			R = r;
			G = g;
			B = b;
			A = a;
		}

		public override string ToString()
		{
			return string.Format(CultureInfo.InvariantCulture, "rgba({0:0.###}, {1:0.###}, {2:0.###}, {3:0.###})", R, G, B, A);
		}

		public override bool Equals(object obj)
		{
			if (obj is RgbaColor rgbaColor && Near(R, rgbaColor.R) && Near(G, rgbaColor.G) && Near(B, rgbaColor.B))
			{
				return Near(A, rgbaColor.A);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return R.GetHashCode() ^ G.GetHashCode() ^ B.GetHashCode() ^ A.GetHashCode();
		}

		private static bool Near(float a, float b)
		{
			if (a - b < 0.002f)
			{
				return b - a < 0.002f;
			}
			return false;
		}
	}
	internal struct Edges
	{
		internal Len Top;

		internal Len Right;

		internal Len Bottom;

		internal Len Left;

		internal static Edges Zero => All(Len.Zero);

		internal static Edges All(Len v)
		{
			return new Edges
			{
				Top = v,
				Right = v,
				Bottom = v,
				Left = v
			};
		}

		public override string ToString()
		{
			return $"{Top} {Right} {Bottom} {Left}";
		}
	}
	internal struct Corners
	{
		internal float TopLeft;

		internal float TopRight;

		internal float BottomRight;

		internal float BottomLeft;

		internal bool IsZero
		{
			get
			{
				if (TopLeft == 0f && TopRight == 0f && BottomRight == 0f)
				{
					return BottomLeft == 0f;
				}
				return false;
			}
		}

		internal static Corners All(float v)
		{
			return new Corners
			{
				TopLeft = v,
				TopRight = v,
				BottomRight = v,
				BottomLeft = v
			};
		}
	}
	internal enum DisplayKind
	{
		Flex,
		None
	}
	internal enum FlexDirection
	{
		Row,
		RowReverse,
		Column,
		ColumnReverse
	}
	internal enum FlexWrap
	{
		NoWrap,
		Wrap,
		WrapReverse
	}
	internal enum Justify
	{
		FlexStart,
		FlexEnd,
		Center,
		SpaceBetween,
		SpaceAround,
		SpaceEvenly
	}
	internal enum AlignKind
	{
		Auto,
		FlexStart,
		FlexEnd,
		Center,
		Stretch,
		Baseline
	}
	internal enum PositionKind
	{
		Static,
		Absolute
	}
	internal enum OverflowKind
	{
		Visible,
		Hidden,
		Scroll,
		Auto
	}
	internal enum EasingKind
	{
		Linear,
		EaseIn,
		EaseOut,
		EaseInOut
	}
	internal enum TextAlignKind
	{
		Left,
		Center,
		Right
	}
	internal enum WhiteSpaceKind
	{
		Normal,
		NoWrap
	}
	internal enum FontStyleKind
	{
		Normal,
		Italic
	}
	internal enum Orientation
	{
		Portrait,
		Landscape
	}
}
namespace Sideload.Config
{
	internal static class Preferences
	{
		private const string CategoryId = "Sideload_01_Main";

		private static MelonPreferences_Category _category;

		private static MelonPreferences_Entry<bool> _devTools;

		private static MelonPreferences_Entry<int> _devToolsPort;

		private static MelonPreferences_Entry<bool> _devToolsAutoOpen;

		private static MelonPreferences_Entry<string> _devToolsFrontend;

		private static MelonPreferences_Entry<bool> _devToolsFetchFrontend;

		internal static bool DevTools => _devTools?.Value ?? false;

		internal static int DevToolsPort => Math.Clamp(_devToolsPort?.Value ?? 9333, 1024, 65535);

		internal static bool DevToolsAutoOpen => _devToolsAutoOpen?.Value ?? true;

		internal static string DevToolsFrontend => (_devToolsFrontend?.Value ?? "").Trim();

		internal static bool DevToolsFetchFrontend => _devToolsFetchFrontend?.Value ?? true;

		internal static void Initialize()
		{
			if (_category == null)
			{
				_category = MelonPreferences.CreateCategory("Sideload_01_Main", "Sideload (Web UI Framework)");
				_devTools = _category.CreateEntry<bool>("DevTools", false, "Chrome DevTools", "OFF (default): nothing listens, and no page can be inspected from outside the game. ON: Sideload runs a Chrome DevTools Protocol server on 127.0.0.1 so you can attach the real DevTools UI to a mounted page - console, evaluate, Elements tree. Anything that can reach the port can run code in your pages, so leave this off unless you are building an app.", false, false, (ValueValidator)null, (string)null);
				_devToolsPort = _category.CreateEntry<int>("DevToolsPort", 9333, "DevTools port", "The loopback port the devtools server listens on. Change it only if 9333 clashes with another tool. Clamped 1024-65535.", false, false, (ValueValidator)(object)new ValueRange<int>(1024, 65535));
				_devToolsAutoOpen = _category.CreateEntry<bool>("DevToolsAutoOpen", true, "Open the browser automatically", "ON (default): once the first page is mounted, Chrome (or Edge) opens at the devtools landing page, where one click attaches the inspector. OFF: the address is only written to the log. Has no effect while Chrome DevTools is off.", false, false, (ValueValidator)null, (string)null);
				_devToolsFrontend = _category.CreateEntry<string>("DevToolsFrontend", "", "Local DevTools frontend folder", "EMPTY (default): Sideload uses its own copy under UserData/Sideload/devtools-frontend, downloading it once if DevToolsFetchFrontend allows, and falls back to Google's servers otherwise. Set this to a folder holding your own copy of the frontend (for example node_modules/@react-native/debugger-frontend/dist/third-party/front_end) to override all of that and serve yours instead. Nothing about your page leaves the machine in any case - the frontend is static JavaScript talking to 127.0.0.1.", false, false, (ValueValidator)null, (string)null);
				_devToolsFetchFrontend = _category.CreateEntry<bool>("DevToolsFetchFrontend", true, "Download the DevTools interface once", "ON (default): the first time you switch Chrome DevTools on, Sideload downloads the DevTools interface in the background - the npm package @react-native/debugger-frontend, about 4.5 MB over the wire and 16 MB on disk - into UserData/Sideload/devtools-frontend. It happens once per machine, never while Chrome DevTools is off, and never blocks the game: DevTools works from Google's servers until the copy lands and offline afterwards. OFF: nothing is downloaded and the interface comes from Google's servers every time, which needs internet. Workspace/tools/install-devtools-frontend.ps1 does the same thing by hand.", false, false, (ValueValidator)null, (string)null);
			}
		}
	}
}
namespace Sideload.Bundle
{
	internal sealed class AppBundle
	{
		private readonly string _prefix;

		private readonly Assembly _asm;

		internal string OverrideRoot { get; }

		internal AppBundle(string appId, string bundlePrefix, Assembly hostAssembly)
		{
			_prefix = bundlePrefix ?? "";
			_asm = hostAssembly;
			OverrideRoot = SafeCombine(MelonEnvironment.ModsDirectory, appId);
		}

		internal string OverridePathOf(string path)
		{
			return SafeCombine(OverrideRoot, (path ?? "").Replace('/', Path.DirectorySeparatorChar));
		}

		internal string ResourceNameOf(string path)
		{
			string text = (path ?? "").Replace('/', '.').Replace('\\', '.');
			if (!string.IsNullOrEmpty(_prefix))
			{
				return _prefix + "." + text;
			}
			return text;
		}

		internal bool Exists(string path)
		{
			if (File.Exists(OverridePathOf(path)))
			{
				return true;
			}
			using Stream stream = OpenEmbedded(path);
			return stream != null;
		}

		internal string ReadText(string path)
		{
			byte[] array = ReadBytes(path);
			if (array == null)
			{
				return null;
			}
			int num = ((array.Length >= 3 && array[0] == 239 && array[1] == 187 && array[2] == 191) ? 3 : 0);
			return Encoding.UTF8.GetString(array, num, array.Length - num);
		}

		internal byte[] ReadBytes(string path)
		{
			string text = OverridePathOf(path);
			if (File.Exists(text))
			{
				try
				{
					return File.ReadAllBytes(text);
				}
				catch (Exception ex)
				{
					Instance log = Core.Log;
					if (log != null)
					{
						log.Warning("[Sideload] override unreadable (" + text + "): " + ex.Message);
					}
				}
			}
			using Stream stream = OpenEmbedded(path);
			if (stream == null)
			{
				return null;
			}
			try
			{
				byte[] array = new byte[stream.Length];
				int num;
				for (int i = 0; i < array.Length; i += num)
				{
					num = stream.Read(array, i, array.Length - i);
					if (num <= 0)
					{
						break;
					}
				}
				return array;
			}
			catch (Exception ex2)
			{
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Warning("[Sideload] embedded resource unreadable (" + ResourceNameOf(path) + "): " + ex2.Message);
				}
				return null;
			}
		}

		private Stream OpenEmbedded(string path)
		{
			if (_asm == null)
			{
				return null;
			}
			try
			{
				return _asm.GetManifestResourceStream(ResourceNameOf(path));
			}
			catch
			{
				return null;
			}
		}

		private static string SafeCombine(string a, string b)
		{
			try
			{
				return Path.Combine(a ?? "", b ?? "");
			}
			catch
			{
				return b ?? "";
			}
		}
	}
	internal sealed class HotReload : IDisposable
	{
		private const float QuietSeconds = 0.25f;

		private readonly FileSystemWatcher _watcher;

		private volatile bool _touched;

		private bool _pending;

		private float _quiet;

		private HotReload(FileSystemWatcher watcher)
		{
			_watcher = watcher;
		}

		internal static HotReload Start(string folder, string appId)
		{
			if (string.IsNullOrEmpty(folder) || !Directory.Exists(folder))
			{
				Instance log = Core.Log;
				if (log != null)
				{
					log.Msg($"[Sideload] no override folder for '{appId}' - create {folder} to edit the app live.");
				}
				return null;
			}
			try
			{
				FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(folder)
				{
					IncludeSubdirectories = true,
					NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite)
				};
				HotReload reload = new HotReload(fileSystemWatcher);
				fileSystemWatcher.Changed += delegate
				{
					reload._touched = true;
				};
				fileSystemWatcher.Created += delegate
				{
					reload._touched = true;
				};
				fileSystemWatcher.Deleted += delegate
				{
					reload._touched = true;
				};
				fileSystemWatcher.Renamed += delegate
				{
					reload._touched = true;
				};
				fileSystemWatcher.EnableRaisingEvents = true;
				Instance log2 = Core.Log;
				if (log2 != null)
				{
					log2.Msg("[Sideload] hot reload watching " + folder);
				}
				return reload;
			}
			catch (Exception ex)
			{
				Instance log3 = Core.Log;
				if (log3 != null)
				{
					log3.Warning("[Sideload] hot reload unavailable for '" + appId + "': " + ex.Message);
				}
				return null;
			}
		}

		internal bool ShouldReload(float deltaSeconds)
		{
			if (_touched)
			{
				_touched = false;
				_pending = true;
				_quiet = 0f;
				return false;
			}
			if (!_pending)
			{
				return false;
			}
			_quiet += deltaSeconds;
			if (_quiet < 0.25f)
			{
				return false;
			}
			_pending = false;
			return true;
		}

		public void Dispose()
		{
			try
			{
				_watcher.EnableRaisingEvents = false;
				_watcher.Dispose();
			}
			catch
			{
			}
		}
	}
}
namespace Sideload.Bridge
{
	public static class SideloadBridge
	{
		public static readonly int AbiVersion = 1;

		public static readonly Action<string, string, string, string, Assembly> RegisterApp = Registry.RegisterApp;

		public static readonly Action<string, string, Func<string, string, string>> Handle = Sideload.Script.Bridge.Handle;

		public static readonly Action<string, string, string> Emit = Sideload.Script.Bridge.Emit;

		public static readonly Action<string, string> AllowHost = HostAllowlist.Allow;

		public static readonly Action<string, string> DeclareOrientations = Registry.DeclareOrientations;

		public static readonly Action<string, int> SetBadge = Registry.SetBadge;

		public static readonly Action<string, string, string> Notify = Registry.Notify;

		public static readonly Func<string, bool> IsAppOnScreen = Registry.IsOnScreen;

		public static readonly Action<string, string, byte[]> SetImage = ImageCache.Supply;
	}
}