using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.XPath;
using System.Xml.Xsl;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: CLSCompliant(true)]
[assembly: AssemblyTitle("Html Agility Pack - Release")]
[assembly: InternalsVisibleTo("HtmlAgilityPack.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010027dc71d8e0b968c7324238e18a4cee4a367f1bf50c9d7a52d91ed46c6a1a584b9142c1d4234c4011d25437c909924079660c434eebe6d2c46412f30520a276e7ca8d8fa7075bb8b9e1c7502ef0e50423b32d469ba750012823fde16989ab42d8428ca5fdd0b06b801788a17239b78e0f75900012a50c5038ab93abbe2ac0d6ee")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("ZZZ Projects Inc.")]
[assembly: AssemblyProduct("Html Agility Pack")]
[assembly: AssemblyCopyright("Copyright © ZZZ Projects Inc.")]
[assembly: AssemblyTrademark("SQL & .NET Tools")]
[assembly: ComVisible(true)]
[assembly: Guid("643622ea-d2aa-4572-a2b2-6202b7fcd83f")]
[assembly: AssemblyFileVersion("1.11.54")]
[assembly: AssemblyInformationalVersion("1.11.54")]
[assembly: AllowPartiallyTrustedCallers]
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyName("")]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: AssemblyVersion("1.11.54.0")]
namespace HtmlAgilityPack;

[Obsolete("This type should not be used; it is intended for internal use in HTML Agility Pack.")]
[CLSCompliant(false)]
public class Crc32
{
	private uint _crc32;

	private static uint[] crc_32_tab = new uint[256]
	{
		0u, 1996959894u, 3993919788u, 2567524794u, 124634137u, 1886057615u, 3915621685u, 2657392035u, 249268274u, 2044508324u,
		3772115230u, 2547177864u, 162941995u, 2125561021u, 3887607047u, 2428444049u, 498536548u, 1789927666u, 4089016648u, 2227061214u,
		450548861u, 1843258603u, 4107580753u, 2211677639u, 325883990u, 1684777152u, 4251122042u, 2321926636u, 335633487u, 1661365465u,
		4195302755u, 2366115317u, 997073096u, 1281953886u, 3579855332u, 2724688242u, 1006888145u, 1258607687u, 3524101629u, 2768942443u,
		901097722u, 1119000684u, 3686517206u, 2898065728u, 853044451u, 1172266101u, 3705015759u, 2882616665u, 651767980u, 1373503546u,
		3369554304u, 3218104598u, 565507253u, 1454621731u, 3485111705u, 3099436303u, 671266974u, 1594198024u, 3322730930u, 2970347812u,
		795835527u, 1483230225u, 3244367275u, 3060149565u, 1994146192u, 31158534u, 2563907772u, 4023717930u, 1907459465u, 112637215u,
		2680153253u, 3904427059u, 2013776290u, 251722036u, 2517215374u, 3775830040u, 2137656763u, 141376813u, 2439277719u, 3865271297u,
		1802195444u, 476864866u, 2238001368u, 4066508878u, 1812370925u, 453092731u, 2181625025u, 4111451223u, 1706088902u, 314042704u,
		2344532202u, 4240017532u, 1658658271u, 366619977u, 2362670323u, 4224994405u, 1303535960u, 984961486u, 2747007092u, 3569037538u,
		1256170817u, 1037604311u, 2765210733u, 3554079995u, 1131014506u, 879679996u, 2909243462u, 3663771856u, 1141124467u, 855842277u,
		2852801631u, 3708648649u, 1342533948u, 654459306u, 3188396048u, 3373015174u, 1466479909u, 544179635u, 3110523913u, 3462522015u,
		1591671054u, 702138776u, 2966460450u, 3352799412u, 1504918807u, 783551873u, 3082640443u, 3233442989u, 3988292384u, 2596254646u,
		62317068u, 1957810842u, 3939845945u, 2647816111u, 81470997u, 1943803523u, 3814918930u, 2489596804u, 225274430u, 2053790376u,
		3826175755u, 2466906013u, 167816743u, 2097651377u, 4027552580u, 2265490386u, 503444072u, 1762050814u, 4150417245u, 2154129355u,
		426522225u, 1852507879u, 4275313526u, 2312317920u, 282753626u, 1742555852u, 4189708143u, 2394877945u, 397917763u, 1622183637u,
		3604390888u, 2714866558u, 953729732u, 1340076626u, 3518719985u, 2797360999u, 1068828381u, 1219638859u, 3624741850u, 2936675148u,
		906185462u, 1090812512u, 3747672003u, 2825379669u, 829329135u, 1181335161u, 3412177804u, 3160834842u, 628085408u, 1382605366u,
		3423369109u, 3138078467u, 570562233u, 1426400815u, 3317316542u, 2998733608u, 733239954u, 1555261956u, 3268935591u, 3050360625u,
		752459403u, 1541320221u, 2607071920u, 3965973030u, 1969922972u, 40735498u, 2617837225u, 3943577151u, 1913087877u, 83908371u,
		2512341634u, 3803740692u, 2075208622u, 213261112u, 2463272603u, 3855990285u, 2094854071u, 198958881u, 2262029012u, 4057260610u,
		1759359992u, 534414190u, 2176718541u, 4139329115u, 1873836001u, 414664567u, 2282248934u, 4279200368u, 1711684554u, 285281116u,
		2405801727u, 4167216745u, 1634467795u, 376229701u, 2685067896u, 3608007406u, 1308918612u, 956543938u, 2808555105u, 3495958263u,
		1231636301u, 1047427035u, 2932959818u, 3654703836u, 1088359270u, 936918000u, 2847714899u, 3736837829u, 1202900863u, 817233897u,
		3183342108u, 3401237130u, 1404277552u, 615818150u, 3134207493u, 3453421203u, 1423857449u, 601450431u, 3009837614u, 3294710456u,
		1567103746u, 711928724u, 3020668471u, 3272380065u, 1510334235u, 755167117u
	};

	internal uint CheckSum
	{
		get
		{
			return _crc32;
		}
		set
		{
			_crc32 = value;
		}
	}

	public static uint CRC32Bytes(byte[] bytes)
	{
		uint num = uint.MaxValue;
		int num2 = bytes.Length;
		int num3 = 0;
		while (num2 > 0)
		{
			num2--;
			num = UPDC32(bytes[num2], num);
			num3++;
		}
		return ~num;
	}

	public static uint CRC32String(string text)
	{
		uint num = uint.MaxValue;
		int num2 = text.Length;
		int num3 = 0;
		while (num2 > 0)
		{
			num2--;
			char num4 = text[num2];
			byte octet = (byte)(num4 & 0xFFu);
			num = UPDC32((byte)((int)num4 >> 8), num);
			num = UPDC32(octet, num);
			num3++;
		}
		return ~num;
	}

	internal uint AddToCRC32(int c)
	{
		return AddToCRC32((ushort)c);
	}

	internal uint AddToCRC32(ushort c)
	{
		byte octet = (byte)(c & 0xFFu);
		byte octet2 = (byte)(c >> 8);
		_crc32 = UPDC32(octet2, _crc32);
		_crc32 = UPDC32(octet, _crc32);
		return ~_crc32;
	}

	private static uint UPDC32(byte octet, uint crc)
	{
		return crc_32_tab[(crc ^ octet) & 0xFF] ^ (crc >> 8);
	}
}
internal class EncodingFoundException : Exception
{
	private Encoding _encoding;

	internal Encoding Encoding => _encoding;

	internal EncodingFoundException(Encoding encoding)
	{
		_encoding = encoding;
	}
}
[DebuggerDisplay("Name: {OriginalName}, Value: {Value}")]
public class HtmlAttribute : IComparable
{
	private int _line;

	internal int _lineposition;

	internal string _name;

	internal int _namelength;

	internal int _namestartindex;

	internal HtmlDocument _ownerdocument;

	internal HtmlNode _ownernode;

	private AttributeValueQuote _quoteType = AttributeValueQuote.DoubleQuote;

	internal int _streamposition;

	internal string _value;

	internal int _valuelength;

	internal int _valuestartindex;

	internal bool _isFromParse;

	internal bool _hasEqual;

	private bool? _localUseOriginalName;

	public int Line
	{
		get
		{
			return _line;
		}
		internal set
		{
			_line = value;
		}
	}

	public int LinePosition => _lineposition;

	public int ValueStartIndex => _valuestartindex;

	public int ValueLength => _valuelength;

	public bool UseOriginalName
	{
		get
		{
			bool result = false;
			if (_localUseOriginalName.HasValue)
			{
				result = _localUseOriginalName.Value;
			}
			else if (OwnerDocument != null)
			{
				result = OwnerDocument.OptionDefaultUseOriginalName;
			}
			return result;
		}
		set
		{
			_localUseOriginalName = value;
		}
	}

	public string Name
	{
		get
		{
			if (_name == null)
			{
				_name = _ownerdocument.Text.Substring(_namestartindex, _namelength);
			}
			if (!UseOriginalName)
			{
				return _name.ToLowerInvariant();
			}
			return _name;
		}
		set
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			_name = value;
			if (_ownernode != null)
			{
				_ownernode.SetChanged();
			}
		}
	}

	public string OriginalName => _name;

	public HtmlDocument OwnerDocument => _ownerdocument;

	public HtmlNode OwnerNode => _ownernode;

	public AttributeValueQuote QuoteType
	{
		get
		{
			return _quoteType;
		}
		set
		{
			_quoteType = value;
		}
	}

	internal AttributeValueQuote InternalQuoteType { get; set; }

	public int StreamPosition => _streamposition;

	public string Value
	{
		get
		{
			if (_value == null && _ownerdocument.Text == null && _valuestartindex == 0 && _valuelength == 0)
			{
				return null;
			}
			if (_value == null)
			{
				_value = _ownerdocument.Text.Substring(_valuestartindex, _valuelength);
				if (!_ownerdocument.BackwardCompatibility)
				{
					_value = HtmlEntity.DeEntitize(_value);
				}
			}
			return _value;
		}
		set
		{
			_value = value;
			if (_ownernode != null)
			{
				_ownernode.SetChanged();
			}
		}
	}

	public string DeEntitizeValue => HtmlEntity.DeEntitize(Value);

	internal string XmlName => HtmlDocument.GetXmlName(Name, isAttribute: true, OwnerDocument.OptionPreserveXmlNamespaces);

	internal string XmlValue => Value;

	public string XPath => ((OwnerNode == null) ? "/" : (OwnerNode.XPath + "/")) + GetRelativeXpath();

	internal HtmlAttribute(HtmlDocument ownerdocument)
	{
		_ownerdocument = ownerdocument;
	}

	public int CompareTo(object obj)
	{
		if (!(obj is HtmlAttribute htmlAttribute))
		{
			throw new ArgumentException("obj");
		}
		return Name.CompareTo(htmlAttribute.Name);
	}

	public HtmlAttribute Clone()
	{
		return new HtmlAttribute(_ownerdocument)
		{
			Name = OriginalName,
			Value = Value,
			QuoteType = QuoteType,
			InternalQuoteType = InternalQuoteType,
			_isFromParse = _isFromParse,
			_hasEqual = _hasEqual
		};
	}

	public void Remove()
	{
		_ownernode.Attributes.Remove(this);
	}

	private string GetRelativeXpath()
	{
		if (OwnerNode == null)
		{
			return Name;
		}
		int num = 1;
		foreach (HtmlAttribute item in (IEnumerable<HtmlAttribute>)OwnerNode.Attributes)
		{
			if (!(item.Name != Name))
			{
				if (item == this)
				{
					break;
				}
				num++;
			}
		}
		return "@" + Name + "[" + num + "]";
	}
}
public enum AttributeValueQuote
{
	SingleQuote,
	DoubleQuote,
	None,
	WithoutValue,
	Initial
}
public class HtmlAttributeCollection : IList<HtmlAttribute>, ICollection<HtmlAttribute>, IEnumerable<HtmlAttribute>, IEnumerable
{
	internal Dictionary<string, HtmlAttribute> Hashitems = new Dictionary<string, HtmlAttribute>(StringComparer.OrdinalIgnoreCase);

	private HtmlNode _ownernode;

	internal List<HtmlAttribute> items = new List<HtmlAttribute>();

	public int Count => items.Count;

	public bool IsReadOnly => false;

	public HtmlAttribute this[int index]
	{
		get
		{
			return items[index];
		}
		set
		{
			HtmlAttribute htmlAttribute = items[index];
			items[index] = value;
			if (htmlAttribute.Name != value.Name)
			{
				Hashitems.Remove(htmlAttribute.Name);
			}
			Hashitems[value.Name] = value;
			value._ownernode = _ownernode;
			_ownernode.SetChanged();
		}
	}

	public HtmlAttribute this[string name]
	{
		get
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (!Hashitems.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}
		set
		{
			if (!Hashitems.TryGetValue(name, out var value2))
			{
				Append(value);
			}
			else
			{
				this[items.IndexOf(value2)] = value;
			}
		}
	}

	internal HtmlAttributeCollection(HtmlNode ownernode)
	{
		_ownernode = ownernode;
	}

	public void Add(string name, string value)
	{
		Append(name, value);
	}

	public void Add(HtmlAttribute item)
	{
		Append(item);
	}

	public void AddRange(IEnumerable<HtmlAttribute> items)
	{
		foreach (HtmlAttribute item in items)
		{
			Append(item);
		}
	}

	public void AddRange(Dictionary<string, string> items)
	{
		foreach (KeyValuePair<string, string> item in items)
		{
			Add(item.Key, item.Value);
		}
	}

	void ICollection<HtmlAttribute>.Clear()
	{
		Clear();
	}

	public bool Contains(HtmlAttribute item)
	{
		return items.Contains(item);
	}

	public void CopyTo(HtmlAttribute[] array, int arrayIndex)
	{
		items.CopyTo(array, arrayIndex);
	}

	IEnumerator<HtmlAttribute> IEnumerable<HtmlAttribute>.GetEnumerator()
	{
		return items.GetEnumerator();
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return items.GetEnumerator();
	}

	public int IndexOf(HtmlAttribute item)
	{
		return items.IndexOf(item);
	}

	public void Insert(int index, HtmlAttribute item)
	{
		if (item == null)
		{
			throw new ArgumentNullException("item");
		}
		Hashitems[item.Name] = item;
		item._ownernode = _ownernode;
		items.Insert(index, item);
		_ownernode.SetChanged();
	}

	bool ICollection<HtmlAttribute>.Remove(HtmlAttribute item)
	{
		if (item == null)
		{
			return false;
		}
		int attributeIndex = GetAttributeIndex(item);
		if (attributeIndex == -1)
		{
			return false;
		}
		RemoveAt(attributeIndex);
		return true;
	}

	public void RemoveAt(int index)
	{
		HtmlAttribute htmlAttribute = items[index];
		Hashitems.Remove(htmlAttribute.Name);
		items.RemoveAt(index);
		_ownernode.SetChanged();
	}

	public HtmlAttribute Append(HtmlAttribute newAttribute)
	{
		if (_ownernode.NodeType == HtmlNodeType.Text || _ownernode.NodeType == HtmlNodeType.Comment)
		{
			throw new Exception("A Text or Comment node cannot have attributes.");
		}
		if (newAttribute == null)
		{
			throw new ArgumentNullException("newAttribute");
		}
		Hashitems[newAttribute.Name] = newAttribute;
		newAttribute._ownernode = _ownernode;
		items.Add(newAttribute);
		_ownernode.SetChanged();
		return newAttribute;
	}

	public HtmlAttribute Append(string name)
	{
		HtmlAttribute newAttribute = _ownernode._ownerdocument.CreateAttribute(name);
		return Append(newAttribute);
	}

	public HtmlAttribute Append(string name, string value)
	{
		HtmlAttribute newAttribute = _ownernode._ownerdocument.CreateAttribute(name, value);
		return Append(newAttribute);
	}

	public bool Contains(string name)
	{
		for (int i = 0; i < items.Count; i++)
		{
			if (string.Equals(items[i].Name, name, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
		}
		return false;
	}

	public HtmlAttribute Prepend(HtmlAttribute newAttribute)
	{
		Insert(0, newAttribute);
		return newAttribute;
	}

	public void Remove(HtmlAttribute attribute)
	{
		if (attribute == null)
		{
			throw new ArgumentNullException("attribute");
		}
		int attributeIndex = GetAttributeIndex(attribute);
		if (attributeIndex == -1)
		{
			throw new IndexOutOfRangeException();
		}
		RemoveAt(attributeIndex);
	}

	public void Remove(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		for (int num = items.Count - 1; num >= 0; num--)
		{
			if (string.Equals(items[num].Name, name, StringComparison.OrdinalIgnoreCase))
			{
				RemoveAt(num);
			}
		}
	}

	public void RemoveAll()
	{
		Hashitems.Clear();
		items.Clear();
		_ownernode.SetChanged();
	}

	public IEnumerable<HtmlAttribute> AttributesWithName(string attributeName)
	{
		for (int i = 0; i < items.Count; i++)
		{
			if (string.Equals(items[i].Name, attributeName, StringComparison.OrdinalIgnoreCase))
			{
				yield return items[i];
			}
		}
	}

	public void Remove()
	{
		items.Clear();
	}

	internal void Clear()
	{
		Hashitems.Clear();
		items.Clear();
	}

	internal int GetAttributeIndex(HtmlAttribute attribute)
	{
		if (attribute == null)
		{
			throw new ArgumentNullException("attribute");
		}
		for (int i = 0; i < items.Count; i++)
		{
			if (items[i] == attribute)
			{
				return i;
			}
		}
		return -1;
	}

	internal int GetAttributeIndex(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		for (int i = 0; i < items.Count; i++)
		{
			if (string.Equals(items[i].Name, name, StringComparison.OrdinalIgnoreCase))
			{
				return i;
			}
		}
		return -1;
	}
}
internal class HtmlCmdLine
{
	internal static bool Help;

	static HtmlCmdLine()
	{
		Help = false;
		ParseArgs();
	}

	internal static string GetOption(string name, string def)
	{
		string ArgValue = def;
		string[] commandLineArgs = Environment.GetCommandLineArgs();
		for (int i = 1; i < commandLineArgs.Length; i++)
		{
			GetStringArg(commandLineArgs[i], name, ref ArgValue);
		}
		return ArgValue;
	}

	internal static string GetOption(int index, string def)
	{
		string ArgValue = def;
		string[] commandLineArgs = Environment.GetCommandLineArgs();
		int num = 0;
		for (int i = 1; i < commandLineArgs.Length; i++)
		{
			if (GetStringArg(commandLineArgs[i], ref ArgValue))
			{
				if (index == num)
				{
					return ArgValue;
				}
				ArgValue = def;
				num++;
			}
		}
		return ArgValue;
	}

	internal static bool GetOption(string name, bool def)
	{
		bool ArgValue = def;
		string[] commandLineArgs = Environment.GetCommandLineArgs();
		for (int i = 1; i < commandLineArgs.Length; i++)
		{
			GetBoolArg(commandLineArgs[i], name, ref ArgValue);
		}
		return ArgValue;
	}

	internal static int GetOption(string name, int def)
	{
		int ArgValue = def;
		string[] commandLineArgs = Environment.GetCommandLineArgs();
		for (int i = 1; i < commandLineArgs.Length; i++)
		{
			GetIntArg(commandLineArgs[i], name, ref ArgValue);
		}
		return ArgValue;
	}

	private static void GetBoolArg(string Arg, string Name, ref bool ArgValue)
	{
		if (Arg.Length >= Name.Length + 1 && ('/' == Arg[0] || '-' == Arg[0]) && Arg.Substring(1, Name.Length).ToLowerInvariant() == Name.ToLowerInvariant())
		{
			ArgValue = true;
		}
	}

	private static void GetIntArg(string Arg, string Name, ref int ArgValue)
	{
		if (Arg.Length < Name.Length + 3 || ('/' != Arg[0] && '-' != Arg[0]) || !(Arg.Substring(1, Name.Length).ToLowerInvariant() == Name.ToLowerInvariant()))
		{
			return;
		}
		try
		{
			ArgValue = Convert.ToInt32(Arg.Substring(Name.Length + 2, Arg.Length - Name.Length - 2));
		}
		catch
		{
		}
	}

	private static bool GetStringArg(string Arg, ref string ArgValue)
	{
		if ('/' == Arg[0] || '-' == Arg[0])
		{
			return false;
		}
		ArgValue = Arg;
		return true;
	}

	private static void GetStringArg(string Arg, string Name, ref string ArgValue)
	{
		if (Arg.Length >= Name.Length + 3 && ('/' == Arg[0] || '-' == Arg[0]) && Arg.Substring(1, Name.Length).ToLowerInvariant() == Name.ToLowerInvariant())
		{
			ArgValue = Arg.Substring(Name.Length + 2, Arg.Length - Name.Length - 2);
		}
	}

	private static void ParseArgs()
	{
		string[] commandLineArgs = Environment.GetCommandLineArgs();
		for (int i = 1; i < commandLineArgs.Length; i++)
		{
			GetBoolArg(commandLineArgs[i], "?", ref Help);
			GetBoolArg(commandLineArgs[i], "h", ref Help);
			GetBoolArg(commandLineArgs[i], "help", ref Help);
		}
	}
}
public class HtmlCommentNode : HtmlNode
{
	private string _comment;

	public string Comment
	{
		get
		{
			if (_comment == null)
			{
				return base.InnerHtml;
			}
			return _comment;
		}
		set
		{
			_comment = value;
		}
	}

	public override string InnerHtml
	{
		get
		{
			if (_comment == null)
			{
				return base.InnerHtml;
			}
			return _comment;
		}
		set
		{
			_comment = value;
		}
	}

	public override string OuterHtml
	{
		get
		{
			if (_comment == null)
			{
				return base.OuterHtml;
			}
			return "<!--" + _comment + "-->";
		}
	}

	internal HtmlCommentNode(HtmlDocument ownerdocument, int index)
		: base(HtmlNodeType.Comment, ownerdocument, index)
	{
	}
}
internal class HtmlConsoleListener : TraceListener
{
	public override void Write(string Message)
	{
		Write(Message, "");
	}

	public override void Write(string Message, string Category)
	{
		Console.Write("T:" + Category + ": " + Message);
	}

	public override void WriteLine(string Message)
	{
		Write(Message + "\n");
	}

	public override void WriteLine(string Message, string Category)
	{
		Write(Message + "\n", Category);
	}
}
public class HtmlDocument : IXPathNavigable
{
	private enum ParseState
	{
		Text,
		WhichTag,
		Tag,
		BetweenAttributes,
		EmptyTag,
		AttributeName,
		AttributeBeforeEquals,
		AttributeAfterEquals,
		AttributeValue,
		Comment,
		QuotedAttributeValue,
		ServerSideCode,
		PcData
	}

	internal static bool _disableBehaviorTagP = true;

	private static int _maxDepthLevel = int.MaxValue;

	private int _c;

	private Crc32 _crc32;

	private HtmlAttribute _currentattribute;

	private HtmlNode _currentnode;

	private Encoding _declaredencoding;

	private HtmlNode _documentnode;

	private bool _fullcomment;

	private int _index;

	internal Dictionary<string, HtmlNode> Lastnodes = new Dictionary<string, HtmlNode>();

	private HtmlNode _lastparentnode;

	private int _line;

	private int _lineposition;

	private int _maxlineposition;

	internal Dictionary<string, HtmlNode> Nodesid;

	private ParseState _oldstate;

	private bool _onlyDetectEncoding;

	internal Dictionary<int, HtmlNode> Openednodes;

	private List<HtmlParseError> _parseerrors = new List<HtmlParseError>();

	private string _remainder;

	private int _remainderOffset;

	private ParseState _state;

	private Encoding _streamencoding;

	private bool _useHtmlEncodingForStream;

	public string Text;

	public bool BackwardCompatibility = true;

	public bool OptionAddDebuggingAttributes;

	public bool OptionAutoCloseOnEnd;

	public bool OptionCheckSyntax = true;

	public bool OptionComputeChecksum;

	public bool OptionEmptyCollection;

	public bool DisableServerSideCode;

	public Encoding OptionDefaultStreamEncoding;

	public bool OptionXmlForceOriginalComment;

	public bool OptionExtractErrorSourceText;

	public int OptionExtractErrorSourceTextMaxLength = 100;

	public bool OptionFixNestedTags;

	public bool OptionOutputAsXml;

	public bool OptionPreserveXmlNamespaces;

	public bool OptionOutputOptimizeAttributeValues;

	public AttributeValueQuote? GlobalAttributeValueQuote;

	public bool OptionOutputOriginalCase;

	public bool OptionOutputUpperCase;

	public bool OptionReadEncoding = true;

	public string OptionStopperNodeName;

	public bool OptionDefaultUseOriginalName;

	public bool OptionUseIdAttribute = true;

	public bool OptionWriteEmptyNodes;

	public int OptionMaxNestedChildNodes;

	internal static readonly string HtmlExceptionRefNotChild = "Reference node must be a child of this node";

	internal static readonly string HtmlExceptionUseIdAttributeFalse = "You need to set UseIdAttribute property to true to enable this feature";

	internal static readonly string HtmlExceptionClassDoesNotExist = "Class name doesn't exist";

	internal static readonly string HtmlExceptionClassExists = "Class name already exists";

	internal static readonly Dictionary<string, string[]> HtmlResetters = new Dictionary<string, string[]>
	{
		{
			"li",
			new string[2] { "ul", "ol" }
		},
		{
			"tr",
			new string[1] { "table" }
		},
		{
			"th",
			new string[2] { "tr", "table" }
		},
		{
			"td",
			new string[2] { "tr", "table" }
		}
	};

	private static List<string> BlockAttributes = new List<string> { "\"", "'" };

	public static bool DisableBehaviorTagP
	{
		get
		{
			return _disableBehaviorTagP;
		}
		set
		{
			if (value)
			{
				if (HtmlNode.ElementsFlags.ContainsKey("p"))
				{
					HtmlNode.ElementsFlags.Remove("p");
				}
			}
			else if (!HtmlNode.ElementsFlags.ContainsKey("p"))
			{
				HtmlNode.ElementsFlags.Add("p", HtmlElementFlag.Empty | HtmlElementFlag.Closed);
			}
			_disableBehaviorTagP = value;
		}
	}

	public static Action<HtmlDocument> DefaultBuilder { get; set; }

	public Action<HtmlDocument> ParseExecuting { get; set; }

	public string ParsedText => Text;

	public static int MaxDepthLevel
	{
		get
		{
			return _maxDepthLevel;
		}
		set
		{
			_maxDepthLevel = value;
		}
	}

	public int CheckSum
	{
		get
		{
			if (_crc32 != null)
			{
				return (int)_crc32.CheckSum;
			}
			return 0;
		}
	}

	public Encoding DeclaredEncoding => _declaredencoding;

	public HtmlNode DocumentNode => _documentnode;

	public Encoding Encoding => GetOutEncoding();

	public IEnumerable<HtmlParseError> ParseErrors => _parseerrors;

	public string Remainder => _remainder;

	public int RemainderOffset => _remainderOffset;

	public Encoding StreamEncoding => _streamencoding;

	public HtmlDocument()
	{
		if (DefaultBuilder != null)
		{
			DefaultBuilder(this);
		}
		_documentnode = CreateNode(HtmlNodeType.Document, 0);
		OptionDefaultStreamEncoding = Encoding.Default;
	}

	public static string GetXmlName(string name)
	{
		return GetXmlName(name, isAttribute: false, preserveXmlNamespaces: false);
	}

	public void UseAttributeOriginalName(string tagName)
	{
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)DocumentNode.SelectNodes("//" + tagName))
		{
			foreach (HtmlAttribute item2 in (IEnumerable<HtmlAttribute>)item.Attributes)
			{
				item2.UseOriginalName = true;
			}
		}
	}

	public static string GetXmlName(string name, bool isAttribute, bool preserveXmlNamespaces)
	{
		string text = string.Empty;
		bool flag = true;
		for (int i = 0; i < name.Length; i++)
		{
			if ((name[i] >= 'a' && name[i] <= 'z') || (name[i] >= 'A' && name[i] <= 'Z') || (name[i] >= '0' && name[i] <= '9') || ((isAttribute || preserveXmlNamespaces) && name[i] == ':') || name[i] == '_' || name[i] == '-' || name[i] == '.')
			{
				text += name[i];
				continue;
			}
			flag = false;
			byte[] bytes = Encoding.UTF8.GetBytes(new char[1] { name[i] });
			for (int j = 0; j < bytes.Length; j++)
			{
				text += bytes[j].ToString("x2");
			}
			text += "_";
		}
		if (flag)
		{
			return text;
		}
		return "_" + text;
	}

	public static string HtmlEncode(string html)
	{
		return HtmlEncodeWithCompatibility(html);
	}

	internal static string HtmlEncodeWithCompatibility(string html, bool backwardCompatibility = true)
	{
		if (html == null)
		{
			throw new ArgumentNullException("html");
		}
		return (backwardCompatibility ? new Regex("&(?!(amp;)|(lt;)|(gt;)|(quot;))", RegexOptions.IgnoreCase) : new Regex("&(?!(amp;)|(lt;)|(gt;)|(quot;)|(nbsp;)|(reg;))", RegexOptions.IgnoreCase)).Replace(html, "&amp;").Replace("<", "&lt;").Replace(">", "&gt;")
			.Replace("\"", "&quot;");
	}

	public static bool IsWhiteSpace(int c)
	{
		if (c == 10 || c == 13 || c == 32 || c == 9)
		{
			return true;
		}
		return false;
	}

	public HtmlAttribute CreateAttribute(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		HtmlAttribute htmlAttribute = CreateAttribute();
		htmlAttribute.Name = name;
		return htmlAttribute;
	}

	public HtmlAttribute CreateAttribute(string name, string value)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		HtmlAttribute htmlAttribute = CreateAttribute(name);
		htmlAttribute.Value = value;
		return htmlAttribute;
	}

	public HtmlCommentNode CreateComment()
	{
		return (HtmlCommentNode)CreateNode(HtmlNodeType.Comment);
	}

	public HtmlCommentNode CreateComment(string comment)
	{
		if (comment == null)
		{
			throw new ArgumentNullException("comment");
		}
		HtmlCommentNode htmlCommentNode = CreateComment();
		htmlCommentNode.Comment = comment;
		return htmlCommentNode;
	}

	public HtmlNode CreateElement(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		HtmlNode htmlNode = CreateNode(HtmlNodeType.Element);
		htmlNode.SetName(name);
		return htmlNode;
	}

	public HtmlTextNode CreateTextNode()
	{
		return (HtmlTextNode)CreateNode(HtmlNodeType.Text);
	}

	public HtmlTextNode CreateTextNode(string text)
	{
		if (text == null)
		{
			throw new ArgumentNullException("text");
		}
		HtmlTextNode htmlTextNode = CreateTextNode();
		htmlTextNode.Text = text;
		return htmlTextNode;
	}

	public Encoding DetectEncoding(Stream stream)
	{
		return DetectEncoding(stream, checkHtml: false);
	}

	public Encoding DetectEncoding(Stream stream, bool checkHtml)
	{
		_useHtmlEncodingForStream = checkHtml;
		if (stream == null)
		{
			throw new ArgumentNullException("stream");
		}
		return DetectEncoding(new StreamReader(stream));
	}

	public Encoding DetectEncoding(TextReader reader)
	{
		if (reader == null)
		{
			throw new ArgumentNullException("reader");
		}
		_onlyDetectEncoding = true;
		if (OptionCheckSyntax)
		{
			Openednodes = new Dictionary<int, HtmlNode>();
		}
		else
		{
			Openednodes = null;
		}
		if (OptionUseIdAttribute)
		{
			Nodesid = new Dictionary<string, HtmlNode>(StringComparer.OrdinalIgnoreCase);
		}
		else
		{
			Nodesid = null;
		}
		if (reader is StreamReader streamReader && !_useHtmlEncodingForStream)
		{
			Text = streamReader.ReadToEnd();
			_streamencoding = streamReader.CurrentEncoding;
			return _streamencoding;
		}
		_streamencoding = null;
		_declaredencoding = null;
		Text = reader.ReadToEnd();
		_documentnode = CreateNode(HtmlNodeType.Document, 0);
		try
		{
			Parse();
		}
		catch (EncodingFoundException ex)
		{
			return ex.Encoding;
		}
		return _streamencoding;
	}

	public Encoding DetectEncodingHtml(string html)
	{
		if (html == null)
		{
			throw new ArgumentNullException("html");
		}
		using StringReader reader = new StringReader(html);
		return DetectEncoding(reader);
	}

	public HtmlNode GetElementbyId(string id)
	{
		if (id == null)
		{
			throw new ArgumentNullException("id");
		}
		if (Nodesid == null)
		{
			throw new Exception(HtmlExceptionUseIdAttributeFalse);
		}
		if (!Nodesid.ContainsKey(id))
		{
			return null;
		}
		return Nodesid[id];
	}

	public void Load(Stream stream)
	{
		Load(new StreamReader(stream, OptionDefaultStreamEncoding));
	}

	public void Load(Stream stream, bool detectEncodingFromByteOrderMarks)
	{
		Load(new StreamReader(stream, detectEncodingFromByteOrderMarks));
	}

	public void Load(Stream stream, Encoding encoding)
	{
		Load(new StreamReader(stream, encoding));
	}

	public void Load(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks)
	{
		Load(new StreamReader(stream, encoding, detectEncodingFromByteOrderMarks));
	}

	public void Load(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int buffersize)
	{
		Load(new StreamReader(stream, encoding, detectEncodingFromByteOrderMarks, buffersize));
	}

	public void Load(TextReader reader)
	{
		if (reader == null)
		{
			throw new ArgumentNullException("reader");
		}
		_onlyDetectEncoding = false;
		if (OptionCheckSyntax)
		{
			Openednodes = new Dictionary<int, HtmlNode>();
		}
		else
		{
			Openednodes = null;
		}
		if (OptionUseIdAttribute)
		{
			Nodesid = new Dictionary<string, HtmlNode>(StringComparer.OrdinalIgnoreCase);
		}
		else
		{
			Nodesid = null;
		}
		if (reader is StreamReader streamReader)
		{
			try
			{
				streamReader.Peek();
			}
			catch (Exception)
			{
			}
			_streamencoding = streamReader.CurrentEncoding;
		}
		else
		{
			_streamencoding = null;
		}
		_declaredencoding = null;
		Text = reader.ReadToEnd();
		_documentnode = CreateNode(HtmlNodeType.Document, 0);
		Parse();
		if (!OptionCheckSyntax || Openednodes == null)
		{
			return;
		}
		foreach (HtmlNode value in Openednodes.Values)
		{
			if (!value._starttag)
			{
				continue;
			}
			string text;
			if (OptionExtractErrorSourceText)
			{
				text = value.OuterHtml;
				if (text.Length > OptionExtractErrorSourceTextMaxLength)
				{
					text = text.Substring(0, OptionExtractErrorSourceTextMaxLength);
				}
			}
			else
			{
				text = string.Empty;
			}
			AddError(HtmlParseErrorCode.TagNotClosed, value._line, value._lineposition, value._streamposition, text, "End tag </" + value.Name + "> was not found");
		}
		Openednodes.Clear();
	}

	public void LoadHtml(string html)
	{
		if (html == null)
		{
			throw new ArgumentNullException("html");
		}
		using StringReader reader = new StringReader(html);
		Load(reader);
	}

	public void Save(Stream outStream)
	{
		StreamWriter writer = new StreamWriter(outStream, GetOutEncoding());
		Save(writer);
	}

	public void Save(Stream outStream, Encoding encoding)
	{
		if (outStream == null)
		{
			throw new ArgumentNullException("outStream");
		}
		if (encoding == null)
		{
			throw new ArgumentNullException("encoding");
		}
		StreamWriter writer = new StreamWriter(outStream, encoding);
		Save(writer);
	}

	public void Save(StreamWriter writer)
	{
		Save((TextWriter)writer);
	}

	public void Save(TextWriter writer)
	{
		if (writer == null)
		{
			throw new ArgumentNullException("writer");
		}
		DocumentNode.WriteTo(writer);
		writer.Flush();
	}

	public void Save(XmlWriter writer)
	{
		DocumentNode.WriteTo(writer);
		writer.Flush();
	}

	internal HtmlAttribute CreateAttribute()
	{
		return new HtmlAttribute(this);
	}

	internal HtmlNode CreateNode(HtmlNodeType type)
	{
		return CreateNode(type, -1);
	}

	internal HtmlNode CreateNode(HtmlNodeType type, int index)
	{
		return type switch
		{
			HtmlNodeType.Comment => new HtmlCommentNode(this, index), 
			HtmlNodeType.Text => new HtmlTextNode(this, index), 
			_ => new HtmlNode(type, this, index), 
		};
	}

	internal Encoding GetOutEncoding()
	{
		return _declaredencoding ?? _streamencoding ?? OptionDefaultStreamEncoding;
	}

	internal HtmlNode GetXmlDeclaration()
	{
		if (!_documentnode.HasChildNodes)
		{
			return null;
		}
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)_documentnode._childnodes)
		{
			if (item.Name == "?xml")
			{
				return item;
			}
		}
		return null;
	}

	internal void SetIdForNode(HtmlNode node, string id)
	{
		if (OptionUseIdAttribute && Nodesid != null && id != null)
		{
			if (node == null)
			{
				Nodesid.Remove(id);
			}
			else
			{
				Nodesid[id] = node;
			}
		}
	}

	internal void UpdateLastParentNode()
	{
		do
		{
			if (_lastparentnode.Closed)
			{
				_lastparentnode = _lastparentnode.ParentNode;
			}
		}
		while (_lastparentnode != null && _lastparentnode.Closed);
		if (_lastparentnode == null)
		{
			_lastparentnode = _documentnode;
		}
	}

	private void AddError(HtmlParseErrorCode code, int line, int linePosition, int streamPosition, string sourceText, string reason)
	{
		HtmlParseError item = new HtmlParseError(code, line, linePosition, streamPosition, sourceText, reason);
		_parseerrors.Add(item);
	}

	private void CloseCurrentNode()
	{
		if (_currentnode.Closed)
		{
			return;
		}
		bool flag = false;
		HtmlNode dictionaryValueOrDefault = Utilities.GetDictionaryValueOrDefault(Lastnodes, _currentnode.Name);
		if (dictionaryValueOrDefault == null)
		{
			if (HtmlNode.IsClosedElement(_currentnode.Name))
			{
				_currentnode.CloseNode(_currentnode);
				if (_lastparentnode != null)
				{
					HtmlNode htmlNode = null;
					Stack<HtmlNode> stack = new Stack<HtmlNode>();
					if (!_currentnode.Name.Equals("br"))
					{
						for (HtmlNode htmlNode2 = _lastparentnode.LastChild; htmlNode2 != null; htmlNode2 = htmlNode2.PreviousSibling)
						{
							if (htmlNode2.Name == _currentnode.Name && !htmlNode2.HasChildNodes)
							{
								htmlNode = htmlNode2;
								break;
							}
							stack.Push(htmlNode2);
						}
					}
					if (htmlNode != null)
					{
						while (stack.Count != 0)
						{
							HtmlNode htmlNode3 = stack.Pop();
							_lastparentnode.RemoveChild(htmlNode3);
							htmlNode.AppendChild(htmlNode3);
						}
					}
					else
					{
						_lastparentnode.AppendChild(_currentnode);
					}
				}
			}
			else if (HtmlNode.CanOverlapElement(_currentnode.Name))
			{
				HtmlNode htmlNode4 = CreateNode(HtmlNodeType.Text, _currentnode._outerstartindex);
				htmlNode4._outerlength = _currentnode._outerlength;
				((HtmlTextNode)htmlNode4).Text = ((HtmlTextNode)htmlNode4).Text.ToLowerInvariant();
				if (_lastparentnode != null)
				{
					_lastparentnode.AppendChild(htmlNode4);
				}
			}
			else if (HtmlNode.IsEmptyElement(_currentnode.Name))
			{
				AddError(HtmlParseErrorCode.EndTagNotRequired, _currentnode._line, _currentnode._lineposition, _currentnode._streamposition, _currentnode.OuterHtml, "End tag </" + _currentnode.Name + "> is not required");
			}
			else
			{
				AddError(HtmlParseErrorCode.TagNotOpened, _currentnode._line, _currentnode._lineposition, _currentnode._streamposition, _currentnode.OuterHtml, "Start tag <" + _currentnode.Name + "> was not found");
				flag = true;
			}
		}
		else
		{
			if (OptionFixNestedTags && FindResetterNodes(dictionaryValueOrDefault, GetResetters(_currentnode.Name)))
			{
				AddError(HtmlParseErrorCode.EndTagInvalidHere, _currentnode._line, _currentnode._lineposition, _currentnode._streamposition, _currentnode.OuterHtml, "End tag </" + _currentnode.Name + "> invalid here");
				flag = true;
			}
			if (!flag)
			{
				Lastnodes[_currentnode.Name] = dictionaryValueOrDefault._prevwithsamename;
				dictionaryValueOrDefault.CloseNode(_currentnode);
			}
		}
		if (!flag && _lastparentnode != null && (!HtmlNode.IsClosedElement(_currentnode.Name) || _currentnode._starttag))
		{
			UpdateLastParentNode();
		}
	}

	private string CurrentNodeName()
	{
		return Text.Substring(_currentnode._namestartindex, _currentnode._namelength);
	}

	private void DecrementPosition()
	{
		_index--;
		if (_lineposition == 0)
		{
			_lineposition = _maxlineposition;
			_line--;
		}
		else
		{
			_lineposition--;
		}
	}

	private HtmlNode FindResetterNode(HtmlNode node, string name)
	{
		HtmlNode dictionaryValueOrDefault = Utilities.GetDictionaryValueOrDefault(Lastnodes, name);
		if (dictionaryValueOrDefault == null)
		{
			return null;
		}
		if (dictionaryValueOrDefault.Closed)
		{
			return null;
		}
		if (dictionaryValueOrDefault._streamposition < node._streamposition)
		{
			return null;
		}
		return dictionaryValueOrDefault;
	}

	private bool FindResetterNodes(HtmlNode node, string[] names)
	{
		if (names == null)
		{
			return false;
		}
		for (int i = 0; i < names.Length; i++)
		{
			if (FindResetterNode(node, names[i]) != null)
			{
				return true;
			}
		}
		return false;
	}

	private void FixNestedTag(string name, string[] resetters)
	{
		if (resetters != null)
		{
			HtmlNode dictionaryValueOrDefault = Utilities.GetDictionaryValueOrDefault(Lastnodes, _currentnode.Name);
			if (dictionaryValueOrDefault != null && !Lastnodes[name].Closed && !FindResetterNodes(dictionaryValueOrDefault, resetters))
			{
				HtmlNode htmlNode = new HtmlNode(dictionaryValueOrDefault.NodeType, this, -1);
				htmlNode._endnode = htmlNode;
				dictionaryValueOrDefault.CloseNode(htmlNode);
			}
		}
	}

	private void FixNestedTags()
	{
		if (_currentnode._starttag)
		{
			string name = CurrentNodeName();
			FixNestedTag(name, GetResetters(name));
		}
	}

	private string[] GetResetters(string name)
	{
		if (!HtmlResetters.TryGetValue(name, out var value))
		{
			return null;
		}
		return value;
	}

	private void IncrementPosition()
	{
		if (_crc32 != null)
		{
			_crc32.AddToCRC32(_c);
		}
		_index++;
		_maxlineposition = _lineposition;
		if (_c == 10)
		{
			_lineposition = 0;
			_line++;
		}
		else
		{
			_lineposition++;
		}
	}

	private bool IsValidTag()
	{
		if (_c == 60 && _index < Text.Length)
		{
			if (!char.IsLetter(Text[_index]) && Text[_index] != '/' && Text[_index] != '?' && Text[_index] != '!')
			{
				return Text[_index] == '%';
			}
			return true;
		}
		return false;
	}

	private bool NewCheck()
	{
		if (_c != 60 || !IsValidTag())
		{
			return false;
		}
		if (_index < Text.Length && Text[_index] == '%')
		{
			if (DisableServerSideCode)
			{
				return false;
			}
			switch (_state)
			{
			case ParseState.AttributeAfterEquals:
				PushAttributeValueStart(_index - 1);
				break;
			case ParseState.BetweenAttributes:
				PushAttributeNameStart(_index - 1, _lineposition - 1);
				break;
			case ParseState.WhichTag:
				PushNodeNameStart(starttag: true, _index - 1);
				_state = ParseState.Tag;
				break;
			}
			_oldstate = _state;
			_state = ParseState.ServerSideCode;
			return true;
		}
		if (!PushNodeEnd(_index - 1, close: true))
		{
			_index = Text.Length;
			return true;
		}
		_state = ParseState.WhichTag;
		if (_index - 1 <= Text.Length - 2 && (Text[_index] == '!' || Text[_index] == '?'))
		{
			PushNodeStart(HtmlNodeType.Comment, _index - 1, _lineposition - 1);
			PushNodeNameStart(starttag: true, _index);
			PushNodeNameEnd(_index + 1);
			_state = ParseState.Comment;
			if (_index < Text.Length - 2)
			{
				if (Text[_index + 1] == '-' && Text[_index + 2] == '-')
				{
					_fullcomment = true;
				}
				else
				{
					_fullcomment = false;
				}
			}
			return true;
		}
		PushNodeStart(HtmlNodeType.Element, _index - 1, _lineposition - 1);
		return true;
	}

	private void Parse()
	{
		if (ParseExecuting != null)
		{
			ParseExecuting(this);
		}
		int num = 0;
		if (OptionComputeChecksum)
		{
			_crc32 = new Crc32();
		}
		Lastnodes = new Dictionary<string, HtmlNode>();
		_c = 0;
		_fullcomment = false;
		_parseerrors = new List<HtmlParseError>();
		_line = 1;
		_lineposition = 0;
		_maxlineposition = 0;
		_state = ParseState.Text;
		_oldstate = _state;
		_documentnode._innerlength = Text.Length;
		_documentnode._outerlength = Text.Length;
		_remainderOffset = Text.Length;
		_lastparentnode = _documentnode;
		_currentnode = CreateNode(HtmlNodeType.Text, 0);
		_currentattribute = null;
		_index = 0;
		PushNodeStart(HtmlNodeType.Text, 0, _lineposition);
		while (_index < Text.Length)
		{
			_c = Text[_index];
			IncrementPosition();
			switch (_state)
			{
			case ParseState.Text:
				if (!NewCheck())
				{
				}
				break;
			case ParseState.WhichTag:
				if (!NewCheck())
				{
					if (_c == 47)
					{
						PushNodeNameStart(starttag: false, _index);
					}
					else
					{
						PushNodeNameStart(starttag: true, _index - 1);
						DecrementPosition();
					}
					_state = ParseState.Tag;
				}
				break;
			case ParseState.Tag:
				if (NewCheck())
				{
					break;
				}
				if (IsWhiteSpace(_c))
				{
					CloseParentImplicitExplicitNode();
					PushNodeNameEnd(_index - 1);
					if (_state == ParseState.Tag)
					{
						_state = ParseState.BetweenAttributes;
					}
				}
				else if (_c == 47)
				{
					CloseParentImplicitExplicitNode();
					PushNodeNameEnd(_index - 1);
					if (_state == ParseState.Tag)
					{
						_state = ParseState.EmptyTag;
					}
				}
				else
				{
					if (_c != 62)
					{
						break;
					}
					CloseParentImplicitExplicitNode();
					PushNodeNameEnd(_index - 1);
					if (_state == ParseState.Tag)
					{
						if (!PushNodeEnd(_index, close: false))
						{
							_index = Text.Length;
						}
						else if (_state == ParseState.Tag)
						{
							_state = ParseState.Text;
							PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
						}
					}
				}
				break;
			case ParseState.BetweenAttributes:
				if (NewCheck() || IsWhiteSpace(_c))
				{
					break;
				}
				if (_c == 47 || _c == 63)
				{
					_state = ParseState.EmptyTag;
				}
				else if (_c == 62)
				{
					if (!PushNodeEnd(_index, close: false))
					{
						_index = Text.Length;
					}
					else if (_state == ParseState.BetweenAttributes)
					{
						_state = ParseState.Text;
						PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
					}
				}
				else
				{
					PushAttributeNameStart(_index - 1, _lineposition - 1);
					_state = ParseState.AttributeName;
				}
				break;
			case ParseState.EmptyTag:
				if (NewCheck())
				{
					break;
				}
				if (_c == 62)
				{
					if (!PushNodeEnd(_index, close: true))
					{
						_index = Text.Length;
					}
					else if (_state == ParseState.EmptyTag)
					{
						_state = ParseState.Text;
						PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
					}
				}
				else if (!IsWhiteSpace(_c))
				{
					DecrementPosition();
					_state = ParseState.BetweenAttributes;
				}
				else
				{
					_state = ParseState.BetweenAttributes;
				}
				break;
			case ParseState.AttributeName:
				if (NewCheck())
				{
					break;
				}
				_currentattribute._isFromParse = true;
				if (_c == 47)
				{
					PushAttributeNameEnd(_index - 1);
					_state = ParseState.AttributeBeforeEquals;
				}
				else if (IsWhiteSpace(_c))
				{
					PushAttributeNameEnd(_index - 1);
					_state = ParseState.AttributeBeforeEquals;
				}
				else if (_c == 61)
				{
					PushAttributeNameEnd(_index - 1);
					_currentattribute._hasEqual = true;
					_state = ParseState.AttributeAfterEquals;
				}
				else if (_c == 62)
				{
					PushAttributeNameEnd(_index - 1);
					if (!PushNodeEnd(_index, close: false))
					{
						_index = Text.Length;
					}
					else if (_state == ParseState.AttributeName)
					{
						_state = ParseState.Text;
						PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
					}
				}
				break;
			case ParseState.AttributeBeforeEquals:
				if (NewCheck() || IsWhiteSpace(_c))
				{
					break;
				}
				if (_c == 62)
				{
					if (!PushNodeEnd(_index, close: false))
					{
						_index = Text.Length;
					}
					else if (_state == ParseState.AttributeBeforeEquals)
					{
						_state = ParseState.Text;
						PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
					}
				}
				else if (_c == 61)
				{
					_currentattribute._hasEqual = true;
					_state = ParseState.AttributeAfterEquals;
				}
				else
				{
					_state = ParseState.BetweenAttributes;
					DecrementPosition();
				}
				break;
			case ParseState.AttributeAfterEquals:
				if (NewCheck() || IsWhiteSpace(_c))
				{
					break;
				}
				if (_c == 39 || _c == 34)
				{
					_state = ParseState.QuotedAttributeValue;
					PushAttributeValueStart(_index, _c);
					num = _c;
				}
				else if (_c == 62)
				{
					if (!PushNodeEnd(_index, close: false))
					{
						_index = Text.Length;
					}
					else if (_state == ParseState.AttributeAfterEquals)
					{
						_state = ParseState.Text;
						PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
					}
				}
				else
				{
					PushAttributeValueStart(_index - 1);
					_state = ParseState.AttributeValue;
				}
				break;
			case ParseState.AttributeValue:
				if (NewCheck())
				{
					break;
				}
				if (IsWhiteSpace(_c))
				{
					PushAttributeValueEnd(_index - 1);
					_state = ParseState.BetweenAttributes;
				}
				else if (_c == 62)
				{
					PushAttributeValueEnd(_index - 1);
					if (!PushNodeEnd(_index, close: false))
					{
						_index = Text.Length;
					}
					else if (_state == ParseState.AttributeValue)
					{
						_state = ParseState.Text;
						PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
					}
				}
				break;
			case ParseState.QuotedAttributeValue:
				if (_c == num)
				{
					PushAttributeValueEnd(_index - 1);
					_state = ParseState.BetweenAttributes;
				}
				else if (_c == 60 && _index < Text.Length && Text[_index] == '%')
				{
					_oldstate = _state;
					_state = ParseState.ServerSideCode;
				}
				break;
			case ParseState.Comment:
				if (_c == 62 && (!_fullcomment || (Text[_index - 2] == '-' && Text[_index - 3] == '-') || (Text[_index - 2] == '!' && Text[_index - 3] == '-' && Text[_index - 4] == '-')))
				{
					if (!PushNodeEnd(_index, close: false))
					{
						_index = Text.Length;
						break;
					}
					_state = ParseState.Text;
					PushNodeStart(HtmlNodeType.Text, _index, _lineposition);
				}
				break;
			case ParseState.ServerSideCode:
				if (_c == 37)
				{
					if (_index < Text.Length && Text[_index] == '>')
					{
						switch (_oldstate)
						{
						case ParseState.AttributeAfterEquals:
							_state = ParseState.AttributeValue;
							break;
						case ParseState.BetweenAttributes:
							PushAttributeNameEnd(_index + 1);
							_state = ParseState.BetweenAttributes;
							break;
						default:
							_state = _oldstate;
							break;
						}
						IncrementPosition();
					}
				}
				else if (_oldstate == ParseState.QuotedAttributeValue && _c == num)
				{
					_state = _oldstate;
					DecrementPosition();
				}
				break;
			case ParseState.PcData:
			{
				if (_currentnode._namelength + 3 > Text.Length - (_index - 1) || string.Compare(Text.Substring(_index - 1, _currentnode._namelength + 2), "</" + _currentnode.Name, StringComparison.OrdinalIgnoreCase) != 0)
				{
					break;
				}
				int num2 = Text[_index - 1 + 2 + _currentnode.Name.Length];
				if (num2 == 62 || IsWhiteSpace(num2))
				{
					HtmlNode htmlNode = CreateNode(HtmlNodeType.Text, _currentnode._outerstartindex + _currentnode._outerlength);
					htmlNode._outerlength = _index - 1 - htmlNode._outerstartindex;
					htmlNode._streamposition = htmlNode._outerstartindex;
					htmlNode._line = _currentnode.Line;
					htmlNode._lineposition = _currentnode.LinePosition + _currentnode._namelength + 2;
					_currentnode.AppendChild(htmlNode);
					if (_currentnode.Name.ToLowerInvariant().Equals("script") || _currentnode.Name.ToLowerInvariant().Equals("style"))
					{
						_currentnode._isHideInnerText = true;
					}
					PushNodeStart(HtmlNodeType.Element, _index - 1, _lineposition - 1);
					PushNodeNameStart(starttag: false, _index - 1 + 2);
					_state = ParseState.Tag;
					IncrementPosition();
				}
				break;
			}
			}
		}
		if (_currentnode._namestartindex > 0)
		{
			PushNodeNameEnd(_index);
		}
		PushNodeEnd(_index, close: false);
		Lastnodes.Clear();
	}

	private void PushAttributeNameEnd(int index)
	{
		_currentattribute._namelength = index - _currentattribute._namestartindex;
		if (_currentattribute.Name != null && !BlockAttributes.Contains(_currentattribute.Name))
		{
			_currentnode.Attributes.Append(_currentattribute);
		}
	}

	private void PushAttributeNameStart(int index, int lineposition)
	{
		_currentattribute = CreateAttribute();
		_currentattribute._namestartindex = index;
		_currentattribute.Line = _line;
		_currentattribute._lineposition = lineposition;
		_currentattribute._streamposition = index;
	}

	private void PushAttributeValueEnd(int index)
	{
		_currentattribute._valuelength = index - _currentattribute._valuestartindex;
	}

	private void PushAttributeValueStart(int index)
	{
		PushAttributeValueStart(index, 0);
	}

	private void CloseParentImplicitExplicitNode()
	{
		bool flag = true;
		while (flag && !_lastparentnode.Closed)
		{
			flag = false;
			bool flag2 = false;
			if (IsParentImplicitEnd())
			{
				if (OptionOutputAsXml)
				{
					flag2 = true;
				}
				else
				{
					CloseParentImplicitEnd();
					flag = true;
				}
			}
			if (flag2 || IsParentExplicitEnd())
			{
				CloseParentExplicitEnd();
				flag = true;
			}
		}
	}

	private bool IsParentImplicitEnd()
	{
		if (!_currentnode._starttag)
		{
			return false;
		}
		bool result = false;
		string name = _lastparentnode.Name;
		string text = Text.Substring(_currentnode._namestartindex, _index - _currentnode._namestartindex - 1).ToLowerInvariant();
		switch (name)
		{
		case "a":
			result = text == "a";
			break;
		case "dd":
			result = text == "dt" || text == "dd";
			break;
		case "dt":
			result = text == "dt" || text == "dd";
			break;
		case "li":
			result = text == "li";
			break;
		case "p":
			if (DisableBehaviorTagP)
			{
				int num;
				switch (text)
				{
				default:
					num = ((text == "ul") ? 1 : 0);
					break;
				case "address":
				case "article":
				case "aside":
				case "blockquote":
				case "dir":
				case "div":
				case "dl":
				case "fieldset":
				case "footer":
				case "form":
				case "h1":
				case "h2":
				case "h3":
				case "h4":
				case "h5":
				case "h6":
				case "header":
				case "hr":
				case "li":
				case "menu":
				case "nav":
				case "ol":
				case "p":
				case "pre":
				case "section":
				case "table":
					num = 1;
					break;
				}
				result = (byte)num != 0;
			}
			else
			{
				result = text == "p";
			}
			break;
		case "option":
			result = text == "option";
			break;
		}
		return result;
	}

	private bool IsParentExplicitEnd()
	{
		if (!_currentnode._starttag)
		{
			return false;
		}
		bool result = false;
		string name = _lastparentnode.Name;
		string text = Text.Substring(_currentnode._namestartindex, _index - _currentnode._namestartindex - 1).ToLowerInvariant();
		switch (name)
		{
		case "title":
			result = text == "title";
			break;
		case "p":
			result = text == "div";
			break;
		case "table":
			result = text == "table";
			break;
		case "tr":
			result = text == "tr";
			break;
		case "td":
			result = text == "td" || text == "th" || text == "tr";
			break;
		case "th":
			result = text == "td" || text == "th" || text == "tr";
			break;
		case "h1":
		{
			int num5;
			switch (text)
			{
			default:
				num5 = ((text == "h5") ? 1 : 0);
				break;
			case "h2":
			case "h3":
			case "h4":
				num5 = 1;
				break;
			}
			result = (byte)num5 != 0;
			break;
		}
		case "h2":
		{
			int num4;
			switch (text)
			{
			default:
				num4 = ((text == "h5") ? 1 : 0);
				break;
			case "h1":
			case "h3":
			case "h4":
				num4 = 1;
				break;
			}
			result = (byte)num4 != 0;
			break;
		}
		case "h3":
		{
			int num3;
			switch (text)
			{
			default:
				num3 = ((text == "h5") ? 1 : 0);
				break;
			case "h1":
			case "h2":
			case "h4":
				num3 = 1;
				break;
			}
			result = (byte)num3 != 0;
			break;
		}
		case "h4":
		{
			int num2;
			switch (text)
			{
			default:
				num2 = ((text == "h5") ? 1 : 0);
				break;
			case "h1":
			case "h2":
			case "h3":
				num2 = 1;
				break;
			}
			result = (byte)num2 != 0;
			break;
		}
		case "h5":
		{
			int num;
			switch (text)
			{
			default:
				num = ((text == "h4") ? 1 : 0);
				break;
			case "h1":
			case "h2":
			case "h3":
				num = 1;
				break;
			}
			result = (byte)num != 0;
			break;
		}
		}
		return result;
	}

	private void CloseParentImplicitEnd()
	{
		HtmlNode htmlNode = new HtmlNode(_lastparentnode.NodeType, this, -1);
		htmlNode._endnode = htmlNode;
		htmlNode._isImplicitEnd = true;
		_lastparentnode._isImplicitEnd = true;
		_lastparentnode.CloseNode(htmlNode);
	}

	private void CloseParentExplicitEnd()
	{
		HtmlNode htmlNode = new HtmlNode(_lastparentnode.NodeType, this, -1);
		htmlNode._endnode = htmlNode;
		_lastparentnode.CloseNode(htmlNode);
	}

	private void PushAttributeValueStart(int index, int quote)
	{
		_currentattribute._valuestartindex = index;
		if (quote == 39)
		{
			_currentattribute.QuoteType = AttributeValueQuote.SingleQuote;
		}
		_currentattribute.InternalQuoteType = _currentattribute.QuoteType;
		if (quote == 0)
		{
			_currentattribute.InternalQuoteType = AttributeValueQuote.None;
		}
	}

	private bool PushNodeEnd(int index, bool close)
	{
		_currentnode._outerlength = index - _currentnode._outerstartindex;
		if (_currentnode._nodetype == HtmlNodeType.Text || _currentnode._nodetype == HtmlNodeType.Comment)
		{
			if (_currentnode._outerlength > 0)
			{
				_currentnode._innerlength = _currentnode._outerlength;
				_currentnode._innerstartindex = _currentnode._outerstartindex;
				if (_lastparentnode != null)
				{
					_lastparentnode.AppendChild(_currentnode);
				}
			}
		}
		else if (_currentnode._starttag && _lastparentnode != _currentnode)
		{
			if (_lastparentnode != null)
			{
				_lastparentnode.AppendChild(_currentnode);
			}
			ReadDocumentEncoding(_currentnode);
			HtmlNode dictionaryValueOrDefault = Utilities.GetDictionaryValueOrDefault(Lastnodes, _currentnode.Name);
			_currentnode._prevwithsamename = dictionaryValueOrDefault;
			Lastnodes[_currentnode.Name] = _currentnode;
			if (_currentnode.NodeType == HtmlNodeType.Document || _currentnode.NodeType == HtmlNodeType.Element)
			{
				_lastparentnode = _currentnode;
			}
			if (HtmlNode.IsCDataElement(CurrentNodeName()))
			{
				_state = ParseState.PcData;
				return true;
			}
			if (HtmlNode.IsClosedElement(_currentnode.Name) || HtmlNode.IsEmptyElement(_currentnode.Name))
			{
				close = true;
			}
		}
		if (close || !_currentnode._starttag)
		{
			if (OptionStopperNodeName != null && _remainder == null && string.Compare(_currentnode.Name, OptionStopperNodeName, StringComparison.OrdinalIgnoreCase) == 0)
			{
				_remainderOffset = index;
				_remainder = Text.Substring(_remainderOffset);
				CloseCurrentNode();
				return false;
			}
			CloseCurrentNode();
		}
		return true;
	}

	private void PushNodeNameEnd(int index)
	{
		_currentnode._namelength = index - _currentnode._namestartindex;
		if (OptionFixNestedTags)
		{
			FixNestedTags();
		}
	}

	private void PushNodeNameStart(bool starttag, int index)
	{
		_currentnode._starttag = starttag;
		_currentnode._namestartindex = index;
	}

	private void PushNodeStart(HtmlNodeType type, int index, int lineposition)
	{
		_currentnode = CreateNode(type, index);
		_currentnode._line = _line;
		_currentnode._lineposition = lineposition;
		_currentnode._streamposition = index;
	}

	private void ReadDocumentEncoding(HtmlNode node)
	{
		if (!OptionReadEncoding || node._namelength != 4 || node.Name != "meta")
		{
			return;
		}
		string text = null;
		HtmlAttribute htmlAttribute = node.Attributes["http-equiv"];
		if (htmlAttribute != null)
		{
			if (string.Compare(htmlAttribute.Value, "content-type", StringComparison.OrdinalIgnoreCase) != 0)
			{
				return;
			}
			HtmlAttribute htmlAttribute2 = node.Attributes["content"];
			if (htmlAttribute2 != null)
			{
				text = NameValuePairList.GetNameValuePairsValue(htmlAttribute2.Value, "charset");
			}
		}
		else
		{
			htmlAttribute = node.Attributes["charset"];
			if (htmlAttribute != null)
			{
				text = htmlAttribute.Value;
			}
		}
		if (!string.IsNullOrEmpty(text))
		{
			if (string.Equals(text, "utf8", StringComparison.OrdinalIgnoreCase))
			{
				text = "utf-8";
			}
			try
			{
				_declaredencoding = Encoding.GetEncoding(text);
			}
			catch (ArgumentException)
			{
				_declaredencoding = null;
			}
			if (_onlyDetectEncoding)
			{
				throw new EncodingFoundException(_declaredencoding);
			}
			if (_streamencoding != null && _declaredencoding != null && _declaredencoding.CodePage != _streamencoding.CodePage)
			{
				AddError(HtmlParseErrorCode.CharsetMismatch, _line, _lineposition, _index, node.OuterHtml, "Encoding mismatch between StreamEncoding: " + _streamencoding.WebName + " and DeclaredEncoding: " + _declaredencoding.WebName);
			}
		}
	}

	public void DetectEncodingAndLoad(string path)
	{
		DetectEncodingAndLoad(path, detectEncoding: true);
	}

	public void DetectEncodingAndLoad(string path, bool detectEncoding)
	{
		if (path == null)
		{
			throw new ArgumentNullException("path");
		}
		Encoding encoding = ((!detectEncoding) ? null : DetectEncoding(path));
		if (encoding == null)
		{
			Load(path);
		}
		else
		{
			Load(path, encoding);
		}
	}

	public Encoding DetectEncoding(string path)
	{
		if (path == null)
		{
			throw new ArgumentNullException("path");
		}
		using StreamReader reader = new StreamReader(path, OptionDefaultStreamEncoding);
		return DetectEncoding(reader);
	}

	public void Load(string path)
	{
		if (path == null)
		{
			throw new ArgumentNullException("path");
		}
		using StreamReader reader = new StreamReader(path, OptionDefaultStreamEncoding);
		Load(reader);
	}

	public void Load(string path, bool detectEncodingFromByteOrderMarks)
	{
		if (path == null)
		{
			throw new ArgumentNullException("path");
		}
		using StreamReader reader = new StreamReader(path, detectEncodingFromByteOrderMarks);
		Load(reader);
	}

	public void Load(string path, Encoding encoding)
	{
		if (path == null)
		{
			throw new ArgumentNullException("path");
		}
		if (encoding == null)
		{
			throw new ArgumentNullException("encoding");
		}
		using StreamReader reader = new StreamReader(path, encoding);
		Load(reader);
	}

	public void Load(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks)
	{
		if (path == null)
		{
			throw new ArgumentNullException("path");
		}
		if (encoding == null)
		{
			throw new ArgumentNullException("encoding");
		}
		using StreamReader reader = new StreamReader(path, encoding, detectEncodingFromByteOrderMarks);
		Load(reader);
	}

	public void Load(string path, Encoding encoding, bool detectEncodingFromByteOrderMarks, int buffersize)
	{
		if (path == null)
		{
			throw new ArgumentNullException("path");
		}
		if (encoding == null)
		{
			throw new ArgumentNullException("encoding");
		}
		using StreamReader reader = new StreamReader(path, encoding, detectEncodingFromByteOrderMarks, buffersize);
		Load(reader);
	}

	public void Save(string filename)
	{
		using StreamWriter writer = new StreamWriter(filename, append: false, GetOutEncoding());
		Save(writer);
	}

	public void Save(string filename, Encoding encoding)
	{
		if (filename == null)
		{
			throw new ArgumentNullException("filename");
		}
		if (encoding == null)
		{
			throw new ArgumentNullException("encoding");
		}
		using StreamWriter writer = new StreamWriter(filename, append: false, encoding);
		Save(writer);
	}

	public XPathNavigator CreateNavigator()
	{
		return new HtmlNodeNavigator(this, _documentnode);
	}
}
[Flags]
public enum HtmlElementFlag
{
	CData = 1,
	Empty = 2,
	Closed = 4,
	CanOverlap = 8
}
public class HtmlEntity
{
	private enum ParseState
	{
		Text,
		EntityStart
	}

	private static readonly int _maxEntitySize;

	private static Dictionary<int, string> _entityName;

	private static Dictionary<string, int> _entityValue;

	public static bool UseWebUtility { get; set; }

	public static Dictionary<int, string> EntityName => _entityName;

	public static Dictionary<string, int> EntityValue => _entityValue;

	static HtmlEntity()
	{
		_entityName = new Dictionary<int, string>();
		_entityValue = new Dictionary<string, int>();
		_entityValue.Add("quot", 34);
		_entityName.Add(34, "quot");
		_entityValue.Add("amp", 38);
		_entityName.Add(38, "amp");
		_entityValue.Add("apos", 39);
		_entityName.Add(39, "apos");
		_entityValue.Add("lt", 60);
		_entityName.Add(60, "lt");
		_entityValue.Add("gt", 62);
		_entityName.Add(62, "gt");
		_entityValue.Add("nbsp", 160);
		_entityName.Add(160, "nbsp");
		_entityValue.Add("iexcl", 161);
		_entityName.Add(161, "iexcl");
		_entityValue.Add("cent", 162);
		_entityName.Add(162, "cent");
		_entityValue.Add("pound", 163);
		_entityName.Add(163, "pound");
		_entityValue.Add("curren", 164);
		_entityName.Add(164, "curren");
		_entityValue.Add("yen", 165);
		_entityName.Add(165, "yen");
		_entityValue.Add("brvbar", 166);
		_entityName.Add(166, "brvbar");
		_entityValue.Add("sect", 167);
		_entityName.Add(167, "sect");
		_entityValue.Add("uml", 168);
		_entityName.Add(168, "uml");
		_entityValue.Add("copy", 169);
		_entityName.Add(169, "copy");
		_entityValue.Add("ordf", 170);
		_entityName.Add(170, "ordf");
		_entityValue.Add("laquo", 171);
		_entityName.Add(171, "laquo");
		_entityValue.Add("not", 172);
		_entityName.Add(172, "not");
		_entityValue.Add("shy", 173);
		_entityName.Add(173, "shy");
		_entityValue.Add("reg", 174);
		_entityName.Add(174, "reg");
		_entityValue.Add("macr", 175);
		_entityName.Add(175, "macr");
		_entityValue.Add("deg", 176);
		_entityName.Add(176, "deg");
		_entityValue.Add("plusmn", 177);
		_entityName.Add(177, "plusmn");
		_entityValue.Add("sup2", 178);
		_entityName.Add(178, "sup2");
		_entityValue.Add("sup3", 179);
		_entityName.Add(179, "sup3");
		_entityValue.Add("acute", 180);
		_entityName.Add(180, "acute");
		_entityValue.Add("micro", 181);
		_entityName.Add(181, "micro");
		_entityValue.Add("para", 182);
		_entityName.Add(182, "para");
		_entityValue.Add("middot", 183);
		_entityName.Add(183, "middot");
		_entityValue.Add("cedil", 184);
		_entityName.Add(184, "cedil");
		_entityValue.Add("sup1", 185);
		_entityName.Add(185, "sup1");
		_entityValue.Add("ordm", 186);
		_entityName.Add(186, "ordm");
		_entityValue.Add("raquo", 187);
		_entityName.Add(187, "raquo");
		_entityValue.Add("frac14", 188);
		_entityName.Add(188, "frac14");
		_entityValue.Add("frac12", 189);
		_entityName.Add(189, "frac12");
		_entityValue.Add("frac34", 190);
		_entityName.Add(190, "frac34");
		_entityValue.Add("iquest", 191);
		_entityName.Add(191, "iquest");
		_entityValue.Add("Agrave", 192);
		_entityName.Add(192, "Agrave");
		_entityValue.Add("Aacute", 193);
		_entityName.Add(193, "Aacute");
		_entityValue.Add("Acirc", 194);
		_entityName.Add(194, "Acirc");
		_entityValue.Add("Atilde", 195);
		_entityName.Add(195, "Atilde");
		_entityValue.Add("Auml", 196);
		_entityName.Add(196, "Auml");
		_entityValue.Add("Aring", 197);
		_entityName.Add(197, "Aring");
		_entityValue.Add("AElig", 198);
		_entityName.Add(198, "AElig");
		_entityValue.Add("Ccedil", 199);
		_entityName.Add(199, "Ccedil");
		_entityValue.Add("Egrave", 200);
		_entityName.Add(200, "Egrave");
		_entityValue.Add("Eacute", 201);
		_entityName.Add(201, "Eacute");
		_entityValue.Add("Ecirc", 202);
		_entityName.Add(202, "Ecirc");
		_entityValue.Add("Euml", 203);
		_entityName.Add(203, "Euml");
		_entityValue.Add("Igrave", 204);
		_entityName.Add(204, "Igrave");
		_entityValue.Add("Iacute", 205);
		_entityName.Add(205, "Iacute");
		_entityValue.Add("Icirc", 206);
		_entityName.Add(206, "Icirc");
		_entityValue.Add("Iuml", 207);
		_entityName.Add(207, "Iuml");
		_entityValue.Add("ETH", 208);
		_entityName.Add(208, "ETH");
		_entityValue.Add("Ntilde", 209);
		_entityName.Add(209, "Ntilde");
		_entityValue.Add("Ograve", 210);
		_entityName.Add(210, "Ograve");
		_entityValue.Add("Oacute", 211);
		_entityName.Add(211, "Oacute");
		_entityValue.Add("Ocirc", 212);
		_entityName.Add(212, "Ocirc");
		_entityValue.Add("Otilde", 213);
		_entityName.Add(213, "Otilde");
		_entityValue.Add("Ouml", 214);
		_entityName.Add(214, "Ouml");
		_entityValue.Add("times", 215);
		_entityName.Add(215, "times");
		_entityValue.Add("Oslash", 216);
		_entityName.Add(216, "Oslash");
		_entityValue.Add("Ugrave", 217);
		_entityName.Add(217, "Ugrave");
		_entityValue.Add("Uacute", 218);
		_entityName.Add(218, "Uacute");
		_entityValue.Add("Ucirc", 219);
		_entityName.Add(219, "Ucirc");
		_entityValue.Add("Uuml", 220);
		_entityName.Add(220, "Uuml");
		_entityValue.Add("Yacute", 221);
		_entityName.Add(221, "Yacute");
		_entityValue.Add("THORN", 222);
		_entityName.Add(222, "THORN");
		_entityValue.Add("szlig", 223);
		_entityName.Add(223, "szlig");
		_entityValue.Add("agrave", 224);
		_entityName.Add(224, "agrave");
		_entityValue.Add("aacute", 225);
		_entityName.Add(225, "aacute");
		_entityValue.Add("acirc", 226);
		_entityName.Add(226, "acirc");
		_entityValue.Add("atilde", 227);
		_entityName.Add(227, "atilde");
		_entityValue.Add("auml", 228);
		_entityName.Add(228, "auml");
		_entityValue.Add("aring", 229);
		_entityName.Add(229, "aring");
		_entityValue.Add("aelig", 230);
		_entityName.Add(230, "aelig");
		_entityValue.Add("ccedil", 231);
		_entityName.Add(231, "ccedil");
		_entityValue.Add("egrave", 232);
		_entityName.Add(232, "egrave");
		_entityValue.Add("eacute", 233);
		_entityName.Add(233, "eacute");
		_entityValue.Add("ecirc", 234);
		_entityName.Add(234, "ecirc");
		_entityValue.Add("euml", 235);
		_entityName.Add(235, "euml");
		_entityValue.Add("igrave", 236);
		_entityName.Add(236, "igrave");
		_entityValue.Add("iacute", 237);
		_entityName.Add(237, "iacute");
		_entityValue.Add("icirc", 238);
		_entityName.Add(238, "icirc");
		_entityValue.Add("iuml", 239);
		_entityName.Add(239, "iuml");
		_entityValue.Add("eth", 240);
		_entityName.Add(240, "eth");
		_entityValue.Add("ntilde", 241);
		_entityName.Add(241, "ntilde");
		_entityValue.Add("ograve", 242);
		_entityName.Add(242, "ograve");
		_entityValue.Add("oacute", 243);
		_entityName.Add(243, "oacute");
		_entityValue.Add("ocirc", 244);
		_entityName.Add(244, "ocirc");
		_entityValue.Add("otilde", 245);
		_entityName.Add(245, "otilde");
		_entityValue.Add("ouml", 246);
		_entityName.Add(246, "ouml");
		_entityValue.Add("divide", 247);
		_entityName.Add(247, "divide");
		_entityValue.Add("oslash", 248);
		_entityName.Add(248, "oslash");
		_entityValue.Add("ugrave", 249);
		_entityName.Add(249, "ugrave");
		_entityValue.Add("uacute", 250);
		_entityName.Add(250, "uacute");
		_entityValue.Add("ucirc", 251);
		_entityName.Add(251, "ucirc");
		_entityValue.Add("uuml", 252);
		_entityName.Add(252, "uuml");
		_entityValue.Add("yacute", 253);
		_entityName.Add(253, "yacute");
		_entityValue.Add("thorn", 254);
		_entityName.Add(254, "thorn");
		_entityValue.Add("yuml", 255);
		_entityName.Add(255, "yuml");
		_entityValue.Add("fnof", 402);
		_entityName.Add(402, "fnof");
		_entityValue.Add("Alpha", 913);
		_entityName.Add(913, "Alpha");
		_entityValue.Add("Beta", 914);
		_entityName.Add(914, "Beta");
		_entityValue.Add("Gamma", 915);
		_entityName.Add(915, "Gamma");
		_entityValue.Add("Delta", 916);
		_entityName.Add(916, "Delta");
		_entityValue.Add("Epsilon", 917);
		_entityName.Add(917, "Epsilon");
		_entityValue.Add("Zeta", 918);
		_entityName.Add(918, "Zeta");
		_entityValue.Add("Eta", 919);
		_entityName.Add(919, "Eta");
		_entityValue.Add("Theta", 920);
		_entityName.Add(920, "Theta");
		_entityValue.Add("Iota", 921);
		_entityName.Add(921, "Iota");
		_entityValue.Add("Kappa", 922);
		_entityName.Add(922, "Kappa");
		_entityValue.Add("Lambda", 923);
		_entityName.Add(923, "Lambda");
		_entityValue.Add("Mu", 924);
		_entityName.Add(924, "Mu");
		_entityValue.Add("Nu", 925);
		_entityName.Add(925, "Nu");
		_entityValue.Add("Xi", 926);
		_entityName.Add(926, "Xi");
		_entityValue.Add("Omicron", 927);
		_entityName.Add(927, "Omicron");
		_entityValue.Add("Pi", 928);
		_entityName.Add(928, "Pi");
		_entityValue.Add("Rho", 929);
		_entityName.Add(929, "Rho");
		_entityValue.Add("Sigma", 931);
		_entityName.Add(931, "Sigma");
		_entityValue.Add("Tau", 932);
		_entityName.Add(932, "Tau");
		_entityValue.Add("Upsilon", 933);
		_entityName.Add(933, "Upsilon");
		_entityValue.Add("Phi", 934);
		_entityName.Add(934, "Phi");
		_entityValue.Add("Chi", 935);
		_entityName.Add(935, "Chi");
		_entityValue.Add("Psi", 936);
		_entityName.Add(936, "Psi");
		_entityValue.Add("Omega", 937);
		_entityName.Add(937, "Omega");
		_entityValue.Add("alpha", 945);
		_entityName.Add(945, "alpha");
		_entityValue.Add("beta", 946);
		_entityName.Add(946, "beta");
		_entityValue.Add("gamma", 947);
		_entityName.Add(947, "gamma");
		_entityValue.Add("delta", 948);
		_entityName.Add(948, "delta");
		_entityValue.Add("epsilon", 949);
		_entityName.Add(949, "epsilon");
		_entityValue.Add("zeta", 950);
		_entityName.Add(950, "zeta");
		_entityValue.Add("eta", 951);
		_entityName.Add(951, "eta");
		_entityValue.Add("theta", 952);
		_entityName.Add(952, "theta");
		_entityValue.Add("iota", 953);
		_entityName.Add(953, "iota");
		_entityValue.Add("kappa", 954);
		_entityName.Add(954, "kappa");
		_entityValue.Add("lambda", 955);
		_entityName.Add(955, "lambda");
		_entityValue.Add("mu", 956);
		_entityName.Add(956, "mu");
		_entityValue.Add("nu", 957);
		_entityName.Add(957, "nu");
		_entityValue.Add("xi", 958);
		_entityName.Add(958, "xi");
		_entityValue.Add("omicron", 959);
		_entityName.Add(959, "omicron");
		_entityValue.Add("pi", 960);
		_entityName.Add(960, "pi");
		_entityValue.Add("rho", 961);
		_entityName.Add(961, "rho");
		_entityValue.Add("sigmaf", 962);
		_entityName.Add(962, "sigmaf");
		_entityValue.Add("sigma", 963);
		_entityName.Add(963, "sigma");
		_entityValue.Add("tau", 964);
		_entityName.Add(964, "tau");
		_entityValue.Add("upsilon", 965);
		_entityName.Add(965, "upsilon");
		_entityValue.Add("phi", 966);
		_entityName.Add(966, "phi");
		_entityValue.Add("chi", 967);
		_entityName.Add(967, "chi");
		_entityValue.Add("psi", 968);
		_entityName.Add(968, "psi");
		_entityValue.Add("omega", 969);
		_entityName.Add(969, "omega");
		_entityValue.Add("thetasym", 977);
		_entityName.Add(977, "thetasym");
		_entityValue.Add("upsih", 978);
		_entityName.Add(978, "upsih");
		_entityValue.Add("piv", 982);
		_entityName.Add(982, "piv");
		_entityValue.Add("bull", 8226);
		_entityName.Add(8226, "bull");
		_entityValue.Add("hellip", 8230);
		_entityName.Add(8230, "hellip");
		_entityValue.Add("prime", 8242);
		_entityName.Add(8242, "prime");
		_entityValue.Add("Prime", 8243);
		_entityName.Add(8243, "Prime");
		_entityValue.Add("oline", 8254);
		_entityName.Add(8254, "oline");
		_entityValue.Add("frasl", 8260);
		_entityName.Add(8260, "frasl");
		_entityValue.Add("weierp", 8472);
		_entityName.Add(8472, "weierp");
		_entityValue.Add("image", 8465);
		_entityName.Add(8465, "image");
		_entityValue.Add("real", 8476);
		_entityName.Add(8476, "real");
		_entityValue.Add("trade", 8482);
		_entityName.Add(8482, "trade");
		_entityValue.Add("alefsym", 8501);
		_entityName.Add(8501, "alefsym");
		_entityValue.Add("larr", 8592);
		_entityName.Add(8592, "larr");
		_entityValue.Add("uarr", 8593);
		_entityName.Add(8593, "uarr");
		_entityValue.Add("rarr", 8594);
		_entityName.Add(8594, "rarr");
		_entityValue.Add("darr", 8595);
		_entityName.Add(8595, "darr");
		_entityValue.Add("harr", 8596);
		_entityName.Add(8596, "harr");
		_entityValue.Add("crarr", 8629);
		_entityName.Add(8629, "crarr");
		_entityValue.Add("lArr", 8656);
		_entityName.Add(8656, "lArr");
		_entityValue.Add("uArr", 8657);
		_entityName.Add(8657, "uArr");
		_entityValue.Add("rArr", 8658);
		_entityName.Add(8658, "rArr");
		_entityValue.Add("dArr", 8659);
		_entityName.Add(8659, "dArr");
		_entityValue.Add("hArr", 8660);
		_entityName.Add(8660, "hArr");
		_entityValue.Add("forall", 8704);
		_entityName.Add(8704, "forall");
		_entityValue.Add("part", 8706);
		_entityName.Add(8706, "part");
		_entityValue.Add("exist", 8707);
		_entityName.Add(8707, "exist");
		_entityValue.Add("empty", 8709);
		_entityName.Add(8709, "empty");
		_entityValue.Add("nabla", 8711);
		_entityName.Add(8711, "nabla");
		_entityValue.Add("isin", 8712);
		_entityName.Add(8712, "isin");
		_entityValue.Add("notin", 8713);
		_entityName.Add(8713, "notin");
		_entityValue.Add("ni", 8715);
		_entityName.Add(8715, "ni");
		_entityValue.Add("prod", 8719);
		_entityName.Add(8719, "prod");
		_entityValue.Add("sum", 8721);
		_entityName.Add(8721, "sum");
		_entityValue.Add("minus", 8722);
		_entityName.Add(8722, "minus");
		_entityValue.Add("lowast", 8727);
		_entityName.Add(8727, "lowast");
		_entityValue.Add("radic", 8730);
		_entityName.Add(8730, "radic");
		_entityValue.Add("prop", 8733);
		_entityName.Add(8733, "prop");
		_entityValue.Add("infin", 8734);
		_entityName.Add(8734, "infin");
		_entityValue.Add("ang", 8736);
		_entityName.Add(8736, "ang");
		_entityValue.Add("and", 8743);
		_entityName.Add(8743, "and");
		_entityValue.Add("or", 8744);
		_entityName.Add(8744, "or");
		_entityValue.Add("cap", 8745);
		_entityName.Add(8745, "cap");
		_entityValue.Add("cup", 8746);
		_entityName.Add(8746, "cup");
		_entityValue.Add("int", 8747);
		_entityName.Add(8747, "int");
		_entityValue.Add("there4", 8756);
		_entityName.Add(8756, "there4");
		_entityValue.Add("sim", 8764);
		_entityName.Add(8764, "sim");
		_entityValue.Add("cong", 8773);
		_entityName.Add(8773, "cong");
		_entityValue.Add("asymp", 8776);
		_entityName.Add(8776, "asymp");
		_entityValue.Add("ne", 8800);
		_entityName.Add(8800, "ne");
		_entityValue.Add("equiv", 8801);
		_entityName.Add(8801, "equiv");
		_entityValue.Add("le", 8804);
		_entityName.Add(8804, "le");
		_entityValue.Add("ge", 8805);
		_entityName.Add(8805, "ge");
		_entityValue.Add("sub", 8834);
		_entityName.Add(8834, "sub");
		_entityValue.Add("sup", 8835);
		_entityName.Add(8835, "sup");
		_entityValue.Add("nsub", 8836);
		_entityName.Add(8836, "nsub");
		_entityValue.Add("sube", 8838);
		_entityName.Add(8838, "sube");
		_entityValue.Add("supe", 8839);
		_entityName.Add(8839, "supe");
		_entityValue.Add("oplus", 8853);
		_entityName.Add(8853, "oplus");
		_entityValue.Add("otimes", 8855);
		_entityName.Add(8855, "otimes");
		_entityValue.Add("perp", 8869);
		_entityName.Add(8869, "perp");
		_entityValue.Add("sdot", 8901);
		_entityName.Add(8901, "sdot");
		_entityValue.Add("lceil", 8968);
		_entityName.Add(8968, "lceil");
		_entityValue.Add("rceil", 8969);
		_entityName.Add(8969, "rceil");
		_entityValue.Add("lfloor", 8970);
		_entityName.Add(8970, "lfloor");
		_entityValue.Add("rfloor", 8971);
		_entityName.Add(8971, "rfloor");
		_entityValue.Add("lang", 9001);
		_entityName.Add(9001, "lang");
		_entityValue.Add("rang", 9002);
		_entityName.Add(9002, "rang");
		_entityValue.Add("loz", 9674);
		_entityName.Add(9674, "loz");
		_entityValue.Add("spades", 9824);
		_entityName.Add(9824, "spades");
		_entityValue.Add("clubs", 9827);
		_entityName.Add(9827, "clubs");
		_entityValue.Add("hearts", 9829);
		_entityName.Add(9829, "hearts");
		_entityValue.Add("diams", 9830);
		_entityName.Add(9830, "diams");
		_entityValue.Add("OElig", 338);
		_entityName.Add(338, "OElig");
		_entityValue.Add("oelig", 339);
		_entityName.Add(339, "oelig");
		_entityValue.Add("Scaron", 352);
		_entityName.Add(352, "Scaron");
		_entityValue.Add("scaron", 353);
		_entityName.Add(353, "scaron");
		_entityValue.Add("Yuml", 376);
		_entityName.Add(376, "Yuml");
		_entityValue.Add("circ", 710);
		_entityName.Add(710, "circ");
		_entityValue.Add("tilde", 732);
		_entityName.Add(732, "tilde");
		_entityValue.Add("ensp", 8194);
		_entityName.Add(8194, "ensp");
		_entityValue.Add("emsp", 8195);
		_entityName.Add(8195, "emsp");
		_entityValue.Add("thinsp", 8201);
		_entityName.Add(8201, "thinsp");
		_entityValue.Add("zwnj", 8204);
		_entityName.Add(8204, "zwnj");
		_entityValue.Add("zwj", 8205);
		_entityName.Add(8205, "zwj");
		_entityValue.Add("lrm", 8206);
		_entityName.Add(8206, "lrm");
		_entityValue.Add("rlm", 8207);
		_entityName.Add(8207, "rlm");
		_entityValue.Add("ndash", 8211);
		_entityName.Add(8211, "ndash");
		_entityValue.Add("mdash", 8212);
		_entityName.Add(8212, "mdash");
		_entityValue.Add("lsquo", 8216);
		_entityName.Add(8216, "lsquo");
		_entityValue.Add("rsquo", 8217);
		_entityName.Add(8217, "rsquo");
		_entityValue.Add("sbquo", 8218);
		_entityName.Add(8218, "sbquo");
		_entityValue.Add("ldquo", 8220);
		_entityName.Add(8220, "ldquo");
		_entityValue.Add("rdquo", 8221);
		_entityName.Add(8221, "rdquo");
		_entityValue.Add("bdquo", 8222);
		_entityName.Add(8222, "bdquo");
		_entityValue.Add("dagger", 8224);
		_entityName.Add(8224, "dagger");
		_entityValue.Add("Dagger", 8225);
		_entityName.Add(8225, "Dagger");
		_entityValue.Add("permil", 8240);
		_entityName.Add(8240, "permil");
		_entityValue.Add("lsaquo", 8249);
		_entityName.Add(8249, "lsaquo");
		_entityValue.Add("rsaquo", 8250);
		_entityName.Add(8250, "rsaquo");
		_entityValue.Add("euro", 8364);
		_entityName.Add(8364, "euro");
		_maxEntitySize = 9;
	}

	private HtmlEntity()
	{
	}

	public static string DeEntitize(string text)
	{
		if (text == null)
		{
			return null;
		}
		if (text.Length == 0)
		{
			return text;
		}
		StringBuilder stringBuilder = new StringBuilder(text.Length);
		ParseState parseState = ParseState.Text;
		StringBuilder stringBuilder2 = new StringBuilder(10);
		for (int i = 0; i < text.Length; i++)
		{
			switch (parseState)
			{
			case ParseState.Text:
				if (text[i] == '&')
				{
					parseState = ParseState.EntityStart;
				}
				else
				{
					stringBuilder.Append(text[i]);
				}
				break;
			case ParseState.EntityStart:
				switch (text[i])
				{
				case ';':
					if (stringBuilder2.Length == 0)
					{
						stringBuilder.Append("&;");
					}
					else
					{
						int value2;
						if (stringBuilder2[0] == '#')
						{
							string text2 = stringBuilder2.ToString();
							try
							{
								string text3 = text2.Substring(1).Trim();
								int fromBase;
								if (text3.StartsWith("x", StringComparison.OrdinalIgnoreCase))
								{
									fromBase = 16;
									text3 = text3.Substring(1);
								}
								else
								{
									fromBase = 10;
								}
								int value = Convert.ToInt32(text3, fromBase);
								stringBuilder.Append(Convert.ToChar(value));
							}
							catch
							{
								stringBuilder.Append("&#" + text2 + ";");
							}
						}
						else if (!_entityValue.TryGetValue(stringBuilder2.ToString(), out value2))
						{
							stringBuilder.Append("&" + stringBuilder2?.ToString() + ";");
						}
						else
						{
							stringBuilder.Append(Convert.ToChar(value2));
						}
						stringBuilder2.Remove(0, stringBuilder2.Length);
					}
					parseState = ParseState.Text;
					break;
				case '&':
					stringBuilder.Append("&" + stringBuilder2);
					stringBuilder2.Remove(0, stringBuilder2.Length);
					break;
				default:
					stringBuilder2.Append(text[i]);
					if (stringBuilder2.Length > _maxEntitySize)
					{
						parseState = ParseState.Text;
						stringBuilder.Append("&" + stringBuilder2);
						stringBuilder2.Remove(0, stringBuilder2.Length);
					}
					break;
				}
				break;
			}
		}
		if (parseState == ParseState.EntityStart)
		{
			stringBuilder.Append("&" + stringBuilder2);
		}
		return stringBuilder.ToString();
	}

	public static HtmlNode Entitize(HtmlNode node)
	{
		if (node == null)
		{
			throw new ArgumentNullException("node");
		}
		HtmlNode htmlNode = node.CloneNode(deep: true);
		if (htmlNode.HasAttributes)
		{
			Entitize(htmlNode.Attributes);
		}
		if (htmlNode.HasChildNodes)
		{
			Entitize(htmlNode.ChildNodes);
		}
		else if (htmlNode.NodeType == HtmlNodeType.Text)
		{
			((HtmlTextNode)htmlNode).Text = Entitize(((HtmlTextNode)htmlNode).Text, useNames: true, entitizeQuotAmpAndLtGt: true);
		}
		return htmlNode;
	}

	public static string Entitize(string text)
	{
		return Entitize(text, useNames: true);
	}

	public static string Entitize(string text, bool useNames)
	{
		return Entitize(text, useNames, entitizeQuotAmpAndLtGt: false);
	}

	public static string Entitize(string text, bool useNames, bool entitizeQuotAmpAndLtGt)
	{
		if (text == null)
		{
			return null;
		}
		if (text.Length == 0)
		{
			return text;
		}
		StringBuilder stringBuilder = new StringBuilder(text.Length);
		if (UseWebUtility)
		{
			TextElementEnumerator textElementEnumerator = StringInfo.GetTextElementEnumerator(text);
			while (textElementEnumerator.MoveNext())
			{
				stringBuilder.Append(WebUtility.HtmlEncode(textElementEnumerator.GetTextElement()));
			}
		}
		else
		{
			for (int i = 0; i < text.Length; i++)
			{
				int num = text[i];
				if (num > 127 || (entitizeQuotAmpAndLtGt && (num == 34 || num == 38 || num == 60 || num == 62)))
				{
					string value = null;
					if (useNames)
					{
						EntityName.TryGetValue(num, out value);
					}
					if (value == null)
					{
						stringBuilder.Append("&#" + num + ";");
					}
					else
					{
						stringBuilder.Append("&" + value + ";");
					}
				}
				else
				{
					stringBuilder.Append(text[i]);
				}
			}
		}
		return stringBuilder.ToString();
	}

	private static void Entitize(HtmlAttributeCollection collection)
	{
		foreach (HtmlAttribute item in (IEnumerable<HtmlAttribute>)collection)
		{
			if (item.Value != null)
			{
				item.Value = Entitize(item.Value);
			}
		}
	}

	private static void Entitize(HtmlNodeCollection collection)
	{
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)collection)
		{
			if (item.HasAttributes)
			{
				Entitize(item.Attributes);
			}
			if (item.HasChildNodes)
			{
				Entitize(item.ChildNodes);
			}
			else if (item.NodeType == HtmlNodeType.Text)
			{
				((HtmlTextNode)item).Text = Entitize(((HtmlTextNode)item).Text, useNames: true, entitizeQuotAmpAndLtGt: true);
			}
		}
	}
}
internal class HtmlNameTable : XmlNameTable
{
	private NameTable _nametable = new NameTable();

	public override string Add(string array)
	{
		return _nametable.Add(array);
	}

	public override string Add(char[] array, int offset, int length)
	{
		return _nametable.Add(array, offset, length);
	}

	public override string Get(string array)
	{
		return _nametable.Get(array);
	}

	public override string Get(char[] array, int offset, int length)
	{
		return _nametable.Get(array, offset, length);
	}

	internal string GetOrAdd(string array)
	{
		string text = Get(array);
		if (text == null)
		{
			return Add(array);
		}
		return text;
	}
}
[DebuggerDisplay("Name: {OriginalName}")]
public class HtmlNode : IXPathNavigable
{
	internal const string DepthLevelExceptionMessage = "The document is too complex to parse";

	internal HtmlAttributeCollection _attributes;

	internal HtmlNodeCollection _childnodes;

	internal HtmlNode _endnode;

	private bool _changed;

	internal string _innerhtml;

	internal int _innerlength;

	internal int _innerstartindex;

	internal int _line;

	internal int _lineposition;

	private string _name;

	internal int _namelength;

	internal int _namestartindex;

	internal HtmlNode _nextnode;

	internal HtmlNodeType _nodetype;

	internal string _outerhtml;

	internal int _outerlength;

	internal int _outerstartindex;

	private string _optimizedName;

	internal HtmlDocument _ownerdocument;

	internal HtmlNode _parentnode;

	internal HtmlNode _prevnode;

	internal HtmlNode _prevwithsamename;

	internal bool _starttag;

	internal int _streamposition;

	internal bool _isImplicitEnd;

	internal bool _isHideInnerText;

	public static readonly string HtmlNodeTypeNameComment;

	public static readonly string HtmlNodeTypeNameDocument;

	public static readonly string HtmlNodeTypeNameText;

	public static Dictionary<string, HtmlElementFlag> ElementsFlags;

	public HtmlAttributeCollection Attributes
	{
		get
		{
			if (!HasAttributes)
			{
				_attributes = new HtmlAttributeCollection(this);
			}
			return _attributes;
		}
		internal set
		{
			_attributes = value;
		}
	}

	public HtmlNodeCollection ChildNodes
	{
		get
		{
			return _childnodes ?? (_childnodes = new HtmlNodeCollection(this));
		}
		internal set
		{
			_childnodes = value;
		}
	}

	public bool Closed => _endnode != null;

	public HtmlAttributeCollection ClosingAttributes
	{
		get
		{
			if (HasClosingAttributes)
			{
				return _endnode.Attributes;
			}
			return new HtmlAttributeCollection(this);
		}
	}

	public HtmlNode EndNode => _endnode;

	public HtmlNode FirstChild
	{
		get
		{
			if (HasChildNodes)
			{
				return _childnodes[0];
			}
			return null;
		}
	}

	public bool HasAttributes
	{
		get
		{
			if (_attributes == null)
			{
				return false;
			}
			if (_attributes.Count <= 0)
			{
				return false;
			}
			return true;
		}
	}

	public bool HasChildNodes
	{
		get
		{
			if (_childnodes == null)
			{
				return false;
			}
			if (_childnodes.Count <= 0)
			{
				return false;
			}
			return true;
		}
	}

	public bool HasClosingAttributes
	{
		get
		{
			if (_endnode == null || _endnode == this)
			{
				return false;
			}
			if (_endnode._attributes == null)
			{
				return false;
			}
			if (_endnode._attributes.Count <= 0)
			{
				return false;
			}
			return true;
		}
	}

	public string Id
	{
		get
		{
			if (_ownerdocument.Nodesid == null)
			{
				throw new Exception(HtmlDocument.HtmlExceptionUseIdAttributeFalse);
			}
			return GetId();
		}
		set
		{
			if (_ownerdocument.Nodesid == null)
			{
				throw new Exception(HtmlDocument.HtmlExceptionUseIdAttributeFalse);
			}
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			SetId(value);
		}
	}

	public virtual string InnerHtml
	{
		get
		{
			if (_changed)
			{
				UpdateHtml();
				return _innerhtml;
			}
			if (_innerhtml != null)
			{
				return _innerhtml;
			}
			if (_innerstartindex < 0 || _innerlength < 0)
			{
				return string.Empty;
			}
			return _ownerdocument.Text.Substring(_innerstartindex, _innerlength);
		}
		set
		{
			HtmlDocument htmlDocument = new HtmlDocument();
			htmlDocument.LoadHtml(value);
			RemoveAllChildren();
			AppendChildren(htmlDocument.DocumentNode.ChildNodes);
		}
	}

	public virtual string InnerText
	{
		get
		{
			StringBuilder stringBuilder = new StringBuilder();
			int depthLevel = 0;
			string name = Name;
			if (name != null)
			{
				name = name.ToLowerInvariant();
				bool isDisplayScriptingText = name == "head" || name == "script" || name == "style";
				InternalInnerText(stringBuilder, isDisplayScriptingText, depthLevel);
			}
			else
			{
				InternalInnerText(stringBuilder, isDisplayScriptingText: false, depthLevel);
			}
			return stringBuilder.ToString();
		}
	}

	public HtmlNode LastChild
	{
		get
		{
			if (HasChildNodes)
			{
				return _childnodes[_childnodes.Count - 1];
			}
			return null;
		}
	}

	public int Line
	{
		get
		{
			return _line;
		}
		internal set
		{
			_line = value;
		}
	}

	public int LinePosition
	{
		get
		{
			return _lineposition;
		}
		internal set
		{
			_lineposition = value;
		}
	}

	public int InnerStartIndex => _innerstartindex;

	public int OuterStartIndex => _outerstartindex;

	public int InnerLength => InnerHtml.Length;

	public int OuterLength => OuterHtml.Length;

	public string Name
	{
		get
		{
			if (_optimizedName == null)
			{
				if (_name == null)
				{
					SetName(_ownerdocument.Text.Substring(_namestartindex, _namelength));
				}
				if (_name == null)
				{
					_optimizedName = string.Empty;
				}
				else if (OwnerDocument != null)
				{
					_optimizedName = (OwnerDocument.OptionDefaultUseOriginalName ? _name : _name.ToLowerInvariant());
				}
				else
				{
					_optimizedName = _name.ToLowerInvariant();
				}
			}
			return _optimizedName;
		}
		set
		{
			SetName(value);
			SetChanged();
		}
	}

	public HtmlNode NextSibling
	{
		get
		{
			return _nextnode;
		}
		internal set
		{
			_nextnode = value;
		}
	}

	public HtmlNodeType NodeType
	{
		get
		{
			return _nodetype;
		}
		internal set
		{
			_nodetype = value;
		}
	}

	public string OriginalName => _name;

	public virtual string OuterHtml
	{
		get
		{
			if (_changed)
			{
				UpdateHtml();
				return _outerhtml;
			}
			if (_outerhtml != null)
			{
				return _outerhtml;
			}
			if (_outerstartindex < 0 || _outerlength < 0)
			{
				return string.Empty;
			}
			return _ownerdocument.Text.Substring(_outerstartindex, _outerlength);
		}
	}

	public HtmlDocument OwnerDocument
	{
		get
		{
			return _ownerdocument;
		}
		internal set
		{
			_ownerdocument = value;
		}
	}

	public HtmlNode ParentNode
	{
		get
		{
			return _parentnode;
		}
		internal set
		{
			_parentnode = value;
		}
	}

	public HtmlNode PreviousSibling
	{
		get
		{
			return _prevnode;
		}
		internal set
		{
			_prevnode = value;
		}
	}

	public int StreamPosition => _streamposition;

	public string XPath => ((ParentNode == null || ParentNode.NodeType == HtmlNodeType.Document) ? "/" : (ParentNode.XPath + "/")) + GetRelativeXpath();

	public int Depth { get; set; }

	static HtmlNode()
	{
		HtmlNodeTypeNameComment = "#comment";
		HtmlNodeTypeNameDocument = "#document";
		HtmlNodeTypeNameText = "#text";
		ElementsFlags = new Dictionary<string, HtmlElementFlag>(StringComparer.OrdinalIgnoreCase);
		ElementsFlags.Add("script", HtmlElementFlag.CData);
		ElementsFlags.Add("style", HtmlElementFlag.CData);
		ElementsFlags.Add("noxhtml", HtmlElementFlag.CData);
		ElementsFlags.Add("textarea", HtmlElementFlag.CData);
		ElementsFlags.Add("title", HtmlElementFlag.CData);
		ElementsFlags.Add("base", HtmlElementFlag.Empty);
		ElementsFlags.Add("link", HtmlElementFlag.Empty);
		ElementsFlags.Add("meta", HtmlElementFlag.Empty);
		ElementsFlags.Add("isindex", HtmlElementFlag.Empty);
		ElementsFlags.Add("hr", HtmlElementFlag.Empty);
		ElementsFlags.Add("col", HtmlElementFlag.Empty);
		ElementsFlags.Add("img", HtmlElementFlag.Empty);
		ElementsFlags.Add("param", HtmlElementFlag.Empty);
		ElementsFlags.Add("embed", HtmlElementFlag.Empty);
		ElementsFlags.Add("frame", HtmlElementFlag.Empty);
		ElementsFlags.Add("wbr", HtmlElementFlag.Empty);
		ElementsFlags.Add("bgsound", HtmlElementFlag.Empty);
		ElementsFlags.Add("spacer", HtmlElementFlag.Empty);
		ElementsFlags.Add("keygen", HtmlElementFlag.Empty);
		ElementsFlags.Add("area", HtmlElementFlag.Empty);
		ElementsFlags.Add("input", HtmlElementFlag.Empty);
		ElementsFlags.Add("basefont", HtmlElementFlag.Empty);
		ElementsFlags.Add("source", HtmlElementFlag.Empty);
		ElementsFlags.Add("form", HtmlElementFlag.CanOverlap);
		ElementsFlags.Add("br", HtmlElementFlag.Empty | HtmlElementFlag.Closed);
		if (!HtmlDocument.DisableBehaviorTagP)
		{
			ElementsFlags.Add("p", HtmlElementFlag.Empty | HtmlElementFlag.Closed);
		}
	}

	public HtmlNode(HtmlNodeType type, HtmlDocument ownerdocument, int index)
	{
		_nodetype = type;
		_ownerdocument = ownerdocument;
		_outerstartindex = index;
		switch (type)
		{
		case HtmlNodeType.Comment:
			SetName(HtmlNodeTypeNameComment);
			_endnode = this;
			break;
		case HtmlNodeType.Document:
			SetName(HtmlNodeTypeNameDocument);
			_endnode = this;
			break;
		case HtmlNodeType.Text:
			SetName(HtmlNodeTypeNameText);
			_endnode = this;
			break;
		}
		if (_ownerdocument.Openednodes != null && !Closed && -1 != index)
		{
			_ownerdocument.Openednodes.Add(index, this);
		}
		if (-1 == index && type != HtmlNodeType.Comment && type != HtmlNodeType.Text)
		{
			SetChanged();
		}
	}

	internal virtual void InternalInnerText(StringBuilder sb, bool isDisplayScriptingText, int depthLevel)
	{
		depthLevel++;
		if (depthLevel > HtmlDocument.MaxDepthLevel)
		{
			throw new Exception($"Maximum deep level reached: {HtmlDocument.MaxDepthLevel}");
		}
		if (!_ownerdocument.BackwardCompatibility)
		{
			if (HasChildNodes)
			{
				AppendInnerText(sb, isDisplayScriptingText);
			}
			else
			{
				sb.Append(GetCurrentNodeText());
			}
		}
		else if (_nodetype == HtmlNodeType.Text)
		{
			sb.Append(((HtmlTextNode)this).Text);
		}
		else
		{
			if (_nodetype == HtmlNodeType.Comment || !HasChildNodes || (_isHideInnerText && !isDisplayScriptingText))
			{
				return;
			}
			foreach (HtmlNode item in (IEnumerable<HtmlNode>)ChildNodes)
			{
				item.InternalInnerText(sb, isDisplayScriptingText, depthLevel);
			}
		}
	}

	public virtual string GetDirectInnerText()
	{
		if (!_ownerdocument.BackwardCompatibility)
		{
			if (HasChildNodes)
			{
				StringBuilder stringBuilder = new StringBuilder();
				AppendDirectInnerText(stringBuilder);
				return stringBuilder.ToString();
			}
			return GetCurrentNodeText();
		}
		if (_nodetype == HtmlNodeType.Text)
		{
			return ((HtmlTextNode)this).Text;
		}
		if (_nodetype == HtmlNodeType.Comment)
		{
			return "";
		}
		if (!HasChildNodes)
		{
			return string.Empty;
		}
		StringBuilder stringBuilder2 = new StringBuilder();
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)ChildNodes)
		{
			if (item._nodetype == HtmlNodeType.Text)
			{
				stringBuilder2.Append(((HtmlTextNode)item).Text);
			}
		}
		return stringBuilder2.ToString();
	}

	internal string GetCurrentNodeText()
	{
		if (_nodetype == HtmlNodeType.Text)
		{
			string text = ((HtmlTextNode)this).Text;
			if (ParentNode.Name != "pre")
			{
				text = text.Replace("\n", "").Replace("\r", "").Replace("\t", "");
			}
			return text;
		}
		return "";
	}

	internal void AppendDirectInnerText(StringBuilder sb)
	{
		if (_nodetype == HtmlNodeType.Text)
		{
			sb.Append(GetCurrentNodeText());
		}
		if (!HasChildNodes)
		{
			return;
		}
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)ChildNodes)
		{
			sb.Append(item.GetCurrentNodeText());
		}
	}

	internal void AppendInnerText(StringBuilder sb, bool isShowHideInnerText)
	{
		if (_nodetype == HtmlNodeType.Text)
		{
			sb.Append(GetCurrentNodeText());
		}
		if (!HasChildNodes || (_isHideInnerText && !isShowHideInnerText))
		{
			return;
		}
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)ChildNodes)
		{
			item.AppendInnerText(sb, isShowHideInnerText);
		}
	}

	internal void SetName(string value)
	{
		_name = value;
		_optimizedName = null;
	}

	public static bool CanOverlapElement(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		if (!ElementsFlags.TryGetValue(name, out var value))
		{
			return false;
		}
		return (value & HtmlElementFlag.CanOverlap) != 0;
	}

	public static HtmlNode CreateNode(string html)
	{
		return CreateNode(html, null);
	}

	public static HtmlNode CreateNode(string html, Action<HtmlDocument> htmlDocumentBuilder)
	{
		HtmlDocument htmlDocument = new HtmlDocument();
		htmlDocumentBuilder?.Invoke(htmlDocument);
		htmlDocument.LoadHtml(html);
		if (!htmlDocument.DocumentNode.IsSingleElementNode())
		{
			throw new Exception("Multiple node elements can't be created.");
		}
		for (HtmlNode htmlNode = htmlDocument.DocumentNode.FirstChild; htmlNode != null; htmlNode = htmlNode.NextSibling)
		{
			if (htmlNode.NodeType == HtmlNodeType.Element && htmlNode.OuterHtml != "\r\n")
			{
				return htmlNode;
			}
		}
		return htmlDocument.DocumentNode.FirstChild;
	}

	public static bool IsCDataElement(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		if (!ElementsFlags.TryGetValue(name, out var value))
		{
			return false;
		}
		return (value & HtmlElementFlag.CData) != 0;
	}

	public static bool IsClosedElement(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		if (!ElementsFlags.TryGetValue(name, out var value))
		{
			return false;
		}
		return (value & HtmlElementFlag.Closed) != 0;
	}

	public static bool IsEmptyElement(string name)
	{
		if (name == null)
		{
			throw new ArgumentNullException("name");
		}
		if (name.Length == 0)
		{
			return true;
		}
		if ('!' == name[0])
		{
			return true;
		}
		if ('?' == name[0])
		{
			return true;
		}
		if (!ElementsFlags.TryGetValue(name, out var value))
		{
			return false;
		}
		return (value & HtmlElementFlag.Empty) != 0;
	}

	public static bool IsOverlappedClosingElement(string text)
	{
		if (text == null)
		{
			throw new ArgumentNullException("text");
		}
		if (text.Length <= 4)
		{
			return false;
		}
		if (text[0] != '<' || text[text.Length - 1] != '>' || text[1] != '/')
		{
			return false;
		}
		return CanOverlapElement(text.Substring(2, text.Length - 3));
	}

	public IEnumerable<HtmlNode> Ancestors()
	{
		HtmlNode node = ParentNode;
		if (node != null)
		{
			yield return node;
			while (node.ParentNode != null)
			{
				yield return node.ParentNode;
				node = node.ParentNode;
			}
		}
	}

	public IEnumerable<HtmlNode> Ancestors(string name)
	{
		for (HtmlNode i = ParentNode; i != null; i = i.ParentNode)
		{
			if (i.Name == name)
			{
				yield return i;
			}
		}
	}

	public IEnumerable<HtmlNode> AncestorsAndSelf()
	{
		for (HtmlNode i = this; i != null; i = i.ParentNode)
		{
			yield return i;
		}
	}

	public IEnumerable<HtmlNode> AncestorsAndSelf(string name)
	{
		for (HtmlNode i = this; i != null; i = i.ParentNode)
		{
			if (i.Name == name)
			{
				yield return i;
			}
		}
	}

	public HtmlNode AppendChild(HtmlNode newChild)
	{
		if (newChild == null)
		{
			throw new ArgumentNullException("newChild");
		}
		ChildNodes.Append(newChild);
		_ownerdocument.SetIdForNode(newChild, newChild.GetId());
		SetChildNodesId(newChild);
		HtmlNode parentnode = _parentnode;
		HtmlDocument htmlDocument = null;
		while (parentnode != null)
		{
			if (parentnode.OwnerDocument != htmlDocument)
			{
				parentnode.OwnerDocument.SetIdForNode(newChild, newChild.GetId());
				parentnode.SetChildNodesId(newChild);
				htmlDocument = parentnode.OwnerDocument;
			}
			parentnode = parentnode._parentnode;
		}
		SetChanged();
		return newChild;
	}

	public void SetChildNodesId(HtmlNode chilNode)
	{
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)chilNode.ChildNodes)
		{
			_ownerdocument.SetIdForNode(item, item.GetId());
			if (item.ChildNodes == chilNode.ChildNodes)
			{
				throw new Exception("Oops! a scenario that will cause a Stack Overflow has been found. See the following issue for an example: https://github.com/zzzprojects/html-agility-pack/issues/513");
			}
			SetChildNodesId(item);
		}
	}

	public void AppendChildren(HtmlNodeCollection newChildren)
	{
		if (newChildren == null)
		{
			throw new ArgumentNullException("newChildren");
		}
		foreach (HtmlNode item in (IEnumerable<HtmlNode>)newChildren)
		{
			AppendChild(item);
		}
	}

	public IEnumerable<HtmlAttribute> ChildAttributes(string name)
	{
		return Attributes.AttributesWithName(name);
	}

	public HtmlNode Clone()
	{
		return CloneNode(deep: true);
	}

	public HtmlNode CloneNode(string newName)
	{
		return CloneNode(newName, deep: true);
	}

	public HtmlNode CloneNode(string newName, bool deep)
	{
		if (newName == null)
		{
			throw new ArgumentNullException("newName");
		}
		HtmlNode htmlNode = CloneNode(deep);
		htmlNode.SetName(newName);
		return htmlNode;
	}

	public HtmlNode CloneNode(bool deep)
	{
		HtmlNode htmlNode = _ownerdocument.CreateNode(_nodetype);
		htmlNode.SetName(OriginalName);
		switch (_nodetype)
		{
		case HtmlNodeType.Comment:
			((HtmlCommentNode)htmlNode).Comment = ((HtmlCommentNode)this).Comment;
			return htmlNode;
		case HtmlNodeType.Text:
			((HtmlTextNode)htmlNode).Text = ((HtmlTextNode)this).Text;
			return htmlNode;
		default:
			if (HasAttributes)
			{
				foreach (HtmlAttribute item in (IEnumerable<HtmlAttribute>)_attributes)
				{
					HtmlAttribute newAttribute = item.Clone();
					htmlNode.Attributes.Append(newAttribute);
				}
			}
			if (HasClosingAttributes)
			{
				htmlNode._endnode = _endnode.CloneNode(deep: false);
				foreach (HtmlAttribute item2 in (IEnumerable<HtmlAttribute>)_endnode._attributes)
				{
					HtmlAttribute newAttribute2 = item2.Clone();
					htmlNode._endnode._attributes.Append(newAttribute2);
				}
			}
			if (!deep)
			{
				return htmlNode;
			}
			if (!HasChildNodes)
			{
				return htmlNode;
			}
			{
				foreach (HtmlNode item3 in (IEnumerable<HtmlNode>)_childnodes)
				{
					HtmlNode newChild = item3.CloneNode(deep);
					htmlNode.AppendChild(newChild);
				}
				return htmlNode;
			}
		}
	}

	public void CopyFrom(HtmlNode node)
	{
		CopyFrom(node, deep: true);
	}

	public void CopyFrom(HtmlNode node, bool deep)
	{
		if (node == null)
		{
			throw new ArgumentNullException("node");
		}
		Attributes.RemoveAll();
		if (node.HasAttributes)
		{
			foreach (HtmlAttribute item in (IEnumerable<HtmlAttribute>)node.Attributes)
			{
				HtmlAttribute newAttribute = item.Clone();
				Attributes.Append(newAttribute);
			}
		}
		if (!deep)
		{
			return;
		}
		RemoveAllChildren();
		if (!node.HasChildNodes)
		{
			return;
		}
		foreach (HtmlNode item2 in (IEnumerable<HtmlNode>)node.ChildNodes)
		{
			AppendChild(item2.CloneNode(deep: true));
		}
	}

	[Obsolete("Use Descendants() instead, the results of this function will change in a future version")]
	public IEnumerable<HtmlNode> DescendantNodes(int level = 0)
	{
		if (level > HtmlDocument.MaxDepthLevel)
		{
			throw new ArgumentException("The document is too complex to parse");
		}
		foreach (HtmlNode node in (IEnumerable<HtmlNode>)ChildNodes)
		{
			yield return node;
			foreach (HtmlNode item in node.DescendantNode