using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Acornima.Ast;
using Acornima.Helpers;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Adam Simon")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Adam Simon")]
[assembly: AssemblyDescription("A standard-compliant JavaScript parser, which is a fork of Esprima.NET combined with the .NET port of the acornjs parser.")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.1+2d9dfb291de04ddba645cd7ff35a4972ac99c691")]
[assembly: AssemblyProduct("Acornima")]
[assembly: AssemblyTitle("Acornima")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/adams85/acornima")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: InternalsVisibleTo("Acornima.Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001009386e741f80212b92e6324bd2d5d89871d081fa41cce46ba30a3d3cae4be4935a92cf6c76a55e5192adad2235139d550816388bdad8a972a7a4eace42838c7694a0124c56174ff27690ba4d470c423ee72efac06decef995b89b6e936b59fe4c6ba88d3c2d3a34216221e1bf455faf1c3e88d93f37b0891b2fbbad9bf606d9ce")]
[assembly: InternalsVisibleTo("Acornima.Extras, PublicKey=00240000048000009400000006020000002400005253413100040000010001009386e741f80212b92e6324bd2d5d89871d081fa41cce46ba30a3d3cae4be4935a92cf6c76a55e5192adad2235139d550816388bdad8a972a7a4eace42838c7694a0124c56174ff27690ba4d470c423ee72efac06decef995b89b6e936b59fe4c6ba88d3c2d3a34216221e1bf455faf1c3e88d93f37b0891b2fbbad9bf606d9ce")]
[assembly: InternalsVisibleTo("Acornima.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001009386e741f80212b92e6324bd2d5d89871d081fa41cce46ba30a3d3cae4be4935a92cf6c76a55e5192adad2235139d550816388bdad8a972a7a4eace42838c7694a0124c56174ff27690ba4d470c423ee72efac06decef995b89b6e936b59fe4c6ba88d3c2d3a34216221e1bf455faf1c3e88d93f37b0891b2fbbad9bf606d9ce")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: SkipLocalsInit]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class RequiresLocationAttribute : 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 System
{
	internal static class SpanExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref readonly T Last<T>(this ReadOnlySpan<T> span)
		{
			return ref span[span.Length - 1];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref T Last<T>(this Span<T> span)
		{
			return ref span[span.Length - 1];
		}

		public static int FindIndex<T>(this ReadOnlySpan<T> s, Predicate<T> match, int startIndex = 0)
		{
			while (startIndex < s.Length)
			{
				if (match(s[startIndex]))
				{
					return startIndex;
				}
				startIndex++;
			}
			return -1;
		}
	}
	internal static class StringExtensions
	{
		private static readonly string[] s_charToString;

		static StringExtensions()
		{
			s_charToString = new string[256];
			for (int i = 0; i < s_charToString.Length; i++)
			{
				s_charToString[i] = ((char)i).ToString();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string ToStringCached(this char c)
		{
			int num = c;
			string[] array = s_charToString;
			if ((uint)num < (uint)array.Length)
			{
				return array[num];
			}
			return c.ToString();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInRange(this char c, ushort min, ushort max)
		{
			return (uint)(c - min) <= (uint)(max - min);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsOctalDigit(this char c)
		{
			return c.IsInRange(48, 55);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsDecimalDigit(this char c)
		{
			return c.IsInRange(48, 57);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsBasicLatinLetter(this char c)
		{
			if (!c.IsInRange(97, 122))
			{
				return c.IsInRange(65, 90);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsSurrogate(this char c)
		{
			return c.IsInRange(55296, 57343);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsHighSurrogate(this char c)
		{
			return c.IsInRange(55296, 56319);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsLowSurrogate(this char c)
		{
			return c.IsInRange(56320, 57343);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CharCodeAt(this string s, int index)
		{
			if ((uint)index < (uint)s.Length)
			{
				return s[index];
			}
			return int.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CharCodeAt(this string s, int index, int endIndex)
		{
			if ((uint)index < (uint)endIndex)
			{
				return s[index];
			}
			return int.MinValue;
		}

		public static int CodePointAt(this string s, int index, int endIndex)
		{
			int num = s.CharCodeAt(index, endIndex);
			if (((char)num).IsHighSurrogate())
			{
				int num2 = s.CharCodeAt(index + 1, endIndex);
				if (((char)num2).IsLowSurrogate())
				{
					return (num << 10) + num2 - 56613888;
				}
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> SliceBetween(this string s, int startIndex, int endIndex)
		{
			return s.AsSpan(startIndex, endIndex - startIndex);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> ToParsable(this ReadOnlySpan<char> s)
		{
			return s;
		}

		public static bool TryReadInt(this ref ReadOnlySpan<char> s, out int result)
		{
			result = 0;
			int i;
			for (i = 0; i < s.Length; i++)
			{
				char c;
				if (!(c = s[i]).IsDecimalDigit())
				{
					break;
				}
				result = checked(result * 10 + c - 48);
			}
			if (i == 0)
			{
				result = 0;
				return false;
			}
			s = s.Slice(i);
			return true;
		}

		public static int GetSequenceHashCode(this ReadOnlySpan<char> span)
		{
			int num = 5381;
			while (span.Length >= 8)
			{
				num = ((num << 5) + num) ^ span[0].GetHashCode();
				num = ((num << 5) + num) ^ span[1].GetHashCode();
				num = ((num << 5) + num) ^ span[2].GetHashCode();
				num = ((num << 5) + num) ^ span[3].GetHashCode();
				num = ((num << 5) + num) ^ span[4].GetHashCode();
				num = ((num << 5) + num) ^ span[5].GetHashCode();
				num = ((num << 5) + num) ^ span[6].GetHashCode();
				num = ((num << 5) + num) ^ span[7].GetHashCode();
				span = span.Slice(8);
			}
			if (span.Length >= 4)
			{
				num = ((num << 5) + num) ^ span[0].GetHashCode();
				num = ((num << 5) + num) ^ span[1].GetHashCode();
				num = ((num << 5) + num) ^ span[2].GetHashCode();
				num = ((num << 5) + num) ^ span[3].GetHashCode();
				span = span.Slice(4);
			}
			if (span.Length > 0)
			{
				num = ((num << 5) + num) ^ span[0].GetHashCode();
				if (span.Length > 1)
				{
					num = ((num << 5) + num) ^ span[1].GetHashCode();
					if (span.Length > 2)
					{
						num = ((num << 5) + num) ^ span[2].GetHashCode();
					}
				}
			}
			return num;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}
namespace Acornima
{
	public enum AllowReservedOption
	{
		Default,
		Yes,
		No,
		Never
	}
	[AutoGeneratedAstVisitor]
	public class AstRewriter : AstVisitor
	{
		public virtual T VisitAndConvert<T>(T node, bool allowNull = false) where T : Node?
		{
			if (node == null)
			{
				if (!allowNull)
				{
					throw new ArgumentNullException("node");
				}
				return null;
			}
			object obj = Visit(node);
			if (!(obj is T result))
			{
				if (obj == null)
				{
					if (allowNull)
					{
						return null;
					}
					throw MustRewriteToSameNodeNonNullable(typeof(T));
				}
				throw allowNull ? MustRewriteToSameNodeNullable(typeof(T)) : MustRewriteToSameNodeNonNullable(typeof(T));
			}
			return result;
			static Exception MustRewriteToSameNodeNonNullable(Type nodeType)
			{
				return new InvalidOperationException(string.Format(null, ExceptionMessages.MustRewriteToSameNodeNonNullable, nodeType));
			}
			static Exception MustRewriteToSameNodeNullable(Type nodeType)
			{
				return new InvalidOperationException(string.Format(null, ExceptionMessages.MustRewriteToSameNodeNullable, nodeType));
			}
		}

		public virtual bool VisitAndConvert<T>(in NodeList<T> nodes, out NodeList<T> newNodes, bool allowNullElement = false) where T : Node?
		{
			List<T> list = null;
			for (int i = 0; i < nodes.Count; i++)
			{
				T val = nodes[i];
				T val2 = VisitAndConvert(val, allowNullElement);
				if (list != null)
				{
					list.Add(val2);
				}
				else if (val2 != val)
				{
					list = new List<T>();
					for (int j = 0; j < i; j++)
					{
						list.Add(nodes[j]);
					}
					list.Add(val2);
				}
			}
			if (list != null)
			{
				newNodes = new NodeList<T>(list);
				return true;
			}
			newNodes = nodes;
			return false;
		}

		protected internal override object? VisitAssignmentProperty(AssignmentProperty node)
		{
			Node node2;
			Expression key;
			if (node.Shorthand)
			{
				node2 = VisitAndConvert(node.Value);
				key = ((node2 is AssignmentPattern assignmentPattern) ? assignmentPattern.Left : node2).As<Identifier>();
			}
			else
			{
				key = VisitAndConvert(node.Key);
				node2 = VisitAndConvert(node.Value);
			}
			return node.UpdateWith(key, node2);
		}

		protected internal override object? VisitExportSpecifier(ExportSpecifier node)
		{
			Expression exported;
			Expression local;
			if (node.Exported == node.Local)
			{
				exported = (local = VisitAndConvert(node.Local));
			}
			else
			{
				local = VisitAndConvert(node.Local);
				exported = VisitAndConvert(node.Exported);
			}
			return node.UpdateWith(local, exported);
		}

		protected internal override object? VisitImportSpecifier(ImportSpecifier node)
		{
			Expression imported;
			Identifier local;
			if (node.Imported == node.Local)
			{
				imported = (local = VisitAndConvert(node.Local));
			}
			else
			{
				imported = VisitAndConvert(node.Imported);
				local = VisitAndConvert(node.Local);
			}
			return node.UpdateWith(imported, local);
		}

		protected internal override object? VisitObjectProperty(ObjectProperty node)
		{
			Node node2;
			Expression key;
			if (node.Shorthand)
			{
				node2 = VisitAndConvert(node.Value);
				key = node2.As<Identifier>();
			}
			else
			{
				key = VisitAndConvert(node.Key);
				node2 = VisitAndConvert(node.Value);
			}
			return node.UpdateWith(key, node2);
		}

		protected internal override object? VisitAccessorProperty(AccessorProperty node)
		{
			VisitAndConvert(in node.Decorators, out var newNodes);
			Expression key = VisitAndConvert(node.Key);
			Expression value = VisitAndConvert(node.Value, allowNull: true);
			return node.UpdateWith(in newNodes, key, value);
		}

		protected internal override object? VisitArrayExpression(ArrayExpression node)
		{
			VisitAndConvert<Expression>(in node.Elements, out var newNodes, allowNullElement: true);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitArrayPattern(ArrayPattern node)
		{
			VisitAndConvert<Node>(in node.Elements, out var newNodes, allowNullElement: true);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitArrowFunctionExpression(ArrowFunctionExpression node)
		{
			VisitAndConvert(in node.Params, out var newNodes);
			StatementOrExpression body = VisitAndConvert(node.Body);
			return node.UpdateWith(in newNodes, body);
		}

		protected internal override object? VisitAssignmentExpression(AssignmentExpression node)
		{
			Node left = VisitAndConvert(node.Left);
			Expression right = VisitAndConvert(node.Right);
			return node.UpdateWith(left, right);
		}

		protected internal override object? VisitAssignmentPattern(AssignmentPattern node)
		{
			Node left = VisitAndConvert(node.Left);
			Expression right = VisitAndConvert(node.Right);
			return node.UpdateWith(left, right);
		}

		protected internal override object? VisitAwaitExpression(AwaitExpression node)
		{
			Expression argument = VisitAndConvert(node.Argument);
			return node.UpdateWith(argument);
		}

		protected internal override object? VisitBinaryExpression(BinaryExpression node)
		{
			Expression left = VisitAndConvert(node.Left);
			Expression right = VisitAndConvert(node.Right);
			return node.UpdateWith(left, right);
		}

		protected internal override object? VisitBlockStatement(BlockStatement node)
		{
			VisitAndConvert(in node.Body, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitBreakStatement(BreakStatement node)
		{
			Identifier label = VisitAndConvert(node.Label, allowNull: true);
			return node.UpdateWith(label);
		}

		protected internal override object? VisitCallExpression(CallExpression node)
		{
			Expression callee = VisitAndConvert(node.Callee);
			VisitAndConvert(in node.Arguments, out var newNodes);
			return node.UpdateWith(callee, in newNodes);
		}

		protected internal override object? VisitCatchClause(CatchClause node)
		{
			Node param = VisitAndConvert(node.Param, allowNull: true);
			NestedBlockStatement body = VisitAndConvert(node.Body);
			return node.UpdateWith(param, body);
		}

		protected internal override object? VisitChainExpression(ChainExpression node)
		{
			Expression expression = VisitAndConvert(node.Expression);
			return node.UpdateWith(expression);
		}

		protected internal override object? VisitClassBody(ClassBody node)
		{
			VisitAndConvert(in node.Body, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitClassDeclaration(ClassDeclaration node)
		{
			VisitAndConvert(in node.Decorators, out var newNodes);
			Identifier id = VisitAndConvert(node.Id, allowNull: true);
			Expression superClass = VisitAndConvert(node.SuperClass, allowNull: true);
			ClassBody body = VisitAndConvert(node.Body);
			return node.UpdateWith(in newNodes, id, superClass, body);
		}

		protected internal override object? VisitClassExpression(ClassExpression node)
		{
			VisitAndConvert(in node.Decorators, out var newNodes);
			Identifier id = VisitAndConvert(node.Id, allowNull: true);
			Expression superClass = VisitAndConvert(node.SuperClass, allowNull: true);
			ClassBody body = VisitAndConvert(node.Body);
			return node.UpdateWith(in newNodes, id, superClass, body);
		}

		protected internal override object? VisitConditionalExpression(ConditionalExpression node)
		{
			Expression test = VisitAndConvert(node.Test);
			Expression consequent = VisitAndConvert(node.Consequent);
			Expression alternate = VisitAndConvert(node.Alternate);
			return node.UpdateWith(test, consequent, alternate);
		}

		protected internal override object? VisitContinueStatement(ContinueStatement node)
		{
			Identifier label = VisitAndConvert(node.Label, allowNull: true);
			return node.UpdateWith(label);
		}

		protected internal override object? VisitDecorator(Decorator node)
		{
			Expression expression = VisitAndConvert(node.Expression);
			return node.UpdateWith(expression);
		}

		protected internal override object? VisitDoWhileStatement(DoWhileStatement node)
		{
			Statement body = VisitAndConvert(node.Body);
			Expression test = VisitAndConvert(node.Test);
			return node.UpdateWith(body, test);
		}

		protected internal override object? VisitExportAllDeclaration(ExportAllDeclaration node)
		{
			Expression exported = VisitAndConvert(node.Exported, allowNull: true);
			StringLiteral source = VisitAndConvert(node.Source);
			VisitAndConvert(in node.Attributes, out var newNodes);
			return node.UpdateWith(exported, source, in newNodes);
		}

		protected internal override object? VisitExportDefaultDeclaration(ExportDefaultDeclaration node)
		{
			StatementOrExpression declaration = VisitAndConvert(node.Declaration);
			return node.UpdateWith(declaration);
		}

		protected internal override object? VisitExportNamedDeclaration(ExportNamedDeclaration node)
		{
			Declaration declaration = VisitAndConvert(node.Declaration, allowNull: true);
			VisitAndConvert(in node.Specifiers, out var newNodes);
			StringLiteral source = VisitAndConvert(node.Source, allowNull: true);
			VisitAndConvert(in node.Attributes, out var newNodes2);
			return node.UpdateWith(declaration, in newNodes, source, in newNodes2);
		}

		protected internal override object? VisitExpressionStatement(ExpressionStatement node)
		{
			Expression expression = VisitAndConvert(node.Expression);
			return node.UpdateWith(expression);
		}

		protected internal override object? VisitForInStatement(ForInStatement node)
		{
			Node left = VisitAndConvert(node.Left);
			Expression right = VisitAndConvert(node.Right);
			Statement body = VisitAndConvert(node.Body);
			return node.UpdateWith(left, right, body);
		}

		protected internal override object? VisitForOfStatement(ForOfStatement node)
		{
			Node left = VisitAndConvert(node.Left);
			Expression right = VisitAndConvert(node.Right);
			Statement body = VisitAndConvert(node.Body);
			return node.UpdateWith(left, right, body);
		}

		protected internal override object? VisitForStatement(ForStatement node)
		{
			StatementOrExpression init = VisitAndConvert(node.Init, allowNull: true);
			Expression test = VisitAndConvert(node.Test, allowNull: true);
			Expression update = VisitAndConvert(node.Update, allowNull: true);
			Statement body = VisitAndConvert(node.Body);
			return node.UpdateWith(init, test, update, body);
		}

		protected internal override object? VisitFunctionBody(FunctionBody node)
		{
			VisitAndConvert(in node.Body, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitFunctionDeclaration(FunctionDeclaration node)
		{
			Identifier id = VisitAndConvert(node.Id, allowNull: true);
			VisitAndConvert(in node.Params, out var newNodes);
			FunctionBody body = VisitAndConvert(node.Body);
			return node.UpdateWith(id, in newNodes, body);
		}

		protected internal override object? VisitFunctionExpression(FunctionExpression node)
		{
			Identifier id = VisitAndConvert(node.Id, allowNull: true);
			VisitAndConvert(in node.Params, out var newNodes);
			FunctionBody body = VisitAndConvert(node.Body);
			return node.UpdateWith(id, in newNodes, body);
		}

		protected internal override object? VisitIfStatement(IfStatement node)
		{
			Expression test = VisitAndConvert(node.Test);
			Statement consequent = VisitAndConvert(node.Consequent);
			Statement alternate = VisitAndConvert(node.Alternate, allowNull: true);
			return node.UpdateWith(test, consequent, alternate);
		}

		protected internal override object? VisitImportAttribute(ImportAttribute node)
		{
			Expression key = VisitAndConvert(node.Key);
			StringLiteral value = VisitAndConvert(node.Value);
			return node.UpdateWith(key, value);
		}

		protected internal override object? VisitImportDeclaration(ImportDeclaration node)
		{
			VisitAndConvert(in node.Specifiers, out var newNodes);
			StringLiteral source = VisitAndConvert(node.Source);
			VisitAndConvert(in node.Attributes, out var newNodes2);
			return node.UpdateWith(in newNodes, source, in newNodes2);
		}

		protected internal override object? VisitImportDefaultSpecifier(ImportDefaultSpecifier node)
		{
			Identifier local = VisitAndConvert(node.Local);
			return node.UpdateWith(local);
		}

		protected internal override object? VisitImportExpression(ImportExpression node)
		{
			Expression source = VisitAndConvert(node.Source);
			Expression options = VisitAndConvert(node.Options, allowNull: true);
			return node.UpdateWith(source, options);
		}

		protected internal override object? VisitImportNamespaceSpecifier(ImportNamespaceSpecifier node)
		{
			Identifier local = VisitAndConvert(node.Local);
			return node.UpdateWith(local);
		}

		protected internal override object? VisitLabeledStatement(LabeledStatement node)
		{
			Identifier label = VisitAndConvert(node.Label);
			Statement body = VisitAndConvert(node.Body);
			return node.UpdateWith(label, body);
		}

		protected internal override object? VisitMemberExpression(MemberExpression node)
		{
			Expression @object = VisitAndConvert(node.Object);
			Expression property = VisitAndConvert(node.Property);
			return node.UpdateWith(@object, property);
		}

		protected internal override object? VisitMetaProperty(MetaProperty node)
		{
			Identifier meta = VisitAndConvert(node.Meta);
			Identifier property = VisitAndConvert(node.Property);
			return node.UpdateWith(meta, property);
		}

		protected internal override object? VisitMethodDefinition(MethodDefinition node)
		{
			VisitAndConvert(in node.Decorators, out var newNodes);
			Expression key = VisitAndConvert(node.Key);
			FunctionExpression value = VisitAndConvert(node.Value);
			return node.UpdateWith(in newNodes, key, value);
		}

		protected internal override object? VisitNewExpression(NewExpression node)
		{
			Expression callee = VisitAndConvert(node.Callee);
			VisitAndConvert(in node.Arguments, out var newNodes);
			return node.UpdateWith(callee, in newNodes);
		}

		protected internal override object? VisitObjectExpression(ObjectExpression node)
		{
			VisitAndConvert(in node.Properties, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitObjectPattern(ObjectPattern node)
		{
			VisitAndConvert(in node.Properties, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitParenthesizedExpression(ParenthesizedExpression node)
		{
			Expression expression = VisitAndConvert(node.Expression);
			return node.UpdateWith(expression);
		}

		protected internal override object? VisitProgram(Program node)
		{
			VisitAndConvert(in node.Body, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitPropertyDefinition(PropertyDefinition node)
		{
			VisitAndConvert(in node.Decorators, out var newNodes);
			Expression key = VisitAndConvert(node.Key);
			Expression value = VisitAndConvert(node.Value, allowNull: true);
			return node.UpdateWith(in newNodes, key, value);
		}

		protected internal override object? VisitRestElement(RestElement node)
		{
			Node argument = VisitAndConvert(node.Argument);
			return node.UpdateWith(argument);
		}

		protected internal override object? VisitReturnStatement(ReturnStatement node)
		{
			Expression argument = VisitAndConvert(node.Argument, allowNull: true);
			return node.UpdateWith(argument);
		}

		protected internal override object? VisitSequenceExpression(SequenceExpression node)
		{
			VisitAndConvert(in node.Expressions, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitSpreadElement(SpreadElement node)
		{
			Expression argument = VisitAndConvert(node.Argument);
			return node.UpdateWith(argument);
		}

		protected internal override object? VisitStaticBlock(StaticBlock node)
		{
			VisitAndConvert(in node.Body, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitSwitchCase(SwitchCase node)
		{
			Expression test = VisitAndConvert(node.Test, allowNull: true);
			VisitAndConvert(in node.Consequent, out var newNodes);
			return node.UpdateWith(test, in newNodes);
		}

		protected internal override object? VisitSwitchStatement(SwitchStatement node)
		{
			Expression discriminant = VisitAndConvert(node.Discriminant);
			VisitAndConvert(in node.Cases, out var newNodes);
			return node.UpdateWith(discriminant, in newNodes);
		}

		protected internal override object? VisitTaggedTemplateExpression(TaggedTemplateExpression node)
		{
			Expression tag = VisitAndConvert(node.Tag);
			TemplateLiteral quasi = VisitAndConvert(node.Quasi);
			return node.UpdateWith(tag, quasi);
		}

		protected internal override object? VisitTemplateLiteral(TemplateLiteral node)
		{
			VisitAndConvert(in node.Quasis, out var newNodes);
			VisitAndConvert(in node.Expressions, out var newNodes2);
			return node.UpdateWith(in newNodes, in newNodes2);
		}

		protected internal override object? VisitThrowStatement(ThrowStatement node)
		{
			Expression argument = VisitAndConvert(node.Argument);
			return node.UpdateWith(argument);
		}

		protected internal override object? VisitTryStatement(TryStatement node)
		{
			NestedBlockStatement block = VisitAndConvert(node.Block);
			CatchClause handler = VisitAndConvert(node.Handler, allowNull: true);
			NestedBlockStatement finalizer = VisitAndConvert(node.Finalizer, allowNull: true);
			return node.UpdateWith(block, handler, finalizer);
		}

		protected internal override object? VisitUnaryExpression(UnaryExpression node)
		{
			Expression argument = VisitAndConvert(node.Argument);
			return node.UpdateWith(argument);
		}

		protected internal override object? VisitVariableDeclaration(VariableDeclaration node)
		{
			VisitAndConvert(in node.Declarations, out var newNodes);
			return node.UpdateWith(in newNodes);
		}

		protected internal override object? VisitVariableDeclarator(VariableDeclarator node)
		{
			Node id = VisitAndConvert(node.Id);
			Expression init = VisitAndConvert(node.Init, allowNull: true);
			return node.UpdateWith(id, init);
		}

		protected internal override object? VisitWhileStatement(WhileStatement node)
		{
			Expression test = VisitAndConvert(node.Test);
			Statement body = VisitAndConvert(node.Body);
			return node.UpdateWith(test, body);
		}

		protected internal override object? VisitWithStatement(WithStatement node)
		{
			Expression @object = VisitAndConvert(node.Object);
			Statement body = VisitAndConvert(node.Body);
			return node.UpdateWith(@object, body);
		}

		protected internal override object? VisitYieldExpression(YieldExpression node)
		{
			Expression argument = VisitAndConvert(node.Argument, allowNull: true);
			return node.UpdateWith(argument);
		}
	}
	[AutoGeneratedAstVisitor]
	public class AstVisitor
	{
		private int _recursionDepth;

		private static NotImplementedException UnsupportedNodeType(Type nodeType, [CallerMemberName] string? callerName = null)
		{
			return new NotImplementedException(string.Format(null, ExceptionMessages.UnsupportedNodeTypeVisited, nodeType, callerName));
		}

		protected virtual void Reset()
		{
			_recursionDepth = 0;
		}

		public virtual object? Visit(Node node)
		{
			_recursionDepth++;
			StackGuard.EnsureSufficientExecutionStack(_recursionDepth);
			object? result = node.Accept(this);
			_recursionDepth--;
			return result;
		}

		protected internal virtual object? VisitAssignmentProperty(AssignmentProperty node)
		{
			if (!node.Shorthand)
			{
				Visit(node.Key);
			}
			Visit(node.Value);
			return node;
		}

		protected internal virtual object? VisitExportSpecifier(ExportSpecifier node)
		{
			Visit(node.Local);
			if (node.Exported != node.Local)
			{
				Visit(node.Exported);
			}
			return node;
		}

		protected internal virtual object? VisitExtension(Node node)
		{
			throw UnsupportedNodeType(node.GetType(), "VisitExtension");
		}

		protected internal virtual object? VisitImportSpecifier(ImportSpecifier node)
		{
			if (node.Imported != node.Local)
			{
				Visit(node.Imported);
			}
			Visit(node.Local);
			return node;
		}

		protected internal virtual object? VisitObjectProperty(ObjectProperty node)
		{
			if (!node.Shorthand)
			{
				Visit(node.Key);
			}
			Visit(node.Value);
			return node;
		}

		protected internal virtual object? VisitTemplateLiteral(TemplateLiteral node)
		{
			ref readonly NodeList<TemplateElement> quasis = ref node.Quasis;
			ref readonly NodeList<Expression> expressions = ref node.Expressions;
			int num = 0;
			TemplateElement node2;
			while (!(node2 = quasis[num]).Tail)
			{
				Visit(node2);
				Visit(expressions[num]);
				num++;
			}
			Visit(node2);
			return node;
		}

		protected internal virtual object? VisitAccessorProperty(AccessorProperty node)
		{
			ref readonly NodeList<Decorator> decorators = ref node.Decorators;
			for (int i = 0; i < decorators.Count; i++)
			{
				Visit(decorators[i]);
			}
			Visit(node.Key);
			if (node.Value != null)
			{
				Visit(node.Value);
			}
			return node;
		}

		protected internal virtual object? VisitArrayExpression(ArrayExpression node)
		{
			ref readonly NodeList<Expression> elements = ref node.Elements;
			for (int i = 0; i < elements.Count; i++)
			{
				Expression expression = elements[i];
				if (expression != null)
				{
					Visit(expression);
				}
			}
			return node;
		}

		protected internal virtual object? VisitArrayPattern(ArrayPattern node)
		{
			ref readonly NodeList<Node> elements = ref node.Elements;
			for (int i = 0; i < elements.Count; i++)
			{
				Node node2 = elements[i];
				if (node2 != null)
				{
					Visit(node2);
				}
			}
			return node;
		}

		protected internal virtual object? VisitArrowFunctionExpression(ArrowFunctionExpression node)
		{
			ref readonly NodeList<Node> @params = ref node.Params;
			for (int i = 0; i < @params.Count; i++)
			{
				Visit(@params[i]);
			}
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitAssignmentExpression(AssignmentExpression node)
		{
			Visit(node.Left);
			Visit(node.Right);
			return node;
		}

		protected internal virtual object? VisitAssignmentPattern(AssignmentPattern node)
		{
			Visit(node.Left);
			Visit(node.Right);
			return node;
		}

		protected internal virtual object? VisitAwaitExpression(AwaitExpression node)
		{
			Visit(node.Argument);
			return node;
		}

		protected internal virtual object? VisitBinaryExpression(BinaryExpression node)
		{
			Visit(node.Left);
			Visit(node.Right);
			return node;
		}

		protected internal virtual object? VisitBlockStatement(BlockStatement node)
		{
			ref readonly NodeList<Statement> body = ref node.Body;
			for (int i = 0; i < body.Count; i++)
			{
				Visit(body[i]);
			}
			return node;
		}

		protected internal virtual object? VisitBreakStatement(BreakStatement node)
		{
			if (node.Label != null)
			{
				Visit(node.Label);
			}
			return node;
		}

		protected internal virtual object? VisitCallExpression(CallExpression node)
		{
			Visit(node.Callee);
			ref readonly NodeList<Expression> arguments = ref node.Arguments;
			for (int i = 0; i < arguments.Count; i++)
			{
				Visit(arguments[i]);
			}
			return node;
		}

		protected internal virtual object? VisitCatchClause(CatchClause node)
		{
			if (node.Param != null)
			{
				Visit(node.Param);
			}
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitChainExpression(ChainExpression node)
		{
			Visit(node.Expression);
			return node;
		}

		protected internal virtual object? VisitClassBody(ClassBody node)
		{
			ref readonly NodeList<Node> body = ref node.Body;
			for (int i = 0; i < body.Count; i++)
			{
				Visit(body[i]);
			}
			return node;
		}

		protected internal virtual object? VisitClassDeclaration(ClassDeclaration node)
		{
			ref readonly NodeList<Decorator> decorators = ref node.Decorators;
			for (int i = 0; i < decorators.Count; i++)
			{
				Visit(decorators[i]);
			}
			if (node.Id != null)
			{
				Visit(node.Id);
			}
			if (node.SuperClass != null)
			{
				Visit(node.SuperClass);
			}
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitClassExpression(ClassExpression node)
		{
			ref readonly NodeList<Decorator> decorators = ref node.Decorators;
			for (int i = 0; i < decorators.Count; i++)
			{
				Visit(decorators[i]);
			}
			if (node.Id != null)
			{
				Visit(node.Id);
			}
			if (node.SuperClass != null)
			{
				Visit(node.SuperClass);
			}
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitConditionalExpression(ConditionalExpression node)
		{
			Visit(node.Test);
			Visit(node.Consequent);
			Visit(node.Alternate);
			return node;
		}

		protected internal virtual object? VisitContinueStatement(ContinueStatement node)
		{
			if (node.Label != null)
			{
				Visit(node.Label);
			}
			return node;
		}

		protected internal virtual object? VisitDebuggerStatement(DebuggerStatement node)
		{
			return node;
		}

		protected internal virtual object? VisitDecorator(Decorator node)
		{
			Visit(node.Expression);
			return node;
		}

		protected internal virtual object? VisitDoWhileStatement(DoWhileStatement node)
		{
			Visit(node.Body);
			Visit(node.Test);
			return node;
		}

		protected internal virtual object? VisitEmptyStatement(EmptyStatement node)
		{
			return node;
		}

		protected internal virtual object? VisitExportAllDeclaration(ExportAllDeclaration node)
		{
			if (node.Exported != null)
			{
				Visit(node.Exported);
			}
			Visit(node.Source);
			ref readonly NodeList<ImportAttribute> attributes = ref node.Attributes;
			for (int i = 0; i < attributes.Count; i++)
			{
				Visit(attributes[i]);
			}
			return node;
		}

		protected internal virtual object? VisitExportDefaultDeclaration(ExportDefaultDeclaration node)
		{
			Visit(node.Declaration);
			return node;
		}

		protected internal virtual object? VisitExportNamedDeclaration(ExportNamedDeclaration node)
		{
			if (node.Declaration != null)
			{
				Visit(node.Declaration);
			}
			ref readonly NodeList<ExportSpecifier> specifiers = ref node.Specifiers;
			for (int i = 0; i < specifiers.Count; i++)
			{
				Visit(specifiers[i]);
			}
			if (node.Source != null)
			{
				Visit(node.Source);
			}
			ref readonly NodeList<ImportAttribute> attributes = ref node.Attributes;
			for (int j = 0; j < attributes.Count; j++)
			{
				Visit(attributes[j]);
			}
			return node;
		}

		protected internal virtual object? VisitExpressionStatement(ExpressionStatement node)
		{
			Visit(node.Expression);
			return node;
		}

		protected internal virtual object? VisitForInStatement(ForInStatement node)
		{
			Visit(node.Left);
			Visit(node.Right);
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitForOfStatement(ForOfStatement node)
		{
			Visit(node.Left);
			Visit(node.Right);
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitForStatement(ForStatement node)
		{
			if (node.Init != null)
			{
				Visit(node.Init);
			}
			if (node.Test != null)
			{
				Visit(node.Test);
			}
			if (node.Update != null)
			{
				Visit(node.Update);
			}
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitFunctionBody(FunctionBody node)
		{
			ref readonly NodeList<Statement> body = ref node.Body;
			for (int i = 0; i < body.Count; i++)
			{
				Visit(body[i]);
			}
			return node;
		}

		protected internal virtual object? VisitFunctionDeclaration(FunctionDeclaration node)
		{
			if (node.Id != null)
			{
				Visit(node.Id);
			}
			ref readonly NodeList<Node> @params = ref node.Params;
			for (int i = 0; i < @params.Count; i++)
			{
				Visit(@params[i]);
			}
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitFunctionExpression(FunctionExpression node)
		{
			if (node.Id != null)
			{
				Visit(node.Id);
			}
			ref readonly NodeList<Node> @params = ref node.Params;
			for (int i = 0; i < @params.Count; i++)
			{
				Visit(@params[i]);
			}
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitIdentifier(Identifier node)
		{
			return node;
		}

		protected internal virtual object? VisitIfStatement(IfStatement node)
		{
			Visit(node.Test);
			Visit(node.Consequent);
			if (node.Alternate != null)
			{
				Visit(node.Alternate);
			}
			return node;
		}

		protected internal virtual object? VisitImportAttribute(ImportAttribute node)
		{
			Visit(node.Key);
			Visit(node.Value);
			return node;
		}

		protected internal virtual object? VisitImportDeclaration(ImportDeclaration node)
		{
			ref readonly NodeList<ImportDeclarationSpecifier> specifiers = ref node.Specifiers;
			for (int i = 0; i < specifiers.Count; i++)
			{
				Visit(specifiers[i]);
			}
			Visit(node.Source);
			ref readonly NodeList<ImportAttribute> attributes = ref node.Attributes;
			for (int j = 0; j < attributes.Count; j++)
			{
				Visit(attributes[j]);
			}
			return node;
		}

		protected internal virtual object? VisitImportDefaultSpecifier(ImportDefaultSpecifier node)
		{
			Visit(node.Local);
			return node;
		}

		protected internal virtual object? VisitImportExpression(ImportExpression node)
		{
			Visit(node.Source);
			if (node.Options != null)
			{
				Visit(node.Options);
			}
			return node;
		}

		protected internal virtual object? VisitImportNamespaceSpecifier(ImportNamespaceSpecifier node)
		{
			Visit(node.Local);
			return node;
		}

		protected internal virtual object? VisitLabeledStatement(LabeledStatement node)
		{
			Visit(node.Label);
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitLiteral(Literal node)
		{
			return node;
		}

		protected internal virtual object? VisitMemberExpression(MemberExpression node)
		{
			Visit(node.Object);
			Visit(node.Property);
			return node;
		}

		protected internal virtual object? VisitMetaProperty(MetaProperty node)
		{
			Visit(node.Meta);
			Visit(node.Property);
			return node;
		}

		protected internal virtual object? VisitMethodDefinition(MethodDefinition node)
		{
			ref readonly NodeList<Decorator> decorators = ref node.Decorators;
			for (int i = 0; i < decorators.Count; i++)
			{
				Visit(decorators[i]);
			}
			Visit(node.Key);
			Visit(node.Value);
			return node;
		}

		protected internal virtual object? VisitNewExpression(NewExpression node)
		{
			Visit(node.Callee);
			ref readonly NodeList<Expression> arguments = ref node.Arguments;
			for (int i = 0; i < arguments.Count; i++)
			{
				Visit(arguments[i]);
			}
			return node;
		}

		protected internal virtual object? VisitObjectExpression(ObjectExpression node)
		{
			ref readonly NodeList<Node> properties = ref node.Properties;
			for (int i = 0; i < properties.Count; i++)
			{
				Visit(properties[i]);
			}
			return node;
		}

		protected internal virtual object? VisitObjectPattern(ObjectPattern node)
		{
			ref readonly NodeList<Node> properties = ref node.Properties;
			for (int i = 0; i < properties.Count; i++)
			{
				Visit(properties[i]);
			}
			return node;
		}

		protected internal virtual object? VisitParenthesizedExpression(ParenthesizedExpression node)
		{
			Visit(node.Expression);
			return node;
		}

		protected internal virtual object? VisitPrivateIdentifier(PrivateIdentifier node)
		{
			return node;
		}

		protected internal virtual object? VisitProgram(Program node)
		{
			ref readonly NodeList<Statement> body = ref node.Body;
			for (int i = 0; i < body.Count; i++)
			{
				Visit(body[i]);
			}
			return node;
		}

		protected internal virtual object? VisitPropertyDefinition(PropertyDefinition node)
		{
			ref readonly NodeList<Decorator> decorators = ref node.Decorators;
			for (int i = 0; i < decorators.Count; i++)
			{
				Visit(decorators[i]);
			}
			Visit(node.Key);
			if (node.Value != null)
			{
				Visit(node.Value);
			}
			return node;
		}

		protected internal virtual object? VisitRestElement(RestElement node)
		{
			Visit(node.Argument);
			return node;
		}

		protected internal virtual object? VisitReturnStatement(ReturnStatement node)
		{
			if (node.Argument != null)
			{
				Visit(node.Argument);
			}
			return node;
		}

		protected internal virtual object? VisitSequenceExpression(SequenceExpression node)
		{
			ref readonly NodeList<Expression> expressions = ref node.Expressions;
			for (int i = 0; i < expressions.Count; i++)
			{
				Visit(expressions[i]);
			}
			return node;
		}

		protected internal virtual object? VisitSpreadElement(SpreadElement node)
		{
			Visit(node.Argument);
			return node;
		}

		protected internal virtual object? VisitStaticBlock(StaticBlock node)
		{
			ref readonly NodeList<Statement> body = ref node.Body;
			for (int i = 0; i < body.Count; i++)
			{
				Visit(body[i]);
			}
			return node;
		}

		protected internal virtual object? VisitSuper(Super node)
		{
			return node;
		}

		protected internal virtual object? VisitSwitchCase(SwitchCase node)
		{
			if (node.Test != null)
			{
				Visit(node.Test);
			}
			ref readonly NodeList<Statement> consequent = ref node.Consequent;
			for (int i = 0; i < consequent.Count; i++)
			{
				Visit(consequent[i]);
			}
			return node;
		}

		protected internal virtual object? VisitSwitchStatement(SwitchStatement node)
		{
			Visit(node.Discriminant);
			ref readonly NodeList<SwitchCase> cases = ref node.Cases;
			for (int i = 0; i < cases.Count; i++)
			{
				Visit(cases[i]);
			}
			return node;
		}

		protected internal virtual object? VisitTaggedTemplateExpression(TaggedTemplateExpression node)
		{
			Visit(node.Tag);
			Visit(node.Quasi);
			return node;
		}

		protected internal virtual object? VisitTemplateElement(TemplateElement node)
		{
			return node;
		}

		protected internal virtual object? VisitThisExpression(ThisExpression node)
		{
			return node;
		}

		protected internal virtual object? VisitThrowStatement(ThrowStatement node)
		{
			Visit(node.Argument);
			return node;
		}

		protected internal virtual object? VisitTryStatement(TryStatement node)
		{
			Visit(node.Block);
			if (node.Handler != null)
			{
				Visit(node.Handler);
			}
			if (node.Finalizer != null)
			{
				Visit(node.Finalizer);
			}
			return node;
		}

		protected internal virtual object? VisitUnaryExpression(UnaryExpression node)
		{
			Visit(node.Argument);
			return node;
		}

		protected internal virtual object? VisitVariableDeclaration(VariableDeclaration node)
		{
			ref readonly NodeList<VariableDeclarator> declarations = ref node.Declarations;
			for (int i = 0; i < declarations.Count; i++)
			{
				Visit(declarations[i]);
			}
			return node;
		}

		protected internal virtual object? VisitVariableDeclarator(VariableDeclarator node)
		{
			Visit(node.Id);
			if (node.Init != null)
			{
				Visit(node.Init);
			}
			return node;
		}

		protected internal virtual object? VisitWhileStatement(WhileStatement node)
		{
			Visit(node.Test);
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitWithStatement(WithStatement node)
		{
			Visit(node.Object);
			Visit(node.Body);
			return node;
		}

		protected internal virtual object? VisitYieldExpression(YieldExpression node)
		{
			if (node.Argument != null)
			{
				Visit(node.Argument);
			}
			return node;
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	internal sealed class AutoGeneratedAstVisitorAttribute : Attribute
	{
		public Type? VisitorType { get; set; }

		public string? TargetVisitorFieldName { get; set; }

		public string? BaseVisitorFieldName { get; set; }
	}
	public readonly struct Comment
	{
		internal readonly Range _range;

		internal readonly SourceLocation _location;

		public CommentKind Kind { get; }

		public Range ContentRange { get; }

		public int Start
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _range.Start;
			}
		}

		public int End
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _range.End;
			}
		}

		public Range Range
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _range;
			}
		}

		public SourceLocation Location
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _location;
			}
		}

		public Comment(CommentKind kind, Range contentRange, Range range, in SourceLocation location)
		{
			Kind = kind;
			ContentRange = contentRange;
			_range = range;
			_location = location;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<char> GetContent(string input)
		{
			return (input ?? ExceptionHelper.ThrowArgumentNullException<string>("input")).SliceBetween(ContentRange.Start, ContentRange.End);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<char> GetRawValue(string input)
		{
			return (input ?? ExceptionHelper.ThrowArgumentNullException<string>("input")).SliceBetween(Start, End);
		}
	}
	public static class CommentExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref readonly Range RangeRef(this in Comment comment)
		{
			return ref comment._range;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ref readonly SourceLocation LocationRef(this in Comment comment)
		{
			return ref comment._location;
		}
	}
	public enum CommentKind
	{
		Unknown,
		Block,
		Line,
		HashBang
	}
	public enum EcmaVersion
	{
		Unknown = 0,
		ES3 = 3,
		ES5 = 5,
		ES6 = 6,
		ES7 = 7,
		ES8 = 8,
		ES9 = 9,
		ES10 = 10,
		ES11 = 11,
		ES12 = 12,
		ES13 = 13,
		ES14 = 14,
		ES2015 = 6,
		ES2016 = 7,
		ES2017 = 8,
		ES2018 = 9,
		ES2019 = 10,
		ES2020 = 11,
		ES2021 = 12,
		ES2022 = 13,
		ES2023 = 14,
		Latest = 14
	}
	[Flags]
	public enum ExperimentalESFeatures
	{
		None = 0,
		Decorators = 1,
		ImportAttributes = 2,
		RegExpDuplicateNamedCapturingGroups = 4,
		All = 7
	}
	public interface IParser
	{
		ParserOptions Options { get; }

		Script ParseScript(string input, int start, int length, string? sourceFile = null, bool strict = false);

		Acornima.Ast.Module ParseModule(string input, int start, int length, string? sourceFile = null);

		Expression ParseExpression(string input, int start, int length, string? sourceFile = null, bool strict = false);
	}
	public interface ITokenizer
	{
		string Input { get; }

		Range Range { get; }

		SourceType SourceType { get; }

		string? SourceFile { get; }

		TokenizerOptions Options { get; }

		Token Current { get; }

		Token GetToken(in TokenizerContext context = default(TokenizerContext));

		void Next(in TokenizerContext context = default(TokenizerContext));

		void Reset(string input, int start, int length, SourceType sourceType = SourceType.Script, string? sourceFile = null);
	}
	internal enum Keyword
	{
		Unknown,
		Break,
		Case,
		Catch,
		Class,
		Const,
		Continue,
		Debugger,
		Default,
		Delete,
		Do,
		Else,
		Export,
		Extends,
		False,
		Finally,
		For,
		Function,
		If,
		Import,
		In,
		InstanceOf,
		New,
		Null,
		Return,
		Super,
		Switch,
		This,
		Throw,
		True,
		Try,
		TypeOf,
		Var,
		Void,
		While,
		With
	}
	public readonly ref struct OnNodeContext
	{
		internal readonly ReadOnlyRef<Scope> _scope;

		public bool HasScope
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return !Unsafe.IsNullRef(ref Unsafe.AsRef(in _scope.Value));
			}
		}

		public ref readonly Scope Scope
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				ref readonly Scope value = ref _scope.Value;
				if (Unsafe.IsNullRef(ref Unsafe.AsRef(in value)))
				{
					ExceptionHelper.ThrowInvalidOperationException<object>();
				}
				return ref value;
			}
		}

		public ReadOnlySpan<Scope> ScopeStack
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal OnNodeContext(ReadOnlyRef<Scope> scope, ArrayList<Scope> scopeStack)
		{
			_scope = scope;
			ScopeStack = scopeStack.AsReadOnlySpan();
		}
	}
	public enum Operator
	{
		Unknown,
		Assignment,
		NullishCoalescingAssignment,
		LogicalOrAssignment,
		LogicalAndAssignment,
		BitwiseOrAssignment,
		BitwiseXorAssignment,
		BitwiseAndAssignment,
		LeftShiftAssignment,
		RightShiftAssignment,
		UnsignedRightShiftAssignment,
		AdditionAssignment,
		SubtractionAssignment,
		MultiplicationAssignment,
		DivisionAssignment,
		RemainderAssignment,
		ExponentiationAssignment,
		NullishCoalescing,
		LogicalOr,
		LogicalAnd,
		BitwiseOr,
		BitwiseXor,
		BitwiseAnd,
		Equality,
		Inequality,
		StrictEquality,
		StrictInequality,
		LessThan,
		LessThanOrEqual,
		GreaterThan,
		GreaterThanOrEqual,
		In,
		InstanceOf,
		LeftShift,
		RightShift,
		UnsignedRightShift,
		Addition,
		Subtraction,
		Multiplication,
		Division,
		Remainder,
		Exponentiation,
		Increment,
		Decrement,
		LogicalNot,
		BitwiseNot,
		UnaryPlus,
		UnaryNegation,
		TypeOf,
		Void,
		Delete
	}
	public abstract class ParseError
	{
		internal delegate ParseError Factory(string code, string description, int index, Position position, string? sourceFile);

		public string Code { get; }

		public string Description { get; }

		public bool IsIndexDefined => Index >= 0;

		public int Index { get; }

		public bool IsPositionDefined => Position.Line > 0;

		public Position Position { get; }

		public int LineNumber => Position.Line;

		public int Column => Position.Column;

		public string? SourceFile { get; }

		public ParseError(string code, string description, int index = -1, Position position = default(Position), string? sourceFile = null)
		{
			Code = code ?? throw new ArgumentNullException("code");
			Description = description ?? throw new ArgumentNullException("description");
			Index = index;
			Position = position;
			SourceFile = sourceFile;
		}

		public override string ToString()
		{
			if (SourceFile != null)
			{
				if (!IsPositionDefined)
				{
					return Description + " (" + SourceFile + ")";
				}
				return $"{Description} ({SourceFile}:{LineNumber}:{Column + 1})";
			}
			if (!IsPositionDefined)
			{
				return Description;
			}
			return $"{Description} ({LineNumber}:{Column + 1})";
		}

		public abstract ParseErrorException ToException();
	}
	public sealed class ParseErrorCollector : ParseErrorHandler
	{
		private readonly List<ParseError> _errors = new List<ParseError>();

		public IReadOnlyCollection<ParseError> Errors => _errors;

		protected internal override void Reset()
		{
			_errors.Clear();
			if (_errors.Capacity > 16)
			{
				_errors.Capacity = 16;
			}
		}

		protected override void RecordError(ParseError error)
		{
			_errors.Add(error);
		}
	}
	public abstract class ParseErrorException : Exception
	{
		public ParseError Error { get; }

		public string Description => Error.Description;

		public int LineNumber => Error.LineNumber;

		public int Column => Error.Column;

		public string? SourceFile => Error.SourceFile;

		protected ParseErrorException(ParseError error, Exception? innerException = null)
			: base((error ?? throw new ArgumentNullException("error")).ToString(), innerException)
		{
			Error = error;
		}
	}
	public class ParseErrorHandler
	{
		public static readonly ParseErrorHandler Default = new ParseErrorHandler();

		protected internal virtual void Reset()
		{
		}

		protected virtual void RecordError(ParseError error)
		{
		}

		[DoesNotReturn]
		internal void ThrowError(ParseError error)
		{
			throw error.ToException();
		}

		internal ParseError TolerateError(ParseError error, bool tolerant)
		{
			if (!tolerant)
			{
				ThrowError(error);
			}
			RecordError(error);
			return error;
		}
	}
	public sealed class Parser : IParser
	{
		internal interface IExtension
		{
			Tokenizer CreateTokenizer(TokenizerOptions tokenizerOptions);

			Expression ParseExprAtom();
		}

		internal enum ReservedWordKind : sbyte
		{
			None = 0,
			OptionalModule = 1,
			Optional = 2,
			Strict = 4,
			StrictBind = -124
		}

		internal delegate bool IsReservedWordDelegate(ReadOnlySpan<char> word, bool strict);

		internal readonly struct Marker
		{
			public readonly int Index;

			public readonly Position Position;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Marker(int index, Position position)
			{
				Index = index;
				Position = position;
			}
		}

		private enum BindingType : byte
		{
			None,
			Var,
			Lexical,
			Function,
			SimpleCatch,
			Outside
		}

		[Flags]
		private enum StatementContext : byte
		{
			Default = 0,
			Label = 1,
			Do = 2,
			For = 4,
			If = 8,
			With = 0x10,
			While = 0x20
		}

		[Flags]
		internal enum ExpressionContext : byte
		{
			Default = 0,
			ForInit = 2,
			AwaitForInit = 3,
			ForNew = 4,
			Decorator = 8
		}

		internal struct DestructuringErrors
		{
			public int ShorthandAssign;

			public int TrailingComma;

			public int ParenthesizedAssign;

			public int ParenthesizedBind;

			public int DoubleProto;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public DestructuringErrors()
			{
				ShorthandAssign = (TrailingComma = (ParenthesizedAssign = (ParenthesizedBind = (DoubleProto = -1))));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public readonly int GetTrailingComma()
			{
				if (TrailingComma != -1)
				{
					return TrailingComma & 0x7FFFFFFF;
				}
				return -1;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void SetTrailingComma(int index, bool isParam)
			{
				TrailingComma = ((!isParam || index == int.MaxValue) ? index : (index | int.MinValue));
			}
		}

		[Flags]
		private enum FunctionOrClassFlags : byte
		{
			None = 0,
			Statement = 1,
			HangingStatement = 2,
			NullableId = 4
		}

		private enum LeftHandSideKind : byte
		{
			Unknown,
			Assignment,
			PrefixUpdate,
			PostfixUpdate,
			ForInOf
		}

		internal readonly struct TokenState
		{
			public readonly int Position;

			public readonly TokenType TokenType;

			public readonly object? TokenValue;

			public TokenState(int position, TokenType tokenType, object? tokenValue)
			{
				Position = position;
				TokenType = tokenType;
				TokenValue = tokenValue;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public TokenState(Tokenizer tokenizer)
				: this(tokenizer._start, tokenizer._type, tokenizer._value.Value)
			{
			}
		}

		private enum LabelKind : byte
		{
			None,
			Loop,
			Switch
		}

		private struct Label
		{
			public LabelKind Kind;

			public string? Name;

			public int StatementStart;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Reset(LabelKind kind, string? name = null, int statementStart = 0)
			{
				Kind = kind;
				Name = name;
				StatementStart = statementStart;
			}
		}

		private struct PrivateNameStatus
		{
			public Dictionary<string, int>? Declared;

			public ArrayList<PrivateIdentifier> Used;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Reset()
			{
				Declared?.Clear();
				Used.Clear();
			}
		}

		private readonly ParserOptions _options;

		private readonly TokenizerOptions _tokenizerOptions;

		internal Tokenizer _tokenizer;

		private readonly IExtension? _extension;

		internal IsReservedWordDelegate _isReservedWord;

		internal IsReservedWordDelegate _isReservedWordBind;

		private bool _inModule;

		private bool _strict;

		private bool _topLevelAwaitAllowed;

		private ScopeFlags _functionsAsVarInScopeFlags;

		private int _potentialArrowAt;

		private int _forInitPosition;

		private int _yieldPosition;

		private int _awaitPosition;

		private int _awaitIdentifierPosition;

		private ArrayList<Label> _labels;

		private HashSet<string>? _exports;

		private Dictionary<string, int>? _undefinedExports;

		private int _scopeId;

		private ArrayList<Scope> _scopeStack;

		private ArrayList<PrivateNameStatus> _privateNameStack;

		private ArrayList<Decorator> _decorators;

		private int _bindingPatternDepth;

		private int _recursionDepth;

		public ParserOptions Options => _options;

		private ref Scope CurrentScope
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref _scopeStack.PeekRef();
			}
		}

		private ref Scope CurrentVarScope
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref _scopeStack.GetItemRef(_scopeStack.PeekRef()._currentVarScopeIndex);
			}
		}

		private ref Scope CurrentThisScope
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref _scopeStack.GetItemRef(_scopeStack.PeekRef()._currentThisScopeIndex);
			}
		}

		private bool InFunction
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (CurrentVarScope._flags & ScopeFlags.Function) != 0;
			}
		}

		private bool InGenerator
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (CurrentVarScope._flags & (ScopeFlags.Generator | ScopeFlags.InClassFieldInit)) == ScopeFlags.Generator;
			}
		}

		private bool InAsync
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (CurrentVarScope._flags & (ScopeFlags.Async | ScopeFlags.InClassFieldInit)) == ScopeFlags.Async;
			}
		}

		private bool CanAwait
		{
			get
			{
				ref Scope currentVarScope = ref CurrentVarScope;
				if ((currentVarScope._flags & ScopeFlags.Function) != 0)
				{
					return (currentVarScope._flags & (ScopeFlags.Async | ScopeFlags.InClassFieldInit)) == ScopeFlags.Async;
				}
				if ((currentVarScope._flags & ScopeFlags.Top) != 0)
				{
					if (_options._allowAwaitOutsideFunction || _topLevelAwaitAllowed)
					{
						return (currentVarScope._flags & ScopeFlags.InClassFieldInit) == 0;
					}
					return false;
				}
				return false;
			}
		}

		private bool AllowSuper
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!_options._allowSuperOutsideMethod)
				{
					return (CurrentThisScope._flags & (ScopeFlags.Super | ScopeFlags.InClassFieldInit)) != 0;
				}
				return true;
			}
		}

		private bool AllowDirectSuper
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (CurrentThisScope._flags & ScopeFlags.DirectSuper) != 0;
			}
		}

		private bool TreatFunctionsAsVar
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (CurrentScope._flags & _functionsAsVarInScopeFlags) != 0;
			}
		}

		private bool AllowNewDotTarget
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!_options._allowNewTargetOutsideFunction)
				{
					return (CurrentThisScope._flags & (ScopeFlags.Function | ScopeFlags.ClassStaticBlock | ScopeFlags.InClassFieldInit)) != 0;
				}
				return true;
			}
		}

		private bool InClassStaticBlock
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (CurrentVarScope._flags & ScopeFlags.ClassStaticBlock) != 0;
			}
		}

		private bool InClassFieldInit
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (CurrentThisScope._flags & ScopeFlags.InClassFieldInit) != 0;
			}
		}

		public Parser()
			: this(ParserOptions.Default)
		{
		}

		public Parser(ParserOptions options)
			: this(options, null)
		{
		}

		internal Parser(ParserOptions options, IExtension? extension)
		{
			_options = options ?? throw new ArgumentNullException("options");
			_extension = extension;
			_tokenizer = ((extension == null) ? new Tokenizer(options.GetTokenizerOptions(), null) : extension.CreateTokenizer(options.GetTokenizerOptions()));
			_tokenizerOptions = _tokenizer.Options;
			_isReservedWord = (_isReservedWordBind = null);
		}

		public Script ParseScript(string input, string? sourceFile = null, bool strict = false)
		{
			return ParseScript(input ?? ExceptionHelper.ThrowArgumentNullException<string>("input"), 0, input.Length, sourceFile, strict);
		}

		public Script ParseScript(string input, int start, int length, string? sourceFile = null, bool strict = false)
		{
			if (strict && _tokenizerOptions._ecmaVersion < EcmaVersion.ES5)
			{
				throw new InvalidOperationException(string.Format(null, ExceptionMessages.InvalidEcmaVersionForStrictMode, EcmaVersion.ES5));
			}
			Reset(input, start, length, SourceType.Script, sourceFile, strict);
			Marker startMarker = StartNode();
			try
			{
				NodeList<Statement> body = ParseTopLevel();
				Marker endMarker = new Marker(_tokenizer._start, _tokenizer._startLocation);
				return FinishNodeAt(in startMarker, in endMarker, new Script(in body, _strict), Scope.GetScopeRef(_scopeStack, 0));
			}
			finally
			{
				ReleaseLargeBuffers();
			}
		}

		public Acornima.Ast.Module ParseModule(string input, string? sourceFile = null)
		{
			return ParseModule(input ?? ExceptionHelper.ThrowArgumentNullException<string>("input"), 0, input.Length, sourceFile);
		}

		public Acornima.Ast.Module ParseModule(string input, int start, int length, string? sourceFile = null)
		{
			if (_tokenizerOptions._ecmaVersion < EcmaVersion.ES6)
			{
				throw new InvalidOperationException(string.Format(null, ExceptionMessages.InvalidEcmaVersionForModule, EcmaVersion.ES6));
			}
			Reset(input, start, length, SourceType.Module, sourceFile, strict: true);
			Marker startMarker = StartNode();
			try
			{
				NodeList<Statement> body = ParseTopLevel();
				Marker endMarker = new Marker(_tokenizer._start, _tokenizer._startLocation);
				return FinishNodeAt(in startMarker, in endMarker, new Acornima.Ast.Module(in body), Scope.GetScopeRef(_scopeStack, 0));
			}
			finally
			{
				ReleaseLargeBuffers();
			}
		}

		public Expression ParseExpression(string input, string? sourceFile = null, bool strict = false)
		{
			return ParseExpression(input ?? ExceptionHelper.ThrowArgumentNullException<string>("input"), 0, input.Length, sourceFile, strict);
		}

		public Expression ParseExpression(string input, int start, int length, string? sourceFile = null, bool strict = false)
		{
			if (strict && _tokenizerOptions._ecmaVersion < EcmaVersion.ES5)
			{
				throw new InvalidOperationException(string.Format(null, ExceptionMessages.InvalidEcmaVersionForStrictMode, EcmaVersion.ES5));
			}
			Reset(input, start, length, SourceType.Unknown, sourceFile, strict);
			try
			{
				Next();
				Expression result = ParseExpression(ref Unsafe.NullRef<DestructuringErrors>());
				if (_tokenizer._type != TokenType.EOF)
				{
					Unexpected();
				}
				return result;
			}
			finally
			{
				ReleaseLargeBuffers();
			}
		}

		private void CheckPropertyClash(Node property, ref bool hasProto, ref Dictionary<string, int>? propHash, ref DestructuringErrors destructuringErrors)
		{
			if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES9 && property.Type == NodeType.SpreadElement)
			{
				return;
			}
			ObjectProperty objectProperty = (ObjectProperty)property;
			if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES6 && (objectProperty.Computed || objectProperty.Method || objectProperty.Shorthand))
			{
				return;
			}
			Expression key = objectProperty.Key;
			string text;
			if (key is Identifier identifier)
			{
				text = identifier.Name;
			}
			else
			{
				if (!(key is Literal literal))
				{
					return;
				}
				text = Convert.ToString(literal.Value, CultureInfo.InvariantCulture);
			}
			PropertyKind kind = objectProperty.Kind;
			if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES6)
			{
				if (kind != PropertyKind.Init || !(text == "__proto__"))
				{
					return;
				}
				if (hasProto)
				{
					if (Unsafe.IsNullRef(ref destructuringErrors))
					{
						Raise(key.Start, SyntaxErrorMessages.DuplicateProto, "DuplicateProto");
					}
					else if (destructuringErrors.DoubleProto < 0)
					{
						destructuringErrors.DoubleProto = key.Start;
					}
				}
				else
				{
					hasProto = true;
				}
				return;
			}
			if (propHash == null)
			{
				propHash = new Dictionary<string, int>();
			}
			if (propHash.TryGetValue(text, out var value))
			{
				bool num;
				if (kind != PropertyKind.Init)
				{
					num = (value & (2 | (1 << (int)kind))) != 0;
				}
				else
				{
					if (_strict && ((uint)value & 2u) != 0)
					{
						goto IL_013c;
					}
					num = (value & 0xC) != 0;
				}
				if (num)
				{
					goto IL_013c;
				}
			}
			else
			{
				value = 0;
			}
			goto IL_0161;
			IL_0161:
			propHash[text] = value | (1 << (int)kind);
			return;
			IL_013c:
			Raise(key.Start, SyntaxErrorMessages.PropertyRedefinition, new object[1] { text }, "PropertyRedefinition");
			goto IL_0161;
		}

		internal Expression ParseExpression(ref DestructuringErrors destructuringErrors, ExpressionContext context = ExpressionContext.Default)
		{
			Marker startMarker = StartNode();
			Expression expression = ParseMaybeAssign(ref destructuringErrors, context);
			if (_tokenizer._type == TokenType.Comma)
			{
				ArrayList<Expression> arrayList = default(ArrayList<Expression>);
				arrayList.Add(expression);
				ArrayList<Expression> arrayList2 = arrayList;
				while (Eat(TokenType.Comma))
				{
					arrayList2.Add(ParseMaybeAssign(ref destructuringErrors, context));
				}
				NodeList<Expression> expressions = NodeList.From(ref arrayList2);
				return FinishNode(in startMarker, new SequenceExpression(in expressions));
			}
			return expression;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		internal Expression ParseMaybeAssign(ref DestructuringErrors destructuringErrors, ExpressionContext context = ExpressionContext.Default)
		{
			EnterRecursion();
			if (IsContextual("yield"))
			{
				if (InGenerator)
				{
					return ExitRecursion(ParseYield(context));
				}
				_tokenizer._expressionAllowed = false;
			}
			bool flag = Unsafe.IsNullRef(ref destructuringErrors);
			DestructuringErrors destructuringErrors2 = new DestructuringErrors();
			ref DestructuringErrors reference = ref flag ? ref destructuringErrors2 : ref destructuringErrors;
			int parenthesizedAssign = reference.ParenthesizedAssign;
			int trailingComma = reference.TrailingComma;
			int doubleProto = reference.DoubleProto;
			reference.ParenthesizedAssign = (reference.TrailingComma = -1);
			Marker startMarker = StartNode();
			if (_tokenizer._type == TokenType.ParenLeft || _tokenizer._type == TokenType.Name)
			{
				_potentialArrowAt = _tokenizer._start;
			}
			Expression expression = ParseMaybeConditional(ref reference, context);
			if (_tokenizer._type.IsAssignment)
			{
				Operator op = AssignmentExpression.OperatorFromString((string)_tokenizer._value.Value);
				Node node = ((_tokenizer._type == TokenType.Eq) ? ToAssignable(expression, ref reference, isBinding: false, isParam: false, LeftHandSideKind.Assignment) : expression);
				if (!flag)
				{
					reference.ParenthesizedAssign = (reference.TrailingComma = (reference.DoubleProto = -1));
				}
				if (reference.ShorthandAssign >= node.Start)
				{
					reference.ShorthandAssign = -1;
				}
				if (_tokenizer._type == TokenType.Eq)
				{
					CheckLValPattern(node, BindingType.None, null, LeftHandSideKind.Assignment);
				}
				else
				{
					CheckLValSimple(node, BindingType.None, null, LeftHandSideKind.Assignment);
				}
				Next();
				Expression right = ParseMaybeAssign(ref Unsafe.NullRef<DestructuringErrors>(), context);
				if (doubleProto >= 0)
				{
					reference.DoubleProto = doubleProto;
				}
				return ExitRecursion(FinishNode(in startMarker, new AssignmentExpression(op, node, right)));
			}
			if (flag)
			{
				CheckExpressionErrors(ref reference, andThrow: true);
			}
			if (parenthesizedAssign >= 0)
			{
				reference.ParenthesizedAssign = parenthesizedAssign;
			}
			if (trailingComma != -1)
			{
				reference.TrailingComma = trailingComma;
			}
			return ExitRecursion(expression);
		}

		private Expression ParseMaybeConditional(ref DestructuringErrors destructuringErrors, ExpressionContext context)
		{
			Marker startMarker = StartNode();
			Expression expression = ParseMaybeBinary(ref destructuringErrors, context);
			if (CheckExpressionErrors(ref destructuringErrors))
			{
				return expression;
			}
			if (Eat(TokenType.Question))
			{
				Expression consequent = ParseMaybeAssign(ref Unsafe.NullRef<DestructuringErrors>());
				Expect(TokenType.Colon);
				Expression alternate = ParseMaybeAssign(ref Unsafe.NullRef<DestructuringErrors>(), context);
				return FinishNode(in startMarker, new ConditionalExpression(expression, consequent, alternate));
			}
			return expression;
		}

		private Expression ParseMaybeBinary(ref DestructuringErrors destructuringErrors, ExpressionContext context)
		{
			Marker leftStartMarker = StartNode();
			Expression expression = ParseMaybeUnary(sawUnary: false, incDec: false, ref destructuringErrors, context);
			if (CheckExpressionErrors(ref destructuringErrors))
			{
				return expression;
			}
			if (expression.Start != leftStartMarker.Index || expression.Type != NodeType.ArrowFunctionExpression)
			{
				return ParseBinaryOp(in leftStartMarker, expression, -1, context);
			}
			return expression;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		private Expression ParseBinaryOp(in Marker leftStartMarker, Expression left, int minPrec, ExpressionContext context)
		{
			while (true)
			{
				int precedence = _tokenizer._type.Precedence;
				if (precedence <= minPrec || ((context & ExpressionContext.ForInit) != 0 && _tokenizer._type == TokenType.In))
				{
					break;
				}
				bool flag = _tokenizer._type == TokenType.LogicalOr || _tokenizer._type == TokenType.LogicalAnd;
				bool flag2;
				Operator op;
				if (flag)
				{
					flag2 = false;
					op = ((_tokenizer._type == TokenType.LogicalOr) ? Operator.LogicalOr : Operator.LogicalAnd);
				}
				else if (_tokenizer._type == TokenType.Coalesce)
				{
					flag2 = true;
					op = Operator.NullishCoalescing;
					precedence = TokenType.LogicalAnd.Precedence;
				}
				else
				{
					flag2 = false;
					op = NonLogicalBinaryExpression.OperatorFromString((string)_tokenizer._value.Value);
				}
				Next();
				Marker leftStartMarker2 = StartNode();
				Expression right = ParseBinaryOp(in leftStartMarker2, ParseMaybeUnary(sawUnary: false, incDec: false, ref Unsafe.NullRef<DestructuringErrors>(), context), precedence, context);
				BinaryExpression binaryExpression = BuildBinary(in leftStartMarker, left, right, op, flag || flag2);
				if ((flag && _tokenizer._type == TokenType.Coalesce) || (flag2 && (_tokenizer._type == TokenType.LogicalOr || _tokenizer._type == TokenType.LogicalAnd)))
				{
					RaiseRecoverable(_tokenizer._start, _tokenizer._type, _tokenizer._value.Value);
				}
				left = binaryExpression;
			}
			return left;
		}

		private BinaryExpression BuildBinary(in Marker startMarker, Expression left, Expression right, Operator op, bool logical)
		{
			if (right.Type == NodeType.PrivateIdentifier)
			{
				Unexpected(right.Start, TokenType.PrivateId, right.As<PrivateIdentifier>().Name);
			}
			return FinishNode(in startMarker, logical ? ((BinaryExpression)new LogicalExpression(op, left, right)) : ((BinaryExpression)new NonLogicalBinaryExpression(op, left, right)));
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		private Expression ParseMaybeUnary(bool sawUnary, bool incDec, ref DestructuringErrors destructuringErrors, ExpressionContext context)
		{
			Marker startMarker = StartNode();
			Expression expression;
			if (IsContextual("await") && CanAwait)
			{
				EnterRecursion();
				expression = ExitRecursion(ParseAwait(context));
				sawUnary = true;
			}
			else if (_tokenizer._type.Prefix)
			{
				bool flag = _tokenizer._type == TokenType.IncDec;
				Operator @operator = (flag ? UpdateExpression.OperatorFromString((string)_tokenizer._value.Value) : NonUpdateUnaryExpression.OperatorFromString((string)_tokenizer._value.Value));
				Next();
				EnterRecursion();
				Expression expression2 = ExitRecursion(ParseMaybeUnary(sawUnary: true, flag, ref Unsafe.NullRef<DestructuringErrors>(), context));
				CheckExpressionErrors(ref destructuringErrors, andThrow: true);
				if (flag)
				{
					CheckLValSimple(expression2, BindingType.None, null, LeftHandSideKind.PrefixUpdate);
				}
				else
				{
					if (@operator == Operator.Delete)
					{
						CheckDeleteErrors(expression2);
					}
					sawUnary = true;
				}
				expression = FinishNode(in startMarker, flag ? ((UnaryExpression)new UpdateExpression(@operator, expression2, prefix: true)) : ((UnaryExpression)new NonUpdateUnaryExpression(@operator, expression2)));
			}
			else if (!sawUnary && _tokenizer._type == TokenType.PrivateId)
			{
				if (_options._checkPrivateFields && ((context & ExpressionContext.ForInit) != 0 || _privateNameStack.Count == 0))
				{
					Unexpected();
				}
				expression = ParsePrivateIdentifier();
				if (_tokenizer._type != TokenType.In)
				{
					Unexpected(expression.Start, TokenType.PrivateId, expression.As<PrivateIdentifier>().Name);
				}
			}
			else
			{
				expression = ParseExprSubscripts(ref destructuringErrors, context);
				while (_tokenizer._type.Postfix && !CanInsertSemicolon())
				{
					Operator @operator = UpdateExpression.OperatorFromString((string)_tokenizer._value.Value);
					CheckLValSimple(expression, BindingType.None, null, LeftHandSideKind.PostfixUpdate);
					Next();
					expression = FinishNode(in startMarker, new UpdateExpression(@operator, expression, prefix: false));
				}
			}
			if (!incDec && Eat(TokenType.StarStar))
			{
				if (!sawUnary)
				{
					EnterRecursion();
					Expression right = ExitRecursion(ParseMaybeUnary(sawUnary: false, incDec: false, ref Unsafe.NullRef<DestructuringErrors>(), context));
					return BuildBinary(in startMarker, expression, right, Operator.Exponentiation, logical: false);
				}
				Raise(_tokenizer._lastTokenStart, SyntaxErrorMessages.UnexpectedTokenUnaryExponentiation, "UnexpectedTokenUnaryExponentiation");
			}
			return expression;
			[MethodImpl(MethodImplOptions.NoInlining)]
			void CheckDeleteErrors(Expression argument)
			{
				if (_strict && IsLocalVariableAccess(argument, out Expression identifier))
				{
					RaiseRecoverable(identifier.Start, SyntaxErrorMessages.StrictDelete, "StrictDelete");
				}
				else if (IsPrivateFieldAccess(argument, out identifier))
				{
					Raise(identifier.Start, SyntaxErrorMessages.DeletePrivateField, "DeletePrivateField");
				}
			}
		}

		private static bool IsLocalVariableAccess(Expression expr, [NotNullWhen(true)] out Expression? identifier)
		{
			while (true)
			{
				if (!(expr is Identifier))
				{
					if (!(expr is ParenthesizedExpression parenthesizedExpression))
					{
						break;
					}
					expr = parenthesizedExpression.Expression;
					continue;
				}
				identifier = expr;
				return true;
			}
			identifier = null;
			return false;
		}

		private static bool IsPrivateFieldAccess(Expression expr, [NotNullWhen(true)] out Expression? identifier)
		{
			while (true)
			{
				if (expr is MemberExpression memberExpression)
				{
					Expression property = memberExpression.Property;
					if (property == null || property.Type != NodeType.PrivateIdentifier)
					{
						break;
					}
					identifier = memberExpression.Property;
					return true;
				}
				if (!(expr is ChainExpression chainExpression))
				{
					if (!(expr is ParenthesizedExpression parenthesizedExpression))
					{
						break;
					}
					expr = parenthesizedExpression.Expression;
				}
				else
				{
					expr = chainExpression.Expression;
				}
			}
			identifier = null;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		private Expression ParseExprSubscripts(ref DestructuringErrors destructuringErrors, ExpressionContext context = ExpressionContext.Default)
		{
			Marker startMarker = StartNode();
			Expression expression;
			if ((context & ExpressionContext.Decorator) == 0)
			{
				expression = ParseExprAtom(ref destructuringErrors, context);
			}
			else
			{
				if (_tokenizer._type != TokenType.Name && _tokenizer._type != TokenType.ParenLeft)
				{
					Unexpected();
				}
				expression = ParseExprAtom(ref destructuringErrors, context & ~ExpressionContext.Decorator);
			}
			if (expression.Type == NodeType.ArrowFunctionExpression && !_tokenizer._input.SliceBetween(_tokenizer._lastTokenStart, _tokenizer._lastTokenEnd).SequenceEqual(")".AsSpan()))
			{
				return expression;
			}
			Expression expression2 = ParseSubscripts(in startMarker, expression, noCalls: false, context);
			if (!Unsafe.IsNullRef(ref destructuringErrors) && expression2.Type == NodeType.MemberExpression)
			{
				if (destructuringErrors.ParenthesizedAssign >= expression2.Start)
				{
					destructuringErrors.ParenthesizedAssign = -1;
				}
				if (destructuringErrors.ParenthesizedBind >= expression2.Start)
				{
					destructuringErrors.ParenthesizedBind = -1;
				}
				if (destructuringErrors.GetTrailingComma() >= expression2.Start)
				{
					destructuringErrors.TrailingComma = -1;
				}
			}
			return expression2;
		}

		private Expression ParseSubscripts(in Marker startMarker, Expression baseExpr, bool noCalls, ExpressionContext context)
		{
			bool maybeAsyncArrow = _tokenizerOptions._ecmaVersion >= EcmaVersion.ES8 && baseExpr is Identifier identifier && identifier.Name == "async" && _tokenizer._lastTokenEnd == baseExpr.End && !CanInsertSemicolon() && baseExpr.End - baseExpr.Start == "async".Length && _potentialArrowAt == baseExpr.Start;
			int optionalChainPos = -1;
			bool hasCall = false;
			Expression expression;
			while (true)
			{
				expression = ParseSubscript(in startMarker, baseExpr, noCalls, maybeAsyncArrow, ref optionalChainPos, ref hasCall, context);
				if (expression == baseExpr || expression.Type == NodeType.ArrowFunctionExpression)
				{
					break;
				}
				baseExpr = expression;
			}
			if (optionalChainPos >= 0)
			{
				expression = FinishNode(in startMarker, new ChainExpression(expression));
			}
			return expression;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		private Expression ParseSubscript(in Marker startMarker, Expression baseExpr, bool noCalls, bool maybeAsyncArrow, ref int optionalChainPos, ref bool hasCall, ExpressionContext context)
		{
			bool flag = _tokenizerOptions._ecmaVersion >= EcmaVersion.ES11 && Eat(TokenType.QuestionDot);
			if (flag)
			{
				if (noCalls)
				{
					Raise(_tokenizer._lastTokenStart, SyntaxErrorMessages.OptionalChainingNoNew, "OptionalChainingNoNew");
				}
				if ((context & ExpressionContext.Decorator) != 0)
				{
					Raise(_tokenizer._lastTokenStart, SyntaxErrorMessages.InvalidDecoratorMemberExpr, "InvalidDecoratorMemberExpr");
				}
				if (optionalChainPos < 0)
				{
					optionalChainPos = _tokenizer._lastTokenStart;
				}
			}
			bool flag2 = Eat(TokenType.BracketLeft);
			if (flag2 || (flag && _tokenizer._type != TokenType.ParenLeft && _tokenizer._type != TokenType.BackQuote) || Eat(TokenType.Dot))
			{
				Expression property;
				if (flag2)
				{
					if ((context & ExpressionContext.Decorator) != 0)
					{
						Raise(_tokenizer._lastTokenStart, SyntaxErrorMessages.InvalidDecoratorMemberExpr, "InvalidDecoratorMemberExpr");
					}
					property = ParseExpression(ref Unsafe.NullRef<DestructuringErrors>());
					Expect(TokenType.BracketRight);
				}
				else
				{
					if (hasCall && (context & ExpressionContext.Decorator) != 0)
					{
						Raise(_tokenizer._lastTokenStart, SyntaxErrorMessages.InvalidDecoratorMemberExpr, "InvalidDecoratorMemberExpr");
					}
					property = ((_tokenizer._type == TokenType.PrivateId && baseExpr.Type != NodeType.Super) ? ((Expression)ParsePrivateIdentifier()) : ((Expression)ParseIdentifier(_options._allowReserved != AllowReservedOption.Never)));
				}
				baseExpr = FinishNode(in startMarker, new MemberExpression(baseExpr, property, flag2, flag));
			}
			else if (!noCalls && Eat(TokenType.ParenLeft))
			{
				DestructuringErrors destructuringErrors = new DestructuringErrors();
				int yieldPosition = _yieldPosition;
				int awaitPosition = _awaitPosition;
				int awaitIdentifierPosition = _awaitIdentifierPosition;
				_yieldPosition = (_awaitPosition = (_awaitIdentifierPosition = 0));
				if (hasCall && (context & ExpressionContext.Decorator) != 0)
				{
					Raise(_tokenizer._lastTokenStart, SyntaxErrorMessages.InvalidDecoratorMemberExpr, "InvalidDecoratorMemberExpr");
				}
				NodeList<Expression> args = ParseExprList(TokenType.ParenRight, _tokenizerOptions._ecmaVersion >= EcmaVersion.ES8, allowEmptyItem: false, ref destructuringErrors);
				if (maybeAsyncArrow && !flag && !CanInsertSemicolon() && Eat(TokenType.Arrow))
				{
					CheckPatternErrors(ref destructuringErrors, isAssign: false);
					CheckYieldAwaitInDefaultParams();
					if (_awaitIdentifierPosition > 0)
					{
						Raise(_awaitIdentifierPosition, SyntaxErrorMessages.AwaitBindingIdentifier, "AwaitBindingIdentifier");
					}
					_yieldPosition = yieldPosition;
					_awaitPosition = awaitPosition;
					_awaitIdentifierPosition = awaitIdentifierPosition;
					NodeList<Node> parameters = args.AsNodes();
					return ParseArrowExpression(in startMarker, in parameters, isAsync: true, context);
				}
				CheckExpressionErrors(ref destructuringErrors, andThrow: true);
				if (yieldPosition != 0)
				{
					_yieldPosition = yieldPosition;
				}
				if (awaitPosition != 0)
				{
					_awaitPosition = awaitPosition;
				}
				if (awaitIdentifierPosition != 0)
				{
					_awaitIdentifierPosition = awaitIdentifierPosition;
				}
				baseExpr = FinishNode(in startMarker, new CallExpression(baseExpr, in args, flag));
				hasCall = true;
			}
			else if (_tokenizer._type == TokenType.BackQuote)
			{
				if (optionalChainPos >= 0)
				{
					Raise(optionalChainPos, SyntaxErrorMessages.OptionalChainingNoTemplate, "OptionalChainingNoTemplate");
				}
				if ((context & ExpressionContext.Decorator) != 0)
				{
					Raise(_tokenizer._start, SyntaxErrorMessages.InvalidDecoratorMemberExpr, "InvalidDecoratorMemberExpr");
				}
				TemplateLiteral quasi = ParseTemplate(isTagged: true);
				baseExpr = FinishNode(in startMarker, new TaggedTemplateExpression(baseExpr, quasi));
			}
			return baseExpr;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		internal Expression ParseExprAtom(ref DestructuringErrors destructuringErrors, ExpressionContext context = ExpressionContext.Default)
		{
			Marker startMarker = StartNode();
			switch (_tokenizer._type.Kind)
			{
			case TokenKind.Keyword:
				switch (_tokenizer._type.Keyword.Value)
				{
				case Keyword.Super:
					if (!AllowSuper)
					{
						Raise(_tokenizer._start, SyntaxErrorMessages.UnexpectedSuper, "UnexpectedSuper");
					}
					Next();
					if (_tokenizer._type == TokenType.ParenLeft && !AllowDirectSuper)
					{
						Raise(startMarker.Index, SyntaxErrorMessages.UnexpectedSuper, "UnexpectedSuper");
					}
					if (_tokenizer._type != TokenType.Dot && _tokenizer._type != TokenType.BracketLeft && _tokenizer._type != TokenType.ParenLeft)
					{
						Raise(startMarker.Index, SyntaxErrorMessages.UnexpectedSuper, "UnexpectedSuper");
					}
					return FinishNode(in startMarker, new Super());
				case Keyword.This:
					Next();
					return FinishNode(in startMarker, new ThisExpression());
				case Keyword.Function:
					Next();
					return (FunctionExpression)ParseFunction(in startMarker, FunctionOrClassFlags.None);
				case Keyword.Class:
					Next();
					EnterRecursion();
					return ExitRecursion((ClassExpression)ParseClass(in startMarker, FunctionOrClassFlags.None));
				case Keyword.New:
					EnterRecursion();
					return ExitRecursion(ParseNew());
				case Keyword.Import:
					if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES11)
					{
						return ParseExprImport(context);
					}
					break;
				}
				break;
			case TokenKind.Identifier:
			{
				if (_tokenizer._type != TokenType.Name)
				{
					break;
				}
				bool canBeArrow = _potentialArrowAt == _tokenizer._start;
				bool containsEscape = _tokenizer._containsEscape;
				Identifier identifier = ParseIdentifier();
				if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES8 && !containsEscape && identifier.Name == "async" && !CanInsertSemicolon() && Eat(TokenType.Function))
				{
					_tokenizer.OverrideContext(TokenContext.FunctionInExpression);
					return (FunctionExpression)ParseFunction(in startMarker, FunctionOrClassFlags.None, isAsync: true, context & ~ExpressionContext.ForNew);
				}
				if (canBeArrow && !CanInsertSemicolon())
				{
					if (Eat(TokenType.Arrow))
					{
						NodeList<Node> parameters = new NodeList<Node>(identifier);
						return ParseArrowExpression(in startMarker, in parameters, isAsync: false, context & ~ExpressionContext.ForNew);
					}
					if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES8 && !containsEscape && identifier.Name == "async" && _tokenizer._type == TokenType.Name && ((context & ExpressionContext.AwaitForInit) != ExpressionContext.AwaitForInit || !"of".Equals(_tokenizer._value.Value) || _tokenizer._containsEscape))
					{
						containsEscape = _tokenizer._containsEscape;
						identifier = ParseIdentifier();
						if (CanInsertSemicolon() || !Eat(TokenType.Arrow))
						{
							if ((context & ExpressionContext.AwaitForInit) == ExpressionContext.ForInit && !containsEscape && identifier.Name == "of")
							{
								if (startMarker.Index == _forInitPosition)
								{
									Raise(_forInitPosition, SyntaxErrorMessages.ForOfAsync, "ForOfAsync");
								}
								else
								{
									Raise(_forInitPosition, SyntaxErrorMessages.InvalidLhsInFor, "InvalidLhsInFor");
								}
							}
							else
							{
								Unexpected();
							}
						}
						NodeList<Node> parameters = new NodeList<Node>(identifier);
						return ParseArrowExpression(in startMarker, in parameters, isAsync: true, context & ~ExpressionContext.ForNew);
					}
				}
				return identifier;
			}
			case TokenKind.NullLiteral:
			case TokenKind.BooleanLiteral:
			{
				string raw2 = (_tokenizer._containsEscape ? Tokenizer.DeduplicateString(_tokenizer._input.SliceBetween(_tokenizer._start, _tokenizer._end), ref _tokenizer._stringPool) : _tokenizer._type.Label);
				Literal node = ((_tokenizer._type.Kind == TokenKind.NullLiteral) ? ((Literal)new NullLiteral(raw2)) : ((Literal)new BooleanLiteral(_tokenizer._type.Value, raw2)));
				Next();
				return FinishNode(in startMarker, node);
			}
			case TokenKind.StringLiteral:
			case TokenKind.NumericLiteral:
			case TokenKind.BigIntLiteral:
			case TokenKind.RegExpLiteral:
			{
				string raw2 = Tokenizer.DeduplicateString(_tokenizer._input.SliceBetween(_tokenizer._start, _tokenizer._end), ref _tokenizer._stringPool, 20);
				Literal node = _tokenizer._type.Kind switch
				{
					TokenKind.StringLiteral => new StringLiteral((string)_tokenizer._value.Value, raw2), 
					TokenKind.NumericLiteral => new NumericLiteral(_tokenizer._value.NumericValue, raw2), 
					TokenKind.BigIntLiteral => new BigIntLiteral(_tokenizer._value.BigIntValue, raw2), 
					_ => CreateRegExpLiteral(in _tokenizer._value, raw2), 
				};
				Next();
				return FinishNode(in startMarker, node);
			}
			case TokenKind.Punctuator:
				if (_tokenizer._type == TokenType.ParenLeft)
				{
					bool canBeArrow = _potentialArrowAt == _tokenizer._start;
					Expression expression = ParseParenAndDistinguishExpression(canBeArrow, context & ~ExpressionContext.ForNew);
					if (!Unsafe.IsNullRef(ref destructuringErrors))
					{
						if (destructuringErrors.ParenthesizedAssign < 0 && !IsSimpleAssignTarget(expression))
						{
							destructuringErrors.ParenthesizedAssign = startMarker.Index;
						}
						if (destructuringErrors.ParenthesizedBind < 0)
						{
							destructuringErrors.ParenthesizedBind = startMarker.Index;
						}
					}
					return expression;
				}
				if (_tokenizer._type == TokenType.BracketLeft)
				{
					Next();
					NodeList<Expression> elements = ParseExprList(TokenType.BracketRight, allowTrailingComma: true, allowEmptyItem: true, ref destructuringErrors);
					return FinishNode(in startMarker, new ArrayExpression(in elements));
				}
				if (_tokenizer._type == TokenType.BraceLeft)
				{
					_tokenizer.OverrideContext(TokenContext.BracketsInExpression);
					EnterRecursion();
					return ExitRecursion((Expression)ParseObject(isPattern: false, ref destructuringErrors));
				}
				if (_tokenizer._type == TokenType.BackQuote)
				{
					return ParseTemplate(isTagged: false);
				}
				if (_tokenizer._type == TokenType.Slash)
				{
					_tokenizer.ReadRegExp();
				}
				else
				{
					if (_tokenizer._type != TokenType.Assign || !"/=".Equals(_tokenizer._value.Value))
					{
						if (_tokenizer._type == TokenType.At)
						{
							EnterRecursion();
							return ExitRecursion(ParseDecoratedClassExpression(in startMarker));
						}
						break;
					}
					_tokenizer._position--;
					_tokenizer.ReadRegExp();
				}
				goto case TokenKind.StringLiteral;
			}
			if (_extension != null)
			{
				return _extension.ParseExprAtom();
			}
			return Unexpected<Expression>();
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			static RegExpLiteral CreateRegExpLiteral(in TokenValue value, string raw)
			{
				Tuple<RegExpValue, RegExpParseResult> tuple = (Tuple<RegExpValue, RegExpParseResult>)value.Value;
				return new RegExpLiteral(tuple.Item1, tuple.Item2, raw);
			}
		}

		private Expression ParseExprImport(ExpressionContext context)
		{
			Marker startMarker = StartNode();
			if (_tokenizer._containsEscape)
			{
				RaiseRecoverable(_tokenizer._start, SyntaxErrorMessages.InvalidEscapedReservedWord, "InvalidEscapedReservedWord");
			}
			Next();
			if (_tokenizer._type == TokenType.ParenLeft && (context & ExpressionContext.ForNew) == 0)
			{
				return ParseDynamicImport(in startMarker);
			}
			if (_tokenizer._type == TokenType.Dot)
			{
				Identifier meta = FinishNode(in startMarker, new Identifier(TokenType.Import.Label));
				return ParseImportMeta(in startMarker, meta);
			}
			return Unexpected<Expression>();
		}

		private ImportExpression ParseDynamicImport(in Marker startMarker)
		{
			Next();
			Expression source = ParseMaybeAssign(ref Unsafe.NullRef<DestructuringErrors>());
			Expression options = null;
			if (_tokenizerOptions.AllowImportAttributes() && Eat(TokenType.Comma) && _tokenizer._type != TokenType.ParenRight)
			{
				options = ParseMaybeAssign(ref Unsafe.NullRef<DestructuringErrors>());
				if (Eat(TokenType.Comma))
				{
					AfterTrailingComma(TokenType.ParenRight, isAllowed: true, notNext: true);
				}
				Expect(TokenType.ParenRight);
			}
			else if (!Eat(TokenType.ParenRight))
			{
				TokenState tokenState = new TokenState(_tokenizer);
				if (Eat(TokenType.Comma) && Eat(TokenType.ParenRight))
				{
					RaiseRecoverable(tokenState.Position, tokenState.TokenType, tokenState.TokenValue);
				}
				else
				{
					Unexpected(tokenState);
				}
			}
			return FinishNode(in startMarker, new ImportExpression(source, options));
		}

		private MetaProperty ParseImportMeta(in Marker startMarker, Identifier meta)
		{
			Next();
			bool containsEscape = _tokenizer._containsEscape;
			Identifier identifier = ParseIdentifier(liberal: true);
			if (identifier.Name != "meta")
			{
				Unexpected(identifier.Start, TokenType.Name, identifier.Name);
			}
			if (containsEscape)
			{
				RaiseRecoverable(identifier.Start, SyntaxErrorMessages.InvalidEscapedMetaProperty, new object[1] { "import.meta" }, "InvalidEscapedMetaProperty");
			}
			if (!_inModule && !_options._allowImportExportEverywhere)
			{
				Raise(identifier.Start, SyntaxErrorMessages.ImportMetaOutsideModule, "ImportMetaOutsideModule");
			}
			return FinishNode(in startMarker, new MetaProperty(meta, identifier));
		}

		private Expression ParseParenExpression()
		{
			Expect(TokenType.ParenLeft);
			Expression result = ParseExpression(ref Unsafe.NullRef<DestructuringErrors>());
			Expect(TokenType.ParenRight);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveOptimization)]
		private Expression ParseParenAndDistinguishExpression(bool canBeArrow, ExpressionContext context)
		{
			Marker startMarker = StartNode();
			Expression expression;
			if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES6)
			{
				Next();
				Marker startMarker2 = StartNode();
				ArrayList<Node> arrayList = default(ArrayList<Node>);
				DestructuringErrors destructuringErrors = new DestructuringErrors();
				int yieldPosition = _yieldPosition;
				int awaitPosition = _awaitPosition;
				_yieldPosition = (_awaitPosition = 0);
				int num = -1;
				bool flag = true;
				bool flag2 = _tokenizerOptions._ecmaVersion >= EcmaVersion.ES8;
				bool flag3 = false;
				while (_tokenizer._type != TokenType.ParenRight)
				{
					if (!flag)
					{
						if (!Eat(TokenType.Comma))
						{
							CheckExpressionErrors(ref destructuringErrors, andThrow: true);
							Unexpected();
						}
						if (AfterTrailingComma(TokenType.ParenRight, flag2, notNext: true))
						{
							flag3 = true;
							break;
						}
					}
					else
					{
						flag = false;
					}
					if (_tokenizer._type == TokenType.Ellipsis)
					{
						if (num < 0)
						{
							num = _tokenizer._start;
						}
						arrayList.Add(ParseSpread(ref destructuringErrors));
						if (_tokenizer._type == TokenType.Comma && destructuringErrors.GetTrailingComma() < 0)
						{
							destructuringErrors.SetTrailingComma(arrayList.LastItemRef().As<SpreadElement>().Argument.Start, isParam: true);
						}
					}
					else
					{
						arrayList.Add(ParseMaybeAssign(ref destructuringErrors));
					}
				}
				Marker endMarker = new Marker(_tokenizer._lastTokenEnd, _tokenizer._lastTokenEndLocation);
				Expect(TokenType.ParenRight);
				if (canBeArrow && !CanInsertSemicolon() && Eat(TokenType.Arrow))
				{
					CheckPatternErrors(ref destructuringErrors, isAssign: false);
					CheckYieldAwaitInDefaultParams();
					_yieldPosition = yieldPosition;
					_awaitPosition = awaitPosition;
					NodeList<Node> parameters = NodeList.From(ref arrayList);
					return ParseArrowExpression(in startMarker, in parameters, isAsync: false, context);
				}
				if (arrayList.Count == 0)
				{
					Unexpected(_tokenizer._lastTokenStart, TokenType.ParenRight, TokenType.ParenRight.Value);
				}
				if (num >= 0)
				{
					Unexpected(num, TokenType.Ellipsis, TokenType.Ellipsis.Value);
				}
				CheckExpressionErrors(ref destructuringErrors, andThrow: true);
				if (flag2 && flag3)
				{
					RaiseRecoverable(_tokenizer._lastTokenStart, TokenType.ParenRight, TokenType.ParenRight.Value);
				}
				if (yieldPosition != 0)
				{
					_yieldPosition = yieldPosition;
				}
				if (awaitPosition != 0)
				{
					_awaitPosition = awaitPosition;
				}
				if (arrayList.Count > 1)
				{
					ArrayList<Expression> arrayList2 = new ArrayList<Expression>(new Expression[arrayList.Count]);
					for (int i = 0; i < arrayList.Count; i++)
					{
						arrayList2[i] = (Expression)arrayList[i];
					}
					NodeList<Expression> expressions = NodeList.From(ref arrayList2);
					expression = FinishNodeAt(in startMarker2, in endMarker, new SequenceExpression(in expressions));
				}
				else
				{
					expression = (Expression)arrayList[0];
				}
			}
			else
			{
				expression = ParseParenExpression();
			}
			if (!_options._preserveParens)
			{
				return expression;
			}
			return FinishNode(in startMarker, new ParenthesizedExpression(expression));
		}

		private Expression ParseNew()
		{
			if (_tokenizer._containsEscape)
			{
				RaiseRecoverable(_tokenizer._start, SyntaxErrorMessages.InvalidEscapedReservedWord, "InvalidEscapedReservedWord");
			}
			Marker startMarker = StartNode();
			Next();
			if (_tokenizerOptions._ecmaVersion >= EcmaVersion.ES6 && _tokenizer._type == TokenType.Dot)
			{
				Identifier meta = FinishNode(in startMarker, new Identifier(TokenType.New.Label));
				Next();
				bool containsEscape = _tokenizer._containsEscape;
				Identifier identifier = ParseIdentifier(liberal: true);
				if (identifier.Name != "target")
				{
					Unexpected(identifier.Start, TokenType.Name, identifier.Name);
				}
				if (containsEscape)
				{
					RaiseRecoverable(identifier.Start, SyntaxErrorMessages.InvalidEscapedMetaProperty, new object[1] { "new.target" }, "InvalidEscapedMetaProperty");
				}
				if (!AllowNewDotTarget)
				{
					Raise(identifier.Start, SyntaxErrorMessages.UnexpectedNewTarget, "UnexpectedNewTarget");
				}
				return FinishNode(in startMarker, new MetaProperty(meta, identifier));
			}
			Marker startMarker2 = StartNode();
			Expression callee = ParseSubscripts(in startMarker2, ParseExprAtom(ref Unsafe.NullRef<DestructuringErrors>(), ExpressionContext.ForNew), noCalls: true, ExpressionContext.Default);
			NodeList<Expression> args = (Eat(TokenType.ParenLeft) ? ParseExprList(TokenType.ParenRight, _tokenizerOptions._ecmaVersion >= EcmaVersion.ES8, allowEmptyItem: false, ref Unsafe.NullRef<DestructuringErrors>()) : default(NodeList<Expression>));
			return FinishNode(in startMarker, new NewExpression(callee, in args));
		}

		private TemplateElement ParseTemplateElement()
		{
			Marker startMarker = StartNode();
			TemplateValue value = new TemplateValue(_tokenizer._value.TemplateCooked, (string)_tokenizer._value.Value);
			Next();
			bool tail = _tokenizer._type == TokenType.BackQuote;
			return FinishNode(in startMarker, new TemplateElement(value, tail));
		}

		private TemplateLiteral ParseTemplate(bool isTagged)
		{
			Marker startMarker = StartNode();
			Next(ignoreEscapeSequenceInKeyword: false, !isTagged);
			TemplateElement templateElement = ParseTemplateElement();
			ArrayList<TemplateElement> arrayList = default(ArrayList<TemplateElement>);
			arrayList.Add(templateElement);
			ArrayList<TemplateElement> arrayList2 = arrayList;
			ArrayList<Expression> arrayList3 = default(ArrayList<Expression>);
			while (!templateElement.Tail)
			{
				if (_tokenizer._type == TokenType.EOF)
				{
					Raise(_tokenizer._start, SyntaxErrorMessages.UnexpectedEOS, "UnexpectedEOS");
				}
				int start = _tokenizer._start;
				Expect(TokenType.DollarBraceLeft);
				arrayList3.Add(ParseExpression(ref Unsafe.NullRef<DestructuringErrors>()));
				if (_tokenizer._type == TokenType.BraceRight)
				{
					Next(ignoreEscapeSequenceInKeyword: false, !isTagged);
				}
				else
				{
					Raise(start, SyntaxErrorMessages.UnterminatedTemplateExpr, "UnterminatedTemplateExpr");
				}
				arrayList2.Add(templateElement = ParseTemplateElement());
			}
			Next();
			NodeList<TemplateElement> quasis = NodeList.From(ref arrayList2);
			NodeList<Expression> expressions = NodeList.From(ref arrayList3);
			return FinishNode(in startMarker, new TemplateLiteral(in quasis, in expressions));
		}

		private bool IsAsyncProperty(Expression key, bool computed)
		{
			bool flag = !computed && key is Identifier identifier && identifier.Name == "async";
			int num;
			if (flag)
			{
				bool flag2 = _tokenizer._type == TokenType.Name || _tokenizer._type == TokenType.BracketLeft;
				if (!flag2)
				{
					TokenKind kind = _tokenizer._type.Kind;
					bool flag3 = (uint)(kind - 6) <= 2u;
					flag2 = flag3;
				}
				if (!flag2)
				{
					Keyword? keyword = _tokenizer._type.Keyword;
					if (!keyword.HasValue)
					{
						num = ((_tokenizerOptions._ecmaVersion >= EcmaVersion.ES9 && _tokenizer._type == TokenType.Star) ? 1 : 0);
						goto IL_00bc;
					}
				}
				num = 1;
				goto IL_00bc;
			}
			goto IL_00bd;
			IL_00bd:
			if (flag)
			{
				return !Tokenizer.ContainsLineBreak(_tokenizer._input.SliceBetween(_tokenizer._lastTokenEnd, _tokenizer._start));
			}
			return false;
			IL_00bc:
			flag = (byte)num != 0;
			goto IL_00bd;
		}

		private Node ParseObject(bool isPattern, ref DestructuringErrors destructuringErrors)
		{
			Marker startMarker = StartNode();
			ArrayList<Node> arrayList = default(ArrayList<Node>);
			Next();
			bool flag = true;
			bool hasProto = false;
			bool isAllowed = _tokenizerOptions._ecmaVersion >= EcmaVersion.ES5;
			Dictionary<string, int> propHash = null;
			while (!Eat(TokenType.BraceRight))
			{
				if (!flag)
				{
					Expect(TokenType.Comma);
					if (AfterTrailingComma(TokenType.BraceRight, isAllowed))
					{
						break;
					}
				}
				else
				{
					flag = false;
				}
				Node node = ParseProperty(isPattern, ref destructuringErr