using System;
using System.Buffers;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using AngleSharp.Attributes;
using AngleSharp.Browser;
using AngleSharp.Browser.Dom;
using AngleSharp.Browser.Dom.Events;
using AngleSharp.Common;
using AngleSharp.Css;
using AngleSharp.Css.Dom;
using AngleSharp.Css.Parser;
using AngleSharp.Dom;
using AngleSharp.Dom.Events;
using AngleSharp.Html;
using AngleSharp.Html.Construction;
using AngleSharp.Html.Dom;
using AngleSharp.Html.Dom.Events;
using AngleSharp.Html.Forms;
using AngleSharp.Html.Forms.Submitters;
using AngleSharp.Html.Forms.Submitters.Json;
using AngleSharp.Html.InputTypes;
using AngleSharp.Html.LinkRels;
using AngleSharp.Html.Parser;
using AngleSharp.Html.Parser.Tokens;
using AngleSharp.Html.Parser.Tokens.Struct;
using AngleSharp.Io;
using AngleSharp.Io.Dom;
using AngleSharp.Io.Processors;
using AngleSharp.Mathml;
using AngleSharp.Mathml.Dom;
using AngleSharp.Media;
using AngleSharp.Media.Dom;
using AngleSharp.Scripting;
using AngleSharp.Svg;
using AngleSharp.Svg.Dom;
using AngleSharp.Text;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCopyright("Copyright © AngleSharp, 2013-2024")]
[assembly: ComVisible(false)]
[assembly: InternalsVisibleTo("AngleSharp.Core.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010001adf274fa2b375134e8e4558d606f1a0f96f5cd0c6b99970f7cce9887477209d7c29f814e2508d8bd2526e99e8cd273bd1158a3984f1ea74830ec5329a77c6ff201a15edeb8b36ab046abd1bce211fe8dbb076d7d806f46b15bfda44def04ead0669971e96c5f666c9eda677f28824fff7aa90d32929ed91d529a7a41699893")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("AngleSharp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("AngleSharp is the ultimate angle brackets parser library. It parses HTML5, CSS3, and XML to construct a DOM based on the official W3C specification.")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+14968235af99415266323f8a8663af287d67459c")]
[assembly: AssemblyProduct("AngleSharp")]
[assembly: AssemblyTitle("AngleSharp")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/AngleSharp/AngleSharp")]
[assembly: AssemblyVersion("1.3.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AngleSharp
{
	public sealed class BrowsingContext : EventTarget, IBrowsingContext, IEventTarget, IDisposable
	{
		[CompilerGenerated]
		private sealed class <GetServices>d__32<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable where T : class?
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			public BrowsingContext <>4__this;

			private int <count>5__2;

			private int <i>5__3;

			T? IEnumerator<T>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object? IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetServices>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				BrowsingContext browsingContext = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00a4;
				}
				<>1__state = -1;
				<count>5__2 = browsingContext._services.Count;
				<i>5__3 = 0;
				goto IL_00b6;
				IL_00a4:
				<i>5__3++;
				goto IL_00b6;
				IL_00b6:
				if (<i>5__3 < <count>5__2)
				{
					object obj = browsingContext._services[<i>5__3];
					T val = obj as T;
					if (val == null)
					{
						if (!(obj is Func<IBrowsingContext, T> func))
						{
							goto IL_00a4;
						}
						val = func(browsingContext);
						browsingContext._services[<i>5__3] = val;
					}
					<>2__current = val;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<GetServices>d__32<T> result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetServices>d__32<T>(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		private readonly IEnumerable<object> _originalServices;

		private readonly List<object> _services;

		private readonly Sandboxes _security;

		private readonly IBrowsingContext? _parent;

		private readonly IDocument? _creator;

		private readonly bool _isFrameContext;

		private readonly IHistory? _history;

		private readonly Dictionary<string, WeakReference<IBrowsingContext>> _children;

		private readonly List<WeakReference<IBrowsingContext>> _contextGroup;

		public IDocument? Active { get; set; }

		public IDocument? Creator => _creator;

		public IEnumerable<object> OriginalServices => _originalServices;

		public IWindow? Current => Active?.DefaultView;

		public IBrowsingContext? Parent => _parent;

		internal bool IsFrame => _isFrameContext;

		public IHistory? SessionHistory => _history;

		public Sandboxes Security => _security;

		public BrowsingContext(IConfiguration? configuration = null)
			: this((configuration ?? Configuration.Default).Services, Sandboxes.None)
		{
		}

		private BrowsingContext(Sandboxes security)
		{
			_services = new List<object>();
			_originalServices = _services;
			_security = security;
			_children = new Dictionary<string, WeakReference<IBrowsingContext>>();
			_contextGroup = new List<WeakReference<IBrowsingContext>>();
		}

		internal BrowsingContext(IEnumerable<object> services, Sandboxes security)
			: this(security)
		{
			_services.AddRange(services);
			_originalServices = services;
			_history = GetService<IHistory>();
		}

		internal BrowsingContext(IBrowsingContext parent, Sandboxes security, bool isFrameContext)
			: this(parent.OriginalServices, security)
		{
			_parent = parent;
			_creator = _parent.Active;
			_isFrameContext = isFrameContext;
		}

		public T? GetService<T>() where T : class
		{
			int count = _services.Count;
			int num = 0;
			while (num < count)
			{
				object obj = _services[num];
				T val = obj as T;
				if (val == null)
				{
					if (!(obj is Func<IBrowsingContext, T> func))
					{
						num++;
						continue;
					}
					val = func(this);
					_services[num] = val;
				}
				return val;
			}
			return null;
		}

		[IteratorStateMachine(typeof(<GetServices>d__32<>))]
		public IEnumerable<T> GetServices<T>() where T : class
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetServices>d__32<T>(-2)
			{
				<>4__this = this
			};
		}

		public IBrowsingContext CreateChild(string? name, Sandboxes security)
		{
			return CreateChild(name, security, isFrameContext: false);
		}

		internal IBrowsingContext CreateChild(string? name, Sandboxes security, bool isFrameContext)
		{
			BrowsingContext browsingContext = new BrowsingContext(this, security, isFrameContext);
			if (!isFrameContext)
			{
				if (_contextGroup == null)
				{
					return _parent.CreateChild(name, security);
				}
				_contextGroup.Add(new WeakReference<IBrowsingContext>(browsingContext));
			}
			if (name != null && name.Length > 0)
			{
				_children[name] = new WeakReference<IBrowsingContext>(browsingContext);
			}
			return browsingContext;
		}

		public IBrowsingContext? FindChild(string name)
		{
			IBrowsingContext browsingContext = null;
			BrowsingContext browsingContext2 = this;
			IBrowsingContext browsingContext3 = null;
			while (browsingContext3 == null && browsingContext2 != null)
			{
				browsingContext3 = browsingContext2.FindChildRecursive(name, browsingContext);
				browsingContext = browsingContext2;
				browsingContext2 = browsingContext2.Parent as BrowsingContext;
			}
			if (browsingContext3 == null && browsingContext is BrowsingContext browsingContext4)
			{
				List<WeakReference<IBrowsingContext>> contextGroup = browsingContext4._contextGroup;
				if (contextGroup != null)
				{
					foreach (WeakReference<IBrowsingContext> item in contextGroup)
					{
						if (item.TryGetTarget(out var target) && target is BrowsingContext browsingContext5)
						{
							browsingContext3 = browsingContext5.FindChildRecursive(name, null);
							if (browsingContext3 != null)
							{
								return browsingContext3;
							}
						}
					}
				}
			}
			return browsingContext3;
		}

		private IBrowsingContext? FindChildRecursive(string name, IBrowsingContext? excludedContext)
		{
			IBrowsingContext target = null;
			if (!string.IsNullOrEmpty(name) && _children.TryGetValue(name, out WeakReference<IBrowsingContext> value))
			{
				value.TryGetTarget(out target);
			}
			if (target == null && Active is Document document)
			{
				foreach (BrowsingContext attachedReference in document.GetAttachedReferences<BrowsingContext>())
				{
					if (!attachedReference.Equals(excludedContext))
					{
						target = attachedReference.FindChildRecursive(name, null);
						if (target != null)
						{
							break;
						}
					}
				}
			}
			return target;
		}

		public static IBrowsingContext New(IConfiguration? configuration = null)
		{
			if (configuration == null)
			{
				configuration = Configuration.Default;
			}
			return new BrowsingContext(configuration.Services, Sandboxes.None);
		}

		public static IBrowsingContext NewFrom<TService>(TService instance)
		{
			return new BrowsingContext(Configuration.Default.WithOnly(instance).Services, Sandboxes.None);
		}

		void IDisposable.Dispose()
		{
			Active?.Dispose();
			Active = null;
		}
	}
	public static class BrowsingContextExtensions
	{
		public static Task<IDocument> OpenNewAsync(this IBrowsingContext context, string? url = null, CancellationToken cancellation = default(CancellationToken))
		{
			string url2 = url;
			return context.OpenAsync(delegate(VirtualResponse m)
			{
				m.Address(url2 ?? "http://localhost/");
			}, cancellation);
		}

		public static Task<IDocument> OpenAsync(this IBrowsingContext context, IResponse response, CancellationToken cancel = default(CancellationToken))
		{
			response = response ?? throw new ArgumentNullException("response");
			if (context == null)
			{
				context = BrowsingContext.New();
			}
			Encoding defaultEncoding = context.GetDefaultEncoding();
			IDocumentFactory factory = context.GetFactory<IDocumentFactory>();
			CreateDocumentOptions options = new CreateDocumentOptions(response, defaultEncoding);
			return factory.CreateAsync(context, options, cancel);
		}

		public static Task<IDocument> OpenAsync(this IBrowsingContext context, DocumentRequest request, CancellationToken cancel = default(CancellationToken))
		{
			request = request ?? throw new ArgumentNullException("request");
			if (context == null)
			{
				context = BrowsingContext.New();
			}
			return context.NavigateToAsync(request, cancel);
		}

		public static Task<IDocument> OpenAsync(this IBrowsingContext context, Url url, CancellationToken cancel = default(CancellationToken))
		{
			url = url ?? throw new ArgumentNullException("url");
			return context.OpenAsync(DocumentRequest.Get(url, null, context?.Active?.DocumentUri), cancel);
		}

		public static async Task<IDocument> OpenAsync(this IBrowsingContext context, Action<VirtualResponse> request, CancellationToken cancel = default(CancellationToken))
		{
			request = request ?? throw new ArgumentNullException("request");
			using IResponse response = VirtualResponse.Create(request);
			return await context.OpenAsync(response, cancel).ConfigureAwait(continueOnCapturedContext: false);
		}

		public static Task<IDocument> OpenAsync(this IBrowsingContext context, string address, CancellationToken cancellation = default(CancellationToken))
		{
			address = address ?? throw new ArgumentNullException("address");
			return context.OpenAsync(Url.Create(address), cancellation);
		}

		internal static Task<IDocument> NavigateToAsync(this IBrowsingContext context, DocumentRequest request, CancellationToken cancel = default(CancellationToken))
		{
			return context.GetNavigationHandler(request.Target)?.NavigateAsync(request, cancel) ?? Task.FromResult<IDocument>(null);
		}

		public static void NavigateTo(this IBrowsingContext context, IDocument document)
		{
			context.SessionHistory?.PushState(document, document.Title, document.Url);
			context.Active = document;
		}

		public static INavigationHandler? GetNavigationHandler(this IBrowsingContext context, Url url)
		{
			Url url2 = url;
			return context.GetServices<INavigationHandler>().FirstOrDefault((INavigationHandler m) => m.SupportsProtocol(url2.Scheme));
		}

		public static Encoding GetDefaultEncoding(this IBrowsingContext context)
		{
			IEncodingProvider? provider = context.GetProvider<IEncodingProvider>();
			string language = context.GetLanguage();
			return provider?.Suggest(language) ?? Encoding.UTF8;
		}

		public static CultureInfo GetCulture(this IBrowsingContext context)
		{
			return context.GetService<CultureInfo>() ?? CultureInfo.CurrentUICulture;
		}

		public static CultureInfo GetCultureFrom(this IBrowsingContext context, string language)
		{
			try
			{
				return new CultureInfo(language);
			}
			catch (CultureNotFoundException ex)
			{
				context.TrackError(ex);
				return context.GetCulture();
			}
		}

		public static string GetLanguage(this IBrowsingContext context)
		{
			return context.GetCulture().Name;
		}

		public static TFactory GetFactory<TFactory>(this IBrowsingContext context) where TFactory : class
		{
			return context.GetServices<TFactory>().Single();
		}

		public static TProvider? GetProvider<TProvider>(this IBrowsingContext context) where TProvider : class
		{
			return context.GetServices<TProvider>().SingleOrDefault();
		}

		public static IResourceService<TResource>? GetResourceService<TResource>(this IBrowsingContext context, string type) where TResource : IResourceInfo
		{
			foreach (IResourceService<TResource> service in context.GetServices<IResourceService<TResource>>())
			{
				if (service.SupportsType(type))
				{
					return service;
				}
			}
			return null;
		}

		public static string GetCookie(this IBrowsingContext context, Url url)
		{
			return context.GetProvider<ICookieProvider>()?.GetCookie(url) ?? string.Empty;
		}

		public static void SetCookie(this IBrowsingContext context, Url url, string value)
		{
			context.GetProvider<ICookieProvider>()?.SetCookie(url, value);
		}

		public static ISpellCheckService? GetSpellCheck(this IBrowsingContext context, string language)
		{
			ISpellCheckService spellCheckService = null;
			IEnumerable<ISpellCheckService> services = context.GetServices<ISpellCheckService>();
			CultureInfo cultureFrom = context.GetCultureFrom(language);
			string twoLetterISOLanguageName = cultureFrom.TwoLetterISOLanguageName;
			foreach (ISpellCheckService item in services)
			{
				CultureInfo culture = item.Culture;
				if (culture != null)
				{
					string twoLetterISOLanguageName2 = culture.TwoLetterISOLanguageName;
					if (culture.Equals(cultureFrom))
					{
						return item;
					}
					if (spellCheckService == null && twoLetterISOLanguageName2.Is(twoLetterISOLanguageName))
					{
						spellCheckService = item;
					}
				}
			}
			return spellCheckService;
		}

		public static IStylingService? GetCssStyling(this IBrowsingContext context)
		{
			return context.GetStyling(MimeTypeNames.Css);
		}

		public static IStylingService? GetStyling(this IBrowsingContext context, string type)
		{
			foreach (IStylingService service in context.GetServices<IStylingService>())
			{
				if (service.SupportsType(type))
				{
					return service;
				}
			}
			return null;
		}

		public static bool IsScripting(this IBrowsingContext context)
		{
			return context.GetServices<IScriptingService>().Any();
		}

		public static IScriptingService? GetJsScripting(this IBrowsingContext context)
		{
			return context.GetScripting(MimeTypeNames.DefaultJavaScript);
		}

		public static IScriptingService? GetScripting(this IBrowsingContext context, string type)
		{
			foreach (IScriptingService service in context.GetServices<IScriptingService>())
			{
				if (service.SupportsType(type))
				{
					return service;
				}
			}
			return null;
		}

		public static ICommand? GetCommand(this IBrowsingContext context, string commandId)
		{
			return context.GetProvider<ICommandProvider>()?.GetCommand(commandId);
		}

		public static void TrackError(this IBrowsingContext context, Exception ex)
		{
			AngleSharp.Browser.Dom.Events.TrackEvent eventData = new AngleSharp.Browser.Dom.Events.TrackEvent("error", ex);
			context.Fire(eventData);
		}

		public static Task InteractAsync<T>(this IBrowsingContext context, string eventName, T data)
		{
			InteractivityEvent<T> interactivityEvent = new InteractivityEvent<T>(eventName, data);
			context.Fire(interactivityEvent);
			return interactivityEvent.Result ?? Task.FromResult(result: false);
		}

		public static IBrowsingContext ResolveTargetContext(this IBrowsingContext context, string? target)
		{
			bool flag = false;
			IBrowsingContext browsingContext = context;
			if (target != null && target.Length > 0)
			{
				browsingContext = context.FindChildFor(target);
				flag = browsingContext == null;
			}
			if (flag)
			{
				browsingContext = context.CreateChildFor(target);
			}
			return browsingContext;
		}

		public static IBrowsingContext CreateChildFor(this IBrowsingContext context, string? target)
		{
			Sandboxes security = Sandboxes.None;
			if (target == "_blank")
			{
				target = null;
			}
			return context.CreateChild(target, security);
		}

		public static IBrowsingContext? FindChildFor(this IBrowsingContext context, string target)
		{
			if (!string.IsNullOrEmpty(target))
			{
				switch (target)
				{
				case "_self":
					break;
				case "_parent":
					if (context is BrowsingContext browsingContext3 && browsingContext3.IsFrame)
					{
						return context.Parent;
					}
					return context;
				case "_top":
				{
					IBrowsingContext browsingContext = context;
					while (browsingContext is BrowsingContext browsingContext2 && browsingContext2.IsFrame)
					{
						browsingContext = browsingContext.Parent;
					}
					return browsingContext;
				}
				default:
					return context.FindChild(target);
				}
			}
			return context;
		}

		public static IEnumerable<Task> GetDownloads<T>(this IBrowsingContext context) where T : INode
		{
			IResourceLoader service = context.GetService<IResourceLoader>();
			if (service == null)
			{
				return Array.Empty<Task>();
			}
			return from m in service.GetDownloads()
				where m.Source is T
				select m.Task;
		}
	}
	public class Configuration : IConfiguration
	{
		private readonly IEnumerable<object> _services;

		public static IConfiguration Default => new Configuration();

		public IEnumerable<object> Services => _services;

		private static T Instance<T>(T instance)
		{
			return instance;
		}

		private static Func<IBrowsingContext, T> Creator<T>(Func<IBrowsingContext, T> creator)
		{
			return creator;
		}

		public Configuration(IEnumerable<object>? services = null)
		{
			_services = services ?? new object[17]
			{
				Instance((IElementFactory<Document, HtmlElement>)new HtmlElementFactory()),
				Instance((IElementFactory<Document, MathElement>)new MathElementFactory()),
				Instance((IElementFactory<Document, SvgElement>)new SvgElementFactory()),
				Instance((IEventFactory)new DefaultEventFactory()),
				Instance((IInputTypeFactory)new DefaultInputTypeFactory()),
				Instance((IAttributeSelectorFactory)new DefaultAttributeSelectorFactory()),
				Instance((IPseudoElementSelectorFactory)new DefaultPseudoElementSelectorFactory()),
				Instance((IPseudoClassSelectorFactory)new DefaultPseudoClassSelectorFactory()),
				Instance((ILinkRelationFactory)new DefaultLinkRelationFactory()),
				Instance((IDocumentFactory)new DefaultDocumentFactory()),
				Instance((IAttributeObserver)new DefaultAttributeObserver()),
				Instance((IMetaHandler)new EncodingMetaHandler()),
				Instance((IHtmlEncoder)new DefaultHtmlEncoder()),
				Creator((Func<IBrowsingContext, ICssSelectorParser>)((IBrowsingContext ctx) => new CssSelectorParser(ctx))),
				Creator((Func<IBrowsingContext, IHtmlParser>)((IBrowsingContext ctx) => new HtmlParser(ctx))),
				Creator((Func<IBrowsingContext, INavigationHandler>)((IBrowsingContext ctx) => new DefaultNavigationHandler(ctx))),
				Creator((Func<IBrowsingContext, IHtmlElementConstructionFactory>)((IBrowsingContext ctx) => new HtmlDomConstructionFactory(ctx)))
			};
		}
	}
	public static class ConfigurationExtensions
	{
		public static IConfiguration With(this IConfiguration configuration, object service)
		{
			configuration = configuration ?? throw new ArgumentNullException("configuration");
			service = service ?? throw new ArgumentNullException("service");
			return new Configuration(configuration.Services.Concat(service));
		}

		public static IConfiguration WithOnly<TService>(this IConfiguration configuration, TService service)
		{
			if (service == null)
			{
				throw new ArgumentNullException("service");
			}
			return configuration.Without<TService>().With(service);
		}

		public static IConfiguration WithOnly<TService>(this IConfiguration configuration, Func<IBrowsingContext, TService> creator)
		{
			creator = creator ?? throw new ArgumentNullException("creator");
			return configuration.Without<TService>().With(creator);
		}

		public static IConfiguration Without(this IConfiguration configuration, object service)
		{
			configuration = configuration ?? throw new ArgumentNullException("configuration");
			service = service ?? throw new ArgumentNullException("service");
			return new Configuration(configuration.Services.Except(service));
		}

		public static IConfiguration With(this IConfiguration configuration, IEnumerable<object> services)
		{
			configuration = configuration ?? throw new ArgumentNullException("configuration");
			services = services ?? throw new ArgumentNullException("services");
			return new Configuration(services.Concat(configuration.Services));
		}

		public static IConfiguration Without(this IConfiguration configuration, IEnumerable<object> services)
		{
			configuration = configuration ?? throw new ArgumentNullException("configuration");
			services = services ?? throw new ArgumentNullException("services");
			return new Configuration(configuration.Services.Except(services));
		}

		public static IConfiguration With<TService>(this IConfiguration configuration, Func<IBrowsingContext, TService> creator)
		{
			creator = creator ?? throw new ArgumentNullException("creator");
			return configuration.With((object)creator);
		}

		public static IConfiguration Without<TService>(this IConfiguration configuration)
		{
			configuration = configuration ?? throw new ArgumentNullException("configuration");
			IEnumerable<object> services = configuration.Services.OfType<TService>().Cast<object>();
			IEnumerable<Func<IBrowsingContext, TService>> services2 = configuration.Services.OfType<Func<IBrowsingContext, TService>>();
			return configuration.Without(services).Without(services2);
		}

		public static bool Has<TService>(this IConfiguration configuration)
		{
			configuration = configuration ?? throw new ArgumentNullException("configuration");
			if (!configuration.Services.OfType<TService>().Any())
			{
				return configuration.Services.OfType<Func<IBrowsingContext, TService>>().Any();
			}
			return true;
		}

		public static IConfiguration WithDefaultLoader(this IConfiguration configuration, LoaderOptions? setup = null)
		{
			LoaderOptions config = setup ?? new LoaderOptions();
			if (!configuration.Has<IRequester>())
			{
				configuration = configuration.With(new DefaultHttpRequester());
			}
			if (!config.IsNavigationDisabled)
			{
				configuration = configuration.With((Func<IBrowsingContext, IDocumentLoader>)((IBrowsingContext ctx) => new DefaultDocumentLoader(ctx, config.Filter)));
			}
			if (config.IsResourceLoadingEnabled)
			{
				configuration = configuration.With((Func<IBrowsingContext, IResourceLoader>)((IBrowsingContext ctx) => new DefaultResourceLoader(ctx, config.Filter)));
			}
			return configuration;
		}

		public static IConfiguration WithCulture(this IConfiguration configuration, string name)
		{
			CultureInfo culture = new CultureInfo(name);
			return configuration.WithCulture(culture);
		}

		public static IConfiguration WithCulture(this IConfiguration configuration, CultureInfo culture)
		{
			return configuration.With(culture);
		}

		public static IConfiguration WithMetaRefresh(this IConfiguration configuration, Predicate<Url>? shouldRefresh = null)
		{
			RefreshMetaHandler service = new RefreshMetaHandler(shouldRefresh);
			return configuration.With(service);
		}

		public static IConfiguration WithLocaleBasedEncoding(this IConfiguration configuration)
		{
			LocaleEncodingProvider service = new LocaleEncodingProvider();
			return configuration.With(service);
		}

		public static IConfiguration WithDefaultCookies(this IConfiguration configuration)
		{
			MemoryCookieProvider service = new MemoryCookieProvider();
			return configuration.With(service);
		}
	}
	public static class FormatExtensions
	{
		public static string ToCss(this IStyleFormattable style)
		{
			return style.ToCss(CssStyleFormatter.Instance);
		}

		public static string ToCss(this IStyleFormattable style, IStyleFormatter formatter)
		{
			StringBuilder sb = StringBuilderPool.Obtain();
			using (StringWriter writer = new StringWriter(sb))
			{
				style.ToCss(writer, formatter);
			}
			return sb.ToPool();
		}

		public static void ToCss(this IStyleFormattable style, TextWriter writer)
		{
			style.ToCss(writer, CssStyleFormatter.Instance);
		}

		public static Task ToCssAsync(this IStyleFormattable style, TextWriter writer)
		{
			return writer.WriteAsync(style.ToCss());
		}

		public static async Task ToCssAsync(this IStyleFormattable style, Stream stream)
		{
			using StreamWriter writer = new StreamWriter(stream);
			await style.ToCssAsync(writer).ConfigureAwait(continueOnCapturedContext: false);
		}

		public static string ToHtml(this IMarkupFormattable markup)
		{
			return markup.ToHtml(HtmlMarkupFormatter.Instance);
		}

		public static string ToHtml(this IMarkupFormattable markup, IMarkupFormatter formatter)
		{
			StringBuilder sb = StringBuilderPool.Obtain();
			using (StringWriter writer = new StringWriter(sb))
			{
				markup.ToHtml(writer, formatter);
			}
			return sb.ToPool();
		}

		public static void ToHtml(this IMarkupFormattable markup, TextWriter writer)
		{
			markup.ToHtml(writer, HtmlMarkupFormatter.Instance);
		}

		public static string Minify(this IMarkupFormattable markup)
		{
			return markup.ToHtml(new MinifyMarkupFormatter());
		}

		public static string Prettify(this IMarkupFormattable markup)
		{
			return markup.ToHtml(new PrettyMarkupFormatter());
		}

		public static Task ToHtmlAsync(this IMarkupFormattable markup, TextWriter writer)
		{
			return writer.WriteAsync(markup.ToHtml());
		}

		public static async Task ToHtmlAsync(this IMarkupFormattable markup, Stream stream)
		{
			using StreamWriter writer = new StreamWriter(stream);
			await markup.ToHtmlAsync(writer).ConfigureAwait(continueOnCapturedContext: false);
		}
	}
	public interface IBrowsingContext : IEventTarget, IDisposable
	{
		IWindow? Current { get; }

		IDocument? Active { get; set; }

		IHistory? SessionHistory { get; }

		Sandboxes Security { get; }

		IBrowsingContext? Parent { get; }

		IDocument? Creator { get; }

		IEnumerable<object> OriginalServices { get; }

		T? GetService<T>() where T : class;

		IEnumerable<T> GetServices<T>() where T : class;

		IBrowsingContext CreateChild(string? name, Sandboxes security);

		IBrowsingContext? FindChild(string name);
	}
	public interface IConfiguration
	{
		IEnumerable<object> Services { get; }
	}
	public interface IMarkupFormattable
	{
		void ToHtml(TextWriter writer, IMarkupFormatter formatter);
	}
	public interface IMarkupFormatter
	{
		string Text(ICharacterData text);

		string LiteralText(ICharacterData text);

		string Comment(IComment comment);

		string Processing(IProcessingInstruction processing);

		string Doctype(IDocumentType doctype);

		string OpenTag(IElement element, bool selfClosing);

		string CloseTag(IElement element, bool selfClosing);
	}
	public interface IStyleFormattable
	{
		void ToCss(TextWriter writer, IStyleFormatter formatter);
	}
	public interface IStyleFormatter
	{
		string Sheet(IEnumerable<IStyleFormattable> rules);

		string Declaration(string name, string value, bool important);

		string BlockDeclarations(IEnumerable<IStyleFormattable> declarations);

		string Rule(string name, string value);

		string Rule(string name, string prelude, string rules);

		string BlockRules(IEnumerable<IStyleFormattable> rules);

		string Comment(string data);
	}
}
namespace AngleSharp.Xhtml
{
	public class XhtmlMarkupFormatter : IMarkupFormatter
	{
		public static readonly IMarkupFormatter Instance = new XhtmlMarkupFormatter();

		private readonly bool _emptyTagsToSelfClosing;

		public bool IsSelfClosingEmptyTags => _emptyTagsToSelfClosing;

		public XhtmlMarkupFormatter()
			: this(emptyTagsToSelfClosing: true)
		{
		}

		public XhtmlMarkupFormatter(bool emptyTagsToSelfClosing)
		{
			_emptyTagsToSelfClosing = emptyTagsToSelfClosing;
		}

		public virtual string CloseTag(IElement element, bool selfClosing)
		{
			string prefix = element.Prefix;
			string localName = element.LocalName;
			string text = ((!string.IsNullOrEmpty(prefix)) ? (prefix + ":" + localName) : localName);
			if (!selfClosing && (!_emptyTagsToSelfClosing || element.HasChildNodes))
			{
				return "</" + text + ">";
			}
			return string.Empty;
		}

		public virtual string Comment(IComment comment)
		{
			return "<!--" + comment.Data + "-->";
		}

		public virtual string Doctype(IDocumentType doctype)
		{
			string publicIdentifier = doctype.PublicIdentifier;
			string systemIdentifier = doctype.SystemIdentifier;
			string text = ((string.IsNullOrEmpty(publicIdentifier) && string.IsNullOrEmpty(systemIdentifier)) ? string.Empty : (" " + (string.IsNullOrEmpty(publicIdentifier) ? ("SYSTEM \"" + systemIdentifier + "\"") : ("PUBLIC \"" + publicIdentifier + "\" \"" + systemIdentifier + "\""))));
			return "<!DOCTYPE " + doctype.Name + text + ">";
		}

		public virtual string OpenTag(IElement element, bool selfClosing)
		{
			string prefix = element.Prefix;
			StringBuilder stringBuilder = StringBuilderPool.Obtain();
			stringBuilder.Append('<');
			if (!string.IsNullOrEmpty(prefix))
			{
				stringBuilder.Append(prefix).Append(':');
			}
			stringBuilder.Append(element.LocalName);
			foreach (IAttr attribute in element.Attributes)
			{
				stringBuilder.Append(' ').Append(Attribute(attribute));
			}
			if (selfClosing || (_emptyTagsToSelfClosing && !element.HasChildNodes))
			{
				stringBuilder.Append(" /");
			}
			stringBuilder.Append('>');
			return stringBuilder.ToPool();
		}

		public virtual string Processing(IProcessingInstruction processing)
		{
			string text = processing.Target + " " + processing.Data;
			return "<?" + text + "?>";
		}

		public virtual string LiteralText(ICharacterData text)
		{
			return text.Data;
		}

		public virtual string Text(ICharacterData text)
		{
			return EscapeText(text.Data);
		}

		protected virtual string Attribute(IAttr attribute)
		{
			string namespaceUri = attribute.NamespaceUri;
			string localName = attribute.LocalName;
			string value = attribute.Value;
			StringBuilder stringBuilder = StringBuilderPool.Obtain();
			if (string.IsNullOrEmpty(namespaceUri))
			{
				stringBuilder.Append(localName);
			}
			else if (namespaceUri.Is(NamespaceNames.XmlUri))
			{
				stringBuilder.Append(NamespaceNames.XmlPrefix).Append(':').Append(localName);
			}
			else if (namespaceUri.Is(NamespaceNames.XLinkUri))
			{
				stringBuilder.Append(NamespaceNames.XLinkPrefix).Append(':').Append(localName);
			}
			else if (namespaceUri.Is(NamespaceNames.XmlNsUri))
			{
				stringBuilder.Append(XmlNamespaceLocalName(localName));
			}
			else
			{
				stringBuilder.Append(attribute.Name);
			}
			stringBuilder.Append('=').Append('"');
			for (int i = 0; i < value.Length; i++)
			{
				switch (value[i])
				{
				case '&':
					stringBuilder.Append("&amp;");
					break;
				case '\u00a0':
					stringBuilder.Append("&#160;");
					break;
				case '<':
					stringBuilder.Append("&lt;");
					break;
				case '"':
					stringBuilder.Append("&quot;");
					break;
				default:
					stringBuilder.Append(value[i]);
					break;
				}
			}
			return stringBuilder.Append('"').ToPool();
		}

		public static string EscapeText(string content)
		{
			StringBuilder stringBuilder = StringBuilderPool.Obtain();
			for (int i = 0; i < content.Length; i++)
			{
				switch (content[i])
				{
				case '&':
					stringBuilder.Append("&amp;");
					break;
				case '\u00a0':
					stringBuilder.Append("&#160;");
					break;
				case '>':
					stringBuilder.Append("&gt;");
					break;
				case '<':
					stringBuilder.Append("&lt;");
					break;
				default:
					stringBuilder.Append(content[i]);
					break;
				}
			}
			return stringBuilder.ToPool();
		}

		public static string XmlNamespaceLocalName(string localName)
		{
			if (localName.Is(NamespaceNames.XmlNsPrefix))
			{
				return localName;
			}
			return NamespaceNames.XmlNsPrefix + ':' + localName;
		}
	}
}
namespace AngleSharp.Text
{
	public sealed class CharArrayTextSource : IReadOnlyTextSource, IDisposable
	{
		private int _index;

		private string? _content;

		private readonly char[] _array;

		private readonly ReadOnlyMemory<char> _memory;

		private readonly int _length;

		public string Text => _content ?? (_content = new string(_array, 0, _length));

		public char this[int index] => _array[index];

		public int Length => _length;

		public Encoding CurrentEncoding
		{
			get
			{
				return TextEncoding.Utf8;
			}
			set
			{
			}
		}

		public int Index
		{
			get
			{
				return _index;
			}
			set
			{
				_index = value;
			}
		}

		public CharArrayTextSource(char[] array, int length)
		{
			_array = array;
			_length = length;
			_memory = array.AsMemory(0, length);
		}

		public void Dispose()
		{
		}

		public char ReadCharacter()
		{
			if (_index < _length)
			{
				return _array[_index++];
			}
			_index++;
			return '\uffff';
		}

		public string ReadCharacters(int characters)
		{
			return ReadMemory(characters).ToString();
		}

		public StringOrMemory ReadMemory(int characters)
		{
			int index = _index;
			if (index + characters <= _length)
			{
				_index += characters;
				return _memory.Slice(index, characters);
			}
			_index += characters;
			characters = Math.Min(characters, _length - index);
			return _memory.Slice(index, characters);
		}

		public Task PrefetchAsync(int length, CancellationToken cancellationToken)
		{
			return Task.CompletedTask;
		}

		public Task PrefetchAllAsync(CancellationToken cancellationToken)
		{
			return Task.CompletedTask;
		}

		public bool TryGetContentLength(out int length)
		{
			length = _length;
			return true;
		}
	}
	public static class CharExtensions
	{
		public static int FromHex(this char c)
		{
			if (!c.IsDigit())
			{
				return c - (c.IsLowercaseAscii() ? 87 : 55);
			}
			return c - 48;
		}

		public static string ToHex(this byte num)
		{
			Span<char> span = stackalloc char[2];
			int num2 = num >> 4;
			span[0] = (char)(num2 + ((num2 < 10) ? 48 : 55));
			num2 = num - 16 * num2;
			span[1] = (char)(num2 + ((num2 < 10) ? 48 : 55));
			return span.ToString();
		}

		public static string ToHex(this char character)
		{
			int num = character;
			return num.ToString("x");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInRange(this char c, int lower, int upper)
		{
			if (c >= lower)
			{
				return c <= upper;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNormalQueryCharacter(this char c)
		{
			if (c.IsInRange(33, 126) && c != '"' && c != '`' && c != '#' && c != '<')
			{
				return c != '>';
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNormalPathCharacter(this char c)
		{
			if (c.IsInRange(32, 126) && c != '"' && c != '`' && c != '#' && c != '<' && c != '>' && c != ' ')
			{
				return c != '?';
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsUppercaseAscii(this char c)
		{
			if (c >= 'A')
			{
				return c <= 'Z';
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLowercaseAscii(this char c)
		{
			if (c >= 'a')
			{
				return c <= 'z';
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsAlphanumericAscii(this char c)
		{
			if (!c.IsDigit() && !c.IsUppercaseAscii())
			{
				return c.IsLowercaseAscii();
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsHex(this char c)
		{
			if (!c.IsDigit() && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNonAscii(this char c)
		{
			if (c != '\uffff')
			{
				return c >= '\u0080';
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNonPrintable(this char c)
		{
			if ((c < '\0' || c > '\b') && (c < '\u000e' || c > '\u001f'))
			{
				if (c >= '\u007f')
				{
					return c <= '\u009f';
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLetter(this char c)
		{
			if (!c.IsUppercaseAscii())
			{
				return c.IsLowercaseAscii();
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsName(this char c)
		{
			if (!c.IsNonAscii() && !c.IsLetter() && c != '_' && c != '-')
			{
				return c.IsDigit();
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsCustomElementName(this char c)
		{
			if (c != '_' && c != '-' && c != '.' && !c.IsDigit() && !c.IsLowercaseAscii() && c != '·' && !c.IsInRange(192, 214) && !c.IsInRange(216, 246) && !c.IsInRange(248, 893) && !c.IsInRange(895, 8191) && !c.IsInRange(8204, 8205) && !c.IsInRange(8255, 8256) && !c.IsInRange(8304, 8591) && !c.IsInRange(11264, 12271) && !c.IsInRange(12289, 55295) && !c.IsInRange(63744, 64975) && !c.IsInRange(65008, 65533))
			{
				return c.IsInRange(65536, 2031615);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNameStart(this char c)
		{
			if (!c.IsNonAscii() && !c.IsUppercaseAscii() && !c.IsLowercaseAscii())
			{
				return c == '_';
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLineBreak(this char c)
		{
			if (c != '\n')
			{
				return c == '\r';
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsSpaceCharacter(this char c)
		{
			if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
			{
				return c == '\f';
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsWhiteSpaceCharacter(this char c)
		{
			if (!c.IsInRange(9, 13) && c != ' ' && c != '\u0085' && c != '\u00a0' && c != '\u1680' && c != '\u180e' && !c.IsInRange(8192, 8202) && c != '\u2028' && c != '\u2029' && c != '\u202f' && c != '\u205f')
			{
				return c == '\u3000';
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsDigit(this char c)
		{
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public static bool IsUrlCodePoint(this char c)
		{
			if (!c.IsAlphanumericAscii() && c != '!' && c != '$' && c != '&' && c != '\'' && c != '(' && c != ')' && c != '*' && c != '+' && c != '-' && c != ',' && c != '.' && c != '/' && c != ':' && c != ';' && c != '=' && c != '?' && c != '@' && c != '_' && c != '~' && !c.IsInRange(160, 55295) && !c.IsInRange(57344, 64975) && !c.IsInRange(65008, 65533) && !c.IsInRange(65536, 131069) && !c.IsInRange(131072, 196605) && !c.IsInRange(196608, 262141) && !c.IsInRange(262144, 327677) && !c.IsInRange(327680, 393213) && !c.IsInRange(393216, 458749) && !c.IsInRange(458752, 524285) && !c.IsInRange(524288, 589821) && !c.IsInRange(589824, 655357) && !c.IsInRange(655360, 720893) && !c.IsInRange(720896, 786429) && !c.IsInRange(786432, 851965) && !c.IsInRange(851968, 917501) && !c.IsInRange(917504, 983037) && !c.IsInRange(983040, 1048573))
			{
				return c.IsInRange(1048576, 1114109);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInvalid(this int c)
		{
			if (c != 0 && c <= 1114111)
			{
				if (c > 55296)
				{
					return c < 57343;
				}
				return false;
			}
			return true;
		}
	}
	public interface ITextSource : IReadOnlyTextSource, IDisposable
	{
		void InsertText(string content);
	}
	public interface IReadOnlyTextSource : IDisposable
	{
		string Text { get; }

		int Length { get; }

		Encoding CurrentEncoding { get; set; }

		int Index { get; set; }

		char this[int index] { get; }

		char ReadCharacter();

		string ReadCharacters(int characters);

		StringOrMemory ReadMemory(int characters);

		Task PrefetchAsync(int length, CancellationToken cancellationToken);

		Task PrefetchAllAsync(CancellationToken cancellationToken);

		bool TryGetContentLength(out int length);
	}
	public static class Punycode
	{
		private const int PunycodeBase = 36;

		private const int Tmin = 1;

		private const int Tmax = 26;

		private static readonly string acePrefix = "xn--";

		private static readonly char[] possibleDots = new char[4] { '.', '。', '．', '｡' };

		public static IDictionary<char, char> Symbols = new Dictionary<char, char>
		{
			{ '。', '.' },
			{ '．', '.' },
			{ 'Ｇ', 'g' },
			{ 'ｏ', 'o' },
			{ 'ｃ', 'c' },
			{ 'Ｘ', 'x' },
			{ '０', '0' },
			{ '１', '1' },
			{ '２', '2' },
			{ '５', '5' },
			{ '⁰', '0' },
			{ '¹', '1' },
			{ '²', '2' },
			{ '³', '3' },
			{ '⁴', '4' },
			{ '⁵', '5' },
			{ '⁶', '6' },
			{ '⁷', '7' },
			{ '⁸', '8' },
			{ '⁹', '9' },
			{ '₀', '0' },
			{ '₁', '1' },
			{ '₂', '2' },
			{ '₃', '3' },
			{ '₄', '4' },
			{ '₅', '5' },
			{ '₆', '6' },
			{ '₇', '7' },
			{ '₈', '8' },
			{ '₉', '9' },
			{ 'ᵃ', 'a' },
			{ 'ᵇ', 'b' },
			{ 'ᶜ', 'c' },
			{ 'ᵈ', 'd' },
			{ 'ᵉ', 'e' },
			{ 'ᶠ', 'f' },
			{ 'ᵍ', 'g' },
			{ 'ʰ', 'h' },
			{ 'ⁱ', 'i' },
			{ 'ʲ', 'j' },
			{ 'ᵏ', 'k' },
			{ 'ˡ', 'l' },
			{ 'ᵐ', 'm' },
			{ 'ⁿ', 'n' },
			{ 'ᵒ', 'o' },
			{ 'ᵖ', 'p' },
			{ 'ʳ', 'r' },
			{ 'ˢ', 's' },
			{ 'ᵗ', 't' },
			{ 'ᵘ', 'u' },
			{ 'ᵛ', 'v' },
			{ 'ʷ', 'w' },
			{ 'ˣ', 'x' },
			{ 'ʸ', 'y' },
			{ 'ᶻ', 'z' },
			{ 'ᴬ', 'A' },
			{ 'ᴮ', 'B' },
			{ 'ᴰ', 'D' },
			{ 'ᴱ', 'E' },
			{ 'ᴳ', 'G' },
			{ 'ᴴ', 'H' },
			{ 'ᴵ', 'I' },
			{ 'ᴶ', 'J' },
			{ 'ᴷ', 'K' },
			{ 'ᴸ', 'L' },
			{ 'ᴹ', 'M' },
			{ 'ᴺ', 'N' },
			{ 'ᴼ', 'O' },
			{ 'ᴾ', 'P' },
			{ 'ᴿ', 'R' },
			{ 'ᵀ', 'T' },
			{ 'ᵁ', 'U' },
			{ 'ⱽ', 'V' },
			{ 'ᵂ', 'W' }
		};

		public static string Encode(string text)
		{
			if (text.Length == 0)
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			while (num < text.Length)
			{
				num = text.IndexOfAny(possibleDots, num2);
				if (num < 0)
				{
					num = text.Length;
				}
				if (num == num2)
				{
					break;
				}
				stringBuilder.Append(acePrefix);
				int num4 = 0;
				int num5 = 0;
				for (num4 = num2; num4 < num; num4++)
				{
					if (text[num4] < '\u0080')
					{
						stringBuilder.Append(EncodeBasic(text[num4]));
						num5++;
					}
					else if (char.IsSurrogatePair(text, num4))
					{
						num4++;
					}
				}
				int num6 = num5;
				if (num6 == num - num2)
				{
					stringBuilder.Remove(num3, acePrefix.Length);
				}
				else
				{
					if (text.Length - num2 >= acePrefix.Length && text.Substring(num2, acePrefix.Length).Isi(acePrefix))
					{
						break;
					}
					int num7 = 0;
					if (num6 > 0)
					{
						stringBuilder.Append('-');
					}
					int num8 = 128;
					int num9 = 0;
					int num10 = 72;
					while (num5 < num - num2)
					{
						int num11 = 0;
						int num12 = 0;
						int num13 = 0;
						num12 = 134217727;
						for (num11 = num2; num11 < num; num11 += ((!IsSupplementary(num13)) ? 1 : 2))
						{
							num13 = char.ConvertToUtf32(text, num11);
							if (num13 >= num8 && num13 < num12)
							{
								num12 = num13;
							}
						}
						num9 += (num12 - num8) * (num5 - num7 + 1);
						num8 = num12;
						for (num11 = num2; num11 < num; num11 += ((!IsSupplementary(num13)) ? 1 : 2))
						{
							num13 = char.ConvertToUtf32(text, num11);
							if (num13 < num8)
							{
								num9++;
							}
							else
							{
								if (num13 != num8)
								{
									continue;
								}
								int num14 = num9;
								int num15 = 36;
								while (true)
								{
									int num16 = ((num15 <= num10) ? 1 : ((num15 >= num10 + 26) ? 26 : (num15 - num10)));
									if (num14 < num16)
									{
										break;
									}
									stringBuilder.Append(EncodeDigit(num16 + (num14 - num16) % (36 - num16)));
									num14 = (num14 - num16) / (36 - num16);
									num15 += 36;
								}
								stringBuilder.Append(EncodeDigit(num14));
								num10 = AdaptChar(num9, num5 - num7 + 1, num5 == num6);
								num9 = 0;
								num5++;
								if (IsSupplementary(num12))
								{
									num5++;
									num7++;
								}
							}
						}
						num9++;
						num8++;
					}
				}
				if (stringBuilder.Length - num3 > 63)
				{
					throw new ArgumentException();
				}
				if (num != text.Length)
				{
					stringBuilder.Append(possibleDots[0]);
				}
				num2 = num + 1;
				num3 = stringBuilder.Length;
			}
			int num17 = ((!IsDot(text[text.Length - 1])) ? 1 : 0);
			int num18 = 255 - num17;
			if (stringBuilder.Length > num18)
			{
				stringBuilder.Remove(num18, stringBuilder.Length - num18);
			}
			return stringBuilder.ToString();
		}

		private static bool IsSupplementary(int test)
		{
			return test >= 65536;
		}

		private static bool IsDot(char c)
		{
			for (int i = 0; i < possibleDots.Length; i++)
			{
				if (possibleDots[i] == c)
				{
					return true;
				}
			}
			return false;
		}

		private static char EncodeDigit(int digit)
		{
			if (digit > 25)
			{
				return (char)(digit + 22);
			}
			return (char)(digit + 97);
		}

		private static char EncodeBasic(char character)
		{
			if (char.IsUpper(character))
			{
				character = (char)(character + 32);
			}
			return character;
		}

		private static int AdaptChar(int delta, int numPoints, bool firstTime)
		{
			uint num = 0u;
			delta = (firstTime ? (delta / 700) : (delta / 2));
			delta += delta / numPoints;
			num = 0u;
			while (delta > 455)
			{
				delta /= 35;
				num += 36;
			}
			return (int)(num + 36 * delta / (delta + 38));
		}
	}
	public sealed class ReadOnlyMemoryTextSource : IReadOnlyTextSource, IDisposable
	{
		private int _index;

		private string? _content;

		private readonly ReadOnlyMemory<char> _memory;

		private readonly int _length;

		public string Text => _content ?? (_content = _memory.Span.ToString());

		public char this[int index]
		{
			get
			{
				if (_content == null)
				{
					return _memory.Span[index];
				}
				return _content[index];
			}
		}

		public int Length => _length;

		public Encoding CurrentEncoding
		{
			get
			{
				return TextEncoding.Utf8;
			}
			set
			{
			}
		}

		public int Index
		{
			get
			{
				return _index;
			}
			set
			{
				_index = value;
			}
		}

		public ReadOnlyMemoryTextSource(ReadOnlyMemory<char> memory)
		{
			_memory = memory;
			_length = memory.Length;
		}

		public ReadOnlyMemoryTextSource(string str)
		{
			_content = str;
			_memory = str.AsMemory();
			_length = _memory.Length;
		}

		public void Dispose()
		{
		}

		public char ReadCharacter()
		{
			if (_index < _length)
			{
				return _memory.Span[_index++];
			}
			_index++;
			return '\uffff';
		}

		public string ReadCharacters(int characters)
		{
			return ReadMemory(characters).ToString();
		}

		public StringOrMemory ReadMemory(int characters)
		{
			int index = _index;
			if (index + characters <= _length)
			{
				_index += characters;
				return _memory.Slice(index, characters);
			}
			_index += characters;
			characters = Math.Min(characters, _length - index);
			return _memory.Slice(index, characters);
		}

		public Task PrefetchAsync(int length, CancellationToken cancellationToken)
		{
			return Task.CompletedTask;
		}

		public Task PrefetchAllAsync(CancellationToken cancellationToken)
		{
			return Task.CompletedTask;
		}

		public bool TryGetContentLength(out int length)
		{
			length = _length;
			return true;
		}
	}
	public static class StringBuilderPool
	{
		private static readonly Stack<StringBuilder> _builder = new Stack<StringBuilder>();

		private static readonly object _lock = new object();

		private static int _count = 4;

		private static int _limit = 85000;

		private static bool _isPoolingDisabled = false;

		private const int _defaultStringBuilderSize = 1024;

		public static bool IsPoolingDisabled
		{
			get
			{
				return _isPoolingDisabled;
			}
			set
			{
				_isPoolingDisabled = value;
			}
		}

		public static int MaxCount
		{
			get
			{
				return _count;
			}
			set
			{
				_count = Math.Max(1, value);
			}
		}

		public static int SizeLimit
		{
			get
			{
				return _limit;
			}
			set
			{
				_limit = Math.Max(1024, value);
			}
		}

		public static StringBuilder Obtain()
		{
			if (_isPoolingDisabled)
			{
				return CreateStringBuilder();
			}
			lock (_lock)
			{
				if (_builder.Count == 0)
				{
					return CreateStringBuilder();
				}
				return _builder.Pop().Clear();
			}
		}

		public static string ToPool(this StringBuilder sb)
		{
			string result = sb.ToString();
			sb.ReturnToPool();
			return result;
		}

		internal static StringBuilder CreateStringBuilder()
		{
			return new StringBuilder(1024);
		}

		internal static void ReturnToPool(this StringBuilder sb)
		{
			if (_isPoolingDisabled)
			{
				return;
			}
			lock (_lock)
			{
				int count = _builder.Count;
				if (sb.Capacity <= _limit)
				{
					if (count == _count)
					{
						DropMinimum(sb);
					}
					else if (count < Math.Min(2, _count) || _builder.Peek().Capacity < sb.Capacity)
					{
						_builder.Push(sb);
					}
				}
			}
		}

		private static void DropMinimum(StringBuilder sb)
		{
			int capacity = sb.Capacity;
			StringBuilder[] instances = _builder.ToArray();
			int num = FindIndex(instances, capacity);
			if (num > -1)
			{
				RebuildPool(sb, instances, num);
			}
		}

		private static void RebuildPool(StringBuilder sb, StringBuilder[] instances, int index)
		{
			_builder.Clear();
			int num = instances.Length - 1;
			while (num > index)
			{
				_builder.Push(instances[num--]);
			}
			while (num > 0)
			{
				_builder.Push(instances[--num]);
			}
			_builder.Push(sb);
		}

		private static int FindIndex(StringBuilder[] instances, int minimum)
		{
			int result = -1;
			for (int i = 0; i < instances.Length; i++)
			{
				int capacity = instances[i].Capacity;
				if (capacity < minimum)
				{
					minimum = capacity;
					result = i;
				}
			}
			return result;
		}
	}
	public static class StringExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Has([NotNullWhen(true)] this string? value, char chr, int index = 0)
		{
			if (value != null && value.Length > index)
			{
				return value[index] == chr;
			}
			return false;
		}

		internal static string GetCompatiblity(this QuirksMode mode)
		{
			string result = "CSS1Compat";
			string text = mode.ToString();
			if (text != null)
			{
				FieldInfo field = typeof(QuirksMode).GetField(text);
				if (field != null)
				{
					DomDescriptionAttribute customAttribute = field.GetCustomAttribute<DomDescriptionAttribute>();
					if (customAttribute != null)
					{
						result = customAttribute.Description;
					}
				}
			}
			return result;
		}

		public static StringOrMemory HtmlLower(this StringOrMemory value)
		{
			int length = value.Length;
			for (int j = 0; j < length; j++)
			{
				if (value[j].IsUppercaseAscii())
				{
					if (length < 128)
					{
						Span<char> result2 = stackalloc char[length];
						return Slow(value, j, result2);
					}
					char[] array = ArrayPool<char>.Shared.Rent(length);
					Span<char> result3 = array.AsSpan(0, length);
					string text = Slow(value, j, result3);
					ArrayPool<char>.Shared.Return(array);
					return text;
				}
			}
			return value;
			static string Slow(StringOrMemory value, int i, Span<char> result)
			{
				for (int k = 0; k < i; k++)
				{
					result[k] = value[k];
				}
				char c = value[i];
				result[i] = char.ToLowerInvariant(c);
				for (int l = i + 1; l < value.Length; l++)
				{
					c = value[l];
					if (c.IsUppercaseAscii())
					{
						c = char.ToLowerInvariant(c);
					}
					result[l] = c;
				}
				return result.ToString();
			}
		}

		public static string HtmlLower(this string value)
		{
			return new StringOrMemory(value).HtmlLower().ToString();
		}

		public static Sandboxes ParseSecuritySettings(this string value, bool allowFullscreen = false)
		{
			string[] list = value.SplitSpaces();
			Sandboxes sandboxes = Sandboxes.Navigation | Sandboxes.Plugins | Sandboxes.DocumentDomain;
			if (!list.Contains("allow-popups", StringComparison.OrdinalIgnoreCase))
			{
				sandboxes |= Sandboxes.AuxiliaryNavigation;
			}
			if (!list.Contains("allow-top-navigation", StringComparison.OrdinalIgnoreCase))
			{
				sandboxes |= Sandboxes.TopLevelNavigation;
			}
			if (!list.Contains("allow-same-origin", StringComparison.OrdinalIgnoreCase))
			{
				sandboxes |= Sandboxes.Origin;
			}
			if (!list.Contains("allow-forms", StringComparison.OrdinalIgnoreCase))
			{
				sandboxes |= Sandboxes.Forms;
			}
			if (!list.Contains("allow-pointer-lock", StringComparison.OrdinalIgnoreCase))
			{
				sandboxes |= Sandboxes.PointerLock;
			}
			if (!list.Contains("allow-scripts", StringComparison.OrdinalIgnoreCase))
			{
				sandboxes |= Sandboxes.Scripts;
				sandboxes |= Sandboxes.AutomaticFeatures;
			}
			if (!list.Contains("allow-presentation", StringComparison.OrdinalIgnoreCase))
			{
				sandboxes |= Sandboxes.Presentation;
			}
			if (!allowFullscreen)
			{
				sandboxes |= Sandboxes.Fullscreen;
			}
			return sandboxes;
		}

		public static T ToEnum<T>(this string? value, T defaultValue) where T : struct, Enum
		{
			if (!string.IsNullOrEmpty(value) && Enum.TryParse<T>(value, ignoreCase: true, out var result))
			{
				return result;
			}
			return defaultValue;
		}

		public static double ToDouble(this string? value, double defaultValue = 0.0)
		{
			if (!string.IsNullOrEmpty(value) && double.TryParse(value, NumberStyles.Any, NumberFormatInfo.InvariantInfo, out var result))
			{
				return result;
			}
			return defaultValue;
		}

		public static int ToInteger(this string? value, int defaultValue = 0)
		{
			if (!string.IsNullOrEmpty(value) && int.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return defaultValue;
		}

		public static uint ToInteger(this string? value, uint defaultValue = 0u)
		{
			if (!string.IsNullOrEmpty(value) && uint.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return defaultValue;
		}

		public static bool ToBoolean(this string? value, bool defaultValue = false)
		{
			if (!string.IsNullOrEmpty(value) && bool.TryParse(value, out var result))
			{
				return result;
			}
			return defaultValue;
		}

		public static string ReplaceFirst(this string text, string search, string replace)
		{
			int num = text.IndexOf(search);
			if (num < 0)
			{
				return text;
			}
			return text.Substring(0, num) + replace + text.Substring(num + search.Length);
		}

		public static string CollapseAndStrip(this string str)
		{
			if (str.Length == 0)
			{
				return str;
			}
			char[] array = ArrayPool<char>.Shared.Rent(str.Length);
			bool flag = true;
			int num = 0;
			int length = str.Length;
			for (int i = 0; i < length; i++)
			{
				if (str[i].IsSpaceCharacter())
				{
					if (!flag)
					{
						flag = true;
						array[num++] = ' ';
					}
				}
				else
				{
					flag = false;
					array[num++] = str[i];
				}
			}
			if (flag && num > 0)
			{
				num--;
			}
			string result = new string(array, 0, num);
			ArrayPool<char>.Shared.Return(array);
			return result;
		}

		public static string Collapse(this string str)
		{
			StringBuilder stringBuilder = StringBuilderPool.Obtain();
			bool flag = false;
			int length = str.Length;
			for (int i = 0; i < length; i++)
			{
				if (str[i].IsSpaceCharacter())
				{
					if (!flag)
					{
						stringBuilder.Append(' ');
						flag = true;
					}
				}
				else
				{
					flag = false;
					stringBuilder.Append(str[i]);
				}
			}
			return stringBuilder.ToPool();
		}

		public static bool Contains(this string[] list, string element, StringComparison comparison = StringComparison.Ordinal)
		{
			int num = list.Length;
			for (int i = 0; i < num; i++)
			{
				if (list[i].Equals(element, comparison))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsCustomElement(this string tag)
		{
			if (tag.IndexOf('-') != -1 && !TagNames.DisallowedCustomElementNames.Contains(tag))
			{
				int length = tag.Length;
				for (int i = 0; i < length; i++)
				{
					if (!tag[i].IsCustomElementName())
					{
						return false;
					}
				}
				return true;
			}
			return false;
		}

		public static bool IsCustomElement(this StringOrMemory tag)
		{
			if (tag.Memory.Span.IndexOf('-') != -1 && !TagNames.DisallowedCustomElementNames.Contains(tag))
			{
				int length = tag.Length;
				for (int i = 0; i < length; i++)
				{
					if (!tag[i].IsCustomElementName())
					{
						return false;
					}
				}
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Is(this string? current, string? other)
		{
			return string.Equals(current, other, StringComparison.Ordinal);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Is(this string? current, StringOrMemory other)
		{
			return other.Memory.Span.SequenceEqual(current.AsSpan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Is(this Span<char> current, string? other)
		{
			if (other == null)
			{
				return false;
			}
			return current.SequenceEqual(other.AsSpan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Is(this ReadOnlySpan<char> current, ReadOnlyMemory<char> other)
		{
			return current.SequenceEqual(other.Span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Is(this ReadOnlySpan<char> current, ReadOnlySpan<char> other)
		{
			return current.SequenceEqual(other);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Isi(this string? current, string? other)
		{
			return string.Equals(current, other, StringComparison.OrdinalIgnoreCase);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Isi(this string? current, StringOrMemory other)
		{
			return MemoryExtensions.Equals(current.AsSpan(), other.Memory.Span, StringComparison.OrdinalIgnoreCase);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Isi(this Span<char> current, string? other)
		{
			if (other == null)
			{
				return false;
			}
			return MemoryExtensions.Equals(current, other.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Isi(this Span<char> current, ReadOnlySpan<char> other)
		{
			return MemoryExtensions.Equals(current, other, StringComparison.OrdinalIgnoreCase);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Isi(this Span<char> current, ReadOnlyMemory<char> other)
		{
			return MemoryExtensions.Equals(current, other.Span, StringComparison.OrdinalIgnoreCase);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Isi(this ReadOnlySpan<char> current, string? other)
		{
			if (other == null)
			{
				return false;
			}
			return MemoryExtensions.Equals(current, other.AsSpan(), StringComparison.OrdinalIgnoreCase);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsOneOf(this string? element, string item1, string item2)
		{
			if (!element.Is(item1))
			{
				return element.Is(item2);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsOneOf(this string element, string item1, string item2, string item3)
		{
			if (!element.Is(item1) && !element.Is(item2))
			{
				return element.Is(item3);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsOneOf(this string element, string item1, string item2, string item3, string item4)
		{
			if (!element.Is(item1) && !element.Is(item2) && !element.Is(item3))
			{
				return element.Is(item4);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsOneOf(this string element, string item1, string item2, string item3, string item4, string item5)
		{
			if (!element.Is(item1) && !element.Is(item2) && !element.Is(item3) && !element.Is(item4))
			{
				return element.Is(item5);
			}
			return true;
		}

		public static string StripLineBreaks(this string str)
		{
			char[] array = str.ToCharArray();
			int num = 0;
			int num2 = array.Length;
			int num3 = 0;
			while (num3 < num2)
			{
				array[num3] = array[num3 + num];
				if (array[num3].IsLineBreak())
				{
					num++;
					num2--;
				}
				else
				{
					num3++;
				}
			}
			return new string(array, 0, num2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string StripLeadingTrailingSpaces(this string str)
		{
			int i = 0;
			int num = str.Length - 1;
			for (; i < str.Length && str[i].IsSpaceCharacter(); i++)
			{
			}
			while (num > i && str[num].IsSpaceCharacter())
			{
				num--;
			}
			return str.Substring(i, 1 + num - i);
		}

		public static string[] SplitWithoutTrimming(this string str, char c)
		{
			List<string> list = new List<string>();
			int num = 0;
			int length = str.Length;
			for (int i = 0; i < length; i++)
			{
				if (str[i] == c)
				{
					if (i > num)
					{
						list.Add(str.Substring(num, i - num));
					}
					num = i + 1;
				}
			}
			if (length > num)
			{
				list.Add(str.Substring(num, length - num));
			}
			return list.ToArray();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string[] SplitCommas(this string str)
		{
			return str.SplitWithTrimming(',');
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool HasHyphen(this string str, string value, StringComparison comparison = StringComparison.Ordinal)
		{
			if (!string.Equals(str, value, comparison))
			{
				if (str.Length > value.Length && str.StartsWith(value, comparison))
				{
					return str[value.Length] == '-';
				}
				return false;
			}
			return true;
		}

		public static string[] SplitSpaces(this string str)
		{
			List<string> list = new List<string>();
			char[] array = ArrayPool<char>.Shared.Rent(str.Length);
			int num = 0;
			for (int i = 0; i <= str.Length; i++)
			{
				if (i == str.Length || str[i].IsSpaceCharacter())
				{
					if (num > 0)
					{
						string text = new string(array, 0, num).StripLeadingTrailingSpaces();
						if (text.Length != 0)
						{
							list.Add(text);
						}
						num = 0;
					}
				}
				else
				{
					array[num] = str[i];
					num++;
				}
			}
			ArrayPool<char>.Shared.Return(array);
			return list.ToArray();
		}

		public static string[] SplitWithTrimming(this string str, char ch)
		{
			List<string> list = new List<string>();
			char[] array = ArrayPool<char>.Shared.Rent(str.Length);
			int num = 0;
			for (int i = 0; i <= str.Length; i++)
			{
				if (i == str.Length || str[i] == ch)
				{
					if (num > 0)
					{
						string text = new string(array, 0, num).StripLeadingTrailingSpaces();
						if (text.Length != 0)
						{
							list.Add(text);
						}
						num = 0;
					}
				}
				else
				{
					array[num] = str[i];
					num++;
				}
			}
			ArrayPool<char>.Shared.Return(array);
			return list.ToArray();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int FromHex(this string s)
		{
			return int.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int FromDec(this string s)
		{
			return int.Parse(s, NumberStyles.Integer, CultureInfo.InvariantCulture);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string HtmlEncode(this string value, Encoding encoding)
		{
			return value;
		}

		public static string CssString(this string value)
		{
			StringBuilder stringBuilder = StringBuilderPool.Obtain();
			stringBuilder.Append('"');
			if (!string.IsNullOrEmpty(value))
			{
				int length = value.Length;
				for (int i = 0; i < length; i++)
				{
					char c = value[i];
					switch (c)
					{
					case '\0':
						stringBuilder.ReturnToPool();
						throw new DomException(DomError.InvalidCharacter);
					case '"':
					case '\\':
						stringBuilder.Append('\\').Append(c);
						continue;
					}
					if (c.IsInRange(1, 31) || c == '{')
					{
						stringBuilder.Append('\\').Append(c.ToHex()).Append((i + 1 != length) ? " " : "");
					}
					else
					{
						stringBuilder.Append(c);
					}
				}
			}
			stringBuilder.Append('"');
			return stringBuilder.ToPool();
		}

		public static string CssFunction(this string value, string argument)
		{
			return value + "(" + argument + ")";
		}

		public static string UrlEncode(this byte[] content)
		{
			StringBuilder stringBuilder = StringBuilderPool.Obtain();
			int num = content.Length;
			for (int i = 0; i < num; i++)
			{
				char c = (char)content[i];
				switch (c)
				{
				case ' ':
					stringBuilder.Append('+');
					break;
				default:
					if (!c.IsAlphanumericAscii())
					{
						stringBuilder.Append('%').Append(content[i].ToString("X2"));
						break;
					}
					goto case '*';
				case '*':
				case '-':
				case '.':
				case '_':
				case '~':
					stringBuilder.Append(c);
					break;
				}
			}
			return stringBuilder.ToPool();
		}

		public static byte[] UrlDecode(this string value)
		{
			MemoryStream memoryStream = new MemoryStream();
			int length = value.Length;
			for (int i = 0; i < length; i++)
			{
				char c = value[i];
				switch (c)
				{
				case '+':
				{
					byte value4 = 32;
					memoryStream.WriteByte(value4);
					break;
				}
				case '%':
				{
					if (i + 2 >= length)
					{
						throw new FormatException();
					}
					byte value3 = (byte)(16 * value[++i].FromHex() + value[++i].FromHex());
					memoryStream.WriteByte(value3);
					break;
				}
				default:
				{
					byte value2 = (byte)c;
					memoryStream.WriteByte(value2);
					break;
				}
				}
			}
			return memoryStream.ToArray();
		}

		public static string NormalizeLineEndings(this string value)
		{
			if (!string.IsNullOrEmpty(value))
			{
				StringBuilder stringBuilder = StringBuilderPool.Obtain();
				bool flag = false;
				int length = value.Length;
				for (int i = 0; i < length; i++)
				{
					char c = value[i];
					bool flag2 = c == '\n';
					if (flag && !flag2)
					{
						stringBuilder.Append('\n');
					}
					else if (!flag && flag2)
					{
						stringBuilder.Append('\r');
					}
					flag = c == '\r';
					stringBuilder.Append(c);
				}
				if (flag)
				{
					stringBuilder.Append('\n');
				}
				return stringBuilder.ToPool();
			}
			return value;
		}

		public static string? ToEncodingType(this string? encType)
		{
			if (!encType.Isi(MimeTypeNames.Plain) && !encType.Isi(MimeTypeNames.MultipartForm) && !encType.Isi(MimeTypeNames.ApplicationJson))
			{
				return null;
			}
			return encType?.ToLowerInvariant();
		}

		public static string? ToFormMethod(this string? method)
		{
			if (!method.Isi(FormMethodNames.Get) && !method.Isi(FormMethodNames.Post) && !method.Isi(FormMethodNames.Dialog))
			{
				return null;
			}
			return method?.ToLowerInvariant();
		}
	}
	public sealed class StringSource
	{
		private readonly string _content;

		private readonly int _last;

		private int _index;

		private char _current;

		public char Current => _current;

		public bool IsDone => _current == '\uffff';

		public int Index => _index;

		public string Content => _content;

		public StringSource(string content)
		{
			_content = content ?? string.Empty;
			_last = _content.Length - 1;
			_index = 0;
			_current = ((_last == -1) ? '\uffff' : content[0]);
		}

		public char Next()
		{
			if (_index == _last)
			{
				_current = '\uffff';
				_index = _content.Length;
			}
			else if (_index < _content.Length)
			{
				_current = _content[++_index];
			}
			return _current;
		}

		public char Back()
		{
			if (_index > 0)
			{
				_current = _content[--_index];
			}
			return _current;
		}
	}
	public static class StringSourceExtensions
	{
		public static char SkipSpaces(this StringSource source)
		{
			char c = source.Current;
			while (c.IsSpaceCharacter())
			{
				c = source.Next();
			}
			return c;
		}

		public static char Next(this StringSource source, int n)
		{
			for (int i = 0; i < n; i++)
			{
				source.Next();
			}
			return source.Current;
		}

		public static char Back(this StringSource source, int n)
		{
			for (int i = 0; i < n; i++)
			{
				source.Back();
			}
			return source.Current;
		}

		public static char Peek(this StringSource source)
		{
			char result = source.Next();
			source.Back();
			return result;
		}
	}
	public sealed class StringTextSource : IReadOnlyTextSource, IDisposable
	{
		private readonly string _string;

		private readonly ReadOnlyMemory<char> _memory;

		private readonly int _length;

		private int _index;

		public string Text => _string;

		public char this[int index] => _string[index];

		public int Length => _length;

		public Encoding CurrentEncoding
		{
			get
			{
				return TextEncoding.Utf8;
			}
			set
			{
			}
		}

		public int Index
		{
			get
			{
				return _index;
			}
			set
			{
				_index = value;
			}
		}

		public StringTextSource(string source)
		{
			_string = source;
			_length = source.Length;
			_memory = source.AsMemory();
		}

		public void Dispose()
		{
		}

		public char ReadCharacter()
		{
			if (_index < _length)
			{
				return _string[_index++];
			}
			_index++;
			return '\uffff';
		}

		public string ReadCharacters(int characters)
		{
			return ReadMemory(characters).ToString();
		}

		public StringOrMemory ReadMemory(int characters)
		{
			int index = _index;
			if (index + characters <= _length)
			{
				_index += characters;
				return _memory.Slice(index, characters);
			}
			_index += characters;
			characters = Math.Min(characters, _length - index);
			return _memory.Slice(index, characters);
		}

		public Task PrefetchAsync(int length, CancellationToken cancellationToken)
		{
			return Task.CompletedTask;
		}

		public Task PrefetchAllAsync(CancellationToken cancellationToken)
		{
			return Task.CompletedTask;
		}

		public bool TryGetContentLength(out int length)
		{
			length = _length;
			return true;
		}
	}
	public static class Symbols
	{
		public const char EndOfFile = '\uffff';

		public const char Tilde = '~';

		public const char Pipe = '|';

		public const char Null = '\0';

		public const char Ampersand = '&';

		public const char Num = '#';

		public const char Dollar = '$';

		public const char Semicolon = ';';

		public const char Asterisk = '*';

		public const char Equality = '=';

		public const char Plus = '+';

		public const char Minus = '-';

		public const char Comma = ',';

		public const char Dot = '.';

		public const char Accent = '^';

		public const char At = '@';

		public const char LessThan = '<';

		public const char GreaterThan = '>';

		public const char SingleQuote = '\'';

		public const char DoubleQuote = '"';

		public const char CurvedQuote = '`';

		public const char QuestionMark = '?';

		public const char Tab = '\t';

		public const char LineFeed = '\n';

		public const char CarriageReturn = '\r';

		public const char FormFeed = '\f';

		public const char Space = ' ';

		public const char Solidus = '/';

		public const char NoBreakSpace = '\u00a0';

		public const char ReverseSolidus = '\\';

		public const char Colon = ':';

		public const char ExclamationMark = '!';

		public const char Replacement = '\ufffd';

		public const char Underscore = '_';

		public const char RoundBracketOpen = '(';

		public const char RoundBracketClose = ')';

		public const char SquareBracketOpen = '[';

		public const char SquareBracketClose = ']';

		public const char CurlyBracketOpen = '{';

		public const char CurlyBracketClose = '}';

		public const char Percent = '%';

		public const int MaximumCodepoint = 1114111;
	}
	public static class TextEncoding
	{
		public static readonly Encoding Utf8 = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

		public static readonly Encoding Utf16Be = new UnicodeEncoding(bigEndian: true, byteOrderMark: false);

		public static readonly Encoding Utf16Le = new UnicodeEncoding(bigEndian: false, byteOrderMark: false);

		public static readonly Encoding Utf32Le = GetEncoding("UTF-32LE");

		public static readonly Encoding Utf32Be = GetEncoding("UTF-32BE");

		public static readonly Encoding Gb18030 = GetEncoding("GB18030");

		public static readonly Encoding Big5 = GetEncoding("big5");

		public static readonly Encoding Windows874 = GetEncoding("windows-874");

		public static readonly Encoding Windows1250 = GetEncoding("windows-1250");

		public static readonly Encoding Windows1251 = GetEncoding("windows-1251");

		public static readonly Encoding Windows1252 = GetEncoding("windows-1252");

		public static readonly Encoding Windows1253 = GetEncoding("windows-1253");

		public static readonly Encoding Windows1254 = GetEncoding("windows-1254");

		public static readonly Encoding Windows1255 = GetEncoding("windows-1255");

		public static readonly Encoding Windows1256 = GetEncoding("windows-1256");

		public static readonly Encoding Windows1257 = GetEncoding("windows-1257");

		public static readonly Encoding Windows1258 = GetEncoding("windows-1258");

		public static readonly Encoding Latin2 = GetEncoding("iso-8859-2");

		public static readonly Encoding Latin3 = GetEncoding("iso-8859-3");

		public static readonly Encoding Latin4 = GetEncoding("iso-8859-4");

		public static readonly Encoding Latin5 = GetEncoding("iso-8859-5");

		public static readonly Encoding Latin13 = GetEncoding("iso-8859-13");

		public static readonly Encoding UsAscii = GetEncoding("us-ascii");

		public static readonly Encoding Korean = GetEncoding("ks_c_5601-1987");

		private static readonly Dictionary<string, Encoding> encodings = CreateEncodings();

		public static bool IsUnicode(this Encoding encoding)
		{
			if (encoding != Utf16Be)
			{
				return encoding == Utf16Le;
			}
			return true;
		}

		public static Encoding? Parse(string content)
		{
			string charset = string.Empty;
			int num = 0;
			for (int i = num; i < content.Length - 7; i++)
			{
				if (content.Substring(i).StartsWith(AttributeNames.Charset, StringComparison.OrdinalIgnoreCase))
				{
					num = i + 7;
					break;
				}
			}
			if (num > 0 && num < content.Length)
			{
				for (int j = num; j < content.Length - 1 && content[j].IsSpaceCharacter(); j++)
				{
					num++;
				}
				if (content[num] != '=')
				{
					return Parse(content.Substring(num));
				}
				num++;
				for (int k = num; k < content.Length && content[k].IsSpaceCharacter(); k++)
				{
					num++;
				}
				if (num < content.Length)
				{
					if (content[num] == '"')
					{
						content = content.Substring(num + 1);
						int num2 = content.IndexOf('"');
						if (num2 != -1)
						{
							charset = content.Substring(0, num2);
						}
					}
					else if (content[num] == '\'')
					{
						content = content.Substring(num + 1);
						int num3 = content.IndexOf('\'');
						if (num3 != -1)
						{
							charset = content.Substring(0, num3);
						}
					}
					else
					{
						content = content.Substring(num);
						int num4 = 0;
						for (int l = 0; l < content.Length && !content[l].IsSpaceCharacter() && content[l] != ';'; l++)
						{
							num4++;
						}
						charset = content.Substring(0, num4);
					}
				}
			}
			if (!IsSupported(charset))
			{
				return null;
			}
			return Resolve(charset);
		}

		public static bool IsSupported(string charset)
		{
			return encodings.ContainsKey(charset);
		}

		public static Encoding Resolve(string? charset)
		{
			if (charset != null && encodings.TryGetValue(charset, out Encoding value))
			{
				return value;
			}
			return Utf8;
		}

		private static Encoding GetEncoding(string name, Encoding? fallback = null)
		{
			try
			{
				return Encoding.GetEncoding(name);
			}
			catch (Exception)
			{
				return fallback ?? Utf8;
			}
		}

		private static Dictionary<string, Encoding> CreateEncodings()
		{
			Dictionary<string, Encoding> obj = new Dictionary<string, Encoding>(StringComparer.OrdinalIgnoreCase)
			{
				{ "unicode-1-1-utf-8", Utf8 },
				{ "utf-8", Utf8 },
				{ "utf8", Utf8 },
				{ "utf-16be", Utf16Be },
				{ "utf-16", Utf16Le },
				{ "utf-16le", Utf16Le },
				{ "dos-874", Windows874 },
				{ "iso-8859-11", Windows874 },
				{ "iso8859-11", Windows874 },
				{ "iso885911", Windows874 },
				{ "tis-620", Windows874 },
				{ "windows-874", Windows874 },
				{ "cp1250", Windows1250 },
				{ "windows-1250", Windows1250 },
				{ "x-cp1250", Windows1250 },
				{ "cp1251", Windows1251 },
				{ "windows-1251", Windows1251 },
				{ "x-cp1251", Windows1251 },
				{ "x-user-defined", Windows1252 },
				{ "ansi_x3.4-1968", Windows1252 },
				{ "ascii", Windows1252 },
				{ "cp1252", Windows1252 },
				{ "cp819", Windows1252 },
				{ "csisolatin1", Windows1252 },
				{ "ibm819", Windows1252 },
				{ "iso-8859-1", Windows1252 },
				{ "iso-ir-100", Windows1252 },
				{ "iso8859-1", Windows1252 },
				{ "iso88591", Windows1252 },
				{ "iso_8859-1", Windows1252 },
				{ "iso_8859-1:1987", Windows1252 },
				{ "l1", Windows1252 },
				{ "latin1", Windows1252 },
				{ "us-ascii", Windows1252 },
				{ "windows-1252", Windows1252 },
				{ "x-cp1252", Windows1252 },
				{ "cp1253", Windows1253 },
				{ "windows-1253", Windows1253 },
				{ "x-cp1253", Windows1253 },
				{ "cp1254", Windows1254 },
				{ "csisolatin5", Windows1254 },
				{ "iso-8859-9", Windows1254 },
				{ "iso-ir-148", Windows1254 },
				{ "iso8859-9", Windows1254 },
				{ "iso88599", Windows1254 },
				{ "iso_8859-9", Windows1254 },
				{ "iso_8859-9:1989", Windows1254 },
				{ "l5", Windows1254 },
				{ "latin5", Windows1254 },
				{ "windows-1254", Windows1254 },
				{ "x-cp1254", Windows1254 },
				{ "cp1255", Windows1255 },
				{ "windows-1255", Windows1255 },
				{ "x-cp1255", Windows1255 },
				{ "cp1256", Windows1256 },
				{ "windows-1256", Windows1256 },
				{ "x-cp1256", Windows1256 },
				{ "cp1257", Windows1257 },
				{ "windows-1257", Windows1257 },
				{ "x-cp1257", Windows1257 },
				{ "cp1258", Windows1258 },
				{ "windows-1258", Windows1258 },
				{ "x-cp1258", Windows1258 }
			};
			Encoding encoding = GetEncoding("macintosh");
			obj.Add("csmacintosh", encoding);
			obj.Add("mac", encoding);
			obj.Add("macintosh", encoding);
			obj.Add("x-mac-roman", encoding);
			Encoding encoding2 = GetEncoding("x-mac-cyrillic");
			obj.Add("x-mac-cyrillic", encoding2);
			obj.Add("x-mac-ukrainian", encoding2);
			Encoding encoding3 = GetEncoding("cp866");
			obj.Add("866", encoding3);
			obj.Add("cp866", encoding3);
			obj.Add("csibm866", encoding3);
			obj.Add("ibm866", encoding3);
			obj.Add("csisolatin2", Latin2);
			obj.Add("iso-8859-2", Latin2);
			obj.Add("iso-ir-101", Latin2);
			obj.Add("iso8859-2", Latin2);
			obj.Add("iso88592", Latin2);
			obj.Add("iso_8859-2", Latin2);
			obj.Add("iso_8859-2:1987", Latin2);
			obj.Add("l2", Latin2);
			obj.Add("latin2", Latin2);
			obj.Add("csisolatin3", Latin3);
			obj.Add("iso-8859-3", Latin3);
			obj.Add("iso-ir-109", Latin3);
			obj.Add("iso8859-3", Latin3);
			obj.Add("iso88593", Latin3);
			obj.Add("iso_8859-3", Latin3);
			obj.Add("iso_8859-3:1988", Latin3);
			obj.Add("l3", Latin3);
			obj.Add("latin3", Latin3);
			obj.Add("csisolatin4", Latin4);
			obj.Add("iso-8859-4", Latin4);
			obj.Add("iso-ir-110", Latin4);
			obj.Add("iso8859-4", Latin4);
			obj.Add("iso88594", Latin4);
			obj.Add("iso_8859-4", Latin4);
			obj.Add("iso_8859-4:1988", Latin4);
			obj.Add("l4", Latin4);
			obj.Add("latin4", Latin4);
			obj.Add("csisolatincyrillic", Latin5);
			obj.Add("cyrillic", Latin5);
			obj.Add("iso-8859-5", Latin5);
			obj.Add("iso-ir-144", Latin5);
			obj.Add("iso8859-5", Latin5);
			obj.Add("iso88595", Latin5);
			obj.Add("iso_8859-5", Latin5);
			obj.Add("iso_8859-5:1988", Latin5);
			Encoding encoding4 = GetEncoding("iso-8859-6");
			obj.Add("arabic", encoding4);
			obj.Add("asmo-708", encoding4);
			obj.Add("csiso88596e", encoding4);
			obj.Add("csiso88596i", encoding4);
			obj.Add("csisolatinarabic", encoding4);
			obj.Add("ecma-114", encoding4);
			obj.Add("iso-8859-6", encoding4);
			obj.Add("iso-8859-6-e", encoding4);
			obj.Add("iso-8859-6-i", encoding4);
			obj.Add("iso-ir-127", encoding4);
			obj.Add("iso8859-6", encoding4);
			obj.Add("iso88596", encoding4);
			obj.Add("iso_8859-6", encoding4);
			obj.Add("iso_8859-6:1987", encoding4);
			Encoding encoding5 = GetEncoding("iso-8859-7");
			obj.Add("csisolatingreek", encoding5);
			obj.Add("ecma-118", encoding5);
			obj.Add("elot_928", encoding5);
			obj.Add("greek", encoding5);
			obj.Add("greek8", encoding5);
			obj.Add("iso-8859-7", encoding5);
			obj.Add("iso-ir-126", encoding5);
			obj.Add("iso8859-7", encoding5);
			obj.Add("iso88597", encoding5);
			obj.Add("iso_8859-7", encoding5);
			obj.Add("iso_8859-7:1987", encoding5);
			obj.Add("sun_eu_greek", encoding5);
			Encoding encoding6 = GetEncoding("iso-8859-8");
			obj.Add("csiso88598e", encoding6);
			obj.Add("csisolatinhebrew", encoding6);
			obj.Add("hebrew", encoding6);
			obj.Add("iso-8859-8", encoding6);
			obj.Add("iso-8859-8-e", encoding6);
			obj.Add("iso-ir-138", encoding6);
			obj.Add("iso8859-8", encoding6);
			obj.Add("iso88598", encoding6);
			obj.Add("iso_8859-8", encoding6);
			obj.Add("iso_8859-8:1988", encoding6);
			obj.Add("visual", encoding6);
			Encoding encoding7 = GetEncoding("iso-8859-8-i");
			obj.Add("csiso88598i", encoding7);
			obj.Add("iso-8859-8-i", encoding7);
			obj.Add("logical", encoding7);
			Encoding encoding8 = GetEncoding("iso-8859-13");
			obj.Add("iso-8859-13", encoding8);
			obj.Add("iso8859-13", encoding8);
			obj.Add("iso885913", encoding8);
			Encoding encoding9 = GetEncoding("iso-8859-15");
			obj.Add("csisolatin9", encoding9);
			obj.Add("iso-8859-15", encoding9);
			obj.Add("iso8859-15", encoding9);
			obj.Add("iso885915", encoding9);
			obj.Add("iso_8859-15", encoding9);
			obj.Add("l9", encoding9);
			Encoding encoding10 = GetEncoding("koi8-r");
			obj.Add("cskoi8r", encoding10);
			obj.Add("koi", encoding10);
			obj.Add("koi8", encoding10);
			obj.Add("koi8-r", encoding10);
			obj.Add("koi8_r", encoding10);
			obj.Add("koi8-u", GetEncoding("koi8-u"));
			Encoding encoding11 = GetEncoding("GB18030", GetEncoding("x-cp20936"));
			obj.Add("chinese", encoding11);
			obj.Add("csgb2312", encoding11);
			obj.Add("csiso58gb231280", encoding11);
			obj.Add("gb2312", encoding11);
			obj.Add("gb_2312", encoding11);
			obj.Add("gb_2312-80", encoding11);
			obj.Add("gbk", encoding11);
			obj.Add("iso-ir-58", encoding11);
			obj.Add("x-gbk", encoding11);
			obj.Add("hz-gb-2312", GetEncoding("hz-gb-2312"));
			obj.Add("gb18030", Gb18030);
			Encoding encoding12 = GetEncoding("x-cp50227");
			obj.Add("x-cp50227", encoding12);
			obj.Add("iso-22-cn", encoding12);
			obj.Add("big5", Big5);
			obj.Add("big5-hkscs", Big5);
			obj.Add("cn-big5", Big5);
			obj.Add("csbig5", Big5);
			obj.Add("x-x-big5", Big5);
			Encoding encoding13 = GetEncoding("iso-2022-jp");
			obj.Add("csiso2022jp", encoding13);
			obj.Add("iso-2022-jp", encoding13);
			Encoding encoding14 = GetEncoding("iso-2022-kr");
			obj.Add("csiso2022kr", encoding14);
			obj.Add("iso-2022-kr", encoding14);
			Encoding encoding15 = GetEncoding("iso-2022-cn");
			obj.Add("iso-2022-cn", encoding15);
			obj.Add("iso-2022-cn-ext", encoding15);
			obj.Add("shift_jis", GetEncoding("shift_jis"));
			Encoding encoding16 = GetEncoding("euc-jp");
			obj.Add("euc-jp", encoding16);
			Encoding encoding17 = GetEncoding("euc-kr");
			obj.Add("euc-kr", encoding17);
			return obj;
		}
	}
	public readonly struct TextPosition : IEquatable<TextPosition>, IComparable<TextPosition>
	{
		public static readonly TextPosition Empty;

		private readonly ushort _line;

		private readonly ushort _column;

		private readonly int _position;

		public int Line => _line;

		public int Column => _column;

		public int Position => _position;

		public int Index => _position - 1;

		public TextPosition(ushort line, ushort column, int position)
		{
			_line = line;
			_column = column;
			_position = position;
		}

		public TextPosition Shift(int columns)
		{
			return new TextPosition(_line, (ushort)(_column + columns), _position + columns);
		}

		public TextPosition After(char chr)
		{
			ushort num = _line;
			ushort num2 = _column;
			if (chr == '\n')
			{
				num++;
				num2 = 0;
			}
			return new TextPosition(num, ++num2, _position + 1);
		}

		public TextPosition After(string str)
		{
			ushort num = _line;
			ushort num2 = _column;
			for (int i = 0; i < str.Length; i++)
			{
				if (str[i] == '\n')
				{
					num++;
					num2 = 0;
				}
				num2++;
			}
			return new TextPosition(num, num2, _position + str.Length);
		}

		public override string ToString()
		{
			return $"Ln {_line}, Col {_column}, Pos {_position}";
		}

		public override int GetHashCode()
		{
			return _position ^ ((_line | _column) + _line);
		}

		public override bool Equals(object? obj)
		{
			if (obj is TextPosition other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(TextPosition other)
		{
			if (_position == other._position && _column == other._column)
			{
				return _line == other._line;
			}
			return false;
		}

		public static bool operator >(TextPosition a, TextPosition b)
		{
			return a._position > b._position;
		}

		public static bool operator <(TextPosition a, TextPosition b)
		{
			return a._position < b._position;
		}

		public int CompareTo(TextPosition other)
		{
			if (!Equals(other))
			{
				if (!(this > other))
				{
					return -1;
				}
				return 1;
			}
			return 0;
		}
	}
	[DebuggerStepThrough]
	public readonly struct TextRange : IEquatable<TextRange>, IComparable<TextRange>
	{
		private readonly TextPosition _start;

		private readonly TextPosition _end;

		public TextPosition Start => _start;

		public TextPosition End => _end;

		public TextRange(TextPosition start, TextPosition end)
		{
			_start = start;
			_end = end;
		}

		public override string ToString()
		{
			return $"({_start}) -- ({_end})";
		}

		public override int GetHashCode()
		{
			return _end.GetHashCode() ^ _start.GetHashCode();
		}

		public override bool Equals(object? obj)
		{
			if (obj is TextRange other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(TextRange other)
		{
			if (_start.Equals(other._start))
			{
				return _end.Equals(other._end);
			}
			return false;
		}

		public static bool operator >(TextRange a, TextRange b)
		{
			return a._start > b._end;
		}

		public static bool operator <(TextRange a, TextRange b)
		{
			return a._end < b._start;
		}

		public int CompareTo(TextRange other)
		{
			if (this > other)
			{
				return 1;
			}
			if (other > this)
			{
				return -1;
			}
			return 0;
		}
	}
	public sealed class TextSource : ITextSource, IReadOnlyTextSource, IDisposable
	{
		private readonly WritableTextSource _writableSource;

		private readonly IReadOnlyTextSource _readOnlyTextSource;

		public string Text => _readOnlyTextSource.Text;

		public int Length => _readOnlyTextSource.Length;

		public Encoding CurrentEncoding
		{
			get
			{
				return _readOnlyTextSource.CurrentEncoding;
			}
			set
			{
				if (_writableSource != null)
				{
					_writableSource.CurrentEncoding = value;
				}
			}
		}

		public int Index
		{
			get
			{
				return _readOnlyTextSource.Index;
			}
			set
			{
				_readOnlyTextSource.Index = value;
			}
		}

		public char this[int index] => _readOnlyTextSource[index];

		public TextSource(string source)
		{
			_writableSource = new WritableTextSource(source);
			_readOnlyTextSource = _writableSource;
		}

		public TextSource(Stream baseStream, Encoding encoding = null)
		{
			_writableSource = new WritableTextSource(baseStream, encoding);
			_readOnlyTextSource = _writableSource;
		}

		public TextSource(ReadOnlyMemoryTextSource source)
		{
			_writableSource = null;
			_readOnlyTextSource = source;
		}

		public TextSource(CharArrayTextSource source)
		{
			_writableSource = null;
			_readOnlyTextSource = source;
		}

		public TextSource(StringTextSource source)
		{
			_writableSource = null;
			_readOnlyTextSource = source;
		}

		public char ReadCharacter()
		{
			return _readOnlyTextSource.ReadCharacter();
		}

		public string ReadCharacters(int characters)
		{
			return _readOnlyTextSource.ReadCharacters(characters);
		}

		public StringOrMemory ReadMemory(int characters)
		{
			return _readOnlyTextSource.ReadMemory(characters);
		}

		public Task PrefetchAsync(int length, CancellationToken cancellationToken)
		{
			return _readOnlyTextSource.PrefetchAsync(length, cancellationToken);
		}

		public Task PrefetchAllAsync(CancellationToken cancellationToken)
		{
			return _readOnlyTextSource.PrefetchAllAsync(cancellationToken);
		}

		public bool TryGetContentLength(out int length)
		{
			return _readOnlyTextSource.TryGetContentLength(out length);
		}

		public void InsertText(string content)
		{
			if (_writableSource == null)
			{
				throw new InvalidOperationException("Cannot insert text into a read-only text source.");
			}
			_writableSource.InsertText(content);
		}

		public void Dispose()
		{
			_readOnlyTextSource.Dispose();
		}

		public IReadOnlyTextSource GetUnderlyingTextSource()
		{
			return _readOnlyTextSource;
		}
	}
	public class TextView
	{
		private readonly TextSource _source;

		private readonly TextRange _range;

		public TextRange Range => _range;

		public string Text
		{
			get
			{
				int num = Math.Max(_range.Start.Position - 1, 0);
				int num2 = _range.End.Position + 1 - _range.Start.Position;
				string text = _source.Text;
				if (num + num2 > text.Length)
				{
					num2 = text.Length - num;
				}
				return text.Substring(num, num2);
			}
		}

		public TextView(TextSource source, TextRange range)
		{
			_source = source;
			_range = range;
		}
	}
	internal sealed class WritableTextSource : ITextSource, IReadOnlyTextSource, IDisposable
	{
		private enum EncodingConfidence : byte
		{
			Tentative,
			Certain,
			Irrelevant
		}

		private const int BufferSize = 4096;

		private readonly Stream _baseStream;

		private readonly MemoryStream _raw;

		private readonly byte[] _buffer;

		private readonly char[] _chars;

		private StringBuilder _content;

		private EncodingConfidence _confidence;

		private bool _finished;

		private Encoding _encoding;

		private Decoder _decoder;

		private int _index;

		[MemberNotNull("_content")]
		public string Text
		{
			[MemberNotNull("_content")]
			get
			{
				return _content.ToString();
			}
		}

		public char this[int index] => Replace(_content[index]);

		public int Length => _content.Length;

		public Encoding CurrentEncoding
		{
			get
			{
				return _encoding;
			}
			set
			{
				if (_confidence != 0)
				{
					return;
				}
				if (_encoding.IsUnicode())
				{
					_confidence = EncodingConfidence.Certain;
					return;
				}
				if (value.IsUnicode())
				{
					value = TextEncoding.Utf8;
				}
				if (value == _encoding)
				{
					_confidence = EncodingConfidence.Certain;
					return;
				}
				_encoding = value;
				_decoder = value.GetDecoder();
				byte[] array = _raw.ToArray();
				char[] array2 = new char[_encoding.GetMaxCharCount(array.Length)];
				int chars = _decoder.GetChars(array, 0, array.Length, array2, 0);
				string text = new string(array2, 0, chars);
				int num = Math.Min(_index, text.Length);
				if (text.Substring(0, num).Is(_content.ToString(0, num)))
				{
					_confidence = EncodingConfidence.Certain;
					_content.Remove(num, _content.Length - num);
					_content.Append(text.Substring(num));
					return;
				}
				_index = 0;
				_content.Clear().Append(text);
				throw new NotSupportedException();
			}
		}

		public int Index
		{
			get
			{
				return _index;
			}
			set
			{
				_index = value;
			}
		}

		private WritableTextSource(Encoding encoding, bool allocateBuffers)
		{
			if (allocateBuffers)
			{
				_buffer = new byte[4096];
				_chars = new char[4097];
			}
			_raw = new MemoryStream();
			_index = 0;
			_encoding = encoding ?? TextEncoding.Utf8;
			_decoder = _encoding.GetDecoder();
		}

		public WritableTextSource(string source)
			: this(null, TextEncoding.Utf8)
		{
			_finished = true;
			_content.Append(source);
			_confidence = EncodingConfidence.Irrelevant;
		}

		public WritableTextSource(Stream baseStream, Encoding encoding = null)
			: this(encoding, baseStream != null)
		{
			_baseStream = baseStream;
			_content = StringBuilderPool.Obtain();
			_confidence = EncodingConfidence.Tentative;
		}

		public void Dispose()
		{
			if (_content != null)
			{
				_raw.Dispose();
				_content.Clear().ReturnToPool();
				_content = null;
			}
		}

		public char ReadCharacter()
		{
			if (_index < _content.Length)
			{
				return Replace(_content[_index++]);
			}
			ExpandBuffer(4096L);
			int num = _index++;
			if (num >= _content.Length)
			{
				return '\uffff';
			}
			return Replace(_content[num]);
		}

		public string ReadCharacters(int characters)
		{
			int index = _index;
			if (index + characters <= _content.Length)
			{
				_index += characters;
				return _content.ToString(index, characters);
			}
			ExpandBuffer(Math.Max(4096, characters));
			_index += characters;
			characters = Math.Min(characters, _content.Length - index);
			return _content.ToString(index, characters);
		}

		public StringOrMemory ReadMemory(int characters)
		{
			return new StringOrMemory(ReadCharacters(characters));
		}

		public Task PrefetchAsync(int length, CancellationToken cancellationToken)
		{
			return ExpandBufferAsync(length, cancellationToken);
		}

		public async Task PrefetchAllAsync(CancellationToken cancellationToken)
		{
			if (_baseStream != null && _content.Length == 0)
			{
				await DetectByteOrderMarkAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			while (!_finished)
			{
				await ReadIntoBufferAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		public bool TryGetContentLength(out int length)
		{
			length = 0;
			return false;
		}

		public void InsertText(string content)
		{
			if (_index >= 0 && _index < _content.Length)
			{
				_content.Insert(_index, content);
			}
			else
			{
				_content.Append(content);
			}
			_index += content.Length;
		}

		private static char Replace(char c)
		{
			if (c != '\uffff')
			{
				return c;
			}
			return '\ufffd';
		}

		private async Task DetectByteOrderMarkAsync(CancellationToken cancellationToken)
		{
			int num = await _baseStream.ReadAsync(_buffer, 0, 4096).ConfigureAwait(continueOnCapturedContext: false);
			int num2 = 0;
			if (num > 2 && _buffer[0] == 239 && _buffer[1] == 187 && _buffer[2] == 191)
			{
				_encoding = TextEncoding.Utf8;
				num2 = 3;
			}
			else if (num > 3 && _buffer[0] == byte.MaxValue && _buffer[1] == 254 && _buffer[2] == 0 && _buffer[3] == 0)
			{
				_encoding = TextEncoding.Utf32Le;
				num2 = 4;
			}
			else if (num > 3 && _buffer[0] == 0 && _buffer[1] == 0 && _buffer[2] == 254 && _buffer[3] == byte.MaxValue)
			{
				_encoding = TextEncoding.Utf32Be;
				num2 = 4;
			}
			else if (num > 1 && _buffer[0] == 254 && _buffer[1] == byte.MaxValue)
			{
				_encoding = TextEncoding.Utf16Be;
				num2 = 2;
			}
			else if (num > 1 && _buffer[0] == byte.MaxValue && _buffer[1] == 254)
			{
				_encoding = TextEncoding.Utf16Le;
				num2 = 2;
			}
			else if (num > 3 && _buffer[0] == 132 && _buffer[1] == 49 && _buffer[2] == 149 && _buffer[3] == 51)
			{
				_encoding = TextEncoding.Gb18030;
				num2 = 4;
			}
			if (num2 > 0)
			{
				num -= num2;
				Array.Copy(_buffer, num2, _buffer, 0, num);
				_decoder = _encoding.GetDecoder();
				_confidence = EncodingConfidence.Certain;
			}
			AppendContentFromBuffer(num);
		}

		private async Task ExpandBufferAsync(long size, CancellationToken cancellationToken)
		{
			if (!_finished && _content.Length == 0)
			{
				await DetectByteOrderMarkAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
			while (!_finished && size + _index > _content.Length)
			{
				await ReadIntoBufferAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		private async Task ReadIntoBufferAsync(CancellationToken cancellationToken)
		{
			AppendContentFromBuffer(await _baseStream.ReadAsync(_buffer, 0, 4096, cancellationToken).ConfigureAwait(continueOnCapturedContext: false));
		}

		private void ExpandBuffer(long size)
		{
			if (!_finished && _content.Length == 0)
			{
				DetectByteOrderMarkAsync(CancellationToken.None).Wait();
			}
			while (!_finished && size + _index > _content.Length)
			{
				ReadIntoBuffer();
			}
		}

		private void ReadIntoBuffer()
		{
			int size = _baseStream.Read(_buffer, 0, 4096);
			AppendContentFromBuffer(size);
		}

		private void AppendContentFromBuffer(int size)
		{
			_finished = size == 0;
			int chars = _decoder.GetChars(_buffer, 0, size, _chars, 0);
			if (_confidence != EncodingConfidence.Certain)
			{
				_raw.Write(_buffer, 0, size);
			}
			_content.Append(_chars, 0, chars);
		}
	}
	public static class XmlExtensions
	{
		public static bool IsPubidChar(this char c)
		{
			if (!c.IsAlphanumericAscii() && c != '-' && c != '\'' && c != '+' && c != ',' && c != '.' && c != '/' && c != ':' && c != '?' && c != '=' && c != '!' && c != '*' && c != '#' && c != '@' && c != '$' && c != '_' && c != '(' && c != ')' && c != ';' && c != '%')
			{
				return c.IsSpaceCharacter();
			}
			return true;
		}

		public static bool IsXmlNameStart(this char c)
		{
			if (!c.IsLetter() && c != ':' && c != '_' && !c.IsInRange(192, 214) && !c.IsInRange(216, 246) && !c.IsInRange(248, 767) && !c.IsInRange(880, 893) &