using System;
using System.Buffers;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Encodings.Web;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Esprima;
using Esprima.Ast;
using Esprima.Utils;
using Jint.Collections;
using Jint.Constraints;
using Jint.Extensions;
using Jint.Native;
using Jint.Native.AggregateError;
using Jint.Native.Array;
using Jint.Native.ArrayBuffer;
using Jint.Native.AsyncFunction;
using Jint.Native.BigInt;
using Jint.Native.Boolean;
using Jint.Native.DataView;
using Jint.Native.Date;
using Jint.Native.Error;
using Jint.Native.FinalizationRegistry;
using Jint.Native.Function;
using Jint.Native.Generator;
using Jint.Native.Global;
using Jint.Native.Intl;
using Jint.Native.Iterator;
using Jint.Native.Json;
using Jint.Native.Map;
using Jint.Native.Math;
using Jint.Native.Number;
using Jint.Native.Number.Dtoa;
using Jint.Native.Object;
using Jint.Native.Promise;
using Jint.Native.Proxy;
using Jint.Native.Reflect;
using Jint.Native.RegExp;
using Jint.Native.Set;
using Jint.Native.ShadowRealm;
using Jint.Native.SharedArrayBuffer;
using Jint.Native.String;
using Jint.Native.Symbol;
using Jint.Native.TypedArray;
using Jint.Native.WeakMap;
using Jint.Native.WeakRef;
using Jint.Native.WeakSet;
using Jint.Pooling;
using Jint.Runtime;
using Jint.Runtime.CallStack;
using Jint.Runtime.Debugger;
using Jint.Runtime.Descriptors;
using Jint.Runtime.Descriptors.Specialized;
using Jint.Runtime.Environments;
using Jint.Runtime.Interop;
using Jint.Runtime.Interop.Reflection;
using Jint.Runtime.Interpreter;
using Jint.Runtime.Interpreter.Expressions;
using Jint.Runtime.Interpreter.Statements;
using Jint.Runtime.Modules;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Jint.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100bf2553c9f214cb21f1f64ed62cadad8fe4f2fa11322a5dfa1d650743145c6085aba05b145b29867af656e0bb9bfd32f5d0deb1668263a38233e7e8e5bad1a3c6edd3f2ec6c512668b4aa797283101444628650949641b4f7cb16707efba542bb754afe87ce956f3a5d43f450d14364eb9571cbf213d1061852fb9dd47a6c05c4")]
[assembly: InternalsVisibleTo("Jint.Tests.Test262, PublicKey=0024000004800000940000000602000000240000525341310004000001000100bf2553c9f214cb21f1f64ed62cadad8fe4f2fa11322a5dfa1d650743145c6085aba05b145b29867af656e0bb9bfd32f5d0deb1668263a38233e7e8e5bad1a3c6edd3f2ec6c512668b4aa797283101444628650949641b4f7cb16707efba542bb754afe87ce956f3a5d43f450d14364eb9571cbf213d1061852fb9dd47a6c05c4")]
[assembly: InternalsVisibleTo("Jint.Benchmark, PublicKey=0024000004800000940000000602000000240000525341310004000001000100bf2553c9f214cb21f1f64ed62cadad8fe4f2fa11322a5dfa1d650743145c6085aba05b145b29867af656e0bb9bfd32f5d0deb1668263a38233e7e8e5bad1a3c6edd3f2ec6c512668b4aa797283101444628650949641b4f7cb16707efba542bb754afe87ce956f3a5d43f450d14364eb9571cbf213d1061852fb9dd47a6c05c4")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Sebastien Ros")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Sebastien Ros")]
[assembly: AssemblyDescription("Javascript interpreter for .NET.")]
[assembly: AssemblyFileVersion("3.1.0.0")]
[assembly: AssemblyInformationalVersion("3.1.5+6cb44564e35d18646604dedb002170be1fd941d9")]
[assembly: AssemblyProduct("Jint")]
[assembly: AssemblyTitle("Jint")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/sebastienros/jint")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.1.5.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: SkipLocalsInit]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class ObsoletedOSPlatformAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public ObsoletedOSPlatformAttribute(string platformName)
		{
		}

		public ObsoletedOSPlatformAttribute(string platformName, string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices2
{
	[AttributeUsage(AttributeTargets.Struct, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class InlineArrayAttribute : Attribute
	{
		public int Length { get; }

		public InlineArrayAttribute(int length)
		{
			Length = length;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class DisableRuntimeMarshallingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnsafeAccessorAttribute : Attribute
	{
		public UnsafeAccessorKind Kind { get; }

		public string? Name { get; set; }

		public UnsafeAccessorAttribute(UnsafeAccessorKind kind)
		{
			Kind = kind;
		}
	}
	internal enum UnsafeAccessorKind
	{
		Constructor,
		Method,
		StaticMethod,
		Field,
		StaticField
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class RequiresDynamicCodeAttribute : Attribute
	{
		public string Message { get; }

		public string? Url { get; set; }

		public RequiresDynamicCodeAttribute(string message)
		{
			Message = message;
		}
	}
}
namespace System.Text
{
	internal ref struct ValueStringBuilder
	{
		private char[]? _arrayToReturnToPool;

		private Span<char> _chars;

		private int _pos;

		public int Length
		{
			get
			{
				return _pos;
			}
			set
			{
				_pos = value;
			}
		}

		public int Capacity => _chars.Length;

		public ref char this[int index] => ref _chars[index];

		public Span<char> RawChars => _chars;

		public ValueStringBuilder(Span<char> initialBuffer)
		{
			_arrayToReturnToPool = null;
			_chars = initialBuffer;
			_pos = 0;
		}

		public ValueStringBuilder(int initialCapacity)
		{
			_arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
			_chars = _arrayToReturnToPool;
			_pos = 0;
		}

		public void EnsureCapacity(int capacity)
		{
			if ((uint)capacity > (uint)_chars.Length)
			{
				Grow(capacity - _pos);
			}
		}

		public ref char GetPinnableReference()
		{
			return ref MemoryMarshal.GetReference(_chars);
		}

		public ref char GetPinnableReference(bool terminate)
		{
			if (terminate)
			{
				EnsureCapacity(Length + 1);
				_chars[Length] = '\0';
			}
			return ref MemoryMarshal.GetReference(_chars);
		}

		public override string ToString()
		{
			string result = _chars.Slice(0, _pos).ToString();
			Dispose();
			return result;
		}

		public ReadOnlySpan<char> AsSpan(bool terminate)
		{
			if (terminate)
			{
				EnsureCapacity(Length + 1);
				_chars[Length] = '\0';
			}
			return _chars.Slice(0, _pos);
		}

		public ReadOnlySpan<char> AsSpan()
		{
			return _chars.Slice(0, _pos);
		}

		public ReadOnlySpan<char> AsSpan(int start)
		{
			return _chars.Slice(start, _pos - start);
		}

		public ReadOnlySpan<char> AsSpan(int start, int length)
		{
			return _chars.Slice(start, length);
		}

		public void Reverse()
		{
			_chars.Slice(0, _pos).Reverse();
		}

		public bool TryCopyTo(Span<char> destination, out int charsWritten)
		{
			if (_chars.Slice(0, _pos).TryCopyTo(destination))
			{
				charsWritten = _pos;
				Dispose();
				return true;
			}
			charsWritten = 0;
			Dispose();
			return false;
		}

		public void Insert(int index, char value, int count)
		{
			if (_pos > _chars.Length - count)
			{
				Grow(count);
			}
			int length = _pos - index;
			_chars.Slice(index, length).CopyTo(_chars.Slice(index + count));
			_chars.Slice(index, count).Fill(value);
			_pos += count;
		}

		public void Insert(int index, string? s)
		{
			if (s != null)
			{
				int length = s.Length;
				if (_pos > _chars.Length - length)
				{
					Grow(length);
				}
				int length2 = _pos - index;
				_chars.Slice(index, length2).CopyTo(_chars.Slice(index + length));
				s.CopyTo(_chars.Slice(index));
				_pos += length;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(char c)
		{
			int pos = _pos;
			Span<char> chars = _chars;
			if ((uint)pos < (uint)chars.Length)
			{
				chars[pos] = c;
				_pos = pos + 1;
			}
			else
			{
				GrowAndAppend(c);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(string? s)
		{
			if (s != null)
			{
				int pos = _pos;
				if (s.Length == 1 && (uint)pos < (uint)_chars.Length)
				{
					_chars[pos] = s[0];
					_pos = pos + 1;
				}
				else
				{
					AppendSlow(s);
				}
			}
		}

		private void AppendSlow(string s)
		{
			int pos = _pos;
			if (pos > _chars.Length - s.Length)
			{
				Grow(s.Length);
			}
			s.CopyTo(_chars.Slice(pos));
			_pos += s.Length;
		}

		public void Append(char c, int count)
		{
			if (_pos > _chars.Length - count)
			{
				Grow(count);
			}
			Span<char> span = _chars.Slice(_pos, count);
			for (int i = 0; i < span.Length; i++)
			{
				span[i] = c;
			}
			_pos += count;
		}

		public unsafe void Append(char* value, int length)
		{
			if (_pos > _chars.Length - length)
			{
				Grow(length);
			}
			Span<char> span = _chars.Slice(_pos, length);
			for (int i = 0; i < span.Length; i++)
			{
				span[i] = *(value++);
			}
			_pos += length;
		}

		public void Append(scoped ReadOnlySpan<char> value)
		{
			if (_pos > _chars.Length - value.Length)
			{
				Grow(value.Length);
			}
			value.CopyTo(_chars.Slice(_pos));
			_pos += value.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span<char> AppendSpan(int length)
		{
			int pos = _pos;
			if (pos > _chars.Length - length)
			{
				Grow(length);
			}
			_pos = pos + length;
			return _chars.Slice(pos, length);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void GrowAndAppend(char c)
		{
			Grow(1);
			Append(c);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Grow(int additionalCapacityBeyondPos)
		{
			int minimumLength = (int)Math.Max((uint)(_pos + additionalCapacityBeyondPos), Math.Min((uint)(_chars.Length * 2), 2147483591u));
			char[] array = ArrayPool<char>.Shared.Rent(minimumLength);
			_chars.Slice(0, _pos).CopyTo(array);
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			_chars = (_arrayToReturnToPool = array);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Dispose()
		{
			char[] arrayToReturnToPool = _arrayToReturnToPool;
			this = default(System.Text.ValueStringBuilder);
			if (arrayToReturnToPool != null)
			{
				ArrayPool<char>.Shared.Return(arrayToReturnToPool);
			}
		}
	}
}
namespace System.Buffers
{
	internal static class SearchValues
	{
		internal static SearchValues<char> Create(string input)
		{
			return new SearchValues<char>(input.AsSpan());
		}

		internal static SearchValues<char> Create(ReadOnlySpan<char> input)
		{
			return new SearchValues<char>(input);
		}
	}
	internal sealed class SearchValues<T>
	{
		private readonly bool[] _data;

		private readonly char _min;

		private readonly char _max;

		internal SearchValues(ReadOnlySpan<char> input)
		{
			_min = '\uffff';
			_max = '\0';
			ReadOnlySpan<char> readOnlySpan = input;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				char val = readOnlySpan[i];
				_min = (char)Math.Min(_min, val);
				_max = (char)Math.Max(_max, val);
			}
			_data = new bool[_max - _min + 1];
			readOnlySpan = input;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				char c = readOnlySpan[i];
				_data[c - _min] = true;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Contains(char c)
		{
			uint num = (uint)(c - _min);
			bool[] data = _data;
			if (num < data.Length)
			{
				return data[num];
			}
			return false;
		}
	}
}
namespace Jint
{
	internal sealed class Agent
	{
		private readonly List<JsValue> _keptAlive = new List<JsValue>();

		public void AddToKeptObjects(JsValue target)
		{
			_keptAlive.Add(target);
		}

		public void ClearKeptObjects()
		{
			_keptAlive.Clear();
		}
	}
	public static class AstExtensions
	{
		internal readonly record struct Record(JsValue Key, ScriptFunction Closure);

		private sealed class MinimalSyntaxElement : SyntaxElement
		{
			public MinimalSyntaxElement(in Location location)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				base.Location = location;
			}
		}

		private sealed class PrivateIdentifierValidator : AstVisitor
		{
			private readonly Realm _realm;

			private HashSet<PrivateIdentifier>? _privateNames;

			public PrivateIdentifierValidator(Realm realm, HashSet<PrivateIdentifier>? privateNames)
			{
				_realm = realm;
				_privateNames = privateNames;
			}

			protected override object VisitPrivateIdentifier(PrivateIdentifier privateIdentifier)
			{
				if (_privateNames == null || !_privateNames.Contains(privateIdentifier))
				{
					Throw(_realm, privateIdentifier);
				}
				return privateIdentifier;
			}

			protected override object VisitClassBody(ClassBody classBody)
			{
				HashSet<PrivateIdentifier> privateNames = _privateNames;
				_privateNames = new HashSet<PrivateIdentifier>(PrivateIdentifierNameComparer._instance);
				((Node)(object)classBody).PrivateBoundIdentifiers(_privateNames);
				((AstVisitor)this).VisitClassBody(classBody);
				_privateNames = privateNames;
				return classBody;
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private static void Throw(Realm r, PrivateIdentifier id)
			{
				ExceptionHelper.ThrowSyntaxError(r, "Private field '#" + id.Name + "' must be declared in an enclosing class");
			}
		}

		public static JsValue GetKey<T>(this T property, Engine engine) where T : IProperty
		{
			return ((IProperty)property).Key.GetKey(engine, ((IProperty)property).Computed);
		}

		public static JsValue GetKey(this Expression expression, Engine engine, bool resolveComputed = false)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			JsValue jsValue = expression.TryGetKey<Expression>(engine, resolveComputed);
			if ((object)jsValue != null)
			{
				return TypeConverter.ToPropertyKey(jsValue);
			}
			ExceptionHelper.ThrowArgumentException("Unable to extract correct key, node type: " + ((object)((Node)expression).Type/*cast due to .constrained prefix*/).ToString());
			return JsValue.Undefined;
		}

		internal static JsValue TryGetKey<T>(this T property, Engine engine) where T : IProperty
		{
			return ((IProperty)property).Key.TryGetKey<Expression>(engine, ((IProperty)property).Computed);
		}

		internal static JsValue TryGetKey<T>(this T expression, Engine engine, bool resolveComputed) where T : Expression
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			object obj = expression;
			Literal val = (Literal)((obj is Literal) ? obj : null);
			if (val != null)
			{
				return ((int)val.TokenType == 5) ? JsValue.Null : ((JsValue)LiteralKeyToString(val));
			}
			if (!resolveComputed)
			{
				object obj2 = expression;
				Identifier val2 = (Identifier)((obj2 is Identifier) ? obj2 : null);
				if (val2 != null)
				{
					return val2.Name;
				}
			}
			object obj3 = expression;
			PrivateIdentifier val3 = (PrivateIdentifier)((obj3 is PrivateIdentifier) ? obj3 : null);
			if (val3 != null)
			{
				return engine.ExecutionContext.PrivateEnvironment.Names[val3];
			}
			if (resolveComputed)
			{
				return TryGetComputedPropertyKey(expression, engine);
			}
			return JsValue.Undefined;
		}

		private static JsValue TryGetComputedPropertyKey<T>(T expression, Engine engine) where T : Expression
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			Nodes type = ((Node)(object)expression).Type;
			if ((int)type <= 16)
			{
				if ((int)type <= 7)
				{
					if (type - 3 <= 1 || (int)type == 7)
					{
						goto IL_0053;
					}
				}
				else if ((int)type == 10 || (int)type == 16)
				{
					goto IL_0053;
				}
			}
			else if ((int)type <= 43)
			{
				if (type - 31 <= 1 || type - 42 <= 1)
				{
					goto IL_0053;
				}
			}
			else if ((int)type == 63 || type - 67 <= 1 || (int)type == 73)
			{
				goto IL_0053;
			}
			bool flag = false;
			goto IL_0059;
			IL_0053:
			flag = true;
			goto IL_0059;
			IL_0059:
			if (flag)
			{
				EvaluationContext activeEvaluationContext = engine._activeEvaluationContext;
				return JintExpression.Build((Expression)(object)expression).GetValue(activeEvaluationContext);
			}
			return JsValue.Undefined;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsFunctionDefinition<T>(this T node) where T : Node
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			Nodes type = ((Node)node).Type;
			if ((int)type == 3 || (int)type == 15 || (int)type == 31)
			{
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsConstantDeclaration(this Declaration d)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			VariableDeclaration val = (VariableDeclaration)(object)((d is VariableDeclaration) ? d : null);
			if (val != null)
			{
				return (int)val.Kind == 2;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool HasName<T>(this T node) where T : Node
		{
			if (!node.IsFunctionDefinition())
			{
				return false;
			}
			object obj = node;
			object obj2 = ((obj is IFunction) ? obj : null);
			if (((obj2 != null) ? ((IFunction)obj2).Id : null) != null)
			{
				return true;
			}
			object obj3 = node;
			object obj4 = ((obj3 is ClassExpression) ? obj3 : null);
			if (((obj4 != null) ? ((ClassExpression)obj4).Id : null) != null)
			{
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsAnonymousFunctionDefinition<T>(this T node) where T : Node
		{
			if (!node.IsFunctionDefinition())
			{
				return false;
			}
			if (node.HasName())
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsOptional<T>(this T node) where T : Expression
		{
			object obj = node;
			MemberExpression val = (MemberExpression)((obj is MemberExpression) ? obj : null);
			if (val != null)
			{
				if (val.Optional)
				{
					goto IL_0030;
				}
			}
			else
			{
				object obj2 = node;
				CallExpression val2 = (CallExpression)((obj2 is CallExpression) ? obj2 : null);
				if (val2 != null && val2.Optional)
				{
					goto IL_0030;
				}
			}
			return false;
			IL_0030:
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string LiteralKeyToString(Literal literal)
		{
			if (literal.Value is double num)
			{
				return TypeConverter.ToString(num);
			}
			return (literal.Value as string) ?? Convert.ToString(literal.Value, null) ?? "";
		}

		internal static void GetBoundNames(this VariableDeclaration variableDeclaration, List<Key> target)
		{
			ref NodeList<VariableDeclarator> declarations = variableDeclaration.Declarations;
			for (int i = 0; i < declarations.Count; i++)
			{
				declarations[i].Id.GetBoundNames(target);
			}
		}

		internal static void GetBoundNames(this Node? parameter, List<Key> target)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			if (parameter == null || (int)parameter.Type == 41)
			{
				return;
			}
			Identifier val = (Identifier)(object)((parameter is Identifier) ? parameter : null);
			if (val != null)
			{
				target.Add(val.Name);
				return;
			}
			VariableDeclaration val2 = (VariableDeclaration)(object)((parameter is VariableDeclaration) ? parameter : null);
			if (val2 != null)
			{
				val2.GetBoundNames(target);
				return;
			}
			while (true)
			{
				Identifier val3 = (Identifier)(object)((parameter is Identifier) ? parameter : null);
				if (val3 != null)
				{
					target.Add(val3.Name);
					return;
				}
				RestElement val4 = (RestElement)(object)((parameter is RestElement) ? parameter : null);
				if (val4 != null)
				{
					parameter = val4.Argument;
					continue;
				}
				ArrayPattern val5 = (ArrayPattern)(object)((parameter is ArrayPattern) ? parameter : null);
				if (val5 != null)
				{
					ref NodeList<Node> elements = val5.Elements;
					for (int i = 0; i < elements.Count; i++)
					{
						elements[i].GetBoundNames(target);
					}
					return;
				}
				ObjectPattern val6 = (ObjectPattern)(object)((parameter is ObjectPattern) ? parameter : null);
				if (val6 != null)
				{
					ref NodeList<Node> properties = val6.Properties;
					for (int j = 0; j < properties.Count; j++)
					{
						Node val7 = properties[j];
						Property val8 = (Property)(object)((val7 is Property) ? val7 : null);
						if (val8 != null)
						{
							val8.Value.GetBoundNames(target);
						}
						else
						{
							((Node?)(RestElement)val7).GetBoundNames(target);
						}
					}
					return;
				}
				AssignmentPattern val9 = (AssignmentPattern)(object)((parameter is AssignmentPattern) ? parameter : null);
				if (val9 == null)
				{
					break;
				}
				parameter = val9.Left;
			}
			ClassDeclaration val10 = (ClassDeclaration)(object)((parameter is ClassDeclaration) ? parameter : null);
			if (val10 != null)
			{
				Identifier id = val10.Id;
				string text = ((id != null) ? id.Name : null);
				if (text != null)
				{
					target.Add(text);
				}
			}
		}

		internal static void PrivateBoundIdentifiers(this Node parameter, HashSet<PrivateIdentifier> target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if ((int)parameter.Type == 49)
			{
				target.Add((PrivateIdentifier)parameter);
				return;
			}
			Nodes type = parameter.Type;
			if (((int)type == 0 || (int)type == 45 || (int)type == 52) ? true : false)
			{
				Expression key = ((ClassProperty)parameter).Key;
				PrivateIdentifier val = (PrivateIdentifier)(object)((key is PrivateIdentifier) ? key : null);
				if (val != null)
				{
					target.Add(val);
				}
			}
			else if ((int)parameter.Type == 13)
			{
				ref NodeList<ClassElement> body = ((ClassBody)parameter).Body;
				for (int i = 0; i < body.Count; i++)
				{
					((Node)(object)body[i]).PrivateBoundIdentifiers(target);
				}
			}
		}

		internal static void BindingInitialization(this Node? expression, EvaluationContext context, JsValue value, Jint.Runtime.Environments.Environment env)
		{
			Identifier val = (Identifier)(object)((expression is Identifier) ? expression : null);
			if (val != null)
			{
				((DeclarativeEnvironment)env).CreateMutableBindingAndInitialize(val.Name, canBeDeleted: false, value);
				return;
			}
			BindingPattern val2 = (BindingPattern)(object)((expression is BindingPattern) ? expression : null);
			if (val2 != null)
			{
				DestructuringPatternAssignmentExpression.ProcessPatterns(context, val2, value, env);
			}
		}

		internal static Record DefineMethod<T>(this T m, ObjectInstance obj, ObjectInstance? functionPrototype = null) where T : IProperty
		{
			Engine engine = obj.Engine;
			JsValue key = TypeConverter.ToPropertyKey(m.GetKey(engine));
			Intrinsics intrinsics = engine.Realm.Intrinsics;
			Jint.Runtime.Environments.ExecutionContext executionContext = engine.ExecutionContext;
			Jint.Runtime.Environments.Environment lexicalEnvironment = executionContext.LexicalEnvironment;
			PrivateEnvironment privateEnvironment = executionContext.PrivateEnvironment;
			ObjectInstance functionPrototype2 = functionPrototype ?? intrinsics.Function.PrototypeObject;
			Node value = ((IProperty)m).Value;
			Node obj2 = ((value is IFunction) ? value : null);
			if (obj2 == null)
			{
				ExceptionHelper.ThrowSyntaxError(engine.Realm);
			}
			JintFunctionDefinition jintFunctionDefinition = new JintFunctionDefinition((IFunction)(object)obj2);
			ScriptFunction scriptFunction = intrinsics.Function.OrdinaryFunctionCreate(functionPrototype2, jintFunctionDefinition, jintFunctionDefinition.ThisMode, lexicalEnvironment, privateEnvironment);
			scriptFunction.MakeMethod(obj);
			return new Record(key, scriptFunction);
		}

		internal unsafe static void GetImportEntries(this ImportDeclaration import, List<ImportEntry> importEntries, HashSet<ModuleRequest> requestedModules)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			string stringValue = import.Source.StringValue;
			NodeList<ImportDeclarationSpecifier> specifiers = Unsafe.Read<NodeList<ImportDeclarationSpecifier>>((void*)import.Specifiers);
			ModuleImportAttribute[] attributes = GetAttributes(import.Attributes);
			requestedModules.Add(new ModuleRequest(stringValue, attributes));
			Enumerator<ImportDeclarationSpecifier> enumerator = specifiers.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ImportDeclarationSpecifier current = enumerator.Current;
					ImportNamespaceSpecifier val = (ImportNamespaceSpecifier)(object)((current is ImportNamespaceSpecifier) ? current : null);
					if (val == null)
					{
						ImportSpecifier val2 = (ImportSpecifier)(object)((current is ImportSpecifier) ? current : null);
						if (val2 == null)
						{
							ImportDefaultSpecifier val3 = (ImportDefaultSpecifier)(object)((current is ImportDefaultSpecifier) ? current : null);
							if (val3 != null)
							{
								importEntries.Add(new ImportEntry(new ModuleRequest(stringValue, attributes), "default", ((Expression)(object)((ImportDeclarationSpecifier)val3).Local).GetModuleKey()));
							}
						}
						else
						{
							importEntries.Add(new ImportEntry(new ModuleRequest(stringValue, attributes), val2.Imported.GetModuleKey(), ((Expression)(object)((ImportDeclarationSpecifier)val2).Local).GetModuleKey()));
						}
					}
					else
					{
						importEntries.Add(new ImportEntry(new ModuleRequest(stringValue, attributes), "*", ((Expression)(object)((ImportDeclarationSpecifier)val).Local).GetModuleKey()));
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static ModuleImportAttribute[] GetAttributes(in NodeList<ImportAttribute> importAttributes)
		{
			if (importAttributes.Count == 0)
			{
				return Array.Empty<ModuleImportAttribute>();
			}
			ModuleImportAttribute[] array = new ModuleImportAttribute[importAttributes.Count];
			for (int i = 0; i < importAttributes.Count; i++)
			{
				ImportAttribute val = importAttributes[i];
				array[i] = new ModuleImportAttribute(((object)val.Key).ToString(), val.Value.StringValue);
			}
			return array;
		}

		internal static void GetExportEntries(this ExportDeclaration export, List<ExportEntry> exportEntries, HashSet<ModuleRequest> requestedModules)
		{
			ExportDefaultDeclaration val = (ExportDefaultDeclaration)(object)((export is ExportDefaultDeclaration) ? export : null);
			if (val == null)
			{
				ExportAllDeclaration val2 = (ExportAllDeclaration)(object)((export is ExportAllDeclaration) ? export : null);
				if (val2 == null)
				{
					ExportNamedDeclaration val3 = (ExportNamedDeclaration)(object)((export is ExportNamedDeclaration) ? export : null);
					if (val3 == null)
					{
						return;
					}
					ref NodeList<ExportSpecifier> specifiers = val3.Specifiers;
					if (specifiers.Count == 0)
					{
						ModuleRequest? obj;
						if (val3.Source == null)
						{
							obj = null;
						}
						else
						{
							Literal source = val3.Source;
							obj = new ModuleRequest((source != null) ? source.StringValue : null, Array.Empty<ModuleImportAttribute>());
						}
						ModuleRequest? moduleRequest = obj;
						GetExportEntries(defaultExport: false, (StatementListItem)(object)val3.Declaration, exportEntries, moduleRequest);
					}
					else
					{
						for (int i = 0; i < specifiers.Count; i++)
						{
							ExportSpecifier val4 = specifiers[i];
							if (val3.Source != null)
							{
								exportEntries.Add(new ExportEntry(val4.Exported.GetModuleKey(), new ModuleRequest(val3.Source.StringValue, Array.Empty<ModuleImportAttribute>()), val4.Local.GetModuleKey(), null));
							}
							else
							{
								exportEntries.Add(new ExportEntry(val4.Exported.GetModuleKey(), null, null, val4.Local.GetModuleKey()));
							}
						}
					}
					if (val3.Source != null)
					{
						requestedModules.Add(new ModuleRequest(val3.Source.StringValue, Array.Empty<ModuleImportAttribute>()));
					}
				}
				else
				{
					requestedModules.Add(new ModuleRequest(val2.Source.StringValue, Array.Empty<ModuleImportAttribute>()));
					Expression exported = val2.Exported;
					exportEntries.Add(new ExportEntry((exported != null) ? exported.GetModuleKey() : null, new ModuleRequest(val2.Source.StringValue, Array.Empty<ModuleImportAttribute>()), "*", null));
				}
			}
			else
			{
				GetExportEntries(defaultExport: true, val.Declaration, exportEntries);
			}
		}

		private static void GetExportEntries(bool defaultExport, StatementListItem declaration, List<ExportEntry> exportEntries, ModuleRequest? moduleRequest = null)
		{
			List<Key> exportNames = GetExportNames(declaration);
			if (exportNames.Count == 0)
			{
				if (defaultExport)
				{
					exportEntries.Add(new ExportEntry("default", null, null, "*default*"));
				}
				return;
			}
			for (int i = 0; i < exportNames.Count; i++)
			{
				Key key = exportNames[i];
				string exportName = (defaultExport ? "default" : key.Name);
				exportEntries.Add(new ExportEntry(exportName, moduleRequest, null, key));
			}
		}

		private static List<Key> GetExportNames(StatementListItem declaration)
		{
			List<Key> list = new List<Key>();
			FunctionDeclaration val = (FunctionDeclaration)(object)((declaration is FunctionDeclaration) ? declaration : null);
			if (val == null)
			{
				ClassDeclaration val2 = (ClassDeclaration)(object)((declaration is ClassDeclaration) ? declaration : null);
				if (val2 == null)
				{
					((VariableDeclaration)(object)((declaration is VariableDeclaration) ? declaration : null))?.GetBoundNames(list);
				}
				else
				{
					Identifier id = val2.Id;
					string text = ((id != null) ? id.Name : null);
					if (text != null)
					{
						list.Add(text);
					}
				}
			}
			else
			{
				Identifier id2 = val.Id;
				string text2 = ((id2 != null) ? id2.Name : null);
				if (text2 != null)
				{
					list.Add(text2);
				}
			}
			return list;
		}

		private static string GetModuleKey(this Expression expression)
		{
			Expression obj = ((expression is Identifier) ? expression : null);
			return ((obj != null) ? ((Identifier)obj).Name : null) ?? ((Literal)((expression is Literal) ? expression : null)).StringValue;
		}

		internal static SyntaxElement CreateLocationNode(in Location location)
		{
			return (SyntaxElement)(object)new MinimalSyntaxElement(in location);
		}

		internal static void AllPrivateIdentifiersValid(this Script script, Realm realm, HashSet<PrivateIdentifier>? privateIdentifiers)
		{
			((AstVisitor)new PrivateIdentifierValidator(realm, privateIdentifiers)).Visit((Node)(object)script);
		}
	}
	public static class ConstraintsOptionsExtensions
	{
		public static Options MaxStatements(this Options options, int maxStatements = 0)
		{
			options.WithoutConstraint((Constraint x) => x is MaxStatementsConstraint);
			if (maxStatements > 0 && maxStatements < int.MaxValue)
			{
				options.Constraint(new MaxStatementsConstraint(maxStatements));
			}
			return options;
		}

		public static Options LimitMemory(this Options options, long memoryLimit)
		{
			options.WithoutConstraint((Constraint x) => x is MemoryLimitConstraint);
			if (memoryLimit > 0 && memoryLimit < int.MaxValue)
			{
				options.Constraint(new MemoryLimitConstraint(memoryLimit));
			}
			return options;
		}

		public static Options TimeoutInterval(this Options options, TimeSpan timeoutInterval)
		{
			if (timeoutInterval > TimeSpan.Zero && timeoutInterval < TimeSpan.MaxValue)
			{
				options.Constraint(new TimeConstraint(timeoutInterval));
			}
			return options;
		}

		public static Options CancellationToken(this Options options, CancellationToken cancellationToken)
		{
			options.WithoutConstraint((Constraint x) => x is CancellationConstraint);
			if (cancellationToken != default(CancellationToken))
			{
				options.Constraint(new CancellationConstraint(cancellationToken));
			}
			return options;
		}
	}
	public enum DeclarationBindingType
	{
		GlobalCode,
		FunctionCode,
		EvalCode
	}
	[DebuggerTypeProxy(typeof(EngineDebugView))]
	public sealed class Engine : IDisposable
	{
		public class AdvancedOperations
		{
			private readonly Engine _engine;

			public string StackTrace
			{
				get
				{
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					SyntaxElement lastSyntaxElement = _engine._lastSyntaxElement;
					if (lastSyntaxElement == null)
					{
						return string.Empty;
					}
					return _engine.CallStack.BuildCallStackString(lastSyntaxElement.Location);
				}
			}

			internal AdvancedOperations(Engine engine)
			{
				_engine = engine;
			}

			public void ResetCallStack()
			{
				_engine.ResetCallStack();
			}

			public void ProcessTasks()
			{
				_engine.RunAvailableContinuations();
			}

			public ManualPromise RegisterPromise()
			{
				return _engine.RegisterPromise();
			}
		}

		private sealed class AstAnalyzer
		{
			private static readonly bool _canCompileNegativeLookaroundAssertions;

			private readonly IPreparationOptions<IParsingOptions> _preparationOptions;

			private readonly Dictionary<string, Jint.Runtime.Environments.Environment.BindingName> _bindingNames = new Dictionary<string, Jint.Runtime.Environments.Environment.BindingName>(StringComparer.Ordinal);

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

			public AstAnalyzer(IPreparationOptions<IParsingOptions> preparationOptions)
			{
				_preparationOptions = preparationOptions;
			}

			public void NodeVisitor(Node node)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Invalid comparison between Unknown and I4
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Invalid comparison between Unknown and I4
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Invalid comparison between Unknown and I4
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Invalid comparison between Unknown and I4
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Invalid comparison between Unknown and I4
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Invalid comparison between Unknown and I4
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Invalid comparison between Unknown and I4
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Expected O, but got Unknown
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Invalid comparison between Unknown and I4
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Expected O, but got Unknown
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Invalid comparison between Unknown and I4
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Expected O, but got Unknown
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Invalid comparison between Unknown and I4
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Invalid comparison between Unknown and I4
				//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Expected O, but got Unknown
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Invalid comparison between Unknown and I4
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Expected O, but got Unknown
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				//IL_0208: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Expected O, but got Unknown
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Expected O, but got Unknown
				//IL_0221: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Invalid comparison between Unknown and I4
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Invalid comparison between Unknown and I4
				//IL_022f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Invalid comparison between Unknown and I4
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Expected O, but got Unknown
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				Nodes type = node.Type;
				if ((int)type <= 32)
				{
					if ((int)type <= 7)
					{
						if ((int)type != 3)
						{
							if ((int)type != 7)
							{
								return;
							}
							BinaryExpression val = (BinaryExpression)node;
							if (!_preparationOptions.FoldConstants || (int)val.Operator == 19 || (int)val.Operator == 20 || val == null)
							{
								return;
							}
							Expression left = val.Left;
							Literal val2 = (Literal)(object)((left is Literal) ? left : null);
							if (val2 == null)
							{
								return;
							}
							Expression right = val.Right;
							Literal val3 = (Literal)(object)((right is Literal) ? right : null);
							if (val3 == null)
							{
								return;
							}
							JsValue? jsValue = JintLiteralExpression.ConvertToJsValue(val2);
							JsValue jsValue2 = JintLiteralExpression.ConvertToJsValue(val3);
							if ((object)jsValue == null || (object)jsValue2 == null)
							{
								return;
							}
							try
							{
								JintExpression jintExpression = JintBinaryExpression.Build(val);
								EvaluationContext context = new EvaluationContext();
								((SyntaxElement)node).AssociatedData = new JintConstantExpression((Expression)(object)val, (JsValue)jintExpression.EvaluateWithoutNodeTracking(context));
								return;
							}
							catch
							{
								return;
							}
						}
					}
					else if (type - 30 > 1)
					{
						if ((int)type == 32)
						{
							Identifier val4 = (Identifier)node;
							string name = val4.Name;
							if (!_bindingNames.TryGetValue(name, out Jint.Runtime.Environments.Environment.BindingName value))
							{
								value = (_bindingNames[name] = new Jint.Runtime.Environments.Environment.BindingName(JsString.CachedCreate(name)));
							}
							((SyntaxElement)node).AssociatedData = new JintIdentifierExpression(val4, value);
						}
						return;
					}
					IFunction function = (IFunction)node;
					((SyntaxElement)node).AssociatedData = JintFunctionDefinition.BuildState(function);
				}
				else if ((int)type <= 43)
				{
					if ((int)type != 41)
					{
						if ((int)type == 43)
						{
							((SyntaxElement)node).AssociatedData = JintMemberExpression.InitializeDeterminedProperty((MemberExpression)node, cache: true);
						}
						return;
					}
					Literal val5 = (Literal)node;
					JsValue jsValue3 = JintLiteralExpression.ConvertToJsValue(val5);
					((SyntaxElement)node).AssociatedData = (((object)jsValue3 != null) ? new JintConstantExpression((Expression)(object)val5, jsValue3) : null);
					if (((SyntaxElement)node).AssociatedData != null || (int)val5.TokenType != 9 || _canCompileNegativeLookaroundAssertions || _preparationOptions.ParsingOptions.CompileRegex == false)
					{
						return;
					}
					RegExpLiteral val6 = (RegExpLiteral)val5;
					RegExpParseResult parseResult = val6.ParseResult;
					if (!((RegExpParseResult)(ref parseResult)).Success || !((Literal)val6).Raw.Contains("(?!"))
					{
						return;
					}
					if (!_regexes.TryGetValue(((Literal)val6).Raw, out Regex value2))
					{
						value2 = ((RegExpParseResult)(ref parseResult)).Regex;
						if ((value2.Options & RegexOptions.Compiled) != RegexOptions.None)
						{
							value2 = new Regex(value2.ToString(), value2.Options & ~RegexOptions.Compiled, value2.MatchTimeout);
						}
						_regexes[((Literal)val6).Raw] = value2;
					}
					((SyntaxElement)val6).AssociatedData = value2;
				}
				else if ((int)type != 50)
				{
					if ((int)type != 54)
					{
						if ((int)type == 67)
						{
							((SyntaxElement)node).AssociatedData = JintUnaryExpression.BuildConstantExpression((UnaryExpression)node);
						}
						return;
					}
					ReturnStatement val7 = (ReturnStatement)node;
					Expression argument = val7.Argument;
					Literal val8 = (Literal)(object)((argument is Literal) ? argument : null);
					if (val8 != null)
					{
						JsValue jsValue4 = JintLiteralExpression.ConvertToJsValue(val8);
						if ((object)jsValue4 != null)
						{
							((SyntaxElement)node).AssociatedData = new ConstantStatement((Statement)(object)val7, CompletionType.Return, jsValue4);
						}
					}
				}
				else
				{
					((SyntaxElement)node).AssociatedData = new CachedHoistingScope((Program)node);
				}
			}

			static AstAnalyzer()
			{
				int? num = typeof(Regex).Assembly.GetName().Version?.Major;
				bool flag;
				if (num.HasValue)
				{
					int valueOrDefault = num.GetValueOrDefault();
					if ((uint)(valueOrDefault - 7) > 1u)
					{
						flag = false;
						goto IL_0050;
					}
				}
				flag = true;
				goto IL_0050;
				IL_0050:
				_canCompileNegativeLookaroundAssertions = !flag;
			}
		}

		public class ConstraintOperations
		{
			private readonly Engine _engine;

			internal ConstraintOperations(Engine engine)
			{
				_engine = engine;
			}

			public void Check()
			{
				Constraint[] constraints = _engine._constraints;
				for (int i = 0; i < constraints.Length; i++)
				{
					constraints[i].Check();
				}
			}

			public T? Find<T>() where T : Constraint
			{
				Constraint[] constraints = _engine._constraints;
				foreach (Constraint constraint in constraints)
				{
					if (constraint.GetType() == typeof(T))
					{
						return (T)constraint;
					}
				}
				return null;
			}

			public void Reset()
			{
				Constraint[] constraints = _engine._constraints;
				for (int i = 0; i < constraints.Length; i++)
				{
					constraints[i].Reset();
				}
			}
		}

		internal readonly record struct ClrPropertyDescriptorFactoriesKey(Type Type, Key PropertyName);

		[DebuggerDisplay("Engine")]
		private sealed class EngineDebugView
		{
			private readonly Engine _engine;

			public ObjectInstance Globals => _engine.Realm.GlobalObject;

			public Options Options => _engine.Options;

			public Jint.Runtime.Environments.Environment VariableEnvironment => _engine.ExecutionContext.VariableEnvironment;

			public Jint.Runtime.Environments.Environment LexicalEnvironment => _engine.ExecutionContext.LexicalEnvironment;

			public EngineDebugView(Engine engine)
			{
				_engine = engine;
			}
		}

		public class ModuleOperations
		{
			private readonly Engine _engine;

			private readonly Dictionary<string, Jint.Runtime.Modules.Module> _modules = new Dictionary<string, Jint.Runtime.Modules.Module>(StringComparer.Ordinal);

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

			internal IModuleLoader ModuleLoader { get; }

			public ModuleOperations(Engine engine, IModuleLoader moduleLoader)
			{
				ModuleLoader = moduleLoader;
				_engine = engine;
			}

			internal Jint.Runtime.Modules.Module Load(string? referencingModuleLocation, ModuleRequest request)
			{
				_ = request.Specifier;
				ResolvedSpecifier resolvedSpecifier = ModuleLoader.Resolve(referencingModuleLocation, request);
				if (_modules.TryGetValue(resolvedSpecifier.Key, out Jint.Runtime.Modules.Module value))
				{
					return value;
				}
				value = ((!_builders.TryGetValue(resolvedSpecifier.Key, out ModuleBuilder value2)) ? LoadFromModuleLoader(resolvedSpecifier) : LoadFromBuilder(resolvedSpecifier.Key, value2, resolvedSpecifier));
				if (value is SourceTextModule sourceTextModule)
				{
					_engine.Debugger.OnBeforeEvaluate((Program)(object)sourceTextModule._source);
				}
				return value;
			}

			private BuilderModule LoadFromBuilder(string specifier, ModuleBuilder moduleBuilder, ResolvedSpecifier moduleResolution)
			{
				Prepared<Module> source = moduleBuilder.Parse();
				BuilderModule builderModule = new BuilderModule(_engine, _engine.Realm, in source, ((SyntaxElement)source.Program).Location.Source, async: false);
				_modules[moduleResolution.Key] = builderModule;
				moduleBuilder.BindExportedValues(builderModule);
				_builders.Remove(specifier);
				return builderModule;
			}

			private Jint.Runtime.Modules.Module LoadFromModuleLoader(ResolvedSpecifier moduleResolution)
			{
				Jint.Runtime.Modules.Module module = ModuleLoader.LoadModule(_engine, moduleResolution);
				_modules[moduleResolution.Key] = module;
				return module;
			}

			public void Add(string specifier, string code)
			{
				ModuleBuilder moduleBuilder = new ModuleBuilder(_engine, specifier);
				moduleBuilder.AddSource(code);
				Add(specifier, moduleBuilder);
			}

			public void Add(string specifier, Action<ModuleBuilder> buildModule)
			{
				ModuleBuilder moduleBuilder = new ModuleBuilder(_engine, specifier);
				buildModule(moduleBuilder);
				Add(specifier, moduleBuilder);
			}

			public void Add(string specifier, ModuleBuilder moduleBuilder)
			{
				_builders.Add(specifier, moduleBuilder);
			}

			public ObjectInstance Import(string specifier)
			{
				return Import(specifier, null);
			}

			internal ObjectInstance Import(string specifier, string? referencingModuleLocation)
			{
				return Import(new ModuleRequest(specifier, Array.Empty<ModuleImportAttribute>()), referencingModuleLocation);
			}

			internal ObjectInstance Import(ModuleRequest request, string? referencingModuleLocation)
			{
				ResolvedSpecifier resolvedSpecifier = ModuleLoader.Resolve(referencingModuleLocation, request);
				if (!_modules.TryGetValue(resolvedSpecifier.Key, out Jint.Runtime.Modules.Module value))
				{
					value = Load(referencingModuleLocation, request);
				}
				CyclicModule cyclicModule = value as CyclicModule;
				if ((object)cyclicModule == null)
				{
					LinkModule(request.Specifier, value);
					EvaluateModule(request.Specifier, value);
				}
				else if (cyclicModule.Status == ModuleStatus.Unlinked)
				{
					LinkModule(request.Specifier, cyclicModule);
					if (cyclicModule.Status == ModuleStatus.Linked)
					{
						_engine.ExecuteWithConstraints(strict: true, () => EvaluateModule(request.Specifier, cyclicModule));
					}
					if (cyclicModule.Status != ModuleStatus.Evaluated)
					{
						ExceptionHelper.ThrowNotSupportedException($"Error while evaluating module: Module is in an invalid state: '{cyclicModule.Status}'");
					}
				}
				_engine.RunAvailableContinuations();
				return Jint.Runtime.Modules.Module.GetModuleNamespace(value);
			}

			private static void LinkModule(string specifier, Jint.Runtime.Modules.Module module)
			{
				module.Link();
			}

			private JsValue EvaluateModule(string specifier, Jint.Runtime.Modules.Module module)
			{
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				bool flag = _engine._activeEvaluationContext == null;
				Engine engine = _engine;
				if (engine._activeEvaluationContext == null)
				{
					engine._activeEvaluationContext = new EvaluationContext(_engine);
				}
				JsValue jsValue;
				try
				{
					jsValue = module.Evaluate();
				}
				finally
				{
					if (flag)
					{
						_engine._activeEvaluationContext = null;
					}
				}
				if (!(jsValue is JsPromise jsPromise))
				{
					ExceptionHelper.ThrowInvalidOperationException($"Error while evaluating module: Module evaluation did not return a promise: {jsValue.Type}");
				}
				else if (jsPromise.State == PromiseState.Rejected)
				{
					SyntaxElement val = AstExtensions.CreateLocationNode((module is CyclicModule cyclicModule) ? cyclicModule.AbnormalCompletionLocation : Location.From(default(Position), default(Position), (string)null));
					ExceptionHelper.ThrowJavaScriptException(_engine, jsPromise.Value, in val.Location);
				}
				else if (jsPromise.State != PromiseState.Fulfilled)
				{
					ExceptionHelper.ThrowInvalidOperationException($"Error while evaluating module: Module evaluation did not return a fulfilled promise: {jsPromise.State}");
				}
				return jsValue;
			}
		}

		private static readonly Options _defaultEngineOptions = new Options();

		private readonly ParserOptions _defaultParserOptions;

		private readonly JavaScriptParser _defaultParser;

		private readonly ExecutionContextStack _executionContexts;

		private JsValue _completionValue = JsValue.Undefined;

		internal EvaluationContext? _activeEvaluationContext;

		internal ErrorDispatchInfo? _error;

		private readonly EventLoop _eventLoop = new EventLoop();

		private readonly Agent _agent = new Agent();

		private DebugHandler? _debugger;

		internal readonly IObjectConverter[]? _objectConverters;

		internal readonly Constraint[] _constraints;

		internal readonly bool _isDebugMode;

		internal readonly bool _isStrict;

		internal readonly IReferenceResolver _referenceResolver;

		internal readonly ReferencePool _referencePool;

		internal readonly ArgumentsInstancePool _argumentsInstancePool;

		internal readonly JsValueArrayPool _jsValueArrayPool;

		internal readonly ExtensionMethodCache _extensionMethods;

		internal readonly Dictionary<string, Type?> TypeCache = new Dictionary<string, Type>(StringComparer.Ordinal);

		internal Dictionary<Type, TypeReference>? _typeReferences;

		internal ConditionalWeakTable<object, ObjectInstance>? _objectWrapperCache;

		internal readonly JintCallStack CallStack;

		internal readonly StackGuard _stackGuard;

		internal Intrinsics _originalIntrinsics;

		internal Host _host;

		internal Dictionary<ClrPropertyDescriptorFactoriesKey, ReflectionAccessor> _reflectionAccessors = new Dictionary<ClrPropertyDescriptorFactoriesKey, ReflectionAccessor>();

		internal Realm? _realmInConstruction;

		internal SyntaxElement? _lastSyntaxElement;

		internal const bool FoldConstantsOnPrepareByDefault = true;

		internal static readonly ParserOptions BaseParserOptions;

		public AdvancedOperations Advanced { get; }

		public ConstraintOperations Constraints { get; }

		public ITypeConverter TypeConverter { get; internal set; }

		internal ref readonly Jint.Runtime.Environments.ExecutionContext ExecutionContext
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref _executionContexts.Peek();
			}
		}

		internal Realm Realm => _realmInConstruction ?? ExecutionContext.Realm;

		public Intrinsics Intrinsics => Realm.Intrinsics;

		public ObjectInstance Global => Realm.GlobalObject;

		internal GlobalSymbolRegistry GlobalSymbolRegistry { get; } = new GlobalSymbolRegistry();

		internal long CurrentMemoryUsage { get; private set; }

		internal Options Options
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			private set; }

		public DebugHandler Debugger => _debugger ?? (_debugger = new DebugHandler(this, Options.Debugger.InitialStepMode));

		public ModuleOperations Modules { get; internal set; }

		public static Prepared<Script> PrepareScript(string code, string? source = null, bool strict = false, ScriptPreparationOptions? options = null)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((object)options == null)
			{
				options = ScriptPreparationOptions.Default;
			}
			AstAnalyzer astAnalyzer = new AstAnalyzer(options);
			ParserOptions parserOptions = options.GetParserOptions();
			ParserOptions obj = parserOptions.<Clone>$();
			obj.set_OnNodeCreated((Action<Node>)astAnalyzer.NodeVisitor);
			return new Prepared<Script>(new JavaScriptParser(obj).ParseScript(code, source, strict), parserOptions);
		}

		public static Prepared<Module> PrepareModule(string code, string? source = null, ModulePreparationOptions? options = null)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((object)options == null)
			{
				options = ModulePreparationOptions.Default;
			}
			AstAnalyzer astAnalyzer = new AstAnalyzer(options);
			ParserOptions parserOptions = options.GetParserOptions();
			ParserOptions obj = parserOptions.<Clone>$();
			obj.set_OnNodeCreated((Action<Node>)astAnalyzer.NodeVisitor);
			return new Prepared<Module>(new JavaScriptParser(obj).ParseModule(code, source), parserOptions);
		}

		public Engine()
			: this(null, null)
		{
		}

		public Engine(Action<Options>? options)
			: this(null, (options != null) ? ((Action<Engine, Options>)delegate(Engine _, Options opts)
			{
				options(opts);
			}) : null)
		{
		}

		public Engine(Options options)
			: this(options, null)
		{
		}

		public Engine(Action<Engine, Options> options)
			: this(null, options)
		{
		}

		private Engine(Options? options, Action<Engine, Options>? configure)
		{
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			Advanced = new AdvancedOperations(this);
			Constraints = new ConstraintOperations(this);
			TypeConverter = new DefaultTypeConverter(this);
			_executionContexts = new ExecutionContextStack(2);
			Options = options ?? ((configure != null) ? new Options() : _defaultEngineOptions);
			configure?.Invoke(this, Options);
			_extensionMethods = ExtensionMethodCache.Build(Options.Interop.ExtensionMethodTypes);
			Reset();
			_isDebugMode = Options.Debugger.Enabled;
			_isStrict = Options.Strict;
			_objectConverters = ((Options.Interop.ObjectConverters.Count > 0) ? Options.Interop.ObjectConverters.ToArray() : null);
			_constraints = Options.Constraints.Constraints.ToArray();
			_referenceResolver = Options.ReferenceResolver;
			_referencePool = new ReferencePool();
			_argumentsInstancePool = new ArgumentsInstancePool(this);
			_jsValueArrayPool = new JsValueArrayPool();
			Options.Apply(this);
			CallStack = new JintCallStack(Options.Constraints.MaxRecursionDepth >= 0);
			_stackGuard = new StackGuard(this);
			_defaultParserOptions = ScriptParsingOptions.Default.GetParserOptions(Options);
			_defaultParser = new JavaScriptParser(_defaultParserOptions);
		}

		private void Reset()
		{
			_host = Options.Host.Factory(this);
			_host.Initialize(this);
		}

		internal ParserOptions GetActiveParserOptions()
		{
			return _executionContexts?.GetActiveParserOptions() ?? _defaultParserOptions;
		}

		internal JavaScriptParser GetParserFor(ScriptParsingOptions parsingOptions, out ParserOptions parserOptions)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if ((object)parsingOptions == ScriptParsingOptions.Default)
			{
				parserOptions = _defaultParserOptions;
				return _defaultParser;
			}
			parserOptions = parsingOptions.GetParserOptions(Options);
			return new JavaScriptParser(parserOptions);
		}

		internal JavaScriptParser GetParserFor(ParserOptions parserOptions)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if (parserOptions != _defaultParserOptions)
			{
				return new JavaScriptParser(parserOptions);
			}
			return _defaultParser;
		}

		internal void EnterExecutionContext(Jint.Runtime.Environments.Environment lexicalEnvironment, Jint.Runtime.Environments.Environment variableEnvironment, Realm realm, PrivateEnvironment? privateEnvironment)
		{
			Jint.Runtime.Environments.ExecutionContext context = new Jint.Runtime.Environments.ExecutionContext(null, lexicalEnvironment, variableEnvironment, privateEnvironment, realm);
			_executionContexts.Push(in context);
		}

		internal void EnterExecutionContext(in Jint.Runtime.Environments.ExecutionContext context)
		{
			_executionContexts.Push(in context);
		}

		public Engine SetValue(string name, Delegate value)
		{
			Realm.GlobalObject.FastSetProperty(name, new PropertyDescriptor(new DelegateWrapper(this, value), PropertyFlag.NonEnumerable));
			return this;
		}

		public Engine SetValue(string name, string? value)
		{
			return SetValue(name, (value == null) ? JsValue.Null : JsString.Create(value));
		}

		public Engine SetValue(string name, double value)
		{
			return SetValue(name, (JsValue)JsNumber.Create(value));
		}

		public Engine SetValue(string name, int value)
		{
			return SetValue(name, (JsValue)JsNumber.Create(value));
		}

		public Engine SetValue(string name, bool value)
		{
			return SetValue(name, (JsValue)(value ? JsBoolean.True : JsBoolean.False));
		}

		public Engine SetValue(string name, JsValue value)
		{
			Realm.GlobalObject.Set(name, value);
			return this;
		}

		public Engine SetValue(string name, object? obj)
		{
			JsValue value = ((obj is Type type) ? TypeReference.CreateTypeReference(this, type) : JsValue.FromObject(this, obj));
			return SetValue(name, value);
		}

		public Engine SetValue(string name, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] Type type)
		{
			return SetValue(name, TypeReference.CreateTypeReference(this, type));
		}

		public Engine SetValue<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] T>(string name, T? obj)
		{
			if (!(obj is Type type))
			{
				return SetValue(name, JsValue.FromObject(this, obj));
			}
			return SetValue(name, type);
		}

		internal void LeaveExecutionContext()
		{
			_executionContexts.Pop();
		}

		internal void ResetConstraints()
		{
			Constraint[] constraints = _constraints;
			for (int i = 0; i < constraints.Length; i++)
			{
				constraints[i].Reset();
			}
		}

		internal void ResetCallStack()
		{
			CallStack.Clear();
		}

		public JsValue Evaluate(string code, string? source = null)
		{
			Script program = _defaultParser.ParseScript(code, source ?? "<anonymous>", _isStrict);
			return Evaluate(new Prepared<Script>(program, _defaultParserOptions));
		}

		public JsValue Evaluate(string code, ScriptParsingOptions parsingOptions)
		{
			return Evaluate(code, "<anonymous>", parsingOptions);
		}

		public JsValue Evaluate(string code, string source, ScriptParsingOptions parsingOptions)
		{
			ParserOptions parserOptions;
			Script program = GetParserFor(parsingOptions, out parserOptions).ParseScript(code, source, _isStrict);
			return Evaluate(new Prepared<Script>(program, parserOptions));
		}

		public JsValue Evaluate(in Prepared<Script> preparedScript)
		{
			return Execute(in preparedScript)._completionValue;
		}

		public Engine Execute(string code, string? source = null)
		{
			Script program = _defaultParser.ParseScript(code, source ?? "<anonymous>", _isStrict);
			return Execute(new Prepared<Script>(program, _defaultParserOptions));
		}

		public Engine Execute(string code, ScriptParsingOptions parsingOptions)
		{
			return Execute(code, "<anonymous>", parsingOptions);
		}

		public Engine Execute(string code, string source, ScriptParsingOptions parsingOptions)
		{
			ParserOptions parserOptions;
			Script program = GetParserFor(parsingOptions, out parserOptions).ParseScript(code, source, _isStrict);
			return Execute(new Prepared<Script>(program, parserOptions));
		}

		public Engine Execute(in Prepared<Script> preparedScript)
		{
			if (!preparedScript.IsValid)
			{
				ExceptionHelper.ThrowInvalidPreparedScriptArgumentException("preparedScript");
			}
			Script script = preparedScript.Program;
			ParserOptions parserOptions = preparedScript.ParserOptions;
			bool strict = _isStrict || ((Program)script).Strict;
			ExecuteWithConstraints(strict, () => ScriptEvaluation(new ScriptRecord(Realm, script, ((SyntaxElement)script).Location.Source), parserOptions));
			return this;
		}

		private Engine ScriptEvaluation(ScriptRecord scriptRecord, ParserOptions parserOptions)
		{
			Debugger.OnBeforeEvaluate((Program)(object)scriptRecord.EcmaScriptCode);
			GlobalEnvironment globalEnv = Realm.GlobalEnv;
			EnterExecutionContext(new Jint.Runtime.Environments.ExecutionContext(scriptRecord, globalEnv, globalEnv, null, Realm, null, null, parserOptions));
			try
			{
				Script ecmaScriptCode = scriptRecord.EcmaScriptCode;
				GlobalDeclarationInstantiation(ecmaScriptCode, globalEnv);
				JintStatementList jintStatementList = new JintStatementList(null, ((Program)ecmaScriptCode).Body);
				Completion completion;
				try
				{
					completion = jintStatementList.Execute(_activeEvaluationContext);
				}
				catch
				{
					ResetCallStack();
					throw;
				}
				if (completion.Type == CompletionType.Throw)
				{
					JavaScriptException ex = new JavaScriptException(completion.GetValueOrDefault()).SetJavaScriptCallstack(this, in completion.Location);
					ResetCallStack();
					throw ex;
				}
				_completionValue = completion.GetValueOrDefault();
				RunAvailableContinuations();
				return this;
			}
			finally
			{
				LeaveExecutionContext();
			}
		}

		internal ManualPromise RegisterPromise()
		{
			JsPromise obj = new JsPromise(this)
			{
				_prototype = Realm.Intrinsics.Promise.PrototypeObject
			};
			var (settle, settle2) = obj.CreateResolvingFunctions();
			return new ManualPromise(Reject: SettleWith(settle2), Promise: obj, Resolve: SettleWith(settle));
			Action<JsValue> SettleWith(Function function3)
			{
				return delegate(JsValue value)
				{
					function3.Call(JsValue.Undefined, new JsValue[1] { value });
					RunAvailableContinuations();
				};
			}
		}

		internal void AddToEventLoop(Action continuation)
		{
			_eventLoop.Events.Enqueue(continuation);
		}

		internal void AddToKeptObjects(JsValue target)
		{
			_agent.AddToKeptObjects(target);
		}

		internal void RunAvailableContinuations()
		{
			Queue<Action> events = _eventLoop.Events;
			if (events.Count != 0)
			{
				DoProcessEventLoop(events);
			}
		}

		private static void DoProcessEventLoop(Queue<Action> queue)
		{
			while (queue.Count != 0)
			{
				queue.Dequeue()();
			}
		}

		internal void RunBeforeExecuteStatementChecks(StatementListItem? statement)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			Constraint[] constraints = _constraints;
			for (int i = 0; i < constraints.Length; i++)
			{
				constraints[i].Check();
			}
			if (_isDebugMode && statement != null && (int)((Node)statement).Type != 8)
			{
				Debugger.OnStep((Node)(object)statement);
			}
		}

		internal JsValue GetValue(object value)
		{
			return GetValue(value, returnReferenceToPool: false);
		}

		internal JsValue GetValue(object value, bool returnReferenceToPool)
		{
			if (value is JsValue result)
			{
				return result;
			}
			if (!(value is Reference reference))
			{
				return ((Completion)value).Value;
			}
			return GetValue(reference, returnReferenceToPool);
		}

		internal JsValue GetValue(Reference reference, bool returnReferenceToPool)
		{
			JsValue value = reference.Base;
			if (value.IsUndefined())
			{
				if (_referenceResolver.TryUnresolvableReference(this, reference, out JsValue value2))
				{
					return value2;
				}
				ExceptionHelper.ThrowReferenceError(Realm, reference);
			}
			if ((value._type & InternalTypes.ObjectEnvironmentRecord) == 0 && _referenceResolver.TryPropertyReference(this, reference, ref value))
			{
				return value;
			}
			if (reference.IsPropertyReference)
			{
				JsValue referencedName = reference.ReferencedName;
				if (returnReferenceToPool)
				{
					_referencePool.Return(reference);
				}
				if (value.IsObject())
				{
					ObjectInstance objectInstance = Jint.Runtime.TypeConverter.ToObject(Realm, value);
					if (reference.IsPrivateReference)
					{
						return objectInstance.PrivateGet((PrivateName)reference.ReferencedName);
					}
					reference.EvaluateAndCachePropertyKey();
					return objectInstance.Get(reference.ReferencedName, reference.ThisValue);
				}
				ObjectInstance o = null;
				if ((referencedName._type & (InternalTypes.String | InternalTypes.Integer)) != InternalTypes.Empty && value is JsString s && TryHandleStringValue(referencedName, s, ref o, out JsValue jsValue))
				{
					return jsValue;
				}
				if ((object)o == null)
				{
					o = Jint.Runtime.TypeConverter.ToObject(Realm, value);
				}
				if (reference.IsPrivateReference)
				{
					return o.PrivateGet((PrivateName)reference.ReferencedName);
				}
				return o.Get(referencedName, reference.ThisValue);
			}
			JsValue bindingValue = ((Jint.Runtime.Environments.Environment)value).GetBindingValue(reference.ReferencedName.ToString(), reference.Strict);
			if (returnReferenceToPool)
			{
				_referencePool.Return(reference);
			}
			return bindingValue;
		}

		private bool TryHandleStringValue(JsValue property, JsString s, ref ObjectInstance? o, out JsValue jsValue)
		{
			if (CommonProperties.Length.Equals(property))
			{
				jsValue = JsNumber.Create((uint)s.Length);
				return true;
			}
			if (property is JsNumber value && value.IsInteger())
			{
				int num = value.AsInteger();
				if (num < 0 || num >= s.Length)
				{
					jsValue = JsValue.Undefined;
					return true;
				}
				jsValue = JsString.Create(s[num]);
				return true;
			}
			if (property is JsString { Length: >0 } jsString && char.IsLower(jsString[0]))
			{
				o = Realm.Intrinsics.String.PrototypeObject;
			}
			jsValue = JsValue.Undefined;
			return false;
		}

		internal void PutValue(Reference reference, JsValue value)
		{
			JsValue referencedName = reference.ReferencedName;
			if (reference.IsUnresolvableReference)
			{
				if (reference.Strict && referencedName != CommonProperties.Arguments)
				{
					ExceptionHelper.ThrowReferenceError(Realm, reference);
				}
				Realm.GlobalObject.Set(referencedName, value, throwOnError: false);
			}
			else if (reference.IsPropertyReference)
			{
				ObjectInstance objectInstance = Jint.Runtime.TypeConverter.ToObject(Realm, reference.Base);
				if (reference.IsPrivateReference)
				{
					objectInstance.PrivateSet((PrivateName)referencedName, value);
					return;
				}
				reference.EvaluateAndCachePropertyKey();
				if (!objectInstance.Set(reference.ReferencedName, value, reference.ThisValue) && reference.Strict)
				{
					ExceptionHelper.ThrowTypeError(Realm, "Cannot assign to read only property '" + referencedName?.ToString() + "' of " + objectInstance);
				}
			}
			else
			{
				((Jint.Runtime.Environments.Environment)reference.Base).SetMutableBinding(Jint.Runtime.TypeConverter.ToString(referencedName), value, reference.Strict);
			}
		}

		public JsValue Invoke(string propertyName, params object?[] arguments)
		{
			return Invoke(propertyName, null, arguments);
		}

		public JsValue Invoke(string propertyName, object? thisObj, object?[] arguments)
		{
			JsValue value = GetValue(propertyName);
			return Invoke(value, thisObj, arguments);
		}

		public JsValue Invoke(JsValue value, params object?[] arguments)
		{
			return Invoke(value, null, arguments);
		}

		public JsValue Invoke(JsValue value, object? thisObj, object?[] arguments)
		{
			ICallable callable = value as ICallable;
			if (callable == null)
			{
				ExceptionHelper.ThrowJavaScriptException(Realm.Intrinsics.TypeError, "Can only invoke functions");
			}
			return ExecuteWithConstraints(Options.Strict, DoInvoke);
			JsValue DoInvoke()
			{
				JsValue[] array = _jsValueArrayPool.RentArray(arguments.Length);
				for (int i = 0; i < arguments.Length; i++)
				{
					array[i] = JsValue.FromObject(this, arguments[i]);
				}
				JsValue thisObject = JsValue.FromObject(this, thisObj);
				JsValue result;
				if (callable is Function function)
				{
					JintCallStack callStack = CallStack;
					callStack.Push(function, null, in ExecutionContext);
					try
					{
						result = function.Call(thisObject, array);
					}
					finally
					{
						if (callStack.Count > 0)
						{
							callStack.Pop();
						}
					}
				}
				else
				{
					result = callable.Call(thisObject, array);
				}
				_jsValueArrayPool.ReturnArray(array);
				return result;
			}
		}

		internal T ExecuteWithConstraints<T>(bool strict, Func<T> callback)
		{
			ResetConstraints();
			bool flag = _activeEvaluationContext == null;
			if (_activeEvaluationContext == null)
			{
				_activeEvaluationContext = new EvaluationContext(this);
			}
			try
			{
				using (new StrictModeScope(strict))
				{
					return callback();
				}
			}
			finally
			{
				if (flag)
				{
					_activeEvaluationContext = null;
				}
				ResetConstraints();
				_agent.ClearKeptObjects();
			}
		}

		internal JsValue Invoke(JsValue v, JsValue p, JsValue[] arguments)
		{
			bool flag = _activeEvaluationContext == null;
			if (_activeEvaluationContext == null)
			{
				_activeEvaluationContext = new EvaluationContext(this);
			}
			try
			{
				ICallable obj = GetV(v, p) as ICallable;
				if (obj == null)
				{
					ExceptionHelper.ThrowTypeErrorNoEngine("Can only invoke functions");
				}
				return obj.Call(v, arguments);
			}
			finally
			{
				if (flag)
				{
					_activeEvaluationContext = null;
				}
			}
		}

		private JsValue GetV(JsValue v, JsValue p)
		{
			return Jint.Runtime.TypeConverter.ToObject(Realm, v).Get(p);
		}

		public JsValue GetValue(string propertyName)
		{
			return GetValue(Realm.GlobalObject, new JsString(propertyName));
		}

		internal SyntaxElement GetLastSyntaxElement()
		{
			return _lastSyntaxElement;
		}

		public JsValue GetValue(JsValue scope, JsValue property)
		{
			Reference reference = _referencePool.Rent(scope, property, _isStrict, null);
			JsValue value = GetValue(reference, returnReferenceToPool: false);
			_referencePool.Return(reference);
			return value;
		}

		internal Reference ResolveBinding(string name, Jint.Runtime.Environments.Environment? env = null)
		{
			if ((object)env == null)
			{
				env = ExecutionContext.LexicalEnvironment;
			}
			return GetIdentifierReference(env, name, StrictModeScope.IsStrictModeCode);
		}

		private static Reference GetIdentifierReference(Jint.Runtime.Environments.Environment? env, string name, bool strict)
		{
			if ((object)env == null)
			{
				return new Reference(JsValue.Undefined, name, strict);
			}
			if (env.HasBinding(name))
			{
				return new Reference(env, name, strict);
			}
			return GetIdentifierReference(env._outerEnv, name, strict);
		}

		internal JsValue GetNewTarget(Jint.Runtime.Environments.Environment? thisEnvironment = null)
		{
			if ((object)thisEnvironment == null)
			{
				thisEnvironment = ExecutionContext.GetThisEnvironment();
			}
			return thisEnvironment.NewTarget ?? JsValue.Undefined;
		}

		internal JsValue ResolveThisBinding()
		{
			return ExecutionContext.GetThisEnvironment().GetThisBinding();
		}

		private void GlobalDeclarationInstantiation(Script script, GlobalEnvironment env)
		{
			HoistingScope hoistingScope = ((Program)(object)script).GetHoistingScope();
			List<FunctionDeclaration> functionDeclarations = hoistingScope._functionDeclarations;
			List<JintFunctionDefinition> list = new List<JintFunctionDefinition>();
			HashSet<Key> hashSet = new HashSet<Key>();
			List<Key> list2 = new List<Key>();
			Realm realm = Realm;
			if (functionDeclarations != null)
			{
				for (int num = functionDeclarations.Count - 1; num >= 0; num--)
				{
					FunctionDeclaration val = functionDeclarations[num];
					Key key = val.Id.Name;
					if (!hashSet.Contains(key))
					{
						if (!env.CanDeclareGlobalFunction(key))
						{
							ExceptionHelper.ThrowTypeError(realm, "Cannot declare global function " + key);
						}
						hashSet.Add(key);
						list.Add(new JintFunctionDefinition((IFunction)(object)val));
					}
				}
			}
			List<Key> varNames = ((Program)(object)script).GetVarNames(hoistingScope);
			for (int i = 0; i < varNames.Count; i++)
			{
				Key key2 = varNames[i];
				if (env.HasLexicalDeclaration(key2))
				{
					ExceptionHelper.ThrowSyntaxError(realm, $"Identifier '{key2}' has already been declared");
				}
				if (!hashSet.Contains(key2))
				{
					if (!env.CanDeclareGlobalVar(key2))
					{
						ExceptionHelper.ThrowTypeError(realm);
					}
					list2.Add(key2);
				}
			}
			PrivateEnvironment privateEnv = null;
			List<CachedHoistingScope.CachedLexicalName> lexNames = ((Program)(object)script).GetLexNames(hoistingScope);
			for (int j = 0; j < lexNames.Count; j++)
			{
				var (key4, flag2) = (CachedHoistingScope.CachedLexicalName)(ref lexNames[j]);
				if (env.HasLexicalDeclaration(key4) || env.HasRestrictedGlobalProperty(key4))
				{
					ExceptionHelper.ThrowSyntaxError(realm, $"Identifier '{key4}' has already been declared");
				}
				if (flag2)
				{
					env.CreateImmutableBinding(key4);
				}
				else
				{
					env.CreateMutableBinding(key4);
				}
			}
			for (int num2 = list.Count - 1; num2 > -1; num2--)
			{
				JintFunctionDefinition jintFunctionDefinition = list[num2];
				Key key5 = jintFunctionDefinition.Name;
				if (env.HasLexicalDeclaration(key5))
				{
					ExceptionHelper.ThrowSyntaxError(realm, $"Identifier '{key5}' has already been declared");
				}
				Function value = realm.Intrinsics.Function.InstantiateFunctionObject(jintFunctionDefinition, env, privateEnv);
				env.CreateGlobalFunctionBinding(key5, value, canBeDeleted: false);
			}
			env.CreateGlobalVarBindings(list2, canBeDeleted: false);
		}

		internal JsArguments? FunctionDeclarationInstantiation(Function function, JsValue[] argumentsList)
		{
			Jint.Runtime.Environments.ExecutionContext executionContext = ExecutionContext;
			JintFunctionDefinition functionDefinition = function._functionDefinition;
			FunctionEnvironment functionEnvironment = (FunctionEnvironment)ExecutionContext.LexicalEnvironment;
			bool flag = _isStrict || StrictModeScope.IsStrictModeCode;
			JintFunctionDefinition.State state = functionDefinition.Initialize();
			Key[] parameterNames = state.ParameterNames;
			bool hasDuplicates = state.HasDuplicates;
			bool isSimpleParameterList = state.IsSimpleParameterList;
			bool hasParameterExpressions = state.HasParameterExpressions;
			int num;
			object obj;
			if (isSimpleParameterList)
			{
				num = ((!state.HasDuplicates) ? 1 : 0);
				if (num != 0)
				{
					obj = argumentsList;
					goto IL_0077;
				}
			}
			else
			{
				num = 0;
			}
			obj = null;
			goto IL_0077;
			IL_0077:
			JsValue[] arguments = (JsValue[])obj;
			functionEnvironment.InitializeParameters(parameterNames, hasDuplicates, arguments);
			JsArguments jsArguments = null;
			if (state.ArgumentsObjectNeeded || _isDebugMode)
			{
				jsArguments = ((!flag && isSimpleParameterList) ? CreateMappedArgumentsObject(function, parameterNames, argumentsList, functionEnvironment, state.HasRestParameter) : CreateUnmappedArgumentsObject(argumentsList));
				if (flag)
				{
					functionEnvironment.CreateImmutableBindingAndInitialize(KnownKeys.Arguments, strict: false, jsArguments);
				}
				else
				{
					functionEnvironment.CreateMutableBindingAndInitialize(KnownKeys.Arguments, canBeDeleted: false, jsArguments);
				}
			}
			if (num == 0)
			{
				functionEnvironment.AddFunctionParameters(_activeEvaluationContext, functionDefinition.Function, argumentsList);
			}
			Jint.Runtime.Environments.Environment environment;
			if (!hasParameterExpressions)
			{
				List<JintFunctionDefinition.State.VariableValuePair> varsToInitialize = state.VarsToInitialize;
				for (int i = 0; i < varsToInitialize.Count; i++)
				{
					functionEnvironment.CreateMutableBindingAndInitialize(varsToInitialize[i].Name, canBeDeleted: false, JsValue.Undefined);
				}
				environment = functionEnvironment;
			}
			else
			{
				DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(this, functionEnvironment);
				environment = declarativeEnvironment;
				UpdateVariableEnvironment(environment);
				List<JintFunctionDefinition.State.VariableValuePair> varsToInitialize2 = state.VarsToInitialize;
				for (int j = 0; j < varsToInitialize2.Count; j++)
				{
					JintFunctionDefinition.State.VariableValuePair variableValuePair = varsToInitialize2[j];
					JsValue value = variableValuePair.InitialValue ?? functionEnvironment.GetBindingValue(variableValuePair.Name, strict: false);
					declarativeEnvironment.CreateMutableBindingAndInitialize(variableValuePair.Name, canBeDeleted: false, value);
				}
			}
			Jint.Runtime.Environments.Environment environment2 = (flag ? environment : JintEnvironment.NewDeclarativeEnvironment(this, environment));
			UpdateLexicalEnvironment(environment2);
			if (state.LexicalDeclarations.Length != 0)
			{
				JintFunctionDefinition.State.LexicalVariableDeclaration[] lexicalDeclarations = state.LexicalDeclarations;
				for (int k = 0; k < lexicalDeclarations.Length; k++)
				{
					JintFunctionDefinition.State.LexicalVariableDeclaration lexicalVariableDeclaration = lexicalDeclarations[k];
					for (int l = 0; l < lexicalVariableDeclaration.BoundNames.Count; l++)
					{
						Key name = lexicalVariableDeclaration.BoundNames[l];
						if (lexicalVariableDeclaration.IsConstantDeclaration)
						{
							environment2.CreateImmutableBinding(name);
						}
						else
						{
							environment2.CreateMutableBinding(name);
						}
					}
				}
			}
			if (state.FunctionsToInitialize != null)
			{
				PrivateEnvironment privateEnvironment = executionContext.PrivateEnvironment;
				Realm realm = Realm;
				foreach (FunctionDeclaration item in state.FunctionsToInitialize)
				{
					JintFunctionDefinition jintFunctionDefinition = new JintFunctionDefinition((IFunction)(object)item);
					string name2 = jintFunctionDefinition.Name;
					Function value2 = realm.Intrinsics.Function.InstantiateFunctionObject(jintFunctionDefinition, environment2, privateEnvironment);
					environment.SetMutableBinding(name2, value2, strict: false);
				}
			}
			return jsArguments;
		}

		private JsArguments CreateMappedArgumentsObject(Function func, Key[] formals, JsValue[] argumentsList, DeclarativeEnvironment envRec, bool hasRestParameter)
		{
			return _argumentsInstancePool.Rent(func, formals, argumentsList, envRec, hasRestParameter);
		}

		private JsArguments CreateUnmappedArgumentsObject(JsValue[] argumentsList)
		{
			return _argumentsInstancePool.Rent(argumentsList);
		}

		internal void EvalDeclarationInstantiation(Script script, Jint.Runtime.Environments.Environment varEnv, Jint.Runtime.Environments.Environment lexEnv, PrivateEnvironment? privateEnv, bool strict)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			HoistingScope programLevelDeclarations = HoistingScope.GetProgramLevelDeclarations((Program)(object)script);
			DeclarativeEnvironment declarativeEnvironment = (DeclarativeEnvironment)lexEnv;
			Realm realm = Realm;
			if (!strict && programLevelDeclarations._variablesDeclarations != null)
			{
				if (varEnv is GlobalEnvironment globalEnvironment)
				{
					ref readonly List<VariableDeclaration> variablesDeclarations = ref programLevelDeclarations._variablesDeclarations;
					for (int i = 0; i < variablesDeclarations.Count; i++)
					{
						Identifier val = (Identifier)((NodeList<VariableDeclarator>)variablesDeclarations[i].Declarations)[0].Id;
						if (globalEnvironment.HasLexicalDeclaration(val.Name))
						{
							ExceptionHelper.ThrowSyntaxError(realm, "Identifier '" + val.Name + "' has already been declared");
						}
					}
				}
				Jint.Runtime.Environments.Environment environment = lexEnv;
				while ((object)environment != varEnv)
				{
					Jint.Runtime.Environments.Environment environment2 = environment;
					if (!(environment2 is ObjectEnvironment))
					{
						ref readonly List<VariableDeclaration> variablesDeclarations2 = ref programLevelDeclarations._variablesDeclarations;
						for (int j = 0; j < variablesDeclarations2.Count; j++)
						{
							Identifier val2 = (Identifier)((NodeList<VariableDeclarator>)variablesDeclarations2[j].Declarations)[0].Id;
							if (environment2.HasBinding(val2.Name))
							{
								ExceptionHelper.ThrowSyntaxError(realm);
							}
						}
					}
					environment = environment._outerEnv;
				}
			}
			HashSet<PrivateIdentifier> hashSet = null;
			for (PrivateEnvironment privateEnvironment = privateEnv; privateEnvironment != null; privateEnvironment = privateEnvironment.OuterPrivateEnvironment)
			{
				foreach (KeyValuePair<PrivateIdentifier, PrivateName> name3 in privateEnvironment.Names)
				{
					if (hashSet == null)
					{
						hashSet = new HashSet<PrivateIdentifier>(PrivateIdentifierNameComparer._instance);
					}
					hashSet.Add(name3.Key);
				}
			}
			script.AllPrivateIdentifiersValid(realm, hashSet);
			List<FunctionDeclaration> functionDeclarations = programLevelDeclarations._functionDeclarations;
			LinkedList<JintFunctionDefinition> linkedList = new LinkedList<JintFunctionDefinition>();
			HashSet<Key> hashSet2 = new HashSet<Key>();
			if (functionDeclarations != null)
			{
				for (int num = functionDeclarations.Count - 1; num >= 0; num--)
				{
					FunctionDeclaration val3 = functionDeclarations[num];
					Key key = val3.Id.Name;
					if (!hashSet2.Contains(key))
					{
						if (varEnv is GlobalEnvironment globalEnvironment2 && !globalEnvironment2.CanDeclareGlobalFunction(key))
						{
							ExceptionHelper.ThrowTypeError(realm);
						}
						hashSet2.Add(key);
						linkedList.AddFirst(new JintFunctionDefinition((IFunction)(object)val3));
					}
				}
			}
			List<Key> list = new List<Key>();
			List<Key> list2 = new List<Key>();
			List<VariableDeclaration> variablesDeclarations3 = programLevelDeclarations._variablesDeclarations;
			int? num2 = variablesDeclarations3?.Count;
			for (int k = 0; k < num2; k++)
			{
				VariableDeclaration variableDeclaration = variablesDeclarations3[k];
				list.Clear();
				variableDeclaration.GetBoundNames(list);
				for (int l = 0; l < list.Count; l++)
				{
					Key key2 = list[l];
					if (!hashSet2.Contains(key2))
					{
						if (varEnv is GlobalEnvironment globalEnvironment3 && !globalEnvironment3.CanDeclareGlobalFunction(key2))
						{
							ExceptionHelper.ThrowTypeError(realm);
						}
						list2.Add(key2);
					}
				}
			}
			List<Declaration> lexicalDeclarations = programLevelDeclarations._lexicalDeclarations;
			int? num3 = lexicalDeclarations?.Count;
			for (int m = 0; m < num3; m++)
			{
				list.Clear();
				Declaration val4 = lexicalDeclarations[m];
				((Node?)(object)val4).GetBoundNames(list);
				for (int n = 0; n < list.Count; n++)
				{
					Key name = list[n];
					if (val4.IsConstantDeclaration())
					{
						declarativeEnvironment.CreateImmutableBinding(name);
					}
					else
					{
						declarativeEnvironment.CreateMutableBinding(name);
					}
				}
			}
			foreach (JintFunctionDefinition item in linkedList)
			{
				Function value = realm.Intrinsics.Function.InstantiateFunctionObject(item, lexEnv, privateEnv);
				if (varEnv is GlobalEnvironment globalEnvironment4)
				{
					globalEnvironment4.CreateGlobalFunctionBinding(item.Name, value, canBeDeleted: true);
					continue;
				}
				Key name2 = item.Name;
				if (!varEnv.HasBinding(name2))
				{
					varEnv.CreateMutableBinding(name2, canBeDeleted: true);
					varEnv.InitializeBinding(name2, value);
				}
				else
				{
					varEnv.SetMutableBinding(name2, value, strict: false);
				}
			}
			foreach (Key item2 in list2)
			{
				if (varEnv is GlobalEnvironment globalEnvironment5)
				{
					globalEnvironment5.CreateGlobalVarBinding(item2, canBeDeleted: true);
				}
				else if (!varEnv.HasBinding(item2))
				{
					varEnv.CreateMutableBinding(item2, canBeDeleted: true);
					varEnv.InitializeBinding(item2, JsValue.Undefined);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void UpdateLexicalEnvironment(Jint.Runtime.Environments.Environment newEnv)
		{
			_executionContexts.ReplaceTopLexicalEnvironment(newEnv);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void UpdateVariableEnvironment(Jint.Runtime.Environments.Environment newEnv)
		{
			_executionContexts.ReplaceTopVariableEnvironment(newEnv);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void UpdatePrivateEnvironment(PrivateEnvironment? newEnv)
		{
			_executionContexts.ReplaceTopPrivateEnvironment(newEnv);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ref readonly Jint.Runtime.Environments.ExecutionContext UpdateGenerator(GeneratorInstance generator)
		{
			return ref _executionContexts.ReplaceTopGenerator(generator);
		}

		public JsValue Call(string callableName, params JsValue[] arguments)
		{
			JsValue callable = Evaluate(callableName);
			return Call(callable, arguments);
		}

		public JsValue Call(JsValue callable, params JsValue[] arguments)
		{
			return Call(callable, JsValue.Undefined, arguments);
		}

		public JsValue Call(JsValue callable, JsValue thisObject, JsValue[] arguments)
		{
			return ExecuteWithConstraints(Options.Strict, Callback);
			JsValue Callback()
			{
				if (!callable.IsCallable)
				{
					ExceptionHelper.ThrowArgumentException(callable?.ToString() + " is not callable");
				}
				return Call((ICallable)callable, thisObject, arguments, null);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal JsValue Call(ICallable callable, JsValue thisObject, JsValue[] arguments, JintExpression? expression)
		{
			if (callable is Function function)
			{
				return Call(function, thisObject, arguments, expression);
			}
			return callable.Call(thisObject, arguments);
		}

		public ObjectInstance Construct(string constructorName, params JsValue[] arguments)
		{
			JsValue constructor = Evaluate(constructorName);
			return Construct(constructor, arguments);
		}

		public ObjectInstance Construct(JsValue constructor, params JsValue[] arguments)
		{
			return ExecuteWithConstraints(Options.Strict, Callback);
			ObjectInstance Callback()
			{
				if (!constructor.IsConstructor)
				{
					ExceptionHelper.ThrowArgumentException(constructor?.ToString() + " is not a constructor");
				}
				return Construct(constructor, arguments, constructor, null);
			}
		}

		internal ObjectInstance Construct(JsValue constructor, JsValue[] arguments, JsValue newTarget, JintExpression? expression)
		{
			if (constructor is Function function)
			{
				return Construct(function, arguments, newTarget, expression);
			}
			return ((IConstructor)constructor).Construct(arguments, newTarget);
		}

		internal JsValue Call(Function function, JsValue thisObject)
		{
			return Call(function, thisObject, Arguments.Empty, null);
		}

		internal JsValue Call(Function function, JsValue thisObject, JsValue[] arguments, JintExpression? expression)
		{
			if (CallStack.Push(function, expression, in ExecutionContext) > Options.Constraints.MaxRecursionDepth)
			{
				ExceptionHelper.ThrowRecursionDepthOverflowException(CallStack);
			}
			try
			{
				return function.Call(thisObject, arguments);
			}
			finally
			{
				if (CallStack.Count > 0)
				{
					CallStack.Pop();
				}
			}
		}

		private ObjectInstance Construct(Function function, JsValue[] arguments, JsValue newTarget, JintExpression? expression)
		{
			if (CallStack.Push(function, expression, in ExecutionContext) > Options.Constraints.MaxRecursionDepth)
			{
				ExceptionHelper.ThrowRecursionDepthOverflowException(CallStack);
			}
			try
			{
				return ((IConstructor)function).Construct(arguments, newTarget);
			}
			finally
			{
				CallStack.Pop();
			}
		}

		internal void SignalError(ErrorDispatchInfo error)
		{
			_error = error;
		}

		internal void RegisterTypeReference(TypeReference reference)
		{
			if (_typeReferences == null)
			{
				_typeReferences = new Dictionary<Type, TypeReference>();
			}
			_typeReferences[reference.ReferenceType] = reference;
		}

		internal ref readonly Jint.Runtime.Environments.ExecutionContext GetExecutionContext(int fromTop)
		{
			return ref _executionContexts.Peek(fromTop);
		}

		public void Dispose()
		{
			if (_objectWrapperCache != null)
			{
				_objectWrapperCache.Clear();
			}
		}

		internal IScriptOrModule? GetActiveScriptOrModule()
		{
			return _executionContexts?.GetActiveScriptOrModule();
		}

		static Engine()
		{
			ParserOptions obj = ParserOptions.Default.<Clone>$();
			obj.set_Tolerant(true);
			obj.set_MaxAssignmentDepth(500);
			BaseParserOptions = obj;
		}
	}
	internal sealed class CachedHoistingScope
	{
		[StructLayout(LayoutKind.Auto)]
		internal readonly record struct CachedLexicalName(Key Name, bool Constant);

		public HoistingScope Scope { get; }

		public List<Key> VarNames { get; }

		public List<CachedLexicalName> LexNames { get; }

		public CachedHoistingScope(Program program)
		{
			Scope = HoistingScope.GetProgramLevelDeclarations(program);
			VarNames = new List<Key>();
			GatherVarNames(Scope, VarNames);
			LexNames = new List<CachedLexicalName>();
			GatherLexNames(Scope, LexNames);
		}

		internal static void GatherVarNames(HoistingScope scope, List<Key> boundNames)
		{
			List<VariableDeclaration> variablesDeclarations = scope._variablesDeclarations;
			if (variablesDeclarations != null)
			{
				for (int i = 0; i < variablesDeclarations.Count; i++)
				{
					variablesDeclarations[i].GetBoundNames(boundNames);
				}
			}
		}

		internal static void GatherLexNames(HoistingScope scope, List<CachedLexicalName> boundNames)
		{
			List<Declaration> lexicalDeclarations = scope._lexicalDeclarations;
			if (lexicalDeclarations == null)
			{
				return;
			}
			List<Key> list = new List<Key>();
			for (int i = 0; i < lexicalDeclarations.Count; i++)
			{
				Declaration val = lexicalDeclarations[i];
				list.Clear();
				((Node?)(object)val).GetBoundNames(list);
				for (int j = 0; j < list.Count; j++)
				{
					boundNames.Add(new CachedLexicalName(list[j], val.IsConstantDeclaration()));
				}
			}
		}
	}
	internal static class AstPreparationExtensions
	{
		internal static HoistingScope GetHoistingScope(this Program program)
		{
			if (!(((SyntaxElement)program).AssociatedData is CachedHoistingScope cachedHoistingScope))
			{
				return HoistingScope.GetProgramLevelDeclarations(program);
			}
			return cachedHoistingScope.Scope;
		}

		internal static List<Key> GetVarNames(this Program program, HoistingScope hoistingScope)
		{
			List<Key> list;
			if (((SyntaxElement)program).AssociatedData is CachedHoistingScope cachedHoistingScope)
			{
				list = cachedHoistingScope.VarNames;
			}
			else
			{
				list = new List<Key>();
				CachedHoistingScope.GatherVarNames(hoistingScope, list);
			}
			return list;
		}

		internal static List<CachedHoistingScope.CachedLexicalName> GetLexNames(this Program program, HoistingScope hoistingScope)
		{
			List<CachedHoistingScope.CachedLexicalName> list;
			if (((SyntaxElement)program).AssociatedData is CachedHoistingScope cachedHoistingScope)
			{
				list = cachedHoistingScope.LexNames;
			}
			else
			{
				list = new List<CachedHoistingScope.CachedLexicalName>();
				CachedHoistingScope.GatherLexNames(hoistingScope, list);
			}
			return list;
		}
	}
	internal static class Polyfills
	{
	}
	internal sealed class HoistingScope
	{
		private sealed class ScriptWalker
		{
			internal List<FunctionDeclaration>? _functions;

			private readonly bool _collectVarNames;

			internal List<VariableDeclaration>? _variableDeclarations;

			internal List<Key>? _varNames;

			private readonly bool _collectLexicalNames;

			internal List<Declaration>? _lexicalDeclarations;

			internal List<string>? _lexicalNames;

			public ScriptWalker(bool collectVarNames, bool collectLexicalNames)
			{
				_collectVarNames = collectVarNames;
				_collectLexicalNames = collectLexicalNames;
			}

			public unsafe void Visit(Node node, Node? parent)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Invalid comparison between Unknown and I4
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Invalid comparison between Unknown and I4
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Invalid comparison between Unknown and I4
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Invalid comparison between Unknown and I4
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_0218: Invalid comparison between Unknown and I4
				//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Expected O, but got Unknown
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Invalid comparison between Unknown and I4
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: Invalid comparison between Unknown and I4
				//IL_020b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Expected O, but got Unknown
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_021e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0221: Invalid comparison between Unknown and I4
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_0229: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				ChildNodes childNodes = node.ChildNodes;
				Enumerator enumerator = ((ChildNodes)(ref childNodes)).GetEnumerator();
				try
				{
					while (((Enumerator)(ref enumerator)).MoveNext())
					{
						Node current = ((Enumerator)(ref enumerator)).Current;
						Nodes type = current.Type;
						if ((int)type == 69)
						{
							VariableDeclaration val = (VariableDeclaration)current;
							if ((int)val.Kind == 0)
							{
								if (_variableDeclarations == null)
								{
									_variableDeclarations = new List<VariableDeclaration>();
								}
								_variableDeclarations.Add(val);
								if (_collectVarNames)
								{
									if (_varNames == null)
									{
										_varNames = new List<Key>();
									}
									Enumerator<VariableDeclarator> enumerator2 = ((NodeList<VariableDeclarator>)val.Declarations).GetEnumerator();
									try
									{
										while (enumerator2.MoveNext())
										{
											Node id = enumerator2.Current.Id;
											Identifier val2 = (Identifier)(object)((id is Identifier) ? id : null);
											if (val2 != null)
											{
												_varNames.Add(val2.Name);
											}
										}
									}
									finally
									{
										((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
									}
								}
							}
							bool flag = ((parent == null || parent is Module) ? true : false);
							if (flag && (int)val.Kind != 0)
							{
								if (_lexicalDeclarations == null)
								{
									_lexicalDeclarations = new List<Declaration>();
								}
								_lexicalDeclarations.Add((Declaration)(object)val);
								if (_collectLexicalNames)
								{
									if (_lexicalNames == null)
									{
										_lexicalNames = new List<string>();
									}
									Enumerator<VariableDeclarator> enumerator2 = ((NodeList<VariableDeclarator>)val.Declarations).GetEnumerator();
									try
									{
										while (enumerator2.MoveNext())
										{
											Node id2 = enumerator2.Current.Id;
											Identifier val3 = (Identifier)(object)((id2 is Identifier) ? id2 : null);
											if (val3 != null)
											{
												_lexicalNames.Add(val3.Name);
											}
										}
									}
									finally
									{
										((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
									}
								}
							}
						}
						else if ((int)type == 30)
						{
							if (parent == null || ((int)node.Type != 8 && (int)node.Type != 59))
							{
								if (_functions == null)
								{
									_functions = new List<FunctionDeclaration>();
								}
								_functions.Add((FunctionDeclaration)current);
							}
						}
						else
						{
							bool flag = (int)type == 14;
							if (flag)
							{
								bool flag2 = ((parent == null || parent is Module) ? true : false);
								flag = flag2;
							}
							if (flag)
							{
								if (_lexicalDeclarations == null)
								{
									_lexicalDeclarations = new List<Declaration>();
								}
								_lexicalDeclarations.Add((Declaration)current);
							}
						}
						if ((int)type != 30 && (int)type != 3 && (int)type != 31)
						{
							childNodes = current.ChildNodes;
							if (!((ChildNodes)(ref childNodes)).IsEmpty())
							{
								Visit(current, node);
							}
						}
					}
				}
				finally
				{
					((IDisposable)(*(Enumerator*)(&enumerator))/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}

		private sealed class ModuleRequestRecordComparer : IComparer<ModuleRequest>
		{
			public int Compare(ModuleRequest x, ModuleRequest y)
			{
				return string.Compare(x.Specifier, y.Specifier, StringComparison.Ordinal);
			}
		}

		private sealed class ModuleWalker
		{
			internal List<ImportEntry>? _importEntries;

			internal List<ExportEntry>? _exportEntries;

			internal HashSet<ModuleRequest>? _requestedModules;

			internal unsafe void Visit(Node node)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Invalid comparison between Unknown and I4
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Invalid comparison between Unknown and I4
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Expected O, but got Unknown
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Expected O, but got Unknown
				ChildNodes childNodes = node.ChildNodes;
				Enumerator enumerator = ((ChildNodes)(ref childNodes)).GetEnumerator();
				try
				{
					while (((Enumerator)(ref enumerator)).MoveNext())
					{
						Node current = ((Enumerator)(ref enumerator)).Current;
						if ((int)current.Type == 35)
						{
							if (_importEntries == null)
							{
								_importEntries = new List<ImportEntry>();
							}
							if (_requestedModules == null)
							{
								_requestedModules = new HashSet<ModuleRequest>();
							}
							AstExtensions.GetImportEntries((ImportDeclaration)current, _importEntries, _requestedModules);
						}
						else
						{
							Nodes type = current.Type;
							if (type - 22 <= 2)
							{
								if (_exportEntries == null)
								{
									_exportEntries = new List<ExportEntry>();
								}
								if (_requestedModules == null)
								{
									_requestedModules = new HashSet<ModuleRequest>();
								}
								AstExtensions.GetExportEntries((ExportDeclaration)current, _exportEntries, _requestedModules);
							}
						}
						childNodes = current.ChildNodes;
						if (!((ChildNodes)(ref childNodes)).IsEmpty())
						{
							Visit(current);
						}
					}
				}
				finally
				{
					((IDisposable)(*(Enumerator*)(&enumerator))/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}

		internal readonly List<FunctionDeclaration>? _functionDeclarations;

		internal readonly List<VariableDeclaration>? _variablesDeclarations;

		internal readonly List<Key>? _varNames;

		internal readonly List<Declaration>? _lexicalDeclarations;

		internal readonly List<string>? _lexicalNames;

		private HoistingScope(List<FunctionDeclaration>? functionDeclarations, List<Key>? varNames, List<VariableDeclaration>? variableDeclarations, List<Declaration>? lexicalDeclarations, List<string>? lexicalNames)
		{
			_functionDeclarations = functionDeclarations;
			_varNames = varNames;
			_variablesDeclarations = variableDeclarations;
			_lexicalDeclarations = lexicalDeclarations;
			_lexicalNames = lexicalNames;
		}

		public static HoistingScope GetProgramLevelDeclarations(Program script, bool collectVarNames = false, bool collectLexicalNames = false)
		{
			ScriptWalker scriptWalker = new ScriptWalker(collectVarNames, collectLexicalNames);
			scriptWalker.Visit((Node)(object)script, null);
			return new HoistingScope(scriptWalker._functions, scriptWalker._varNames, scriptWalker._variableDeclarations, scriptWalker._lexicalDeclarations, scriptWalker._lexicalNames);
		}

		public static HoistingScope GetFunctionLevelDeclarations(bool strict, IFunction node)
		{
			ScriptWalker scriptWalker = new ScriptWalker(collectVarNames: true, collectLexicalNames: true);
			scriptWalker.Visit((Node)(object)node.Body, null);
			return new HoistingScope(scriptWalker._functions, scriptWalker._varNames, scriptWalker._variableDeclarations, scriptWalker._lexicalDeclarations, scriptWalker._lexicalNames);
		}

		public static HoistingScope GetModuleLevelDeclarations(Module module, bool collectVarNames = false, bool collectLexicalNames = false)
		{
			ScriptWalker scriptWalker = new ScriptWalker(collectVarNames, collectLexicalNames);
			scriptWalker.Visit((Node)(object)module, null);
			return new HoistingScope(scriptWalker._functions, scriptWalker._varNames, scriptWalker._variableDeclarations, scriptWalker._lexicalDeclarations, scriptWalker._lexicalNames);
		}

		public static List<Declaration>? GetLexicalDeclarations(BlockStatement statement)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			List<Declaration> list = null;
			ref NodeList<Statement> body = statement.Body;
			for (int i = 0; i < body.Count; i++)
			{
				Statement val = body[i];
				if ((int)((Node)val).Type != 69 && (int)((Node)val).Type != 30 && (int)((Node)val).Type != 14)
				{
					continue;
				}
				VariableDeclaration val2 = (VariableDeclaration)(object)((val is VariableDeclaration) ? val : null);
				if (val2 == null || (int)val2.Kind != 0)
				{
					if (list == null)
					{
						list = new List<Declaration>();
					}
					list.Add((Declaration)val);
				}
			}
			return list;
		}

		public static List<Declaration>? GetLexicalDeclarations(SwitchCase statement)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			List<Declaration> list = null;
			ref NodeList<Statement> consequent = statement.Consequent;
			for (int i = 0; i < consequent.Count; i++)
			{
				Statement val = consequent[i];
				if ((int)((Node)val).Type != 69)
				{
					continue;
				}
				VariableDeclaration val2 = (VariableDeclaration)val;
				if ((int)val2.Kind != 0)
				{
					if (list == null)
					{
						list = new List<Declaration>();
					}
					list.Add((Declaration)(object)val2);
				}
			}
			return list;
		}

		public static void GetImportsAndExports(Module module, out HashSet<ModuleRequest> requestedModules, out List<ImportEntry>? importEntries, out List<ExportEntry> localExportEntries, out List<ExportEntry> indirectExportEntries, out List<ExportEntry> starExportEntries)
		{
			ModuleWalker moduleWalker = new ModuleWalker();
			moduleWalker.Visit((Node)(object)module);
			importEntries = moduleWalker._importEntries;
			requestedModules = moduleWalker._requestedModules ?? new HashSet<ModuleRequest>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			if (importEntries != null)
			{
				for (int i = 0; i < importEntries.Count; i++)
				{
					ImportEntry importEntry = importEntries[i];
					if (importEntry.LocalName != null)
					{
						hashSet.Add(importEntry.LocalName);
					}
				}
			}
			List<ExportEntry> exportEntries = moduleWalker._exportEntries;
			localExportEntries = new List<ExportEntry>();
			indirectExportEntries = new List<ExportEntry>();
			starExportEntries = new List<ExportEntry>();
			if (exportEntries == null)
			{
				return;
			}
			for (int j = 0; j < exportEntries.Count; j++)
			{
				ExportEntry exportEntry = exportEntries[j];
				if (!exportEntry.ModuleRequest.HasValue)
				{
					if (!hashSet.Contains(exportEntry.LocalName))
					{
						localExportEntries.Add(exportEntry);
						continue;
					}
					for (int k = 0; k < importEntries.Count; k++)
					{
						ImportEntry importEntry2 = importEntries[k];
						if (string.Equals(importEntry2.LocalName, exportEntry.LocalName, StringComparison.Ordinal))
						{
							if (string.Equals(importEntry2.ImportName, "*", StringComparison.Ordinal))
							{
								localExportEntries.Add(exportEntry);
							}
							else
							{
								indirectExportEntries.Add(new ExportEntry(exportEntry.ExportName, importEntry2.ModuleRequest, importEntry2.ImportName, null));
							}
							break;
						}
					}
				}
				else if (string.Equals(exportEntry.ImportName, "*", StringComparison.Ordinal) && exportEntry.ExportName == null)
				{
					starExportEntries.Add(exportEntry);
				}
				else
				{
					indirectExportEntries.Add(exportEntry);
				}
			}
		}
	}
	public abstract class Constraint
	{
		public abstract void Check();

		public abstract void Reset();
	}
	public static class JsValueExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPrimitive(this JsValue value)
		{
			return (value._type & (InternalTypes.Primitive | InternalTypes.Undefined | InternalTypes.Null)) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsUndefined(this JsValue value)
		{
			return value._type == InternalTypes.Undefined;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsArray(this JsValue value)
		{
			return value is JsArray;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsNullOrUndefined(this JsValue value)
		{
			return value._type < InternalTypes.Boolean;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsDate(this JsValue value)
		{
			return value is JsDate;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPromise(this JsValue value)
		{
			return value is JsPromise;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPrivateName(this JsValue value)
		{
			return value._type == InternalTypes.PrivateName;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsRegExp(this JsValue value)
		{
			if (!(value is ObjectInstance objectInstance))
			{
				return false;
			}
			JsValue jsValue = objectInstance.Get(GlobalSymbolRegistry.Match);
			if (!jsValue.IsUndefined())
			{
				return TypeConverter.ToBoolean(jsValue);
			}
			return value is JsRegExp;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsObject(this JsValue value)
		{
			return (value._type & InternalTypes.Object) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsString(this JsValue value)
		{
			return (value._type & InternalTypes.String) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNumber(this JsValue value)
		{
			return (value._type & (InternalTypes.Number | InternalTypes.Integer)) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsBigInt(this JsValue value)
		{
			return (value._type & InternalTypes.BigInt) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsInteger(this JsValue value)
		{
			return value._type == InternalTypes.Integer;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsBoolean(this JsValue value)
		{
			return value._type == InternalTypes.Boolean;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNull(this JsValue value)
		{
			return value._type == InternalTypes.Null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsSymbol(this JsValue value)
		{
			return value._type == InternalTypes.Symbol;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool CanBeHeldWeakly(this JsValue value, GlobalSymbolRegistry symbolRegistry)
		{
			if (!value.IsObject())
			{
				if (value.IsSymbol())
				{
					return !symbolRegistry.ContainsCustom(value);
				}
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsDate AsDate(this JsValue value)
		{
			if (!value.IsDate())
			{
				ExceptionHelper.ThrowArgumentException("The value is not a date");
			}
			return (JsDate)value;
		}

		public static JsRegExp AsRegExp(this JsValue value)
		{
			if (!value.IsRegExp())
			{
				ExceptionHelper.ThrowArgumentException("The value is not a regex");
			}
			return (JsRegExp)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ObjectInstance AsObject(this JsValue value)
		{
			if (!value.IsObject())
			{
				ExceptionHelper.ThrowArgumentException("The value is not an object");
			}
			return (ObjectInstance)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static TInstance AsInstance<TInstance>(this JsValue value) where TInstance : class
		{
			if (!value.IsObject())
			{
				ExceptionHelper.ThrowArgumentException("The value is not an object");
			}
			return value as TInstance;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsArray AsArray(this JsValue value)
		{
			if (!value.IsArray())
			{
				ExceptionHelper.ThrowArgumentException("The value is not an array");
			}
			return (JsArray)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool AsBoolean(this JsValue value)
		{
			if (value._type != InternalTypes.Boolean)
			{
				ThrowWrongTypeException(value, "boolean");
			}
			return ((JsBoolean)value)._value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double AsNumber(this JsValue value)
		{
			if (!value.IsNumber())
			{
				ThrowWrongTypeException(value, "number");
			}
			return ((JsNumber)value)._value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int AsInteger(this JsValue value)
		{
			return (int)((JsNumber)value)._value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static BigInteger AsBigInt(this JsValue value)
		{
			return ((JsBigInt)value)._value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string AsString(this JsValue value)
		{
			if (!value.IsString())
			{
				ThrowWrongTypeException(value, "string");
			}
			return value.ToString();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsArrayBuffer(this JsValue value)
		{
			return value is JsArrayBuffer;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte[]? AsArrayBuffer(this JsValue value)
		{
			if (!value.IsArrayBuffer())
			{
				ThrowWrongTypeException(value, "ArrayBuffer");
			}
			return ((JsArrayBuffer)value)._arrayBufferData;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsDataView(this JsValue value)
		{
			return value is JsDataView;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte[]? AsDataView(this JsValue value)
		{
			if (!value.IsDataView())
			{
				ThrowWrongTypeException(value, "DataView");
			}
			JsDataView jsDataView = (JsDataView)value;
			if (jsDataView._viewedArrayBuffer?._arrayBufferData == null)
			{
				return null;
			}
			byte[] array = new byte[jsDataView._byteLength];
			Array.Copy(jsDataView._viewedArrayBuffer._arrayBufferData, jsDataView._byteOffset, array, 0L, jsDataView._byteLength);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsUint8Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Uint8;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte[] AsUint8Array(this JsValue value)
		{
			if (!value.IsUint8Array())
			{
				ThrowWrongTypeException(value, "Uint8Array");
			}
			return ((JsTypedArray)value).ToNativeArray<byte>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsUint8ClampedArray(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Uint8C;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte[] AsUint8ClampedArray(this JsValue value)
		{
			if (!value.IsUint8ClampedArray())
			{
				ThrowWrongTypeException(value, "Uint8ClampedArray");
			}
			return ((JsTypedArray)value).ToNativeArray<byte>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInt8Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Int8;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static sbyte[] AsInt8Array(this JsValue value)
		{
			if (!value.IsInt8Array())
			{
				ThrowWrongTypeException(value, "Int8Array");
			}
			return ((JsTypedArray)value).ToNativeArray<sbyte>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInt16Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Int16;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short[] AsInt16Array(this JsValue value)
		{
			if (!value.IsInt16Array())
			{
				ThrowWrongTypeException(value, "Int16Array");
			}
			return ((JsTypedArray)value).ToNativeArray<short>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsUint16Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Uint16;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ushort[] AsUint16Array(this JsValue value)
		{
			if (!value.IsUint16Array())
			{
				ThrowWrongTypeException(value, "Uint16Array");
			}
			return ((JsTypedArray)value).ToNativeArray<ushort>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInt32Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Int32;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int[] AsInt32Array(this JsValue value)
		{
			if (!value.IsInt32Array())
			{
				ThrowWrongTypeException(value, "Int32Array");
			}
			return ((JsTypedArray)value).ToNativeArray<int>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsUint32Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Uint32;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint[] AsUint32Array(this JsValue value)
		{
			if (!value.IsUint32Array())
			{
				ThrowWrongTypeException(value, "Uint32Array");
			}
			return ((JsTypedArray)value).ToNativeArray<uint>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsBigInt64Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.BigInt64;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long[] AsBigInt64Array(this JsValue value)
		{
			if (!value.IsBigInt64Array())
			{
				ThrowWrongTypeException(value, "BigInt64Array");
			}
			return ((JsTypedArray)value).ToNativeArray<long>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsBigUint64Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.BigUint64;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong[] AsBigUint64Array(this JsValue value)
		{
			if (!value.IsBigUint64Array())
			{
				ThrowWrongTypeException(value, "BigUint64Array");
			}
			return ((JsTypedArray)value).ToNativeArray<ulong>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsFloat32Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Float32;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float[] AsFloat32Array(this JsValue value)
		{
			if (!value.IsFloat32Array())
			{
				ThrowWrongTypeException(value, "Float32Array");
			}
			return ((JsTypedArray)value).ToNativeArray<float>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsFloat64Array(this JsValue value)
		{
			if (value is JsTypedArray jsTypedArray)
			{
				return jsTypedArray._arrayElementType == TypedArrayElementType.Float64;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double[] AsFloat64Array(this JsValue value)
		{
			if (!value.IsFloat64Array())
			{
				ThrowWrongTypeException(value, "Float64Array");
			}
			return ((JsTypedArray)value).ToNativeArray<double>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T? TryCast<T>(this JsValue value) where T : class
		{
			return value as T;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T? TryCast<T>(this JsValue value, Action<JsValue> fail) where T : class
		{
			if (value is T result)
			{
				return result;
			}
			fail(value);
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T? As<T>(this JsValue value) where T : ObjectInstance
		{
			if (value.IsObject())
			{
				return value as T;
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Function AsFunctionInstance(this JsValue value)
		{
			if (!(value is Function result))
			{
				ThrowWrongTypeException(value, "FunctionInstance");
				return null;
			}
			return result;
		}

		public static JsValue Call(this JsValue value)
		{
			if (value is ObjectInstance objectInstance)
			{
				return objectInstance.Engine.Call(value);
			}
			return ThrowNotObject(value);
		}

		public static JsValue Call(this JsValue value, JsValue arg1)
		{
			if (value is ObjectInstance objectInstance)
			{
				Engine engine = objectInstance.Engine;
				JsValue[] array = engine._jsValueArrayPool.RentArray(1);
				array[0] = arg1;
				JsValue result = engine.Call(value, array);
				engine._jsValueArrayPool.ReturnArray(array);
				return result;
			}
			return ThrowNotObject(value);
		}

		public static JsValue Call(this JsValue value, JsValue arg1, JsValue arg2)
		{
			if (value is ObjectInstance objectInstance)
			{
				Engine engine = objectInstance.Engine;
				JsValue[] array = engine._jsValueArrayPool.RentArray(2);
				array[0] = arg1;
				array[1] = arg2;
				JsValue result = engine.Call(value, array);
				engine._jsValueArrayPool.ReturnArray(array);
				return result;
			}
			return ThrowNotObject(value);
		}

		public static JsValue Call(this JsValue value, JsValue arg1, JsValue arg2, JsValue arg3)
		{
			if (value is ObjectInstance objectInstance)
			{
				Engine engine = objectInstance.Engine;
				JsValue[] array = engine._jsValueArrayPool.RentArray(3);
				array[0] = arg1;
				array[1] = arg2;
				array[2] = arg3;
				JsValue result = engine.Call(value, array);
				engine._jsValueArrayPool.ReturnArray(array);
				return result;
			}
			return ThrowNotObject(value);
		}

		public static JsValue Call(this JsValue value, params JsValue[] arguments)
		{
			if (value is ObjectInstance objectInstance)
			{
				return objectInstance.Engine.Call(value, arguments);
			}
			return ThrowNotObject(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsValue Call(this JsValue value, JsValue thisObj, JsValue[] arguments)
		{
			if (value is ObjectInstance objectInstance)
			{
				return objectInstance.Engine.Call(value, thisObj, arguments);
			}
			return ThrowNotObject(value);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static JsValue ThrowNotObject(JsValue value)
		{
			ExceptionHelper.ThrowArgumentException(value?.ToString() + " is not object");
			return null;
		}

		public static JsValue UnwrapIfPromise(this JsValue value)
		{
			if (value is JsPromise jsPromise)
			{
				Engine engine = jsPromise.Engine;
				Task<JsPromise> task = jsPromise.TaskCompletionSource.Task;
				engine.RunAvailableContinuations();
				engine.AddToEventLoop(delegate
				{
					if (!task.IsCompleted)
					{
						((IAsyncResult)task).AsyncWaitHandle.WaitOne();
					}
				});
				engine.RunAvailableContinuations();
				switch (jsPromise.State)
				{
				case PromiseState.Pending:
					ExceptionHelper.ThrowInvalidOperationException("'UnwrapIfPromise' called before Promise was settled");
					return null;
				case PromiseState.Fulfilled:
					return jsPromise.Value;
				case PromiseState.Rejected:
					ExceptionHelper.ThrowPromiseRejectedException(jsPromise.Value);
					return null;
				default:
					ExceptionHelper.ThrowArgumentOutOfRangeException();
					return null;
				}
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowWrongTypeException(JsValue value, string expectedType)
		{
			ExceptionHelper.ThrowArgumentException($"Expected {expectedType} but got {value._type}");
		}

		internal static BigInteger ToBigInteger(this JsValue value, Engine engine)
		{
			//IL_000a: Expected O, but got Unknown
			try
			{
				return TypeConverter.ToBigInt(value);
			}
			catch (ParserException ex)
			{
				ParserException ex2 = ex;
				ExceptionHelper.ThrowSyntaxError(engine.Realm, ((Exception)(object)ex2).Message);
				return default(BigInteger);
			}
		}

		internal static ICallable GetCallable(this JsValue source, Realm realm)
		{
			if (source is ICallable result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(realm, "Argument must be callable");
			return null;
		}

		internal static uint? GetArrayBufferMaxByteLengthOption(this JsValue options)
		{
			if (!(options is JsObject jsObject))
			{
				return null;
			}
			JsValue value = options.Get("maxByteLength");
			if (value.IsUndefined())
			{
				return null;
			}
			return TypeConverter.ToIndex(jsObject.Engine.Realm, value);
		}
	}
	[DebuggerDisplay("{Name}")]
	internal readonly struct Key : IEquatable<Key>
	{
		internal readonly string Name;

		internal readonly int HashCode;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private Key(string name)
		{
			Name = name;
			HashCode = Hash.GetFNVHashCode(name);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator Key(string name)
		{
			return new Key(name);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static implicit operator string(Key key)
		{
			return key.Name;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator ==(in Key a, in Key b)
		{
			if (a.HashCode == b.HashCode)
			{
				return string.Equals(a.Name, b.Name, StringComparison.Ordinal);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool operator !=(in Key a, in Key b)
		{
			if (a.HashCode == b.HashCode)
			{
				return !string.Equals(a.Name, b.Name, StringComparison.Ordinal);
			}
			return true;
		}

		public bool Equals(Key other)
		{
			if (HashCode == other.HashCode)
			{
				return string.Equals(Name, other.Name, StringComparison.Ordinal);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return HashCode;
		}

		public override string ToString()
		{
			return Name;
		}
	}
	internal static class Messages
	{
		public const string InvalidLHSInAssignment = "Invalid left-hand side in assignment";
	}
	public class Options
	{
		public delegate JsValue? MemberAccessorDelegate(Engine engine, object target, string member);

		public delegate ObjectInstance? WrapObjectDelegate(Engine engine, object target, Type? type);

		public delegate bool ExceptionHandlerDelegate(Exception exception);

		public class DebuggerOptions
		{
			public bool Enabled { get; set; }

			public DebuggerStatementHandling StatementHandling { get; set; }

			public StepMode InitialStepMode { get; set; }
		}

		public class InteropOptions
		{
			public Func<ObjectInstance, IDictionary<string, object?>>? CreateClrObject = (ObjectInstance _) => new ExpandoObject();

			public Func<Engine, Type, JsValue[], object?> CreateTypeReferenceObject = (Engine _, Type _, JsValue[] _) => (object?)null;

			internal static readonly ExceptionHandlerDelegate _defaultExceptionHandler = (Exception exception) => false;

			public bool Enabled { get; set; }

			public bool AllowGetType { get; set; }

			public bool AllowSystemReflection { get; set; }

			public bool AllowWrite { get; set; } = true;

			public bool AllowOperatorOverloading { get; set; }

			public List<Type> ExtensionMethodTypes { get; } = new List<Type>();

			public List<IObjectConverter> ObjectConverters { get; } = new List<IObjectConverter>();

			public bool TrackObjectWrapperIdentity { get; set; }

			public WrapObjectDelegate WrapObjectHandler { get; set; } = (Engine engine, object target, Type? type) => ObjectWrapper.Create(engine, target, type);

			public MemberAccessorDelegate MemberAccessor { get; set; } = (Engine engine, object target, string member) => (JsValue?)null;

			public ExceptionHandlerDelegate ExceptionHandler { get; set; } = _defaultExceptionHandler;

			public List<Assembly> AllowedAssemblies { get; set; } = new List<Assembly>();

			public TypeResolver TypeResolver { get; set; } = Jint.Runtime.Interop.TypeResolver.Default;

			public ValueCoercionType ValueCoercion { get; set; } = ValueCoercionType.String;

			public Func<object, string>? SerializeToJson { get; set; }

			public DateTimeKind DateTimeKind { get; set; } = DateTimeKind.Utc;

			public bool AttachArrayPrototype { get; set; } = true;

			public bool ThrowOnUnresolvedMember { get; set; }
		}

		public class ConstraintOptions
		{
			public List<Constraint> Constraints { get; } = new List<Constraint>();

			public int MaxRecursionDepth { get; set; } = -1;

			public int MaxExecutionStackCount { get; set; } = -1;

			public TimeSpan RegexTimeout { get; set; } = TimeSpan.FromSeconds(10.0);

			public uint MaxArraySize { get; set; } = uint.MaxValue;
		}

		public class HostOptions
		{
			internal Func<Engine, Host> Factory { get; set; } = (Engine _) => new Host();
		}

		public class ModuleOptions
		{
			public bool RegisterRequire { get; set; }

			public IModuleLoader ModuleLoader { get; set; } = FailFastModuleLoader.Instance;
		}

		public class JsonOptions
		{
			public int MaxParseDepth { get; set; } = 64;
		}

		private static readonly CultureInfo _defaultCulture = CultureInfo.CurrentCulture;

		private static readonly TimeZoneInfo _defaultTimeZone = TimeZoneInfo.Local;

		private ITimeSystem? _timeSystem;

		internal List<Action<Engine>> _configurations { get; } = new List<Action<Engine>>();

		public ConstraintOptions Constraints { get; } = new ConstraintOptions();

		public InteropOptions Interop { get; } = new InteropOptions();

		public DebuggerOptions Debugger { get; } = new DebuggerOptions();

		internal HostOptions Host { get; } = new HostOptions();

		public ModuleOptions Modules { get; } = new ModuleOptions();

		public bool Strict { get; set; }

		public CultureInfo Culture { get; set; } = _defaultCulture;

		public ITimeSystem TimeSystem
		{
			get
			{
				return _timeSystem ?? (_timeSystem = new DefaultTimeSystem(TimeZone, Culture));
			}
			set
			{
				_timeSystem = value;
			}
		}

		public TimeZoneInfo TimeZone { get; set; } = _defaultTimeZone;

		public IReferenceResolver ReferenceResolver { get; set; } = DefaultReferenceResolver.Instance;

		public bool StringCompilationAllowed { get; set; } = true;

		public JsonOptions Json { get; set; } = new JsonOptions();

		public ExperimentalFeature ExperimentalFeatures { get; set; }

		internal void Apply(Engine engine)
		{
			foreach (Action<Engine> configuration in _configurations)
			{
				configuration(engine);
			}
			if (Interop.Enabled)
			{
				engine.Realm.GlobalObject.SetProperty("System", new PropertyDescriptor(new NamespaceReference(engine, "System"), PropertyFlag.AllForbidden));
				engine.Realm.GlobalObject.SetProperty("importNamespace", new PropertyDescriptor(new ClrFunction(engine, "importNamespace", (JsValue _, JsValue[] arguments) => new NamespaceReference(engine, arguments.At(0).IsNullOrUndefined() ? null : TypeConverter.ToString(arguments.At(0)))), PropertyFlag.AllForbidden));
				engine.Realm.GlobalObject.SetProperty("clrHelper", new PropertyDescriptor(ObjectWrapper.Create(engine, new ClrHelper(Interop)), PropertyFlag.AllForbidden));
			}
			if (Interop.ExtensionMethodTypes.Count > 0)
			{
				AttachExtensionMethodsToPrototypes(engine);
			}
			if (Modules.RegisterRequire)
			{
				engine.Realm.GlobalObject.SetProperty("require", new PropertyDescriptor(new ClrFunction(engine, "require", delegate(JsValue thisObj, JsValue[] arguments)
				{
					string specifier = TypeConverter.ToString(arguments.At(0));
					return engine.Modules.Import(specifier);
				}), PropertyFlag.AllForbidden));
			}
			engine.Modules = new Engine.ModuleOperations(engine, Modules.ModuleLoader);
		}

		private static void AttachExtensionMethodsToPrototypes(Engine engine)
		{
			AttachExtensionMethodsToPrototype(engine, engine.Realm.Intrinsics.Array.PrototypeObject, typeof(Array));
			AttachExtensionMethodsToPrototype(engine, engine.Realm.Intrinsics.Boolean.PrototypeObject, typeof(bool));
			AttachExtensionMethodsToPrototype(engine, engine.Realm.Intrinsics.Date.PrototypeObject, typeof(DateTime));
			AttachExtensionMethodsToPrototype(engine, engine.Realm.Intrinsics.Number.PrototypeObject, typeof(double));
			AttachExtensionMethodsToPrototype(engine, engine.Realm.Intrinsics.Object.PrototypeObject, typeof(ExpandoObject));
			AttachExtensionMethodsToPrototype(engine, engine.Realm.Intrinsics.RegExp.PrototypeObject, typeof(Regex));
			AttachExtensionMethodsToPrototype(engine, engine.Realm.Intrinsics.String.PrototypeObject, typeof(string));
		}

		private static void AttachExtensionMethodsToPrototype(Engine engine, ObjectInstance prototype, Type objectType)
		{
			if (!engine._extensionMethods.TryGetExtensionMethods(objectType, out MethodInfo[] methods))
			{
				return;
			}
			foreach (IGrouping<string, MethodInfo> item in methods.GroupBy<MethodInfo, string>((MethodInfo x) => x.Name, StringComparer.Ordinal))
			{
				IGrouping<string, MethodInfo> overloads = item;
				JsValue property = overloads.Key;
				PropertyDescriptor propertyDescriptor = null;
				PropertyDescriptor propertyDescriptor2 = null;
				if (prototype.HasOwnProperty(property) && prototype.GetOwnProperty(property).Value is ClrFunction function)
				{
					propertyDescriptor = CreateMethodInstancePropertyDescriptor(function);
					prototype.SetOwnProperty(property, propertyDescriptor);
				}
				else
				{
					propertyDescriptor2 = CreateMethodInstancePropertyDescriptor(null);
					prototype.SetOwnProperty(property, propertyDescriptor2);
				}
				if (!char.IsUpper(overloads.Key[0]))
				{
					continue;
				}
				property = char.ToLower(overloads.Key[0], CultureInfo.InvariantCulture) + overloads.Key.Substring(1);
				if (prototype.HasOwnProperty(property) && prototype.GetOwnProperty(property).Value is ClrFunction function2)
				{
					if (propertyDescriptor == null)
					{
						propertyDescriptor = CreateMethodInstancePropertyDescriptor(function2);
					}
					prototype.SetOwnProperty(property, propertyDescriptor);
				}
				else
				{
					if (propertyDescriptor2 == null)
					{
						propertyDescriptor2 = CreateMethodInstancePropertyDescriptor(null);
					}
					prototype.SetOwnProperty(property, propertyDescriptor2);
				}
				PropertyDescriptor CreateMethodInstancePropertyDescriptor(ClrFunction? fallbackClrFunctionInstance)
				{
					return new PropertyDescriptor(new MethodInfoFunction(engine, objectType, null, overloads.Key, MethodDescriptor.Build(overloads.ToList()), fallbackClrFunctionInstance), PropertyFlag.AllForbidden);
				}
			}
		}
	}
	[Flags]
	public enum ValueCoercionType
	{
		None = 0,
		Boolean = 1,
		Number = 2,
		String = 4,
		All = 7
	}
	[Flags]
	public enum ExperimentalFeature
	{
		None = 0,
		Generators = 1,
		TaskInterop = 2,
		All = 3
	}
	public static class OptionsExtensions
	{
		public static Options Strict(this Options options, bool strict = true)
		{
			options.Strict = strict;
			return options;
		}

		public static Options DebuggerStatementHandling(this Options options, DebuggerStatementHandling debuggerStatementHandling)
		{
			options.Debugger.StatementHandling = debuggerStatementHandling;
			return options;
		}

		public static Options DebugMode(this Options options, bool debugMode = true)
		{
			options.Debugger.Enabled = debugMode;
			return options;
		}

		public static Options InitialStepMode(this Options options, StepMode initialStepMode = StepMode.None)
		{
			options.Debugger.InitialStepMode = initialStepMode;
			return options;
		}

		public static Options AddObjectConverter<T>(this Options options) where T : IObjectConverter, new()
		{
			return options.AddObjectConverter(new T());
		}

		public static Options AddObjectConverter(this Options options, IObjectConverter objectConverter)
		{
			options.Interop.ObjectConverters.Add(objectConverter);
			return options;
		}

		public static Options LimitRecursion(this Options options, int maxRecursionDepth = 0)
		{
			options.Constraints.MaxRecursionDepth = maxRecursionDepth;
			return options;
		}

		public static Options Culture(this Options options, CultureInfo cultureInfo)
		{
			options.Culture = cultureInfo;
			return options;
		}

		public static Options LocalTimeZone(this Options options, TimeZoneInfo timeZoneInfo)
		{
			options.TimeZone = timeZoneInfo;
			return options;
		}

		public static Options DisableStringCompilation(this Options options, bool disable = true)
		{
			options.StringCompilationAllowed = !disable;
			return options;
		}

		public static Options AddExtensionMethods(this Options options, params Type[] types)
		{
			options.Interop.ExtensionMethodTypes.AddRange(types);
			return options;
		}

		public static Options SetWrapObjectHandler(this Options options, Options.WrapObjectDelegate wrapObjectHandler)
		{
			options.Interop.WrapObjectHandler = wrapObjectHandler;
			return options;
		}

		public static Options SetTypeConverter(this Options options, Func<Engine, ITypeConverter> typeConverterFactory)
		{
			options._configurations.Add(delegate(Engine engine)
			{
				engine.TypeConverter = typeConverterFactory(engine);
			});
			return options;
		}

		public static Options SetMemberAccessor(this Options options, Options.MemberAccessorDelegate accessor)
		{
			options.Interop.MemberAccessor = accessor;
			return options;
		}

		public static Options AllowClr(this Options options, params Assembly[] assemblies)
		{
			options.Interop.Enabled = true;
			options.Interop.AllowedAssemblies.AddRange(assemblies);
			options.Interop.AllowedAssemblies = options.Interop.AllowedAssemblies.Distinct().ToList();
			return options;
		}

		public static Options AllowClrWrite(this Options options, bool allow = true)
		{
			options.Interop.AllowWrite = allow;
			return options;
		}

		public static Options AllowOperatorOverloading(this Options options, bool allow = true)
		{
			options.Interop.AllowOperatorOverloading = allow;
			return options;
		}

		public static Options CatchClrExceptions(this Options options)
		{
			options.CatchClrExceptions((Exception _) => true);
			return options;
		}

		public static Options CatchClrExceptions(this Options options, Options.ExceptionHandlerDelegate handler)
		{
			options.Interop.ExceptionHandler = handler;
			return options;
		}

		public static Options Constraint(this Options options, Constraint constraint)
		{
			if (constraint != null)
			{
				options.Constraints.Constraints.Add(constraint);
			}
			return options;
		}

		public static Options WithoutConstraint(this Options options, Predicate<Constraint> predicate)
		{
			options.Constraints.Constraints.RemoveAll(predicate);
			return options;
		}

		public static Options RegexTimeoutInterval(this Options options, TimeSpan regexTimeoutInterval)
		{
			options.Constraints.RegexTimeout = regexTimeoutInterval;
			return options;
		}

		public static Options MaxArraySize(this Options options, uint maxSize)
		{
			options.Constraints.MaxArraySize = maxSize;
			return options;
		}

		public static Options MaxJsonParseDepth(this Options options, int maxDepth)
		{
			options.Json.MaxParseDepth = maxDepth;
			return options;
		}

		public static Options SetReferencesResolver(this Options options, IReferenceResolver resolver)
		{
			options.ReferenceResolver = resolver;
			return options;
		}

		public static Options SetTypeResolver(this Options options, TypeResolver resolver)
		{
			options.Interop.TypeResolver = resolver;
			return options;
		}

		public static Options Configure(this Options options, Action<Engine> configuration)
		{
			options._configurations.Add(configuration);
			return options;
		}

		public static Options UseHostFactory<T>(this Options options, Func<Engine, T> factory) where T : Host
		{
			options.Host.Factory = factory;
			return options;
		}

		public static Options EnableModules(this Options options, string basePath, bool restrictToBasePath = true)
		{
			return options.EnableModules(new DefaultModuleLoader(basePath, restrictToBasePath));
		}

		public static Options EnableModules(this Options options, IModuleLoader moduleLoader)
		{
			options.Modules.ModuleLoader = moduleLoader;
			return options;
		}
	}
	public interface IParsingOptions
	{
		bool? CompileRegex { get; init; }

		TimeSpan? RegexTimeout { get; init; }

		bool Tolerant { get; init; }
	}
	public sealed record ScriptParsingOptions : IParsingOptions
	{
		public bool AllowReturnOutsideFunction { get; init; } = _defaultParserOptions.AllowReturnOutsideFunction;

		public bool? CompileRegex { get; init; }

		public TimeSpan? RegexTimeout { get; init; }

		public bool Tolerant { get; init; } = _defaultParserOptions.Tolerant;

		private static readonly ParserOptions _defaultParserOptions;

		public static readonly ScriptParsingOptions Default;

		internal ParserOptions ApplyTo(ParserOptions parserOptions, RegExpParseMode defaultRegExpParseMode, TimeSpan defaultRegexTimeout)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			ParserOptions obj = parserOptions.<Clone>$();
			obj.AllowReturnOutsideFunction = AllowReturnOutsideFunction;
			obj.set_RegExpParseMode((RegExpParseMode)(CompileRegex.HasValue ? (CompileRegex.Value ? 3 : 2) : ((int)defaultRegExpParseMode)));
			obj.set_RegexTimeout(RegexTimeout ?? defaultRegexTimeout);
			obj.set_Tolerant(Tolerant);
			return obj;
		}

		internal ParserOptions GetParserOptions()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if ((object)this != Default)
			{
				return ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
			}
			return _defaultParserOptions;
		}

		internal ParserOptions GetParserOptions(Options engineOptions)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, engineOptions.Constraints.RegexTimeout);
		}

		[CompilerGenerated]
		private ScriptParsingOptions(ScriptParsingOptions original)
		{
			AllowReturnOutsideFunction = original.AllowReturnOutsideFunction;
			CompileRegex = original.CompileRegex;
			RegexTimeout = original.RegexTimeout;
			Tolerant = original.Tolerant;
		}

		public ScriptParsingOptions()
		{
		}

		static ScriptParsingOptions()
		{
			ParserOptions obj = Engine.BaseParserOptions.<Clone>$();
			obj.AllowReturnOutsideFunction = true;
			obj.set_RegExpParseMode((RegExpParseMode)2);
			_defaultParserOptions = obj;
			Default = new ScriptParsingOptions();
		}
	}
	public sealed record ModuleParsingOptions : IParsingOptions
	{
		public bool? CompileRegex { get; init; }

		public TimeSpan? RegexTimeout { get; init; }

		public bool Tolerant { get; init; } = _defaultParserOptions.Tolerant;

		private static readonly ParserOptions _defaultParserOptions;

		public static readonly ModuleParsingOptions Default;

		internal ParserOptions ApplyTo(ParserOptions baseOptions, RegExpParseMode defaultRegExpParseMode, TimeSpan defaultRegexTimeout)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			ParserOptions obj = baseOptions.<Clone>$();
			obj.set_RegExpParseMode((RegExpParseMode)(CompileRegex.HasValue ? (CompileRegex.Value ? 3 : 2) : ((int)defaultRegExpParseMode)));
			obj.set_RegexTimeout(RegexTimeout ?? defaultRegexTimeout);
			obj.set_Tolerant(Tolerant);
			return obj;
		}

		internal ParserOptions GetParserOptions()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if ((object)this != Default)
			{
				return ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
			}
			return _defaultParserOptions;
		}

		internal ParserOptions GetParserOptions(Options engineOptions)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, engineOptions.Constraints.RegexTimeout);
		}

		[CompilerGenerated]
		private ModuleParsingOptions(ModuleParsingOptions original)
		{
			CompileRegex = original.CompileRegex;
			RegexTimeout = original.RegexTimeout;
			Tolerant = original.Tolerant;
		}

		public ModuleParsingOptions()
		{
		}

		static ModuleParsingOptions()
		{
			ParserOptions obj = Engine.BaseParserOptions.<Clone>$();
			obj.set_RegExpParseMode((RegExpParseMode)2);
			_defaultParserOptions = obj;
			Default = new ModuleParsingOptions();
		}
	}
	public interface IPreparationOptions<out TParsingOptions> where TParsingOptions : IParsingOptions
	{
		TParsingOptions ParsingOptions { get; }

		bool FoldConstants { get; init; }
	}
	public sealed record ScriptPreparationOptions : IPreparationOptions<ScriptParsingOptions>
	{
		public ScriptParsingOptions ParsingOptions { get; init; } = ScriptParsingOptions.Default;

		public bool FoldConstants { get; init; } = true;

		private static readonly ParserOptions _defaultParserOptions;

		public static readonly ScriptPreparationOptions Default;

		internal ParserOptions GetParserOptions()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((object)this != Default)
			{
				return ParsingOptions.ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
			}
			return _defaultParserOptions;
		}

		[CompilerGenerated]
		private ScriptPreparationOptions(ScriptPreparationOptions original)
		{
			ParsingOptions = original.ParsingOptions;
			FoldConstants = original.FoldConstants;
		}

		public ScriptPreparationOptions()
		{
		}

		static ScriptPreparationOptions()
		{
			ParserOptions obj = ScriptParsingOptions.Default.GetParserOptions().<Clone>$();
			obj.set_RegExpParseMode((RegExpParseMode)3);
			_defaultParserOptions = obj;
			Default = new ScriptPreparationOptions();
		}
	}
	public sealed record ModulePreparationOptions : IPreparationOptions<ModuleParsingOptions>
	{
		public ModuleParsingOptions ParsingOptions { get; init; } = ModuleParsingOptions.Default;

		public bool FoldConstants { get; init; } = true;

		private static readonly ParserOptions _defaultParserOptions;

		public static readonly ModulePreparationOptions Default;

		internal ParserOptions GetParserOptions()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((object)this != Default)
			{
				return ParsingOptions.ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
			}
			return _defaultParserOptions;
		}

		[CompilerGenerated]
		private ModulePreparationOptions(ModulePreparationOptions original)
		{
			ParsingOptions = original.ParsingOptions;
			FoldConstants = original.FoldConstants;
		}

		public ModulePreparationOptions()
		{
		}

		static ModulePreparationOptions()
		{
			ParserOptions obj = ModuleParsingOptions.Default.GetParserOptions().<Clone>$();
			obj.set_RegExpParseMode((RegExpParseMode)3);
			_defaultParserOptions = obj;
			Default = new ModulePreparationOptions();
		}
	}
	public readonly struct Prepared<TProgram> where TProgram : Program
	{
		public TProgram? Program { get; }

		public ParserOptions? ParserOptions { get; }

		[MemberNotNullWhen(true, "Program")]
		[MemberNotNullWhen(true, "ParserOptions")]
		public bool IsValid
		{
			[MemberNotNullWhen(true, "Program")]
			[MemberNotNullWhen(true, "ParserOptions")]
			get
			{
				return Program != null;
			}
		}

		internal Prepared(TProgram program, ParserOptions parserOptions)
		{
			Program = program;
			ParserOptions = parserOptions;
		}
	}
	internal static class DefaultObjectConverter
	{
		private static Dictionary<Type, Func<Engine, object, JsValue>> _typeMappers = new Dictionary<Type, Func<Engine, object, JsValue>>
		{
			{
				typeof(bool),
				(Engine engine, object v) => (!(bool)v) ? JsBoolean.False : JsBoolean.True
			},
			{
				typeof(byte),
				(Engine engine, object v) => JsNumber.Create((byte)v)
			},
			{
				typeof(char),
				(Engine engine, object v) => JsString.Create((char)v)
			},
			{
				typeof(DateTime),
				(Engine engine, object v) => engine.Realm.Intrinsics.Date.Construct((DateTime)v)
			},
			{
				typeof(DateTimeOffset),
				(Engine engine, object v) => engine.Realm.Intrinsics.Date.Construct((DateTimeOffset)v)
			},
			{
				typeof(decimal),
				(Engine engine, object v) => (double)(decimal)v
			},
			{
				typeof(double),
				(Engine engine, object v) => (double)v
			},
			{
				typeof(short),
				(Engine engine, object v) => JsNumber.Create((short)v)
			},
			{
				typeof(int),
				(Engine engine, object v) => JsNumber.Create((int)v)
			},
			{
				typeof(long),
				(Engine engine, object v) => (long)v
			},
			{
				typeof(sbyte),
				(Engine engine, object v) => JsNumber.Create((sbyte)v)
			},
			{
				typeof(float),
				(Engine engine, object v) => (float)v
			},
			{
				typeof(string),
				(Engine engine, object v) => JsString.Create((string)v)
			},
			{
				typeof(ushort),
				(Engine engine, object v) => JsNumber.Create((ushort)v)
			},
			{
				typeof(uint),
				(Engine engine, object v) => JsNumber.Create((uint)v)
			},
			{
				typeof(ulong),
				(Engine engine, object v) => JsNumber.Create((ulong)v)
			},
			{
				typeof(Regex),
				(Engine engine, object v) => engine.Realm.Intrinsics.RegExp.Construct((Regex)v, ((Regex)v).ToString(), "")
			}
		};

		public static bool TryConvert(Engine engine, object value, Type? type, [NotNullWhen(true)] out JsValue? result)
		{
			result = null;
			Type clrType = ObjectWrapper.GetClrType(value, type);
			Dictionary<Type, Func<Engine, object, JsValue>> typeMappers = _typeMappers;
			if (typeMappers.TryGetValue(clrType, out var value2))
			{
				result = value2(engine, value);
			}
			else
			{
				if (value is Array v)
				{
					Interlocked.CompareExchange(ref _typeMappers, new Dictionary<Type, Func<Engine, object, JsValue>>(typeMappers) { [clrType] = ConvertArray }, typeMappers);
					result = ConvertArray(engine, v);
					return (object)result != null;
				}
				if (value is IConvertible convertible && TryConvertConvertible(engine, convertible, out result))
				{
					return true;
				}
				if (value is Delegate d)
				{
					result = new DelegateWrapper(engine, d);
					return (object)result != null;
				}
				if ((engine.Options.ExperimentalFeatures & ExperimentalFeature.TaskInterop) != ExperimentalFeature.None)
				{
					if (value is Task obj)
					{
						result = JsValue.ConvertAwaitableToPromise(engine, obj);
						return (object)result != null;
					}
					if (value is ValueTask valueTask)
					{
						result = JsValue.ConvertAwaitableToPromise(engine, valueTask);
						return (object)result != null;
					}
				}
				Type type2 = value.GetType();
				if (!engine.Options.Interop.AllowSystemReflection)
				{
					string? text = type2.Namespace;
					if (text != null && text.StartsWith("System.Reflection", StringComparison.Ordinal))
					{
						ExceptionHelper.ThrowInvalidOperationException("Cannot access System.Reflection namespace, check Engine's interop options");
					}
				}
				if (type2.IsEnum)
				{
					Type underlyingType = Enum.GetUnderlyingType(type2);
					if (underlyingType == typeof(ulong))
					{
						result = JsNumber.Create(Convert.ToDouble(value, CultureInfo.InvariantCulture));
					}
					else if (underlyingType == typeof(uint) || underlyingType == typeof(long))
					{
						result = JsNumber.Create(Convert.ToInt64(value, CultureInfo.InvariantCulture));
					}
					else
					{
						result = JsNumber.Create(Convert.ToInt32(value, CultureInfo.InvariantCulture));
					}
				}
				else
				{
					ConditionalWeakTable<object, ObjectInstance>? objectWrapperCache = engine._objectWrapperCache;
					if (objectWrapperCache != null && objectWrapperCache.TryGetValue(value, out ObjectInstance value3))
					{
						result = value3;
					}
					else
					{
						ObjectInstance objectInstance = engine.Options.Interop.WrapObjectHandler(engine, value, type);
						if ((object)objectInstance?.GetPrototypeOf() == engine.Realm.Intrinsics.Object.PrototypeObject)
						{
							Dictionary<Type, TypeReference>? typeReferences = engine._typeReferences;
							if (typeReferences != null && typeReferences.TryGetValue(type2, out TypeReference value4))
							{
								objectInstance.SetPrototypeOf(value4);
							}
						}
						result = objectInstance;
						if (engine.Options.Interop.TrackObjectWrapperIdentity && (object)objectInstance != null)
						{
							if (engine._objectWrapperCache == null)
							{
								engine._objectWrapperCache = new ConditionalWeakTable<object, ObjectInstance>();
							}
							engine._objectWrapperCache.Add(value, objectInstance);
						}
					}
				}
			}
			return (object)result != null;
		}

		private static bool TryConvertConvertible(Engine engine, IConvertible convertible, [NotNullWhen(true)] out JsValue? result)
		{
			result = convertible.GetTypeCode() switch
			{
				TypeCode.Boolean => convertible.ToBoolean(engine.Options.Culture) ? JsBoolean.True : JsBoolean.False, 
				TypeCode.Byte => JsNumber.Create(convertible.ToByte(engine.Options.Culture)), 
				TypeCode.Char => JsString.Create(convertible.ToChar(engine.Options.Culture)), 
				TypeCode.Double => JsNumber.Create(convertible.ToDouble(engine.Options.Culture)), 
				TypeCode.SByte => JsNumber.Create(convertible.ToSByte(engine.Options.Culture)), 
				TypeCode.Int16 => JsNumber.Create(convertible.ToInt16(engine.Options.Culture)), 
				TypeCode.Int32 => JsNumber.Create(convertible.ToInt32(engine.Options.Culture)), 
				TypeCode.UInt16 => JsNumber.Create(convertible.ToUInt16(engine.Options.Culture)), 
				TypeCode.Int64 => JsNumber.Create(convertible.ToInt64(engine.Options.Culture)), 
				TypeCode.Single => JsNumber.Create(convertible.ToSingle(engine.Options.Culture)), 
				TypeCode.String => JsString.Create(convertible.ToString(engine.Options.Culture)), 
				TypeCode.UInt32 => JsNumber.Create(convertible.ToUInt32(engine.Options.Culture)), 
				TypeCode.UInt64 => JsNumber.Create(convertible.ToUInt64(engine.Options.Culture)), 
				TypeCode.DateTime => engine.Realm.Intrinsics.Date.Construct(convertible.ToDateTime(engine.Options.Culture)), 
				TypeCode.Decimal => JsNumber.Create(convertible.ToDecimal(engine.Options.Culture)), 
				TypeCode.DBNull => JsValue.Null, 
				TypeCode.Empty => JsValue.Null, 
				_ => null, 
			};
			return (object)result != null;
		}

		private static JsArray ConvertArray(Engine e, object v)
		{
			Array array = (Array)v;
			uint length = (uint)array.Length;
			JsValue[] array2 = new JsValue[length];
			for (uint num = 0u; num < length; num++)
			{
				array2[num] = JsValue.FromObject(e, array.GetValue(num));
			}
			return new JsArray(e, array2);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct StrictModeScope : IDisposable
	{
		private readonly bool _strict;

		private readonly bool _force;

		private readonly ushort _forcedRefCount;

		[ThreadStatic]
		private static ushort _refCount;

		public static bool IsStrictModeCode => _refCount > 0;

		public StrictModeScope(bool strict = true, bool force = false)
		{
			_strict = strict;
			_force = force;
			if (_force)
			{
				_forcedRefCount = _refCount;
				_refCount = 0;
			}
			else
			{
				_forcedRefCount = 0;
			}
			if (_strict)
			{
				_refCount++;
			}
		}

		public void Dispose()
		{
			if (_strict)
			{
				_refCount--;
			}
			if (_force)
			{
				_refCount = _forcedRefCount;
			}
		}
	}
}
namespace Jint.Runtime
{
	public static class Arguments
	{
		public static readonly JsValue[] Empty = Array.Empty<JsValue>();

		public static JsValue[] From(params JsValue[] o)
		{
			return o;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsValue At(this JsValue[] args, int index, JsValue undefinedValue)
		{
			if ((uint)index >= (uint)args.Length)
			{
				return undefinedValue;
			}
			return args[index];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsValue At(this JsValue[] args, int index)
		{
			return args.At(index, JsValue.Undefined);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsValue[] Skip(this JsValue[] args, int count)
		{
			int num = args.Length - count;
			if (num <= 0)
			{
				return Array.Empty<JsValue>();
			}
			JsValue[] array = new JsValue[num];
			Array.Copy(args, count, array, 0, num);
			return array;
		}
	}
	internal static class CommonProperties
	{
		internal static readonly JsString Arguments = JsString.CachedCreate("arguments");

		internal static readonly JsString Callee = JsString.CachedCreate("callee");

		internal static readonly JsString Caller = JsString.CachedCreate("caller");

		internal static readonly JsString Configurable = JsString.CachedCreate("configurable");

		internal static readonly JsString Constructor = JsString.CachedCreate("constructor");

		internal static readonly JsString Done = JsString.CachedCreate("done");

		internal static readonly JsString Enumerable = JsString.CachedCreate("enumerable");

		internal static readonly JsString Eval = JsString.CachedCreate("eval");

		internal static readonly JsString Get = JsString.CachedCreate("get");

		internal static readonly JsString Has = JsString.CachedCreate("has");

		internal static readonly JsString Infinity = JsString.CachedCreate("Infinity");

		internal static readonly JsString Keys = JsString.CachedCreate("keys");

		internal static readonly JsString Length = JsString.CachedCreate("length");

		internal static readonly JsString Message = JsString.CachedCreate("message");

		internal static readonly JsString Name = JsString.CachedCreate("name");

		internal static readonly JsString Next = JsString.CachedCreate("next");

		internal static readonly JsString Prototype = JsString.CachedCreate("prototype");

		internal static readonly JsString Return = JsString.CachedCreate("return");

		internal static readonly JsString Set = JsString.CachedCreate("set");

		internal static readonly JsString Size = JsString.CachedCreate("size");

		internal static readonly JsString Stack = JsString.CachedCreate("stack");

		internal static readonly JsString Value = JsString.CachedCreate("value");

		internal static readonly JsString Writable = JsString.CachedCreate("writable");
	}
	public enum CompletionType : byte
	{
		Normal,
		Return,
		Throw,
		Break,
		Continue
	}
	[StructLayout(LayoutKind.Auto)]
	public readonly struct Completion
	{
		private static readonly Node _emptyNode = (Node)new Identifier("");

		private static readonly Completion _emptyCompletion = new Completion(CompletionType.Normal, JsEmpty.Instance, (SyntaxElement)(object)_emptyNode);

		internal readonly SyntaxElement _source;

		public readonly CompletionType Type;

		public readonly JsValue Value;

		public ref readonly Location Location => ref _source.Location;

		public Completion(CompletionType type, JsValue value, SyntaxElement source)
		{
			Type = type;
			Value = value;
			_source = source;
		}

		public static ref readonly Completion Empty()
		{
			return ref _emptyCompletion;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public JsValue GetValueOrDefault()
		{
			if (!Value.IsEmpty)
			{
				return Value;
			}
			return JsValue.Undefined;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsAbrupt()
		{
			return Type != CompletionType.Normal;
		}

		internal Completion UpdateEmpty(JsValue value)
		{
			JsValue value2 = Value;
			if ((object)value2 == null || value2._type != InternalTypes.Empty)
			{
				return this;
			}
			return new Completion(Type, value, _source);
		}
	}
	internal sealed class DefaultReferenceResolver : IReferenceResolver
	{
		public static readonly DefaultReferenceResolver Instance = new DefaultReferenceResolver();

		private DefaultReferenceResolver()
		{
		}

		public bool TryUnresolvableReference(Engine engine, Reference reference, out JsValue value)
		{
			value = JsValue.Undefined;
			return false;
		}

		public bool TryPropertyReference(Engine engine, Reference reference, ref JsValue value)
		{
			return false;
		}

		public bool TryGetCallable(Engine engine, object callee, out JsValue value)
		{
			value = JsValue.Undefined;
			return false;
		}

		public bool CheckCoercible(JsValue value)
		{
			return false;
		}
	}
	public class DefaultTimeSystem : ITimeSystem
	{
		private static readonly string[] _defaultFormats = new string[3] { "yyyy-MM-dd", "yyyy-MM", "yyyy" };

		private static readonly string[] _secondaryFormats = new string[27]
		{
			"yyyy-MM-ddTHH:mm:ss.FFF", "yyyy-MM-ddTHH:mm:ss", "yyyy-MM-ddTHH:mm", "ddd MMM dd yyyy HH:mm:ss 'GMT'K", "ddd MMM dd yyyy", "HH:mm:ss 'GMT'K", "yyyy-M-dTH:m:s.FFFK", "yyyy/M/dTH:m:s.FFFK", "yyyy-M-dTH:m:sK", "yyyy/M/dTH:m:sK",
			"yyyy-M-dTH:mK", "yyyy/M/dTH:mK", "yyyy-M-d H:m:s.FFFK", "yyyy/M/d H:m:s.FFFK", "yyyy-M-d H:m:sK", "yyyy/M/d H:m:sK", "yyyy-M-d H:mK", "yyyy/M/d H:mK", "yyyy-M-dK", "yyyy/M/dK",
			"yyyy-MK", "yyyy/MK", "yyyyK", "THH:mm:ss.FFFK", "THH:mm:ssK", "THH:mmK", "THHK"
		};

		private readonly CultureInfo _parsingCulture;

		public TimeZoneInfo DefaultTimeZone { get; }

		public DefaultTimeSystem(TimeZoneInfo timeZoneInfo, CultureInfo parsingCulture)
		{
			_parsingCulture = parsingCulture;
			DefaultTimeZone = timeZoneInfo;
		}

		public virtual DateTimeOffset GetUtcNow()
		{
			return DateTimeOffset.UtcNow;
		}

		public virtual bool TryParse(string date, out long epochMilliseconds)
		{
			epochMilliseconds = long.MinValue;
			if (string.IsNullOrEmpty(date))
			{
				return false;
			}
			if ((date[0] == '+' || date[0] == '-') && date.IndexOf('-', 1) == 7)
			{
				return TryParseLargeYear(date, out epochMilliseconds);
			}
			int num = date.IndexOf('(');
			if (num != -1)
			{
				date = date.Substring(0, num);
			}
			date = date.Trim();
			if (!DateTime.TryParseExact(date, _defaultFormats, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal, out var result) && !DateTime.TryParseExact(date, _secondaryFormats, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out result) && !DateTime.TryParse(date, _parsingCulture, DateTimeStyles.AdjustToUniversal, out result) && !DateTime.TryParse(date, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out result))
			{
				if (DateUtils.TryParse(date, out var date2))
				{
					DateTimeOffset dateTimeOffset = date2.ToUniversalTime();
					epochMilliseconds = (long)Math.Floor((dateTimeOffset - DateConstructor.Epoch).TotalMilliseconds);
					return true;
				}
				return false;
			}
			bool num2 = result.Kind == DateTimeKind.Unspecified;
			DatePresentation datePresentation = (long)(((result.Kind == DateTimeKind.Local) ? result.ToUniversalTime() : DateTime.SpecifyKind(result, DateTimeKind.Utc)) - DateConstructor.Epoch).TotalMilliseconds;
			if (num2)
			{
				double totalMilliseconds = GetUtcOffset(datePresentation.Value).TotalMilliseconds;
				datePresentation -= (DatePresentation)totalMilliseconds;
			}
			epochMilliseconds = datePresentation.Value;
			return true;
		}

		private static bool TryParseLargeYear(string date, out long epochMilliseconds)
		{
			epochMilliseconds = long.MinValue;
			if (!int.TryParse(date.Substring(0, 7), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (result == 0 && date[0] == '-')
			{
				return false;
			}
			if (!DateTime.TryParse("2000" + date.Substring(7), CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out var result2))
			{
				return false;
			}
			DateTime dateTime = result2.ToUniversalTime();
			epochMilliseconds = DatePrototype.MakeDate(DatePrototype.MakeDay(result, dateTime.Month - 1, dateTime.Day), DatePrototype.MakeTime(dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond)).Value;
			return true;
		}

		public virtual TimeSpan GetUtcOffset(long epochMilliseconds)
		{
			if ((epochMilliseconds < -62135596800000L || epochMilliseconds > 253402300799999L) ? true : false)
			{
				return DefaultTimeZone.BaseUtcOffset;
			}
			return DefaultTimeZone.GetUtcOffset(DateTimeOffset.FromUnixTimeMilliseconds(epochMilliseconds));
		}
	}
	internal sealed record EventLoop
	{
		internal readonly Queue<Action> Events = new Queue<Action>();

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			return false;
		}
	}
	internal sealed record ErrorDispatchInfo(ErrorConstructor ErrorConstructor, string? Message = null);
	internal static class ExceptionHelper
	{
		[DoesNotReturn]
		public static void ThrowSyntaxError(Realm realm, string? message = null)
		{
			throw new JavaScriptException(realm.Intrinsics.SyntaxError, message);
		}

		[DoesNotReturn]
		public static void ThrowSyntaxError(Realm realm, string message, in Location location)
		{
			throw new JavaScriptException(realm.Intrinsics.SyntaxError, message).SetJavaScriptLocation(in location);
		}

		[DoesNotReturn]
		public static void ThrowArgumentException(string? message = null)
		{
			ThrowArgumentException(message, null);
		}

		[DoesNotReturn]
		public static void ThrowArgumentException(string? message, string? paramName)
		{
			throw new ArgumentException(message, paramName);
		}

		[DoesNotReturn]
		public static void ThrowReferenceError(Realm realm, Reference reference)
		{
			ThrowReferenceNameError(realm, reference?.ReferencedName?.ToString());
		}

		[DoesNotReturn]
		public static void ThrowReferenceNameError(Realm realm, string? name)
		{
			string message = ((name != null) ? (name + " is not defined") : null);
			ThrowReferenceError(realm, message);
		}

		[DoesNotReturn]
		public static void ThrowReferenceError(Realm realm, string? message)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Location location = (Location)(((??)realm.GlobalObject.Engine.GetLastSyntaxElement()?.Location) ?? default(Location));
			throw new JavaScriptException(realm.Intrinsics.ReferenceError, message).SetJavaScriptLocation(in location);
		}

		[DoesNotReturn]
		public static void ThrowTypeErrorNoEngine(string? message = null, Node? source = null)
		{
			throw new TypeErrorException(message, source);
		}

		[DoesNotReturn]
		public static void ThrowTypeError(Realm realm, string? message = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Location location = (Location)(((??)realm.GlobalObject.Engine.GetLastSyntaxElement()?.Location) ?? default(Location));
			throw new JavaScriptException(realm.Intrinsics.TypeError, message).SetJavaScriptLocation(in location);
		}

		[DoesNotReturn]
		public static void ThrowRangeError(Realm realm, string? message = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Location location = (Location)(((??)realm.GlobalObject.Engine.GetLastSyntaxElement()?.Location) ?? default(Location));
			throw new JavaScriptException(realm.Intrinsics.RangeError, message).SetJavaScriptLocation(in location);
		}

		public static ErrorDispatchInfo CreateUriError(Realm realm, string message)
		{
			return new ErrorDispatchInfo(realm.Intrinsics.UriError, message);
		}

		public static ErrorDispatchInfo CreateRangeError(Realm realm, string message)
		{
			return new ErrorDispatchInfo(realm.Intrinsics.RangeError, message);
		}

		[DoesNotReturn]
		public static void ThrowNotImplementedException(string? message = null)
		{
			throw new NotImplementedException(message);
		}

		[DoesNotReturn]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}

		[DoesNotReturn]
		public static void ThrowTimeoutException()
		{
			throw new TimeoutException();
		}

		[DoesNotReturn]
		public static void ThrowStatementsCountOverflowException()
		{
			throw new StatementsCountOverflowException();
		}

		[DoesNotReturn]
		public static void ThrowArgumentOutOfRangeException()
		{
			throw new ArgumentOutOfRangeException();
		}

		[DoesNotReturn]
		public static void ThrowNotSupportedException(string? message = null)
		{
			throw new NotSupportedException(message);
		}

		[DoesNotReturn]
		public static void ThrowInvalidOperationException(string? message = null, Exception? exception = null)
		{
			throw new InvalidOperationException(message, exception);
		}

		[DoesNotReturn]
		public static void ThrowPromiseRejectedException(JsValue error)
		{
			throw new PromiseRejectedException(error);
		}

		[DoesNotReturn]
		public static void ThrowJavaScriptException(Engine engine, JsValue value, in Completion result)
		{
			throw new JavaScriptException(value).SetJavaScriptCallstack(engine, in result.Location);
		}

		[DoesNotReturn]
		public static void ThrowJavaScriptException(Engine engine, JsValue value, in Location location)
		{
			throw new JavaScriptException(value).SetJavaScriptCallstack(engine, in location);
		}

		[DoesNotReturn]
		public static void ThrowJavaScriptException(ErrorConstructor errorConstructor, string message)
		{
			throw new JavaScriptException(errorConstructor, message);
		}

		[DoesNotReturn]
		public static void ThrowRecursionDepthOverflowException(JintCallStack currentStack)
		{
			string currentExpressionReference = currentStack.Pop().ToString();
			throw new RecursionDepthOverflowException(currentStack, currentExpressionReference);
		}

		[DoesNotReturn]
		public static void ThrowArgumentNullException(string paramName)
		{
			throw new ArgumentNullException(paramName);
		}

		[DoesNotReturn]
		public static void ThrowMeaningfulException(Engine engine, TargetInvocationException exception)
		{
			Exception ex = exception.InnerException ?? exception;
			if (engine.Options.Interop.ExceptionHandler(ex))
			{
				ThrowError(engine, ex.Message);
			}
			ExceptionDispatchInfo.Capture(ex).Throw();
		}

		[DoesNotReturn]
		internal static void ThrowError(Engine engine, string message)
		{
			throw new JavaScriptException(engine.Realm.Intrinsics.Error, message);
		}

		[DoesNotReturn]
		public static void ThrowPlatformNotSupportedException(string message)
		{
			throw new PlatformNotSupportedException(message);
		}

		[DoesNotReturn]
		public static void ThrowMemoryLimitExceededException(string message)
		{
			throw new MemoryLimitExceededException(message);
		}

		[DoesNotReturn]
		public static void ThrowExecutionCanceledException()
		{
			throw new ExecutionCanceledException();
		}

		[DoesNotReturn]
		public static void ThrowModuleResolutionException(string message, string specifier, string? parent, string? filePath = null)
		{
			throw new ModuleResolutionException(message, specifier, parent, filePath);
		}

		[DoesNotReturn]
		public static void ThrowInvalidPreparedScriptArgumentException(string paramName)
		{
			throw new ArgumentException($"Instances of {typeof(Prepared<Script>)} returned by {"PrepareScript"} are allowed only.", paramName);
		}

		[DoesNotReturn]
		public static void ThrowInvalidPreparedModuleArgumentException(string paramName)
		{
			throw new ArgumentException($"Instances of {typeof(Prepared<Module>)} returned by {"PrepareModule"} are allowed only.", paramName);
		}
	}
	public sealed class ExecutionCanceledException : JintException
	{
		public ExecutionCanceledException()
			: base("The script execution was canceled.")
		{
		}
	}
	internal sealed class ExecutionContextStack
	{
		private readonly RefStack<Jint.Runtime.Environments.ExecutionContext> _stack;

		public ExecutionContextStack(int capacity)
		{
			_stack = new RefStack<Jint.Runtime.Environments.ExecutionContext>(capacity);
		}

		public void ReplaceTopLexicalEnvironment(Jint.Runtime.Environments.Environment newEnv)
		{
			Jint.Runtime.Environments.ExecutionContext[] array = _stack._array;
			int size = _stack._size;
			ref Jint.Runtime.Environments.ExecutionContext reference = ref array[size - 1];
			reference = reference.UpdateLexicalEnvironment(newEnv);
		}

		public void ReplaceTopVariableEnvironment(Jint.Runtime.Environments.Environment newEnv)
		{
			Jint.Runtime.Environments.ExecutionContext[] array = _stack._array;
			int size = _stack._size;
			ref Jint.Runtime.Environments.ExecutionContext reference = ref array[size - 1];
			reference = reference.UpdateVariableEnvironment(newEnv);
		}

		public void ReplaceTopPrivateEnvironment(PrivateEnvironment? newEnv)
		{
			Jint.Runtime.Environments.ExecutionContext[] array = _stack._array;
			int size = _stack._size;
			ref Jint.Runtime.Environments.ExecutionContext reference = ref array[size - 1];
			reference = reference.UpdatePrivateEnvironment(newEnv);
		}

		public ref readonly Jint.Runtime.Environments.ExecutionContext ReplaceTopGenerator(GeneratorInstance newEnv)
		{
			Jint.Runtime.Environments.ExecutionContext[] array = _stack._array;
			int size = _stack._size;
			ref Jint.Runtime.Environments.ExecutionContext reference = ref array[size - 1];
			reference = reference.UpdateGenerator(newEnv);
			return ref reference;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref readonly Jint.Runtime.Environments.ExecutionContext Peek()
		{
			return ref _stack.Peek();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref readonly Jint.Runtime.Environments.ExecutionContext Peek(int fromTop)
		{
			return ref _stack.Peek(fromTop);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Push(in Jint.Runtime.Environments.ExecutionContext context)
		{
			_stack.Push(in context);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref readonly Jint.Runtime.Environments.ExecutionContext Pop()
		{
			return ref _stack.Pop();
		}

		public IScriptOrModule? GetActiveScriptOrModule()
		{
			Jint.Runtime.Environments.ExecutionContext[] array = _stack._array;
			for (int num = _stack._size - 1; num > -1; num--)
			{
				ref Jint.Runtime.Environments.ExecutionContext reference = ref array[num];
				if (reference.ScriptOrModule != null)
				{
					return reference.ScriptOrModule;
				}
			}
			return null;
		}

		public ParserOptions? GetActiveParserOptions()
		{
			Jint.Runtime.Environments.ExecutionContext[] array = _stack._array;
			for (int num = _stack._size - 1; num > -1; num--)
			{
				ref Jint.Runtime.Environments.ExecutionContext reference = ref array[num];
				if (reference.ParserOptions != null)
				{
					return reference.ParserOptions;
				}
			}
			return null;
		}
	}
	public class Host
	{
		private Engine? _engine;

		private readonly List<string> _supportedImportAttributes = new List<string>(1) { "type" };

		protected Engine Engine
		{
			get
			{
				if (_engine == null)
				{
					ExceptionHelper.ThrowInvalidOperationException("Initialize has not been called");
				}
				return _engine;
			}
			private set
			{
				_engine = value;
			}
		}

		public void Initialize(Engine engine)
		{
			Engine = engine;
			InitializeHostDefinedRealm();
			PostInitialize();
		}

		protected virtual void PostInitialize()
		{
		}

		protected virtual void InitializeHostDefinedRealm()
		{
			Realm realm = CreateRealm();
			Jint.Runtime.Environments.ExecutionContext context = new Jint.Runtime.Environments.ExecutionContext(null, realm.GlobalEnv, realm.GlobalEnv, null, realm);
			Engine.EnterExecutionContext(in context);
		}

		internal virtual GlobalEnvironment CreateGlobalEnvironment(ObjectInstance globalObject)
		{
			return JintEnvironment.NewGlobalEnvironment(Engine, globalObject, globalObject);
		}

		protected virtual ObjectInstance CreateGlobalObject(Realm realm)
		{
			GlobalObject globalObject = new GlobalObject(Engine, realm);
			globalObject.EnsureInitialized();
			return globalObject;
		}

		protected internal virtual Realm CreateRealm()
		{
			Realm realm = new Realm();
			Engine._realmInConstruction = realm;
			CreateIntrinsics(realm);
			ObjectInstance globalObject = CreateGlobalObject(realm);
			GlobalEnvironment globalEnv = CreateGlobalEnvironment(globalObject);
			realm.GlobalEnv = globalEnv;
			realm.GlobalObject = globalObject;
			Engine._realmInConstruction = null;
			return realm;
		}

		protected virtual void CreateIntrinsics(Realm realmRec)
		{
			Intrinsics intrinsics = new Intrinsics(Engine, realmRec);
			realmRec.Intrinsics = intrinsics;
		}

		public virtual void EnsureCanCompileStrings(Realm callerRealm, Realm evalRealm)
		{
			if (!Engine.Options.StringCompilationAllowed)
			{
				ExceptionHelper.ThrowJavaScriptException(callerRealm.Intrinsics.TypeError, "String compilation has been disabled in engine options");
			}
		}

		internal virtual Jint.Runtime.Modules.Module GetImportedModule(IScriptOrModule? referrer, ModuleRequest request)
		{
			return Engine.Modules.Load(referrer?.Location, request);
		}

		internal virtual void LoadImportedModule(IScriptOrModule? referrer, ModuleRequest moduleRequest, PromiseCapability payload)
		{
			ManualPromise manualPromise = Engine.RegisterPromise();
			try
			{
				Engine.Modules.Import(moduleRequest.Specifier, referrer?.Location);
				manualPromise.Resolve(JsValue.Undefined);
			}
			catch (JavaScriptException ex)
			{
				manualPromise.Reject(ex.Error);
			}
			FinishLoadingImportedModule(referrer, moduleRequest, payload, (JsPromise)manualPromise.Promise);
		}

		internal virtual void FinishLoadingImportedModule(IScriptOrModule? referrer, ModuleRequest moduleRequest, PromiseCapability payload, JsPromise result)
		{
			ClrFunction onFulfilled = new ClrFunction(Engine, "", delegate
			{
				Jint.Runtime.Modules.Module importedModule = GetImportedModule(referrer, moduleRequest);
				try
				{
					ObjectInstance moduleNamespace = Jint.Runtime.Modules.Module.GetModuleNamespace(importedModule);
					payload.Resolve.Call(JsValue.Undefined, moduleNamespace);
				}
				catch (JavaScriptException ex)
				{
					payload.Reject.Call(JsValue.Undefined, ex.Error);
				}
				return JsValue.Undefined;
			}, 0, PropertyFlag.Configurable);
			ClrFunction onRejected = new ClrFunction(Engine, "", delegate(JsValue thisObj, JsValue[] args)
			{
				JsValue jsValue = args.At(0);
				payload.Reject.Call(JsValue.Undefined, jsValue);
				return JsValue.Undefined;
			}, 0, PropertyFlag.Configurable);
			PromiseOperations.PerformPromiseThen(Engine, result, onFulfilled, onRejected, payload);
		}

		public virtual List<KeyValuePair<JsValue, JsValue>> GetImportMetaProperties(Jint.Runtime.Modules.Module moduleRecord)
		{
			return new List<KeyValuePair<JsValue, JsValue>>();
		}

		public virtual void FinalizeImportMeta(ObjectInstance importMeta, Jint.Runtime.Modules.Module moduleRecord)
		{
		}

		public virtual void InitializeShadowRealm(Realm realm)
		{
		}

		internal virtual JobCallback MakeJobCallBack(ICallable cleanupCallback)
		{
			return new JobCallback(cleanupCallback, null);
		}

		internal void HostEnqueuePromiseJob(Action job, Realm realm)
		{
			Engine.AddToEventLoop(job);
		}

		internal virtual List<string> GetSupportedImportAttributes()
		{
			return _supportedImportAttributes;
		}
	}
	internal sealed record JobCallback(ICallable Callback, object? HostDefined);
	[Flags]
	internal enum InternalTypes
	{
		Empty = 0,
		Undefined = 1,
		Null = 2,
		Boolean = 4,
		String = 8,
		Number = 0x10,
		Integer = 0x20,
		Symbol = 0x40,
		BigInt = 0x80,
		Object = 0x100,
		PrivateName = 0x200,
		ObjectEnvironmentRecord = 0x400,
		RequiresCloning = 0x800,
		Module = 0x1000,
		PlainObject = 0x2000,
		Array = 0x4000,
		Primitive = 0xFC,
		InternalFlags = 0x7C00
	}
	public sealed class Intrinsics
	{
		private static readonly JsString _errorFunctionName = new JsString("Error");

		private static readonly JsString _evalErrorFunctionName = new JsString("EvalError");

		private static readonly JsString _rangeErrorFunctionName = new JsString("RangeError");

		private static readonly JsString _referenceErrorFunctionName = new JsString("ReferenceError");

		private static readonly JsString _syntaxErrorFunctionName = new JsString("SyntaxError");

		private static readonly JsString _typeErrorFunctionName = new JsString("TypeError");

		private static readonly JsString _uriErrorFunctionName = new JsString("URIError");

		private readonly Engine _engine;

		private readonly Realm _realm;

		private ThrowTypeError? _throwTypeError;

		private AggregateErrorConstructor? _aggregateError;

		private ErrorConstructor? _error;

		private ErrorConstructor? _evalError;

		private ErrorConstructor? _rangeError;

		private ErrorConstructor? _referenceError;

		private ErrorConstructor? _syntaxError;

		private ErrorConstructor? _typeError;

		private ErrorConstructor? _uriError;

		private WeakMapConstructor? _weakMap;

		private WeakSetConstructor? _weakSet;

		private WeakRefConstructor? _weakRef;

		private PromiseConstructor? _promise;

		private ProxyConstructor? _proxy;

		private ReflectInstance? _reflect;

		private EvalFunction? _eval;

		private DateConstructor? _date;

		private IteratorPrototype? _iteratorPrototype;

		private MathInstance? _math;

		private JsonInstance? _json;

		private SymbolConstructor? _symbol;

		private GeneratorFunctionConstructor? _generatorFunction;

		private RegExpConstructor? _regExp;

		private RegExpStringIteratorPrototype? _regExpStringIteratorPrototype;

		private NumberConstructor? _number;

		private BigIntConstructor? _bigInt;

		private StringConstructor? _string;

		private StringIteratorPrototype? _stringIteratorPrototype;

		private MapConstructor? _map;

		private MapIteratorPrototype? _mapIteratorPrototype;

		private SetConstructor? _set;

		private SetIteratorPrototype? _setIteratorPrototype;

		private ArrayConstructor? _array;

		private ArrayIteratorPrototype? _arrayIteratorPrototype;

		private BooleanConstructor? _boolean;

		private ArrayBufferConstructor? _arrayBufferConstructor;

		private SharedArrayBufferConstructor? _sharedArrayBufferConstructor;

		private DataViewConstructor? _dataView;

		private AsyncFunctionConstructor? _asyncFunction;

		private FinalizationRegistryConstructor? _finalizationRegistry;

		private IntrinsicTypedArrayConstructor? _typedArray;

		private Int8ArrayConstructor? _int8Array;

		private Uint8ArrayConstructor? _uint8Array;

		private Uint8ClampedArrayConstructor? _uint8ClampedArray;

		private Int16ArrayConstructor? _int16Array;

		private Uint16ArrayConstructor? _uint16Array;

		private Int32ArrayConstructor? _int32Array;

		private Uint32ArrayConstructor? _uint32Array;

		private BigInt64ArrayConstructor? _bigInt64Array;

		private BigUint64ArrayConstructor? _bigUint64Array;

		private Float32ArrayConstructor? _float32Array;

		private Float64ArrayConstructor? _float64Array;

		private ShadowRealmConstructor? _shadowRealm;

		private IntlInstance? _intl;

		private CollatorConstructor? _collator;

		private DateTimeFormatConstructor? _dateTimeFormat;

		private DisplayNamesConstructor? _displayNames;

		private ListFormatConstructor? _listFormat;

		private LocaleConstructor? _locale;

		private NumberFormatConstructor? _numberFormat;

		private PluralRulesConstructor? _pluralRules;

		private RelativeTimeFormatConstructor? _relativeTimeFormat;

		private SegmenterConstructor? _segmenter;

		public ObjectConstructor Object { get; }

		public FunctionConstructor Function { get; }

		internal FinalizationRegistryConstructor FinalizationRegistry => _finalizationRegistry ?? (_finalizationRegistry = new FinalizationRegistryConstructor(_engine, _realm, Function, Object.PrototypeObject));

		internal AsyncFunctionConstructor AsyncFunction => _asyncFunction ?? (_asyncFunction = new AsyncFunctionConstructor(_engine, _realm, Function));

		public ArrayConstructor Array => _array ?? (_array = new ArrayConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal AggregateErrorConstructor AggregateError => _aggregateError ?? (_aggregateError = new AggregateErrorConstructor(_engine, _realm, Error));

		internal ArrayIteratorPrototype ArrayIteratorPrototype => _arrayIteratorPrototype ?? (_arrayIteratorPrototype = new ArrayIteratorPrototype(_engine, _realm, IteratorPrototype));

		internal DataViewConstructor DataView => _dataView ?? (_dataView = new DataViewConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		public ArrayBufferConstructor ArrayBuffer => _arrayBufferConstructor ?? (_arrayBufferConstructor = new ArrayBufferConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal SharedArrayBufferConstructor SharedArrayBuffer => _sharedArrayBufferConstructor ?? (_sharedArrayBufferConstructor = new SharedArrayBufferConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal IntrinsicTypedArrayConstructor TypedArray => _typedArray ?? (_typedArray = new IntrinsicTypedArrayConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject, "TypedArray"));

		public Int8ArrayConstructor Int8Array => _int8Array ?? (_int8Array = new Int8ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Uint8ArrayConstructor Uint8Array => _uint8Array ?? (_uint8Array = new Uint8ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Uint8ClampedArrayConstructor Uint8ClampedArray => _uint8ClampedArray ?? (_uint8ClampedArray = new Uint8ClampedArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Int16ArrayConstructor Int16Array => _int16Array ?? (_int16Array = new Int16ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Uint16ArrayConstructor Uint16Array => _uint16Array ?? (_uint16Array = new Uint16ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Int32ArrayConstructor Int32Array => _int32Array ?? (_int32Array = new Int32ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Uint32ArrayConstructor Uint32Array => _uint32Array ?? (_uint32Array = new Uint32ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public BigInt64ArrayConstructor BigInt64Array => _bigInt64Array ?? (_bigInt64Array = new BigInt64ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public BigUint64ArrayConstructor BigUint64Array => _bigUint64Array ?? (_bigUint64Array = new BigUint64ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Float32ArrayConstructor Float32Array => _float32Array ?? (_float32Array = new Float32ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		public Float64ArrayConstructor Float64Array => _float64Array ?? (_float64Array = new Float64ArrayConstructor(_engine, _realm, TypedArray, TypedArray.PrototypeObject));

		internal MapConstructor Map => _map ?? (_map = new MapConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal MapIteratorPrototype MapIteratorPrototype => _mapIteratorPrototype ?? (_mapIteratorPrototype = new MapIteratorPrototype(_engine, _realm, IteratorPrototype));

		internal SetConstructor Set => _set ?? (_set = new SetConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal SetIteratorPrototype SetIteratorPrototype => _setIteratorPrototype ?? (_setIteratorPrototype = new SetIteratorPrototype(_engine, _realm, IteratorPrototype));

		internal WeakMapConstructor WeakMap => _weakMap ?? (_weakMap = new WeakMapConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal WeakSetConstructor WeakSet => _weakSet ?? (_weakSet = new WeakSetConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal WeakRefConstructor WeakRef => _weakRef ?? (_weakRef = new WeakRefConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal PromiseConstructor Promise => _promise ?? (_promise = new PromiseConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal IteratorPrototype IteratorPrototype => _iteratorPrototype ?? (_iteratorPrototype = new IteratorPrototype(_engine, _realm, Object.PrototypeObject));

		internal StringConstructor String => _string ?? (_string = new StringConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal StringIteratorPrototype StringIteratorPrototype => _stringIteratorPrototype ?? (_stringIteratorPrototype = new StringIteratorPrototype(_engine, _realm, IteratorPrototype));

		public RegExpConstructor RegExp => _regExp ?? (_regExp = new RegExpConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal RegExpStringIteratorPrototype RegExpStringIteratorPrototype => _regExpStringIteratorPrototype ?? (_regExpStringIteratorPrototype = new RegExpStringIteratorPrototype(_engine, _realm, IteratorPrototype));

		internal BooleanConstructor Boolean => _boolean ?? (_boolean = new BooleanConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal NumberConstructor Number => _number ?? (_number = new NumberConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal BigIntConstructor BigInt => _bigInt ?? (_bigInt = new BigIntConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal DateConstructor Date => _date ?? (_date = new DateConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal MathInstance Math => _math ?? (_math = new MathInstance(_engine, Object.PrototypeObject));

		internal JsonInstance Json => _json ?? (_json = new JsonInstance(_engine, _realm, Object.PrototypeObject));

		internal ProxyConstructor Proxy => _proxy ?? (_proxy = new ProxyConstructor(_engine, _realm));

		internal ReflectInstance Reflect => _reflect ?? (_reflect = new ReflectInstance(_engine, _realm, Object.PrototypeObject));

		internal SymbolConstructor Symbol => _symbol ?? (_symbol = new SymbolConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		public ShadowRealmConstructor ShadowRealm => _shadowRealm ?? (_shadowRealm = new ShadowRealmConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal GeneratorFunctionConstructor GeneratorFunction => _generatorFunction ?? (_generatorFunction = new GeneratorFunctionConstructor(_engine, _realm, Function.PrototypeObject, IteratorPrototype));

		public EvalFunction Eval => _eval ?? (_eval = new EvalFunction(_engine, _realm, Function.PrototypeObject));

		public ErrorConstructor Error => _error ?? (_error = new ErrorConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject, _errorFunctionName, (Intrinsics intrinsics) => intrinsics.Error.PrototypeObject));

		internal ErrorConstructor EvalError => _evalError ?? (_evalError = new ErrorConstructor(_engine, _realm, Error, Error.PrototypeObject, _evalErrorFunctionName, (Intrinsics intrinsics) => intrinsics.EvalError.PrototypeObject));

		internal ErrorConstructor SyntaxError => _syntaxError ?? (_syntaxError = new ErrorConstructor(_engine, _realm, Error, Error.PrototypeObject, _syntaxErrorFunctionName, (Intrinsics intrinsics) => intrinsics.SyntaxError.PrototypeObject));

		public ErrorConstructor TypeError => _typeError ?? (_typeError = new ErrorConstructor(_engine, _realm, Error, Error.PrototypeObject, _typeErrorFunctionName, (Intrinsics intrinsics) => intrinsics.TypeError.PrototypeObject));

		internal ErrorConstructor RangeError => _rangeError ?? (_rangeError = new ErrorConstructor(_engine, _realm, Error, Error.PrototypeObject, _rangeErrorFunctionName, (Intrinsics intrinsics) => intrinsics.RangeError.PrototypeObject));

		internal ErrorConstructor ReferenceError => _referenceError ?? (_referenceError = new ErrorConstructor(_engine, _realm, Error, Error.PrototypeObject, _referenceErrorFunctionName, (Intrinsics intrinsics) => intrinsics.ReferenceError.PrototypeObject));

		internal ErrorConstructor UriError => _uriError ?? (_uriError = new ErrorConstructor(_engine, _realm, Error, Error.PrototypeObject, _uriErrorFunctionName, (Intrinsics intrinsics) => intrinsics.UriError.PrototypeObject));

		internal ThrowTypeError ThrowTypeError
		{
			get
			{
				ThrowTypeError throwTypeError = _throwTypeError;
				if ((object)throwTypeError == null)
				{
					ThrowTypeError obj = new ThrowTypeError(_engine, _engine.Realm)
					{
						_prototype = _engine.Realm.Intrinsics.Function.PrototypeObject
					};
					ThrowTypeError throwTypeError2 = obj;
					_throwTypeError = obj;
					throwTypeError = throwTypeError2;
				}
				return throwTypeError;
			}
		}

		internal IntlInstance Intl => _intl ?? (_intl = new IntlInstance(_engine, _realm, Object.PrototypeObject));

		internal CollatorConstructor Collator => _collator ?? (_collator = new CollatorConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal DateTimeFormatConstructor DateTimeFormat => _dateTimeFormat ?? (_dateTimeFormat = new DateTimeFormatConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal DisplayNamesConstructor DisplayNames => _displayNames ?? (_displayNames = new DisplayNamesConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal ListFormatConstructor ListFormat => _listFormat ?? (_listFormat = new ListFormatConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal LocaleConstructor Locale => _locale ?? (_locale = new LocaleConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal NumberFormatConstructor NumberFormat => _numberFormat ?? (_numberFormat = new NumberFormatConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal PluralRulesConstructor PluralRules => _pluralRules ?? (_pluralRules = new PluralRulesConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal RelativeTimeFormatConstructor RelativeTimeFormat => _relativeTimeFormat ?? (_relativeTimeFormat = new RelativeTimeFormatConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal SegmenterConstructor Segmenter => _segmenter ?? (_segmenter = new SegmenterConstructor(_engine, _realm, Function.PrototypeObject, Object.PrototypeObject));

		internal Intrinsics(Engine engine, Realm realm)
		{
			_engine = engine;
			_realm = realm;
			_engine._originalIntrinsics = this;
			Object = new ObjectConstructor(engine, realm);
			Function = new FunctionConstructor(engine, realm, Object.PrototypeObject);
			Object._prototype = Function.PrototypeObject;
		}
	}
	internal interface IScriptOrModule
	{
		string? Location { get; }
	}
	internal static class ScriptOrModuleExtensions
	{
		public static Jint.Runtime.Modules.Module AsModule(this IScriptOrModule? scriptOrModule, Engine engine, in Location location)
		{
			if (!(scriptOrModule is Jint.Runtime.Modules.Module result))
			{
				ExceptionHelper.ThrowSyntaxError(engine.Realm, "Cannot use import/export statements outside a module", in location);
				return null;
			}
			return result;
		}
	}
	public interface ITimeSystem
	{
		TimeZoneInfo DefaultTimeZone { get; }

		DateTimeOffset GetUtcNow();

		bool TryParse(string date, out long epochMilliseconds);

		TimeSpan GetUtcOffset(long epochMilliseconds);
	}
	public class JavaScriptException : JintException
	{
		private sealed class JavaScriptErrorWrapperException : JintException
		{
			private string? _callStack;

			private Location _location;

			public JsValue Error { get; }

			public ref readonly Location Location => ref _location;

			public override string? StackTrace
			{
				get
				{
					if (_callStack != null)
					{
						return _callStack;
					}
					if (!(Error is ObjectInstance objectInstance))
					{
						return null;
					}
					JsValue value = objectInstance.Get(CommonProperties.Stack, Error);
					if (!value.IsUndefined())
					{
						return value.AsString();
					}
					return null;
				}
			}

			internal JavaScriptErrorWrapperException(JsValue error, string? message = null)
				: base(message ?? GetMessage(error))
			{
				Error = error;
			}

			internal void SetLocation(in Location location)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				_location = location;
			}

			internal void SetCallstack(Engine engine, in Location location, bool overwriteExisting)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				_location = location;
				ObjectInstance objectInstance = (Error.IsObject() ? Error.AsObject() : null);
				if ((object)objectInstance == null)
				{
					_callStack = engine.CallStack.BuildCallStackString(location);
					return;
				}
				if (objectInstance.HasProperty(CommonProperties.Stack) && !overwriteExisting)
				{
					_callStack = objectInstance.Get(CommonProperties.Stack).AsString();
					return;
				}
				_callStack = engine.CallStack.BuildCallStackString(location);
				objectInstance.FastSetProperty(CommonProperties.Stack._value, new PropertyDescriptor(_callStack, false, false, false));
			}

			public override string ToString()
			{
				System.Text.ValueStringBuilder valueStringBuilder = default(System.Text.ValueStringBuilder);
				valueStringBuilder.Append("Error");
				string message = Message;
				if (!string.IsNullOrEmpty(message))
				{
					valueStringBuilder.Append(": ");
					valueStringBuilder.Append(message);
				}
				string stackTrace = StackTrace;
				if (stackTrace != null)
				{
					valueStringBuilder.Append(System.Environment.NewLine);
					valueStringBuilder.Append(stackTrace);
				}
				return valueStringBuilder.ToString();
			}
		}

		private readonly JavaScriptErrorWrapperException _jsErrorException;

		public string? JavaScriptStackTrace => _jsErrorException.StackTrace;

		public ref readonly Location Location => ref _jsErrorException.Location;

		public JsValue Error => _jsErrorException.Error;

		private static string? GetMessage(JsValue? error)
		{
			string result = null;
			if (error is ObjectInstance objectInstance)
			{
				result = objectInstance.Get(CommonProperties.Message).ToString();
			}
			else if ((object)error != null)
			{
				result = (error.IsSymbol() ? error.ToString() : TypeConverter.ToString(error));
			}
			return result;
		}

		internal JavaScriptException(ErrorConstructor errorConstructor)
			: base("", new JavaScriptErrorWrapperException(errorConstructor.Construct(), ""))
		{
			_jsErrorException = (JavaScriptErrorWrapperException)base.InnerException;
		}

		public JavaScriptException(ErrorConstructor errorConstructor, string? message = null)
			: base(message, new JavaScriptErrorWrapperException(errorConstructor.Construct(message), message))
		{
			_jsErrorException = (JavaScriptErrorWrapperException)base.InnerException;
		}

		public JavaScriptException(JsValue error)
			: base(GetMessage(error), new JavaScriptErrorWrapperException(error, GetMessage(error)))
		{
			_jsErrorException = (JavaScriptErrorWrapperException)base.InnerException;
		}

		public string GetJavaScriptErrorString()
		{
			return _jsErrorException.ToString();
		}

		public JavaScriptException SetJavaScriptCallstack(Engine engine, in Location location, bool overwriteExisting = false)
		{
			_jsErrorException.SetCallstack(engine, in location, overwriteExisting);
			return this;
		}

		public JavaScriptException SetJavaScriptLocation(in Location location)
		{
			_jsErrorException.SetLocation(in location);
			return this;
		}
	}
	public abstract class JintException : Exception
	{
		protected JintException()
		{
		}

		protected JintException(string? message)
			: base(message)
		{
		}

		protected JintException(string? message, Exception? innerException)
			: base(message, innerException)
		{
		}
	}
	internal static class KnownKeys
	{
		internal static readonly Key Arguments = "arguments";

		internal static readonly Key Caller = "caller";

		internal static readonly Key Constructor = "constructor";

		internal static readonly Key Default = "default";

		internal static readonly Key Done = "done";

		internal static readonly Key Eval = "eval";

		internal static readonly Key Length = "length";

		internal static readonly Key Next = "next";

		internal static readonly Key Prototype = "prototype";

		internal static readonly Key Undefined = "undefined";

		internal static readonly Key Value = "value";
	}
	public sealed class MemoryLimitExceededException : JintException
	{
		public MemoryLimitExceededException(string message)
			: base(message)
		{
		}
	}
	[DebuggerDisplay("Count = {Count}")]
	internal sealed class OrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IList<KeyValuePair<TKey, TValue>> where TKey : class where TValue : class
	{
		public sealed class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> parent;

			public int Count => parent.dictionary.Count;

			[EditorBrowsable(EditorBrowsableState.Never)]
			bool ICollection<TKey>.IsReadOnly => true;

			public KeyCollection(OrderedDictionary<TKey, TValue> dictionary)
			{
				parent = dictionary;
			}

			public void CopyTo(TKey[] array, int arrayIndex)
			{
				parent.keys.CopyTo(array, arrayIndex);
			}

			public IEnumerator<TKey> GetEnumerator()
			{
				return parent.keys.GetEnumerator();
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			bool ICollection<TKey>.Contains(TKey item)
			{
				return parent.dictionary.ContainsKey(item);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			void ICollection<TKey>.Add(TKey item)
			{
				ExceptionHelper.ThrowNotSupportedException("An attempt was made to edit a read-only list.");
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			void ICollection<TKey>.Clear()
			{
				ExceptionHelper.ThrowNotSupportedException("An attempt was made to edit a read-only list.");
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			bool ICollection<TKey>.Remove(TKey item)
			{
				ExceptionHelper.ThrowNotSupportedException("An attempt was made to edit a read-only list.");
				return false;
			}

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

		public sealed class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> parent;

			public int Count => parent.dictionary.Count;

			[EditorBrowsable(EditorBrowsableState.Never)]
			bool ICollection<TValue>.IsReadOnly => true;

			public ValueCollection(OrderedDictionary<TKey, TValue> dictionary)
			{
				parent = dictionary;
			}

			public void CopyTo(TValue[] array, int arrayIndex)
			{
				if (arrayIndex < 0)
				{
					ExceptionHelper.ThrowArgumentOutOfRangeException("arrayIndex", string.Format(CultureInfo.InvariantCulture, "The given value cannot be less than {0}.", 0));
				}
				if (parent.dictionary.Count > array.Length - arrayIndex)
				{
					ExceptionHelper.ThrowArgumentException("The given array was too small to hold the items.", "array");
				}
				foreach (TKey key in parent.keys)
				{
					TValue val = parent.dictionary[key];
					array[arrayIndex] = val;
					arrayIndex++;
				}
			}

			public IEnumerator<TValue> GetEnumerator()
			{
				foreach (TKey key in parent.keys)
				{
					yield return parent.dictionary[key];
				}
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			bool ICollection<TValue>.Contains(TValue item)
			{
				return parent.dictionary.ContainsValue(item);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			void ICollection<TValue>.Add(TValue item)
			{
				ExceptionHelper.ThrowNotSupportedException("An attempt was made to edit a read-only list.");
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			void ICollection<TValue>.Clear()
			{
				ExceptionHelper.ThrowNotSupportedException("An attempt was made to edit a read-only list.");
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			bool ICollection<TValue>.Remove(TValue item)
			{
				ExceptionHelper.ThrowNotSupportedException("An attempt was made to edit a read-only list.");
				return false;
			}

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

		private readonly Dictionary<TKey, TValue> dictionary;

		private readonly List<TKey> keys;

		private const string ArrayTooSmall = "The given array was too small to hold the items.";

		private const string EditReadOnlyList = "An attempt was made to edit a read-only list.";

		private const string IndexOutOfRange = "The index is negative or outside the bounds of the collection.";

		private const string TooSmall = "The given value cannot be less than {0}.";

		public KeyCollection Keys => new KeyCollection(this);

		public ValueCollection Values => new ValueCollection(this);

		public TValue this[int index]
		{
			get
			{
				return dictionary[keys[index]];
			}
			set
			{
				dictionary[keys[index]] = value;
			}
		}

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				if (!dictionary.ContainsKey(key))
				{
					keys.Add(key);
				}
				dictionary[key] = value;
			}
		}

		public int Count => dictionary.Count;

		KeyValuePair<TKey, TValue> IList<KeyValuePair<TKey, TValue>>.this[int index]
		{
			get
			{
				TKey key = keys[index];
				TValue value = dictionary[key];
				return new KeyValuePair<TKey, TValue>(key, value);
			}
			set
			{
				TKey val = keys[index];
				if (dictionary.Comparer.Equals(val, value.Key))
				{
					dictionary[value.Key] = value.Value;
					return;
				}
				dictionary.Add(value.Key, value.Value);
				dictionary.Remove(val);
				keys[index] = value.Key;
			}
		}

		ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys;

		ICollection<TValue> IDictionary<TKey, TValue>.Values => Values;

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

		public OrderedDictionary()
		{
			dictionary = new Dictionary<TKey, TValue>();
			keys = new List<TKey>();
		}

		public OrderedDictionary(int capacity)
		{
			dictionary = new Dictionary<TKey, TValue>(capacity);
			keys = new List<TKey>(capacity);
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			dictionary = new Dictionary<TKey, TValue>(comparer);
			keys = new List<TKey>();
		}

		public OrderedDictionary(int capacity, IEqualityComparer<TKey> comparer)
		{
			dictionary = new Dictionary<TKey, TValue>(capacity, comparer);
			keys = new List<TKey>(capacity);
		}

		public void Add(TKey key, TValue value)
		{
			dictionary.Add(key, value);
			keys.Add(key);
		}

		public void Insert(int index, TKey key, TValue value)
		{
			if (index < 0 || index > dictionary.Count)
			{
				ExceptionHelper.ThrowArgumentOutOfRangeException("index", "The index is negative or outside the bounds of the collection.");
			}
			dictionary.Add(key, value);
			keys.Insert(index, key);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public TKey GetKey(int index)
		{
			return keys[index];
		}

		public int IndexOf(TKey key)
		{
			if (!dictionary.ContainsKey(key))
			{
				return -1;
			}
			int count = keys.Count;
			for (int i = 0; i < count; i++)
			{
				if (dictionary.Comparer.Equals(keys[i], key))
				{
					return i;
				}
			}
			return -1;
		}

		public bool Remove(TKey key)
		{
			if (dictionary.Remove(key))
			{
				int count = keys.Count;
				for (int i = 0; i < count; i++)
				{
					if (dictionary.Comparer.Equals(keys[i], key))
					{
						keys.RemoveAt(i);
						break;
					}
				}
				return true;
			}
			return false;
		}

		public void RemoveAt(int index)
		{
			TKey key = keys[index];
			dictionary.Remove(key);
			keys.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

		public void Clear()
		{
			dictionary.Clear();
			keys.Clear();
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			foreach (TKey key in keys)
			{
				yield return new KeyValuePair<TKey, TValue>(key, dictionary[key]);
			}
		}

		int IList<KeyValuePair<TKey, TValue>>.IndexOf(KeyValuePair<TKey, TValue> item)
		{
			if (!dictionary.TryGetValue(item.Key, out var value))
			{
				return -1;
			}
			if (!object.Equals(item.Value, value))
			{
				return -1;
			}
			int count = keys.Count;
			for (int i = 0; i < count; i++)
			{
				if (dictionary.Comparer.Equals(keys[i], item.Key))
				{
					return i;
				}
			}
			return -1;
		}

		void IList<KeyValuePair<TKey, TValue>>.Insert(int index, KeyValuePair<TKey, TValue> item)
		{
			if (index < 0 || index > dictionary.Count)
			{
				ExceptionHelper.ThrowArgumentOutOfRangeException("index", "The index is negative or outside the bounds of the collection.");
			}
			dictionary.Add(item.Key, item.Value);
			keys.Insert(index, item.Key);
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			dictionary.Add(item.Key, item.Value);
			keys.Add(item.Key);
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
		{
			if (!dictionary.TryGetValue(item.Key, out var value))
			{
				return false;
			}
			return object.Equals(value, item.Value);
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			if (array == null)
			{
				ExceptionHelper.ThrowArgumentNullException("array");
				return;
			}
			if (arrayIndex < 0)
			{
				ExceptionHelper.ThrowArgumentOutOfRangeException("arrayIndex", string.Format(CultureInfo.CurrentCulture, "The given value cannot be less than {0}.", 0));
			}
			if (dictionary.Count > array.Length - arrayIndex)
			{
				ExceptionHelper.ThrowArgumentException("The given array was too small to hold the items.", "array");
			}
			foreach (TKey key in keys)
			{
				TValue value = dictionary[key];
				array[arrayIndex] = new KeyValuePair<TKey, TValue>(key, value);
				arrayIndex++;
			}
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			if (!dictionary.TryGetValue(item.Key, out var value))
			{
				return false;
			}
			if (!object.Equals(item.Value, value))
			{
				return false;
			}
			dictionary.Remove(item.Key);
			int count = keys.Count;
			for (int i = 0; i < count; i++)
			{
				if (dictionary.Comparer.Equals(keys[i], item.Key))
				{
					keys.RemoveAt(i);
				}
			}
			return true;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal sealed class OrderedSet<T>
	{
		internal List<T> _list;

		internal HashSet<T> _set;

		public T this[int index]
		{
			get
			{
				return _list[index];
			}
			set
			{
				if (_set.Add(value))
				{
					_list[index] = value;
				}
			}
		}

		public int Count => _list.Count;

		public OrderedSet(HashSet<T> values)
		{
			_list = new List<T>(values);
			_set = new HashSet<T>(values);
		}

		public OrderedSet(IEqualityComparer<T> comparer)
		{
			_list = new List<T>();
			_set = new HashSet<T>(comparer);
		}

		public OrderedSet<T> Clone()
		{
			return new OrderedSet<T>(EqualityComparer<T>.Default)
			{
				_set = new HashSet<T>(_set, _set.Comparer),
				_list = new List<T>(_list)
			};
		}

		public void Add(T item)
		{
			if (_set.Add(item))
			{
				_list.Add(item);
			}
		}

		public void Clear()
		{
			_list.Clear();
			_set.Clear();
		}

		public bool Contains(T item)
		{
			return _set.Contains(item);
		}

		public bool Remove(T item)
		{
			_set.Remove(item);
			return _list.Remove(item);
		}
	}
	public sealed class PromiseRejectedException : JintException
	{
		public JsValue RejectedValue { get; }

		public PromiseRejectedException(JsValue value)
			: base($"Promise was rejected with value {value}")
		{
			RejectedValue = value;
		}
	}
	internal sealed class RangeErrorException : JintException
	{
		public RangeErrorException(string message)
			: base(message)
		{
		}
	}
	public sealed class Realm
	{
		internal readonly Dictionary<Node, JsArray> _templateMap = new Dictionary<Node, JsArray>();

		public Intrinsics Intrinsics { get; internal set; }

		public ObjectInstance GlobalObject { get; internal set; }

		internal GlobalEnvironment GlobalEnv { get; set; }

		public object? HostDefined { get; set; }
	}
	public sealed class RecursionDepthOverflowException : JintException
	{
		public string CallChain { get; }

		public string CallExpressionReference { get; }

		internal RecursionDepthOverflowException(JintCallStack currentStack, string currentExpressionReference)
			: base("The recursion is forbidden by script host.")
		{
			CallExpressionReference = currentExpressionReference;
			CallChain = currentStack.ToString();
		}
	}
	public sealed class Reference
	{
		private JsValue _base;

		private JsValue _referencedName;

		internal bool _strict;

		private JsValue? _thisValue;

		public JsValue Base
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _base;
			}
		}

		public JsValue ReferencedName
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _referencedName;
			}
		}

		public bool Strict
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _strict;
			}
		}

		public bool HasPrimitiveBase
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_base._type & InternalTypes.Primitive) != 0;
			}
		}

		public bool IsUnresolvableReference
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _base._type == InternalTypes.Undefined;
			}
		}

		public bool IsSuperReference => (object)_thisValue != null;

		public bool IsPropertyReference
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_base._type & (InternalTypes.Primitive | InternalTypes.Object)) != 0;
			}
		}

		public JsValue ThisValue
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (!IsSuperReference)
				{
					return Base;
				}
				return _thisValue;
			}
		}

		public bool IsPrivateReference
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _referencedName._type == InternalTypes.PrivateName;
			}
		}

		internal Reference(JsValue baseValue, JsValue referencedName, bool strict, JsValue? thisValue = null)
		{
			_base = baseValue;
			_referencedName = referencedName;
			_thisValue = thisValue;
		}

		internal Reference Reassign(JsValue baseValue, JsValue name, bool strict, JsValue? thisValue)
		{
			_base = baseValue;
			_referencedName = name;
			_strict = strict;
			_thisValue = thisValue;
			return this;
		}

		internal void AssertValid(Realm realm)
		{
			if (_strict && (_base._type & InternalTypes.ObjectEnvironmentRecord) != InternalTypes.Empty && (CommonProperties.Eval.Equals(_referencedName) || CommonProperties.Arguments.Equals(_referencedName)))
			{
				ExceptionHelper.ThrowSyntaxError(realm);
			}
		}

		internal void InitializeReferencedBinding(JsValue value)
		{
			((Jint.Runtime.Environments.Environment)_base).InitializeBinding(TypeConverter.ToString(_referencedName), value);
		}

		internal void EvaluateAndCachePropertyKey()
		{
			if (!_referencedName.IsInteger() || !_base.IsIntegerIndexedArray)
			{
				_referencedName = TypeConverter.ToPropertyKey(_referencedName);
			}
		}
	}
	internal sealed record ScriptRecord(Realm Realm, Script EcmaScriptCode, string? Location) : IScriptOrModule;
	public sealed class StatementsCountOverflowException : JintException
	{
		public StatementsCountOverflowException()
			: base("The maximum number of statements executed have been reached.")
		{
		}
	}
	public static class TypeConverter
	{
		private const double DoubleIsIntegerTolerance = 4.94E-322;

		private static readonly string[] intToString;

		private static readonly string[] charToString;

		static TypeConverter()
		{
			intToString = new string[1024];
			charToString = new string[256];
			for (int i = 0; i < intToString.Length; i++)
			{
				intToString[i] = i.ToString(CultureInfo.InvariantCulture);
			}
			for (int j = 0; j < charToString.Length; j++)
			{
				charToString[j] = ((char)j).ToString();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsValue ToPrimitive(JsValue input, Types preferredType = Types.Empty)
		{
			if (input is ObjectInstance oi)
			{
				return ToPrimitiveObjectInstance(oi, preferredType);
			}
			return input;
		}

		private static JsValue ToPrimitiveObjectInstance(ObjectInstance oi, Types preferredType)
		{
			ICallable method = oi.GetMethod(GlobalSymbolRegistry.ToPrimitive);
			if (method != null)
			{
				JsString jsString = preferredType switch
				{
					Types.String => JsString.StringString, 
					Types.Number => JsString.NumberString, 
					_ => JsString.DefaultString, 
				};
				JsValue jsValue = method.Call(oi, jsString);
				if (jsValue.IsPrimitive())
				{
					return jsValue;
				}
				if (jsValue.IsObject())
				{
					ExceptionHelper.ThrowTypeError(oi.Engine.Realm, "Cannot convert object to primitive value");
				}
			}
			return OrdinaryToPrimitive(oi, (preferredType == Types.Empty) ? Types.Number : preferredType);
		}

		internal static JsValue OrdinaryToPrimitive(ObjectInstance input, Types hint = Types.Empty)
		{
			JsString property;
			JsString property2;
			switch (hint)
			{
			case Types.String:
				property = (JsString)(JsValue)"toString";
				property2 = (JsString)(JsValue)"valueOf";
				break;
			case Types.Number:
				property = (JsString)(JsValue)"valueOf";
				property2 = (JsString)(JsValue)"toString";
				break;
			default:
				ExceptionHelper.ThrowTypeError(input.Engine.Realm);
				return null;
			}
			if (input.Get(property) is ICallable callable)
			{
				JsValue jsValue = callable.Call(input, Arguments.Empty);
				if (jsValue.IsPrimitive())
				{
					return jsValue;
				}
			}
			if (input.Get(property2) is ICallable callable2)
			{
				JsValue jsValue2 = callable2.Call(input, Arguments.Empty);
				if (jsValue2.IsPrimitive())
				{
					return jsValue2;
				}
			}
			ExceptionHelper.ThrowTypeError(input.Engine.Realm);
			return null;
		}

		public static bool ToBoolean(JsValue o)
		{
			return o.ToBoolean();
		}

		public static JsValue ToNumeric(JsValue value)
		{
			if (value.IsNumber() || value.IsBigInt())
			{
				return value;
			}
			JsValue jsValue = ToPrimitive(value, Types.Number);
			if (jsValue.IsBigInt())
			{
				return jsValue;
			}
			return ToNumber(jsValue);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double ToNumber(JsValue o)
		{
			if (!o.IsNumber())
			{
				return ToNumberUnlikely(o);
			}
			return ((JsNumber)o)._value;
		}

		private static double ToNumberUnlikely(JsValue o)
		{
			InternalTypes internalTypes = o._type & ~InternalTypes.InternalFlags;
			switch (internalTypes)
			{
			case InternalTypes.Undefined:
				return double.NaN;
			case InternalTypes.Null:
				return 0.0;
			case InternalTypes.Boolean:
				return ((JsBoolean)o)._value ? 1 : 0;
			case InternalTypes.String:
				return ToNumber(o.ToString());
			case InternalTypes.Empty:
			case InternalTypes.Symbol:
			case InternalTypes.BigInt:
				ExceptionHelper.ThrowTypeErrorNoEngine("Cannot convert a " + internalTypes.ToString() + " value to a number");
				return 0.0;
			default:
				return ToNumber(ToPrimitive(o, Types.Number));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsNumber ToJsNumber(JsValue o)
		{
			if (!o.IsNumber())
			{
				return ToJsNumberUnlikely(o);
			}
			return (JsNumber)o;
		}

		private static JsNumber ToJsNumberUnlikely(JsValue o)
		{
			InternalTypes internalTypes = o._type & ~InternalTypes.InternalFlags;
			switch (internalTypes)
			{
			case InternalTypes.Undefined:
				return JsNumber.DoubleNaN;
			case InternalTypes.Null:
				return JsNumber.PositiveZero;
			case InternalTypes.Boolean:
				if (!((JsBoolean)o)._value)
				{
					return JsNumber.PositiveZero;
				}
				return JsNumber.PositiveOne;
			case InternalTypes.String:
				return new JsNumber(ToNumber(o.ToString()));
			case InternalTypes.Empty:
			case InternalTypes.Symbol:
			case InternalTypes.BigInt:
				ExceptionHelper.ThrowTypeErrorNoEngine("Cannot convert a " + internalTypes.ToString() + " value to a number");
				return JsNumber.PositiveZero;
			default:
				return new JsNumber(ToNumber(ToPrimitive(o, Types.Number)));
			}
		}

		private static double ToNumber(string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				return 0.0;
			}
			char c = input[0];
			if (input.Length == 1)
			{
				if (c < '0' || c > '9')
				{
					return double.NaN;
				}
				return c - 48;
			}
			input = StringPrototype.TrimEx(input);
			c = input[0];
			if (long.TryParse(input, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				if (result != 0L || c != '-')
				{
					return result;
				}
				return -0.0;
			}
			int length = input.Length;
			if ((uint)(length - 8) <= 1u)
			{
				switch (input)
				{
				case "+Infinity":
				case "Infinity":
					return double.PositiveInfinity;
				case "-Infinity":
					return double.NegativeInfinity;
				}
				if (input.EndsWith("infinity", StringComparison.OrdinalIgnoreCase))
				{
					return double.NaN;
				}
			}
			if (input.Length > 2 && c == '0' && char.IsLetter(input[1]))
			{
				switch (input[1])
				{
				case 'X':
				case 'x':
					length = 16;
					break;
				case 'O':
				case 'o':
					length = 8;
					break;
				case 'B':
				case 'b':
					length = 2;
					break;
				default:
					length = 0;
					break;
				}
				int num = length;
				if (num > 0)
				{
					try
					{
						return Convert.ToInt32(input.Substring(2), num);
					}
					catch
					{
						return double.NaN;
					}
				}
			}
			if (double.TryParse(input, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				if (result2 != 0.0 || c != '-')
				{
					return result2;
				}
				return -0.0;
			}
			return double.NaN;
		}

		public static ulong ToLength(JsValue o)
		{
			double num = ToInteger(o);
			if (num <= 0.0)
			{
				return 0uL;
			}
			return (ulong)Math.Min(num, 9007199254740991.0);
		}

		public static double ToIntegerOrInfinity(JsValue argument)
		{
			double num = ToNumber(argument);
			if (double.IsNaN(num) || num == 0.0)
			{
				return 0.0;
			}
			if (double.IsInfinity(num))
			{
				return num;
			}
			long num2 = (long)Math.Floor(Math.Abs(num));
			if (num < 0.0)
			{
				num2 *= -1;
			}
			return num2;
		}

		public static double ToInteger(JsValue o)
		{
			return ToInteger(ToNumber(o));
		}

		internal static double ToInteger(double number)
		{
			if (double.IsNaN(number))
			{
				return 0.0;
			}
			if (number == 0.0 || double.IsInfinity(number))
			{
				return number;
			}
			if (number >= -9.223372036854776E+18 && number <= 9.223372036854776E+18)
			{
				return (long)number;
			}
			double num = Math.Floor(Math.Abs(number));
			if (number < 0.0)
			{
				num *= -1.0;
			}
			return num;
		}

		internal static int DoubleToInt32Slow(double o)
		{
			long num = BitConverter.DoubleToInt64Bits(o);
			int num2 = (int)(num >> 63);
			int num3 = (int)((num >> 52) & 0x7FF) - 1023;
			if ((uint)num3 >= 84u)
			{
				return 0;
			}
			long num4 = (num & 0xFFFFFFFFFFFFFL) | 0x10000000000000L;
			return ((int)((num3 >= 52) ? (num4 << num3 - 52) : (num4 >> 52 - num3)) + num2) ^ num2;
		}

		public static int ToInt32(JsValue o)
		{
			if (o._type == InternalTypes.Integer)
			{
				return o.AsInteger();
			}
			double num = ToNumber(o);
			if (num >= 2147483648.0 && num <= 2147483647.0)
			{
				return (int)num;
			}
			return DoubleToInt32Slow(num);
		}

		public static uint ToUint32(JsValue o)
		{
			if (o._type == InternalTypes.Integer)
			{
				return (uint)o.AsInteger();
			}
			double num = ToNumber(o);
			if (num >= 0.0 && num <= 4294967295.0)
			{
				return (uint)num;
			}
			return (uint)DoubleToInt32Slow(num);
		}

		public static ushort ToUint16(JsValue o)
		{
			if (o._type == InternalTypes.Integer)
			{
				int num = o.AsInteger();
				if (num >= 0 && num <= 65535)
				{
					return (ushort)num;
				}
			}
			double num2 = ToNumber(o);
			if (double.IsNaN(num2) || num2 == 0.0 || double.IsInfinity(num2))
			{
				return 0;
			}
			double num3 = Math.Floor(Math.Abs(num2));
			if (num2 < 0.0)
			{
				num3 *= -1.0;
			}
			return (ushort)(num3 % 65536.0);
		}

		internal static double ToInt16(JsValue o)
		{
			return (o._type == InternalTypes.Integer) ? ((short)o.AsInteger()) : ((short)(long)ToNumber(o));
		}

		internal static double ToInt8(JsValue o)
		{
			return (o._type == InternalTypes.Integer) ? ((sbyte)o.AsInteger()) : ((sbyte)(long)ToNumber(o));
		}

		internal static double ToUint8(JsValue o)
		{
			return (int)((o._type == InternalTypes.Integer) ? ((byte)o.AsInteger()) : ((byte)(long)ToNumber(o)));
		}

		internal static byte ToUint8Clamp(JsValue o)
		{
			if (o._type == InternalTypes.Integer)
			{
				int num = o.AsInteger();
				if (num > -1 && num < 256)
				{
					return (byte)num;
				}
			}
			return ToUint8ClampUnlikely(o);
		}

		private static byte ToUint8ClampUnlikely(JsValue o)
		{
			double num = ToNumber(o);
			if (double.IsNaN(num))
			{
				return 0;
			}
			if (num <= 0.0)
			{
				return 0;
			}
			if (num >= 255.0)
			{
				return byte.MaxValue;
			}
			double num2 = Math.Floor(num);
			if (num2 + 0.5 < num)
			{
				return (byte)(num2 + 1.0);
			}
			if (num < num2 + 0.5)
			{
				return (byte)num2;
			}
			if (num2 % 2.0 != 0.0)
			{
				return (byte)(num2 + 1.0);
			}
			return (byte)num2;
		}

		public static BigInteger ToBigInt(JsValue value)
		{
			if (!(value is JsBigInt jsBigInt))
			{
				return ToBigIntUnlikely(value);
			}
			return jsBigInt._value;
		}

		private static BigInteger ToBigIntUnlikely(JsValue value)
		{
			JsValue jsValue = ToPrimitive(value, Types.Number);
			switch (jsValue.Type)
			{
			case Types.BigInt:
				return ((JsBigInt)jsValue)._value;
			case Types.Boolean:
				if (!((JsBoolean)jsValue)._value)
				{
					return BigInteger.Zero;
				}
				return BigInteger.One;
			case Types.String:
				return StringToBigInt(jsValue.ToString());
			default:
				ExceptionHelper.ThrowTypeErrorNoEngine("Cannot convert a " + jsValue.Type.ToString() + " to a BigInt");
				return BigInteger.One;
			}
		}

		public static JsBigInt ToJsBigInt(JsValue value)
		{
			return (value as JsBigInt) ?? ToJsBigIntUnlikely(value);
		}

		private static JsBigInt ToJsBigIntUnlikely(JsValue value)
		{
			JsValue jsValue = ToPrimitive(value, Types.Number);
			switch (jsValue.Type)
			{
			case Types.BigInt:
				return (JsBigInt)jsValue;
			case Types.Boolean:
				if (!((JsBoolean)jsValue)._value)
				{
					return JsBigInt.Zero;
				}
				return JsBigInt.One;
			case Types.String:
				return new JsBigInt(StringToBigInt(jsValue.ToString()));
			default:
				ExceptionHelper.ThrowTypeErrorNoEngine("Cannot convert a " + jsValue.Type.ToString() + " to a BigInt");
				return JsBigInt.One;
			}
		}

		internal static BigInteger StringToBigInt(string str)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!TryStringToBigInt(str, out var result))
			{
				throw new ParserException(" Cannot convert " + str + " to a BigInt", (Exception)null, (ParseError)null);
			}
			return result;
		}

		internal static bool TryStringToBigInt(string str, out BigInteger result)
		{
			if (string.IsNullOrWhiteSpace(str))
			{
				result = BigInteger.Zero;
				return true;
			}
			str = str.Trim();
			for (int i = 0; i < str.Length; i++)
			{
				char c = str[i];
				if (char.IsDigit(c) || (i == 0 && (c == '-' || Character.IsDecimalDigit(c))) || (i != 1 && Character.IsHexDigit(c)))
				{
					continue;
				}
				bool flag = i == 1;
				if (flag)
				{
					bool flag2 = Character.IsDecimalDigit(c);
					if (!flag2)
					{
						bool flag3;
						switch (c)
						{
						case 'B':
						case 'O':
						case 'X':
						case 'b':
						case 'o':
						case 'x':
							flag3 = true;
							break;
						default:
							flag3 = false;
							break;
						}
						flag2 = flag3;
					}
					flag = flag2;
				}
				if (!flag)
				{
					result = default(BigInteger);
					return false;
				}
			}
			if (BigInteger.TryParse(str, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
			{
				return true;
			}
			if (str.Length > 2)
			{
				if (str.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
				{
					ReadOnlySpan<char> value = str.AsSpan(2);
					char c2 = value[0];
					if (c2 > '\a' && Character.IsHexDigit(c2))
					{
						value = "0" + value;
					}
					if (BigInteger.TryParse(value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out result))
					{
						return true;
					}
				}
				else
				{
					if (str.StartsWith("0o", StringComparison.OrdinalIgnoreCase) && Character.IsOctalDigit(str[2]))
					{
						BigInteger bigInteger = default(BigInteger);
						for (int j = 2; j < str.Length; j++)
						{
							char c3 = str[j];
							if (!Character.IsHexDigit(c3))
							{
								return false;
							}
							bigInteger = bigInteger * 8 + (ushort)c3 - (ushort)48;
						}
						result = bigInteger;
						return true;
					}
					if (str.StartsWith("0b", StringComparison.OrdinalIgnoreCase) && Character.IsDecimalDigit(str[2]))
					{
						BigInteger bigInteger2 = default(BigInteger);
						for (int k = 2; k < str.Length; k++)
						{
							char c4 = str[k];
							if (c4 != '0' && c4 != '1')
							{
								return false;
							}
							bigInteger2 <<= 1;
							bigInteger2 += (BigInteger)((c4 == '1') ? 1 : 0);
						}
						result = bigInteger2;
						return true;
					}
				}
			}
			return false;
		}

		internal static long ToBigInt64(BigInteger value)
		{
			BigInteger bigInteger = BigIntegerModulo(value, BigInteger.Pow(2, 64));
			if (bigInteger >= BigInteger.Pow(2, 63))
			{
				return (long)(bigInteger - BigInteger.Pow(2, 64));
			}
			return (long)bigInteger;
		}

		internal static ulong ToBigUint64(BigInteger value)
		{
			return (ulong)BigIntegerModulo(value, BigInteger.Pow(2, 64));
		}

		internal static BigInteger BigIntegerModulo(BigInteger a, BigInteger n)
		{
			if ((!((a %= n) < 0L) || !(n > 0L)) && (!(a > 0L) || !(n < 0L)))
			{
				return a;
			}
			return a + n;
		}

		internal static double? CanonicalNumericIndexString(JsValue value)
		{
			if (value is JsNumber jsNumber)
			{
				return jsNumber._value;
			}
			if (value is JsString jsString)
			{
				if (string.Equals(jsString.ToString(), "-0", StringComparison.Ordinal))
				{
					return JsNumber.NegativeZero._value;
				}
				double num = ToNumber(value);
				if (!JsValue.SameValue(ToString(num), value))
				{
					return null;
				}
				return num;
			}
			return null;
		}

		public static uint ToIndex(Realm realm, JsValue value)
		{
			if (value.IsUndefined())
			{
				return 0u;
			}
			double num = ToIntegerOrInfinity(value);
			if (num < 0.0)
			{
				ExceptionHelper.ThrowRangeError(realm);
			}
			ulong num2 = ToLength(num);
			if (num != (double)num2)
			{
				ExceptionHelper.ThrowRangeError(realm, "Invalid index");
			}
			return (uint)Math.Min(4294967295uL, num2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string ToString(long i)
		{
			string[] array = intToString;
			if ((ulong)i >= (ulong)array.Length)
			{
				return i.ToString(CultureInfo.InvariantCulture);
			}
			return array[i];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string ToString(int i)
		{
			string[] array = intToString;
			if ((uint)i >= (uint)array.Length)
			{
				return i.ToString(CultureInfo.InvariantCulture);
			}
			return array[i];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string ToString(uint i)
		{
			string[] array = intToString;
			if (i >= (uint)array.Length)
			{
				return i.ToString(CultureInfo.InvariantCulture);
			}
			return array[i];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string ToString(char c)
		{
			string[] array = charToString;
			if ((uint)c >= (uint)array.Length)
			{
				return c.ToString();
			}
			return array[(uint)c];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string ToString(ulong i)
		{
			string[] array = intToString;
			if (i >= (ulong)array.Length)
			{
				return i.ToString(CultureInfo.InvariantCulture);
			}
			return array[i];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string ToString(double d)
		{
			if (CanBeStringifiedAsLong(d))
			{
				return ToString((long)d);
			}
			return NumberPrototype.ToNumberString(d);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool CanBeStringifiedAsLong(double d)
		{
			if (d > -9.223372036854776E+18 && d < 9.223372036854776E+18)
			{
				return Math.Abs(d % 1.0) <= 4.94E-322;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string ToString(BigInteger bigInteger)
		{
			return bigInteger.ToString(CultureInfo.InvariantCulture);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static JsValue ToPropertyKey(JsValue o)
		{
			if ((o._type & (InternalTypes.String | InternalTypes.Symbol | InternalTypes.PrivateName)) == 0)
			{
				return ToPropertyKeyNonString(o);
			}
			return o;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static JsValue ToPropertyKeyNonString(JsValue o)
		{
			JsValue jsValue = ToPrimitive(o, Types.String);
			if ((jsValue._type & (InternalTypes.String | InternalTypes.Symbol | InternalTypes.PrivateName)) == 0)
			{
				return ToStringNonString(jsValue);
			}
			return jsValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string ToString(JsValue o)
		{
			if (!o.IsString())
			{
				return ToStringNonString(o);
			}
			return o.ToString();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static JsString ToJsString(JsValue o)
		{
			if (o is JsString result)
			{
				return result;
			}
			return JsString.Create(ToStringNonString(o));
		}

		private static string ToStringNonString(JsValue o)
		{
			switch (o._type & ~InternalTypes.InternalFlags)
			{
			case InternalTypes.Boolean:
				if (!((JsBoolean)o)._value)
				{
					return "false";
				}
				return "true";
			case InternalTypes.Integer:
				return ToString((int)((JsNumber)o)._value);
			case InternalTypes.Number:
				return ToString(((JsNumber)o)._value);
			case InternalTypes.BigInt:
				return ToString(((JsBigInt)o)._value);
			case InternalTypes.Symbol:
				ExceptionHelper.ThrowTypeErrorNoEngine("Cannot convert a Symbol value to a string");
				return null;
			case InternalTypes.Undefined:
				return "undefined";
			case InternalTypes.Null:
				return "null";
			case InternalTypes.PrivateName:
				return o.ToString();
			case InternalTypes.Object:
				if (o is IObjectWrapper objectWrapper)
				{
					return objectWrapper.Target?.ToString();
				}
				break;
			}
			return ToString(ToPrimitive(o, Types.String));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ObjectInstance ToObject(Realm realm, JsValue value)
		{
			if (value is ObjectInstance result)
			{
				return result;
			}
			return ToObjectNonObject(realm, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsIntegralNumber(double value)
		{
			if (!double.IsNaN(value) && !double.IsInfinity(value))
			{
				return value % 1.0 == 0.0;
			}
			return false;
		}

		private static ObjectInstance ToObjectNonObject(Realm realm, JsValue value)
		{
			InternalTypes internalTypes = value._type & ~InternalTypes.InternalFlags;
			Intrinsics intrinsics = realm.Intrinsics;
			switch (internalTypes)
			{
			case InternalTypes.Boolean:
				return intrinsics.Boolean.Construct((JsBoolean)value);
			case InternalTypes.Number:
			case InternalTypes.Integer:
				return intrinsics.Number.Construct((JsNumber)value);
			case InternalTypes.BigInt:
				return intrinsics.BigInt.Construct((JsBigInt)value);
			case InternalTypes.String:
				return intrinsics.String.Construct((value as JsString) ?? JsString.Create(value.ToString()));
			case InternalTypes.Symbol:
				return intrinsics.Symbol.Construct((JsSymbol)value);
			case InternalTypes.Undefined:
			case InternalTypes.Null:
				ExceptionHelper.ThrowTypeError(realm, "Cannot convert undefined or null to object");
				return null;
			default:
				ExceptionHelper.ThrowTypeError(realm, "Cannot convert given item to object");
				return null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void CheckObjectCoercible(Engine engine, JsValue o, Node sourceNode, string referenceName)
		{
			if (!engine._referenceResolver.CheckCoercible(o))
			{
				ThrowMemberNullOrUndefinedError(engine, o, sourceNode, referenceName);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowMemberNullOrUndefinedError(Engine engine, JsValue o, Node sourceNode, string referencedName)
		{
			if (referencedName == null)
			{
				referencedName = "unknown";
			}
			string message = $"Cannot read property '{referencedName}' of {o}";
			throw new JavaScriptException(engine.Realm.Intrinsics.TypeError, message).SetJavaScriptCallstack(engine, in ((SyntaxElement)sourceNode).Location, overwriteExisting: true);
		}

		public static void CheckObjectCoercible(Engine engine, JsValue o)
		{
			if (o._type < InternalTypes.Boolean)
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, "Cannot call method on " + o);
			}
		}
	}
	internal sealed class TypeErrorException : JintException
	{
		public Node? Node { get; }

		public TypeErrorException(string? message, Node? node)
			: base(message)
		{
			Node = node;
		}
	}
	[Flags]
	public enum Types
	{
		Empty = 0,
		Undefined = 1,
		Null = 2,
		Boolean = 4,
		String = 8,
		Number = 0x10,
		Symbol = 0x40,
		BigInt = 0x80,
		Object = 0x100
	}
}
namespace Jint.Runtime.Modules
{
	internal sealed class BuilderModule : SourceTextModule
	{
		private List<KeyValuePair<string, JsValue>> _exportBuilderDeclarations = new List<KeyValuePair<string, JsValue>>();

		internal BuilderModule(Engine engine, Realm realm, in Prepared<Module> source, string? location, bool async)
			: base(engine, realm, in source, location, async)
		{
		}

		internal void BindExportedValue(string name, JsValue value)
		{
			if ((object)_environment != null)
			{
				ExceptionHelper.ThrowInvalidOperationException("Cannot bind exported values after the environment has been initialized");
			}
			if (_exportBuilderDeclarations == null)
			{
				_exportBuilderDeclarations = new List<KeyValuePair<string, JsValue>>();
			}
			_exportBuilderDeclarations.Add(new KeyValuePair<string, JsValue>(name, value));
		}

		protected override void InitializeEnvironment()
		{
			base.InitializeEnvironment();
			if (_exportBuilderDeclarations != null)
			{
				for (int i = 0; i < _exportBuilderDeclarations.Count; i++)
				{
					KeyValuePair<string, JsValue> keyValuePair = _exportBuilderDeclarations[i];
					_environment.CreateImmutableBindingAndInitialize(keyValuePair.Key, strict: true, keyValuePair.Value);
					_localExportEntries.Add(new ExportEntry(keyValuePair.Key, null, null, keyValuePair.Key));
				}
				_exportBuilderDeclarations.Clear();
			}
		}
	}
	internal sealed record ResolvedBinding(Module Module, string BindingName)
	{
		internal static ResolvedBinding Ambiguous => new ResolvedBinding(null, "ambiguous");
	}
	public abstract class CyclicModule : Module
	{
		private Completion? _evalError;

		private int _dfsIndex;

		private int _dfsAncestorIndex;

		internal HashSet<ModuleRequest> _requestedModules;

		private CyclicModule _cycleRoot;

		protected bool _hasTLA;

		private bool _asyncEvaluation;

		private PromiseCapability _topLevelCapability;

		private readonly List<CyclicModule> _asyncParentModules;

		private int _asyncEvalOrder;

		private int _pendingAsyncDependencies;

		internal JsValue _evalResult;

		internal ModuleStatus Status { get; private set; }

		internal Location AbnormalCompletionLocation { get; private set; }

		internal CyclicModule(Engine engine, Realm realm, string location, bool async)
			: base(engine, realm, location)
		{
		}

		public override void Link()
		{
			ModuleStatus status = Status;
			if ((status == ModuleStatus.Linking || status == ModuleStatus.Evaluating) ? true : false)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while linking module: Module is already either linking or evaluating");
			}
			Stack<CyclicModule> stack = new Stack<CyclicModule>();
			try
			{
				InnerModuleLinking(stack, 0);
			}
			catch
			{
				foreach (CyclicModule item in stack)
				{
					item._environment = null;
					if (item.Status != ModuleStatus.Linking)
					{
						ExceptionHelper.ThrowInvalidOperationException("Error while linking module: Module should be linking after abrupt completion");
					}
					item.Status = ModuleStatus.Unlinked;
					item._dfsIndex = -1;
					item._dfsAncestorIndex = -1;
				}
				if (Status != ModuleStatus.Unlinked)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while processing abrupt completion of module link: Module should be unlinked after cleanup");
				}
				throw;
			}
			status = Status;
			if ((status != ModuleStatus.Linked && (uint)(status - 4) > 1u) || 1 == 0)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while linking module: Module is neither linked, evaluating-async or evaluated");
			}
			if (stack.Count > 0)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while linking module: One or more modules were not linked");
			}
		}

		public override JsValue Evaluate()
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			CyclicModule cyclicModule = this;
			if (cyclicModule.Status != ModuleStatus.Linked && cyclicModule.Status != ModuleStatus.EvaluatingAsync && cyclicModule.Status != ModuleStatus.Evaluated)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
			}
			ModuleStatus status = cyclicModule.Status;
			if ((uint)(status - 4) <= 1u)
			{
				cyclicModule = cyclicModule._cycleRoot;
			}
			if ((object)cyclicModule._topLevelCapability != null)
			{
				return cyclicModule._topLevelCapability.PromiseInstance;
			}
			Stack<CyclicModule> stack = new Stack<CyclicModule>();
			PromiseCapability promiseCapability = PromiseConstructor.NewPromiseCapability(_engine, _realm.Intrinsics.Promise);
			int asyncEvalOrder = 0;
			cyclicModule._topLevelCapability = promiseCapability;
			Completion value = cyclicModule.InnerModuleEvaluation(stack, 0, ref asyncEvalOrder);
			if (value.Type != CompletionType.Normal)
			{
				foreach (CyclicModule item in stack)
				{
					item.Status = ModuleStatus.Evaluated;
					item._evalError = value;
				}
				AbnormalCompletionLocation = value.Location;
				promiseCapability.Reject.Call(JsValue.Undefined, value.Value);
			}
			else
			{
				if (cyclicModule.Status != ModuleStatus.EvaluatingAsync && cyclicModule.Status != ModuleStatus.Evaluated)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				}
				Completion? evalError = cyclicModule._evalError;
				if (evalError.HasValue)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				}
				if (!cyclicModule._asyncEvaluation)
				{
					if (cyclicModule.Status != ModuleStatus.Evaluated)
					{
						ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
					}
					promiseCapability.Resolve.Call(JsValue.Undefined);
				}
				if (stack.Count > 0)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				}
			}
			return promiseCapability.PromiseInstance;
		}

		protected internal override int InnerModuleLinking(Stack<CyclicModule> stack, int index)
		{
			ModuleStatus status = Status;
			if (((uint)(status - 1) <= 1u || (uint)(status - 4) <= 1u) ? true : false)
			{
				return index;
			}
			if (Status != ModuleStatus.Unlinked)
			{
				ExceptionHelper.ThrowInvalidOperationException($"Error while linking module: Module in an invalid state: {Status}");
			}
			Status = ModuleStatus.Linking;
			_dfsIndex = index;
			_dfsAncestorIndex = index;
			index++;
			stack.Push(this);
			foreach (ModuleRequest requestedModule in _requestedModules)
			{
				Module importedModule = _engine._host.GetImportedModule(this, requestedModule);
				index = importedModule.InnerModuleLinking(stack, index);
				if (importedModule is CyclicModule { Status: var status2 } cyclicModule)
				{
					if (((uint)(status2 - 1) > 1u && (uint)(status2 - 4) > 1u) || 1 == 0)
					{
						ExceptionHelper.ThrowInvalidOperationException($"Error while linking module: Required module is in an invalid state: {cyclicModule.Status}");
					}
					if (cyclicModule.Status == ModuleStatus.Linking == !stack.Contains(cyclicModule))
					{
						ExceptionHelper.ThrowInvalidOperationException($"Error while linking module: Required module is in an invalid state: {cyclicModule.Status}");
					}
					if (cyclicModule.Status == ModuleStatus.Linking)
					{
						_dfsAncestorIndex = Math.Min(_dfsAncestorIndex, cyclicModule._dfsAncestorIndex);
					}
				}
			}
			InitializeEnvironment();
			if (StackReferenceCount(stack) != 1)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while linking module: Recursive dependency detected");
			}
			if (_dfsAncestorIndex > _dfsIndex)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while linking module: Recursive dependency detected");
			}
			if (_dfsIndex == _dfsAncestorIndex)
			{
				CyclicModule cyclicModule2;
				do
				{
					cyclicModule2 = stack.Pop();
					cyclicModule2.Status = ModuleStatus.Linked;
				}
				while (!(cyclicModule2 == this));
			}
			return index;
		}

		protected internal override Completion InnerModuleEvaluation(Stack<CyclicModule> stack, int index, ref int asyncEvalOrder)
		{
			ModuleStatus status = Status;
			if ((uint)(status - 4) <= 1u)
			{
				Completion? evalError = _evalError;
				if (!evalError.HasValue)
				{
					return new Completion(CompletionType.Normal, index, null);
				}
				return _evalError.Value;
			}
			if (Status == ModuleStatus.Evaluating)
			{
				return new Completion(CompletionType.Normal, index, null);
			}
			if (Status != ModuleStatus.Linked)
			{
				ExceptionHelper.ThrowInvalidOperationException($"Error while evaluating module: Module is in an invalid state: {Status}");
			}
			Status = ModuleStatus.Evaluating;
			_dfsIndex = index;
			_dfsAncestorIndex = index;
			_pendingAsyncDependencies = 0;
			index++;
			stack.Push(this);
			foreach (ModuleRequest requestedModule in _requestedModules)
			{
				Module importedModule = _engine._host.GetImportedModule(this, requestedModule);
				Completion result = importedModule.InnerModuleEvaluation(stack, index, ref asyncEvalOrder);
				if (result.Type != CompletionType.Normal)
				{
					return result;
				}
				index = TypeConverter.ToInt32(result.Value);
				CyclicModule cyclicModule = importedModule as CyclicModule;
				if ((object)cyclicModule == null)
				{
					continue;
				}
				if (cyclicModule.Status != ModuleStatus.Evaluating && cyclicModule.Status != ModuleStatus.EvaluatingAsync && cyclicModule.Status != ModuleStatus.Evaluated)
				{
					ExceptionHelper.ThrowInvalidOperationException($"Error while evaluating module: Module is in an invalid state: {cyclicModule.Status}");
				}
				if (cyclicModule.Status == ModuleStatus.Evaluating && !stack.Contains(cyclicModule))
				{
					ExceptionHelper.ThrowInvalidOperationException($"Error while evaluating module: Module is in an invalid state: {cyclicModule.Status}");
				}
				if (cyclicModule.Status == ModuleStatus.Evaluating)
				{
					_dfsAncestorIndex = Math.Min(_dfsAncestorIndex, cyclicModule._dfsAncestorIndex);
				}
				else
				{
					cyclicModule = cyclicModule._cycleRoot;
					status = cyclicModule.Status;
					if ((uint)(status - 4) > 1u)
					{
						ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
					}
					if (cyclicModule._evalError.HasValue)
					{
						return cyclicModule._evalError.Value;
					}
				}
				if (cyclicModule._asyncEvaluation)
				{
					_pendingAsyncDependencies++;
					cyclicModule._asyncParentModules.Add(this);
				}
			}
			Completion result2;
			if (_pendingAsyncDependencies > 0 || _hasTLA)
			{
				if (_asyncEvaluation)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state (async evaluation is true)");
				}
				_asyncEvaluation = true;
				_asyncEvalOrder = asyncEvalOrder++;
				result2 = ((_pendingAsyncDependencies != 0) ? ExecuteModule() : ExecuteAsyncModule());
			}
			else
			{
				result2 = ExecuteModule();
			}
			if (StackReferenceCount(stack) != 1)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state (not found exactly once in stack)");
			}
			if (_dfsAncestorIndex > _dfsIndex)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state (mismatch DFS ancestor index)");
			}
			if (_dfsIndex == _dfsAncestorIndex)
			{
				bool flag = false;
				while (!flag)
				{
					CyclicModule cyclicModule2 = stack.Pop();
					if (!cyclicModule2._asyncEvaluation)
					{
						cyclicModule2.Status = ModuleStatus.Evaluated;
					}
					else
					{
						cyclicModule2.Status = ModuleStatus.EvaluatingAsync;
					}
					flag = (object)cyclicModule2 == this;
					cyclicModule2._cycleRoot = this;
				}
			}
			return result2;
		}

		private int StackReferenceCount(Stack<CyclicModule> stack)
		{
			int num = 0;
			foreach (CyclicModule item in stack)
			{
				if ((object)item == this)
				{
					num++;
				}
			}
			return num;
		}

		private Completion ExecuteAsyncModule()
		{
			if ((Status != ModuleStatus.Evaluating && Status != ModuleStatus.EvaluatingAsync) || !_hasTLA)
			{
				ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
			}
			PromiseCapability promiseCapability = PromiseConstructor.NewPromiseCapability(_engine, _realm.Intrinsics.Promise);
			ClrFunction onFulfilled = new ClrFunction(_engine, "fulfilled", AsyncModuleExecutionFulfilled, 1, PropertyFlag.Configurable);
			ClrFunction onRejected = new ClrFunction(_engine, "rejected", AsyncModuleExecutionRejected, 1, PropertyFlag.Configurable);
			PromiseOperations.PerformPromiseThen(_engine, (JsPromise)promiseCapability.PromiseInstance, onFulfilled, onRejected, null);
			return ExecuteModule(promiseCapability);
		}

		private static JsValue AsyncModuleExecutionFulfilled(JsValue thisObject, JsValue[] arguments)
		{
			CyclicModule cyclicModule = (CyclicModule)arguments.At(0);
			if (cyclicModule.Status == ModuleStatus.Evaluated)
			{
				Completion? evalError = cyclicModule._evalError;
				if (evalError.HasValue)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				}
				return JsValue.Undefined;
			}
			if (cyclicModule.Status == ModuleStatus.EvaluatingAsync && cyclicModule._asyncEvaluation)
			{
				Completion? evalError = cyclicModule._evalError;
				if (!evalError.HasValue)
				{
					goto IL_0063;
				}
			}
			ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
			goto IL_0063;
			IL_0063:
			if ((object)cyclicModule._topLevelCapability != null)
			{
				if ((object)cyclicModule._cycleRoot == null)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				}
				cyclicModule._topLevelCapability.Resolve.Call(JsValue.Undefined);
			}
			List<CyclicModule> list = new List<CyclicModule>();
			cyclicModule.GatherAvailableAncestors(list);
			list.Sort((CyclicModule x, CyclicModule y) => x._asyncEvalOrder - y._asyncEvalOrder);
			for (int num = 0; num < list.Count; num++)
			{
				CyclicModule cyclicModule2 = list[num];
				if (cyclicModule2.Status == ModuleStatus.Evaluated)
				{
					Completion? evalError = cyclicModule2._evalError;
					if (!evalError.HasValue)
					{
						ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
						continue;
					}
				}
				if (cyclicModule2._hasTLA)
				{
					cyclicModule2.ExecuteAsyncModule();
					continue;
				}
				Completion completion = cyclicModule2.ExecuteModule();
				if (completion.Type != CompletionType.Normal)
				{
					AsyncModuleExecutionRejected(JsValue.Undefined, new JsValue[2] { cyclicModule2, completion.Value });
					continue;
				}
				cyclicModule2.Status = ModuleStatus.Evaluated;
				if ((object)cyclicModule2._topLevelCapability != null)
				{
					if ((object)cyclicModule2._cycleRoot == null)
					{
						ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
					}
					cyclicModule2._topLevelCapability.Resolve.Call(JsValue.Undefined);
				}
			}
			return JsValue.Undefined;
		}

		private static JsValue AsyncModuleExecutionRejected(JsValue thisObject, JsValue[] arguments)
		{
			SourceTextModule sourceTextModule = (SourceTextModule)arguments.At(0);
			JsValue jsValue = arguments.At(1);
			if (sourceTextModule.Status == ModuleStatus.Evaluated)
			{
				Completion? evalError = sourceTextModule._evalError;
				if (!evalError.HasValue)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				}
				return JsValue.Undefined;
			}
			if (sourceTextModule.Status == ModuleStatus.EvaluatingAsync && sourceTextModule._asyncEvaluation)
			{
				Completion? evalError = sourceTextModule._evalError;
				if (!evalError.HasValue)
				{
					goto IL_006b;
				}
			}
			ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
			goto IL_006b;
			IL_006b:
			sourceTextModule._evalError = new Completion(CompletionType.Throw, jsValue, null);
			sourceTextModule.Status = ModuleStatus.Evaluated;
			List<CyclicModule> asyncParentModules = sourceTextModule._asyncParentModules;
			for (int i = 0; i < asyncParentModules.Count; i++)
			{
				CyclicModule cyclicModule = asyncParentModules[i];
				AsyncModuleExecutionRejected(thisObject, new JsValue[2] { cyclicModule, jsValue });
			}
			if ((object)sourceTextModule._topLevelCapability != null)
			{
				if ((object)sourceTextModule._cycleRoot == null)
				{
					ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				}
				sourceTextModule._topLevelCapability.Reject.Call(JsValue.Undefined, jsValue);
			}
			return JsValue.Undefined;
		}

		private void GatherAvailableAncestors(List<CyclicModule> execList)
		{
			foreach (CyclicModule asyncParentModule in _asyncParentModules)
			{
				if (execList.Contains(asyncParentModule))
				{
					continue;
				}
				Completion? evalError = asyncParentModule._cycleRoot._evalError;
				if (evalError.HasValue)
				{
					continue;
				}
				if (asyncParentModule.Status == ModuleStatus.EvaluatingAsync)
				{
					evalError = asyncParentModule._evalError;
					if (!evalError.HasValue && asyncParentModule._asyncEvaluation && asyncParentModule._pendingAsyncDependencies > 0)
					{
						goto IL_006c;
					}
				}
				ExceptionHelper.ThrowInvalidOperationException("Error while evaluating module: Module is in an invalid state");
				goto IL_006c;
				IL_006c:
				if (--asyncParentModule._pendingAsyncDependencies == 0)
				{
					execList.Add(asyncParentModule);
					if (!asyncParentModule._hasTLA)
					{
						asyncParentModule.GatherAvailableAncestors(execList);
					}
				}
			}
		}

		protected abstract void InitializeEnvironment();

		internal abstract Completion ExecuteModule(PromiseCapability capability = null);
	}
	public class DefaultModuleLoader : ModuleLoader
	{
		private readonly Uri _basePath;

		private readonly bool _restrictToBasePath;

		public DefaultModuleLoader(string basePath, bool restrictToBasePath = true)
		{
			if (string.IsNullOrWhiteSpace(basePath))
			{
				ExceptionHelper.ThrowArgumentException("Value cannot be null or whitespace.", "basePath");
			}
			_restrictToBasePath = restrictToBasePath;
			if (!Uri.TryCreate(basePath, UriKind.Absolute, out Uri result))
			{
				if (!Path.IsPathRooted(basePath))
				{
					ExceptionHelper.ThrowArgumentException("Path must be rooted", "basePath");
				}
				basePath = Path.GetFullPath(basePath);
				_basePath = new Uri(basePath, UriKind.Absolute);
			}
			else
			{
				_basePath = result;
			}
			string absolutePath = _basePath.AbsolutePath;
			if (absolutePath[absolutePath.Length - 1] != '/')
			{
				UriBuilder uriBuilder = new UriBuilder(_basePath);
				uriBuilder.Path += "/";
				_basePath = uriBuilder.Uri;
			}
		}

		public override ResolvedSpecifier Resolve(string? referencingModuleLocation, ModuleRequest moduleRequest)
		{
			string specifier = moduleRequest.Specifier;
			if (string.IsNullOrEmpty(specifier))
			{
				ExceptionHelper.ThrowModuleResolutionException("Invalid Module Specifier", specifier, referencingModuleLocation);
				return null;
			}
			Uri uri;
			if (Uri.TryCreate(specifier, UriKind.Absolute, out Uri result))
			{
				uri = result;
			}
			else
			{
				if (!IsRelative(specifier))
				{
					if (specifier[0] == '#')
					{
						ExceptionHelper.ThrowNotSupportedException("PACKAGE_IMPORTS_RESOLVE is not supported: '" + specifier + "'");
						return null;
					}
					return new ResolvedSpecifier(moduleRequest, specifier, null, SpecifierType.Bare);
				}
				uri = new Uri(BuildBaseUri(referencingModuleLocation), specifier);
			}
			if (uri.IsFile)
			{
				if (uri.UserEscaped)
				{
					ExceptionHelper.ThrowModuleResolutionException("Invalid Module Specifier", specifier, referencingModuleLocation);
					return null;
				}
				if (!Path.HasExtension(uri.LocalPath))
				{
					ExceptionHelper.ThrowModuleResolutionException("Unsupported Directory Import", specifier, referencingModuleLocation);
					return null;
				}
			}
			if (_restrictToBasePath && !_basePath.IsBaseOf(uri))
			{
				ExceptionHelper.ThrowModuleResolutionException("Unauthorized Module Path", specifier, referencingModuleLocation);
				return null;
			}
			return new ResolvedSpecifier(moduleRequest, uri.AbsoluteUri, uri, SpecifierType.RelativeOrAbsolute);
		}

		private Uri BuildBaseUri(string? referencingModuleLocation)
		{
			if (referencingModuleLocation != null && (Uri.TryCreate(referencingModuleLocation, UriKind.Absolute, out Uri result) || Uri.TryCreate(_basePath, referencingModuleLocation, out result)))
			{
				return result;
			}
			return _basePath;
		}

		protected override string LoadModuleContents(Engine engine, ResolvedSpecifier resolved)
		{
			string specifier = resolved.ModuleRequest.Specifier;
			if (resolved.Type != SpecifierType.RelativeOrAbsolute)
			{
				ExceptionHelper.ThrowNotSupportedException($"The default module loader can only resolve files. You can define modules directly to allow imports using {"Engine"}.{"Add"}(). Attempted to resolve: '{specifier}'.");
			}
			if (resolved.Uri == null)
			{
				ExceptionHelper.ThrowInvalidOperationException($"Module '{specifier}' of type '{resolved.Type}' has no resolved URI.");
			}
			string text = Uri.UnescapeDataString(resolved.Uri.AbsolutePath);
			if (!File.Exists(text))
			{
				ExceptionHelper.ThrowModuleResolutionException("Module Not Found", specifier, null, text);
			}
			return File.ReadAllText(text);
		}

		private static bool IsRelative(string specifier)
		{
			if (!specifier.StartsWith('.'))
			{
				return specifier.StartsWith('/');
			}
			return true;
		}
	}
	internal sealed class FailFastModuleLoader : IModuleLoader
	{
		public static readonly IModuleLoader Instance = new FailFastModuleLoader();

		public Uri BasePath
		{
			get
			{
				ExceptionHelper.ThrowInvalidOperationException("Cannot access base path when modules loading is disabled");
				return null;
			}
		}

		public ResolvedSpecifier Resolve(string? referencingModuleLocation, ModuleRequest moduleRequest)
		{
			return new ResolvedSpecifier(moduleRequest, moduleRequest.Specifier, null, SpecifierType.Bare);
		}

		public Module LoadModule(Engine engine, ResolvedSpecifier resolved)
		{
			ThrowDisabledException();
			return null;
		}

		private static void ThrowDisabledException()
		{
			ExceptionHelper.ThrowInvalidOperationException("Module loading has been disabled, you need to enable it in engine options");
		}
	}
	public interface IModuleLoader
	{
		ResolvedSpecifier Resolve(string? referencingModuleLocation, ModuleRequest moduleRequest);

		Module LoadModule(Engine engine, ResolvedSpecifier resolved);
	}
	internal sealed record ExportResolveSetItem(CyclicModule Module, string ExportName);
	public abstract class Module : JsValue, IScriptOrModule
	{
		private ObjectInstance _namespace;

		protected readonly Engine _engine;

		protected readonly Realm _realm;

		internal ModuleEnvironment _environment;

		public string Location { get; }

		internal Module(Engine engine, Realm realm, string location)
			: base(InternalTypes.Module)
		{
			_engine = engine;
			_realm = realm;
			Location = location;
		}

		public abstract List<string> GetExportedNames(List<CyclicModule> exportStarSet = null);

		internal abstract ResolvedBinding ResolveExport(string exportName, List<ExportResolveSetItem> resolveSet = null);

		public abstract void Link();

		public abstract JsValue Evaluate();

		protected internal abstract int InnerModuleLinking(Stack<CyclicModule> stack, int index);

		protected internal abstract Completion InnerModuleEvaluation(Stack<CyclicModule> stack, int index, ref int asyncEvalOrder);

		public static ObjectInstance GetModuleNamespace(Module module)
		{
			ObjectInstance objectInstance = module._namespace;
			if ((object)objectInstance == null)
			{
				List<string> exportedNames = module.GetExportedNames();
				List<string> list = new List<string>();
				for (int i = 0; i < exportedNames.Count; i++)
				{
					string text = exportedNames[i];
					ResolvedBinding resolvedBinding = module.ResolveExport(text);
					if ((object)resolvedBinding != null && resolvedBinding != ResolvedBinding.Ambiguous)
					{
						list.Add(text);
					}
				}
				objectInstance = CreateModuleNamespace(module, list);
			}
			return objectInstance;
		}

		private static ModuleNamespace CreateModuleNamespace(Module module, List<string> unambiguousNames)
		{
			return (ModuleNamespace)(module._namespace = new ModuleNamespace(module._engine, module, unambiguousNames));
		}

		public override object ToObject()
		{
			ExceptionHelper.ThrowNotSupportedException();
			return null;
		}

		public override string ToString()
		{
			return $"{base.Type}: {Location}";
		}
	}
	public sealed class ModuleBuilder
	{
		private readonly Engine _engine;

		private readonly string _specifier;

		private Prepared<Module>? _module;

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

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

		private readonly ParserOptions _defaultParserOptions;

		private readonly JavaScriptParser _defaultParser;

		private ModuleParsingOptions _parsingOptions;

		internal ModuleBuilder(Engine engine, string specifier)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			_engine = engine;
			_specifier = specifier;
			_parsingOptions = ModuleParsingOptions.Default;
			_defaultParserOptions = _parsingOptions.GetParserOptions(engine.Options);
			_defaultParser = new JavaScriptParser(_defaultParserOptions);
		}

		private JavaScriptParser GetParserFor(ModuleParsingOptions parsingOptions, out ParserOptions parserOptions)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if ((object)parsingOptions == ModuleParsingOptions.Default)
			{
				parserOptions = _defaultParserOptions;
				return _defaultParser;
			}
			parserOptions = parsingOptions.GetParserOptions(_engine.Options);
			return new JavaScriptParser(parserOptions);
		}

		public ModuleBuilder AddSource(string code)
		{
			if (_module.HasValue)
			{
				throw new InvalidOperationException("Cannot have both source text and pre-compiled.");
			}
			_sourceRaw.Add(code);
			return this;
		}

		public ModuleBuilder AddModule(in Prepared<Module> preparedModule)
		{
			if (_sourceRaw.Count > 0)
			{
				throw new InvalidOperationException("Cannot have both source text and pre-compiled.");
			}
			if (_module.HasValue)
			{
				throw new InvalidOperationException("pre-compiled module already exists.");
			}
			_module = preparedModule;
			return this;
		}

		public ModuleBuilder ExportValue(string name, JsValue value)
		{
			_exports.Add(name, value);
			return this;
		}

		public ModuleBuilder ExportObject(string name, object value)
		{
			_exports.Add(name, JsValue.FromObject(_engine, value));
			return this;
		}

		public ModuleBuilder ExportType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] T>()
		{
			ExportType<T>(typeof(T).Name);
			return this;
		}

		public ModuleBuilder ExportType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] T>(string name)
		{
			_exports.Add(name, TypeReference.CreateTypeReference<T>(_engine));
			return this;
		}

		public ModuleBuilder ExportType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] Type type)
		{
			ExportType(type.Name, type);
			return this;
		}

		public ModuleBuilder ExportType(string name, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] Type type)
		{
			_exports.Add(name, TypeReference.CreateTypeReference(_engine, type));
			return this;
		}

		public ModuleBuilder ExportFunction(string name, Func<JsValue[], JsValue> fn)
		{
			_exports.Add(name, new ClrFunction(_engine, name, (JsValue _, JsValue[] args) => fn(args)));
			return this;
		}

		public ModuleBuilder ExportFunction(string name, Func<JsValue> fn)
		{
			_exports.Add(name, new ClrFunction(_engine, name, (JsValue _, JsValue[] _) => fn()));
			return this;
		}

		public ModuleBuilder ExportFunction(string name, Action<JsValue[]> fn)
		{
			_exports.Add(name, new ClrFunction(_engine, name, delegate(JsValue _, JsValue[] args)
			{
				fn(args);
				return JsValue.Undefined;
			}));
			return this;
		}

		public ModuleBuilder ExportFunction(string name, Action fn)
		{
			_exports.Add(name, new ClrFunction(_engine, name, delegate
			{
				fn();
				return JsValue.Undefined;
			}));
			return this;
		}

		public ModuleBuilder WithOptions(Func<ModuleParsingOptions, ModuleParsingOptions> configure)
		{
			_parsingOptions = configure(_parsingOptions);
			return this;
		}

		internal Prepared<Module> Parse()
		{
			//IL_00c4: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			if (_module.HasValue)
			{
				return _module.Value;
			}
			ParserOptions parserOptions;
			if (_sourceRaw.Count <= 0)
			{
				parserOptions = (((object)_parsingOptions == ModuleParsingOptions.Default) ? _defaultParserOptions : _parsingOptions.GetParserOptions(_engine.Options));
				NodeList<Statement> val = NodeList.Create<Statement>((IEnumerable<Statement>)Array.Empty<Statement>());
				return new Prepared<Module>(new Module(ref val), parserOptions);
			}
			JavaScriptParser parserFor = GetParserFor(_parsingOptions, out parserOptions);
			try
			{
				string text = ((_sourceRaw.Count == 1) ? _sourceRaw[0] : string.Join(System.Environment.NewLine, _sourceRaw));
				return new Prepared<Module>(parserFor.ParseModule(text, _specifier), parserOptions);
			}
			catch (ParserException ex)
			{
				ParserException ex2 = ex;
				Location location = Location.From(Position.From(ex2.LineNumber, ex2.Column), Position.From(ex2.LineNumber, ex2.Column), _specifier);
				ExceptionHelper.ThrowSyntaxError(_engine.Realm, $"Error while loading module: error in module '{_specifier}': {ex2.Error}", in location);
				return default(Prepared<Module>);
			}
		}

		internal void BindExportedValues(BuilderModule module)
		{
			foreach (KeyValuePair<string, JsValue> export in _exports)
			{
				module.BindExportedValue(export.Key, export.Value);
			}
		}
	}
	public static class ModuleFactory
	{
		public static Module BuildSourceTextModule(Engine engine, ResolvedSpecifier resolved, string code, ModuleParsingOptions? parsingOptions = null)
		{
			//IL_0041: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			string text = resolved.Uri?.LocalPath ?? resolved.Key;
			ParserOptions parserOptions = (parsingOptions ?? ModuleParsingOptions.Default).GetParserOptions();
			JavaScriptParser val = new JavaScriptParser(parserOptions);
			Module program;
			try
			{
				program = val.ParseModule(code, text);
			}
			catch (ParserException ex)
			{
				ParserException ex2 = ex;
				ExceptionHelper.ThrowSyntaxError(engine.Realm, $"Error while loading module: error in module '{text}': {ex2.Error}");
				program = null;
			}
			catch (Exception)
			{
				ExceptionHelper.ThrowJavaScriptException(engine, "Could not load module " + text, default(Location));
				program = null;
			}
			return BuildSourceTextModule(engine, new Prepared<Module>(program, parserOptions));
		}

		public static Module BuildSourceTextModule(Engine engine, Prepared<Module> preparedModule)
		{
			if (!preparedModule.IsValid)
			{
				ExceptionHelper.ThrowInvalidPreparedModuleArgumentException("preparedModule");
			}
			return new SourceTextModule(engine, engine.Realm, in preparedModule, ((SyntaxElement)preparedModule.Program).Location.Source, async: false);
		}

		public static Module BuildJsonModule(Engine engine, ResolvedSpecifier resolved, string jsonString)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			string text = resolved.Uri?.LocalPath;
			JsValue parsedJson;
			try
			{
				parsedJson = new JsonParser(engine).Parse(jsonString);
			}
			catch (Exception)
			{
				ExceptionHelper.ThrowJavaScriptException(engine, "Could not load module " + text, default(Location));
				parsedJson = null;
			}
			return BuildJsonModule(engine, parsedJson, resolved.Uri?.LocalPath);
		}

		public static Module BuildJsonModule(Engine engine, JsValue parsedJson, string? location)
		{
			return new SyntheticModule(engine, engine.Realm, parsedJson, location);
		}
	}
	public abstract class ModuleLoader : IModuleLoader
	{
		public abstract ResolvedSpecifier Resolve(string? referencingModuleLocation, ModuleRequest moduleRequest);

		public Module LoadModule(Engine engine, ResolvedSpecifier resolved)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			string text;
			try
			{
				text = LoadModuleContents(engine, resolved);
			}
			catch (Exception)
			{
				ExceptionHelper.ThrowJavaScriptException(engine, "Could not load module " + resolved.ModuleRequest.Specifier, default(Location));
				return null;
			}
			if (!resolved.ModuleRequest.IsJsonModule())
			{
				return ModuleFactory.BuildSourceTextModule(engine, resolved, text);
			}
			return ModuleFactory.BuildJsonModule(engine, resolved, text);
		}

		protected abstract string LoadModuleContents(Engine engine, ResolvedSpecifier resolved);
	}
	internal sealed class ModuleNamespace : ObjectInstance
	{
		private readonly Module _module;

		private readonly HashSet<string> _exports;

		public override bool Extensible => false;

		public ModuleNamespace(Engine engine, Module module, List<string> exports)
			: base(engine)
		{
			_module = module;
			_exports = new HashSet<string>(exports, StringComparer.Ordinal);
		}

		protected override void Initialize()
		{
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Module", false, false, false);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		protected internal override ObjectInstance GetPrototypeOf()
		{
			return null;
		}

		internal override bool SetPrototypeOf(JsValue value)
		{
			return SetImmutablePrototype(value);
		}

		private bool SetImmutablePrototype(JsValue value)
		{
			ObjectInstance prototypeOf = GetPrototypeOf();
			return JsValue.SameValue(value, prototypeOf ?? JsValue.Null);
		}

		public override bool PreventExtensions()
		{
			return true;
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (property.IsSymbol())
			{
				return base.GetOwnProperty(property);
			}
			string item = TypeConverter.ToString(property);
			if (!_exports.Contains(item))
			{
				return PropertyDescriptor.Undefined;
			}
			return new PropertyDescriptor(Get(property), true, true, false);
		}

		public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			if (property.IsSymbol())
			{
				return base.DefineOwnProperty(property, desc);
			}
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty == PropertyDescriptor.Undefined)
			{
				return false;
			}
			if (desc.Configurable)
			{
				return false;
			}
			if (desc.EnumerableSet && !desc.Enumerable)
			{
				return false;
			}
			if (desc.IsAccessorDescriptor())
			{
				return false;
			}
			if (desc.WritableSet && !desc.Writable)
			{
				return false;
			}
			if ((object)desc.Value != null)
			{
				return JsValue.SameValue(desc.Value, ownProperty.Value);
			}
			return true;
		}

		public override bool HasProperty(JsValue property)
		{
			if (property.IsSymbol())
			{
				return base.HasProperty(property);
			}
			string item = TypeConverter.ToString(property);
			return _exports.Contains(item);
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			if (property.IsSymbol())
			{
				return base.Get(property, receiver);
			}
			string text = TypeConverter.ToString(property);
			if (!_exports.Contains(text))
			{
				return JsValue.Undefined;
			}
			ResolvedBinding resolvedBinding = _module.ResolveExport(text);
			Module module = resolvedBinding.Module;
			if (string.Equals(resolvedBinding.BindingName, "*namespace*", StringComparison.Ordinal))
			{
				return Module.GetModuleNamespace(module);
			}
			ModuleEnvironment environment = module._environment;
			if ((object)environment == null)
			{
				ExceptionHelper.ThrowReferenceError(_engine.Realm, "Module's environment hasn't been initialized");
			}
			return environment.GetBindingValue(resolvedBinding.BindingName, strict: true);
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			return false;
		}

		public override bool Delete(JsValue property)
		{
			if (property.IsSymbol())
			{
				return base.Delete(property);
			}
			string item = TypeConverter.ToString(property);
			return !_exports.Contains(item);
		}

		public override List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			List<JsValue> list = new List<JsValue>();
			if ((types & Types.String) != Types.Empty)
			{
				list.Capacity = _exports.Count;
				foreach (string export in _exports)
				{
					list.Add(export);
				}
				list.Sort(ArrayPrototype.ArrayComparer.Default);
			}
			list.AddRange(base.GetOwnPropertyKeys(types));
			return list;
		}
	}
	public readonly record struct ModuleImportAttribute(string Key, string Value);
	public readonly record struct ModuleRequest(string Specifier, ModuleImportAttribute[] Attributes)
	{
		public bool Equals(ModuleRequest other)
		{
			if (!string.Equals(Specifier, other.Specifier, StringComparison.Ordinal))
			{
				return false;
			}
			if (Attributes.Length != other.Attributes.Length)
			{
				return false;
			}
			if (Attributes.Length == 0 || (Attributes.Length == 1 && Attributes[0].Equals(other.Attributes[0])))
			{
				return true;
			}
			ModuleImportAttribute[] attributes = Attributes;
			foreach (ModuleImportAttribute value in attributes)
			{
				if (Array.IndexOf(other.Attributes, value) == -1)
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			return StringComparer.Ordinal.GetHashCode(Specifier);
		}
	}
	public static class ModuleRequestExtensions
	{
		public static bool IsJsonModule(this ModuleRequest request)
		{
			if (request.Attributes != null)
			{
				return Array.Exists(request.Attributes, (ModuleImportAttribute x) => string.Equals(x.Key, "type", StringComparison.Ordinal) && string.Equals(x.Value, "json", StringComparison.Ordinal));
			}
			return false;
		}
	}
	public sealed class ModuleResolutionException : JintException
	{
		public string ResolverAlgorithmError { get; }

		public string Specifier { get; }

		public string? FilePath { get; }

		public ModuleResolutionException(string resolverAlgorithmError, string specifier, string? parent, string? filePath)
			: base($"{resolverAlgorithmError} in module '{parent ?? "(null)"}': '{specifier}'")
		{
			ResolverAlgorithmError = resolverAlgorithmError;
			Specifier = specifier;
			FilePath = filePath;
		}
	}
	internal enum ModuleStatus
	{
		Unlinked,
		Linking,
		Linked,
		Evaluating,
		EvaluatingAsync,
		Evaluated
	}
	public record ResolvedSpecifier(ModuleRequest ModuleRequest, string Key, Uri? Uri, SpecifierType Type);
	internal sealed record ImportEntry(ModuleRequest ModuleRequest, string? ImportName, string LocalName);
	internal sealed record ExportEntry(string? ExportName, ModuleRequest? ModuleRequest, string? ImportName, string? LocalName);
	internal class SourceTextModule : CyclicModule
	{
		internal readonly Module _source;

		private readonly ParserOptions _parserOptions;

		private Jint.Runtime.Environments.ExecutionContext _context;

		private ObjectInstance? _importMeta;

		private readonly List<ImportEntry>? _importEntries;

		internal readonly List<ExportEntry> _localExportEntries;

		private readonly List<ExportEntry> _indirectExportEntries;

		private readonly List<ExportEntry> _starExportEntries;

		internal ObjectInstance ImportMeta
		{
			get
			{
				if ((object)_importMeta == null)
				{
					_importMeta = _realm.Intrinsics.Object.Construct(1);
					_importMeta.CreateDataProperty("url", base.Location);
				}
				return _importMeta;
			}
			set
			{
				_importMeta = value;
			}
		}

		internal SourceTextModule(Engine engine, Realm realm, in Prepared<Module> source, string? location, bool async)
			: base(engine, realm, location, async)
		{
			_source = source.Program;
			_parserOptions = source.ParserOptions;
			HoistingScope.GetImportsAndExports(_source, out _requestedModules, out _importEntries, out _localExportEntries, out _indirectExportEntries, out _starExportEntries);
		}

		public override List<string?> GetExportedNames(List<CyclicModule>? exportStarSet = null)
		{
			if (exportStarSet == null)
			{
				exportStarSet = new List<CyclicModule>();
			}
			if (exportStarSet.Contains(this))
			{
				return new List<string>();
			}
			exportStarSet.Add(this);
			List<string> list = new List<string>();
			for (int i = 0; i < _localExportEntries.Count; i++)
			{
				ExportEntry exportEntry = _localExportEntries[i];
				list.Add(exportEntry.ExportName);
			}
			for (int j = 0; j < _indirectExportEntries.Count; j++)
			{
				ExportEntry exportEntry2 = _indirectExportEntries[j];
				list.Add(exportEntry2.ExportName);
			}
			for (int k = 0; k < _starExportEntries.Count; k++)
			{
				ExportEntry exportEntry3 = _starExportEntries[k];
				List<string> exportedNames = _engine._host.GetImportedModule(this, exportEntry3.ModuleRequest.Value).GetExportedNames(exportStarSet);
				for (int l = 0; l < exportedNames.Count; l++)
				{
					string text = exportedNames[l];
					if (!"default".Equals(text, StringComparison.Ordinal) && !list.Contains(text))
					{
						list.Add(text);
					}
				}
			}
			return list;
		}

		internal override ResolvedBinding? ResolveExport(string? exportName, List<ExportResolveSetItem>? resolveSet = null)
		{
			if (resolveSet == null)
			{
				resolveSet = new List<ExportResolveSetItem>();
			}
			for (int i = 0; i < resolveSet.Count; i++)
			{
				ExportResolveSetItem exportResolveSetItem = resolveSet[i];
				if ((object)this == exportResolveSetItem.Module && string.Equals(exportName, exportResolveSetItem.ExportName, StringComparison.Ordinal))
				{
					return null;
				}
			}
			resolveSet.Add(new ExportResolveSetItem(this, exportName));
			for (int j = 0; j < _localExportEntries.Count; j++)
			{
				ExportEntry exportEntry = _localExportEntries[j];
				if (string.Equals(exportName, exportEntry.ExportName, StringComparison.Ordinal))
				{
					return new ResolvedBinding(this, exportEntry.LocalName);
				}
			}
			for (int k = 0; k < _indirectExportEntries.Count; k++)
			{
				ExportEntry exportEntry2 = _indirectExportEntries[k];
				if (string.Equals(exportName, exportEntry2.ExportName, StringComparison.Ordinal))
				{
					Module importedModule = _engine._host.GetImportedModule(this, exportEntry2.ModuleRequest.Value);
					if (string.Equals(exportEntry2.ImportName, "*", StringComparison.Ordinal))
					{
						return new ResolvedBinding(importedModule, "*namespace*");
					}
					return importedModule.ResolveExport(exportEntry2.ImportName, resolveSet);
				}
			}
			if ("default".Equals(exportName, StringComparison.Ordinal))
			{
				return null;
			}
			ResolvedBinding resolvedBinding = null;
			for (int l = 0; l < _starExportEntries.Count; l++)
			{
				ExportEntry exportEntry3 = _starExportEntries[l];
				ResolvedBinding resolvedBinding2 = _engine._host.GetImportedModule(this, exportEntry3.ModuleRequest.Value).ResolveExport(exportName, resolveSet);
				if (resolvedBinding2 == ResolvedBinding.Ambiguous)
				{
					return resolvedBinding2;
				}
				if ((object)resolvedBinding2 != null)
				{
					if ((object)resolvedBinding == null)
					{
						resolvedBinding = resolvedBinding2;
					}
					else if (resolvedBinding2.Module != resolvedBinding.Module || !string.Equals(resolvedBinding2.BindingName, resolvedBinding.BindingName, StringComparison.Ordinal))
					{
						return ResolvedBinding.Ambiguous;
					}
				}
			}
			return resolvedBinding;
		}

		protected override void InitializeEnvironment()
		{
			for (int i = 0; i < _indirectExportEntries.Count; i++)
			{
				ExportEntry exportEntry = _indirectExportEntries[i];
				ResolvedBinding resolvedBinding = ResolveExport(exportEntry.ExportName);
				if ((object)resolvedBinding == null || resolvedBinding == ResolvedBinding.Ambiguous)
				{
					ExceptionHelper.ThrowSyntaxError(_realm, "Ambiguous import statement for identifier: " + exportEntry.ExportName);
				}
			}
			Realm realm = _realm;
			ModuleEnvironment moduleEnvironment = (_environment = JintEnvironment.NewModuleEnvironment(_engine, realm.GlobalEnv));
			if (_importEntries != null)
			{
				for (int j = 0; j < _importEntries.Count; j++)
				{
					ImportEntry importEntry = _importEntries[j];
					Module importedModule = _engine._host.GetImportedModule(this, importEntry.ModuleRequest);
					if (string.Equals(importEntry.ImportName, "*", StringComparison.Ordinal))
					{
						ObjectInstance moduleNamespace = Module.GetModuleNamespace(importedModule);
						moduleEnvironment.CreateImmutableBinding(importEntry.LocalName);
						moduleEnvironment.InitializeBinding(importEntry.LocalName, moduleNamespace);
						continue;
					}
					ResolvedBinding resolvedBinding2 = importedModule.ResolveExport(importEntry.ImportName);
					if ((object)resolvedBinding2 == null || resolvedBinding2 == ResolvedBinding.Ambiguous)
					{
						ExceptionHelper.ThrowSyntaxError(_realm, "Ambiguous import statement for identifier " + importEntry.ImportName);
					}
					if (string.Equals(resolvedBinding2.BindingName, "*namespace*", StringComparison.Ordinal))
					{
						ObjectInstance moduleNamespace2 = Module.GetModuleNamespace(resolvedBinding2.Module);
						moduleEnvironment.CreateImmutableBinding(importEntry.LocalName);
						moduleEnvironment.InitializeBinding(importEntry.LocalName, moduleNamespace2);
					}
					else
					{
						moduleEnvironment.CreateImportBinding(importEntry.LocalName, resolvedBinding2.Module, resolvedBinding2.BindingName);
					}
				}
			}
			Jint.Runtime.Environments.ExecutionContext context = new Jint.Runtime.Environments.ExecutionContext(this, _environment, _environment, null, realm);
			_context = context;
			_engine.EnterExecutionContext(in _context);
			HoistingScope moduleLevelDeclarations = HoistingScope.GetModuleLevelDeclarations(_source);
			List<VariableDeclaration> variablesDeclarations = moduleLevelDeclarations._variablesDeclarations;
			HashSet<Key> hashSet = new HashSet<Key>();
			if (variablesDeclarations != null)
			{
				List<Key> list = new List<Key>();
				for (int k = 0; k < variablesDeclarations.Count; k++)
				{
					VariableDeclaration variableDeclaration = variablesDeclarations[k];
					list.Clear();
					variableDeclaration.GetBoundNames(list);
					for (int l = 0; l < list.Count; l++)
					{
						Key key = list[l];
						if (hashSet.Add(key))
						{
							moduleEnvironment.CreateMutableBinding(key);
							moduleEnvironment.InitializeBinding(key, JsValue.Undefined);
						}
					}
				}
			}
			List<Declaration> lexicalDeclarations = moduleLevelDeclarations._lexicalDeclarations;
			if (lexicalDeclarations != null)
			{
				List<Key> list2 = new List<Key>();
				for (int m = 0; m < lexicalDeclarations.Count; m++)
				{
					Declaration val = lexicalDeclarations[m];
					list2.Clear();
					((Node?)(object)val).GetBoundNames(list2);
					for (int n = 0; n < list2.Count; n++)
					{
						Key name = list2[n];
						if (val.IsConstantDeclaration())
						{
							moduleEnvironment.CreateImmutableBinding(name);
						}
						else
						{
							moduleEnvironment.CreateMutableBinding(name);
						}
					}
				}
			}
			List<FunctionDeclaration> functionDeclarations = moduleLevelDeclarations._functionDeclarations;
			if (functionDeclarations != null)
			{
				for (int num = 0; num < functionDeclarations.Count; num++)
				{
					FunctionDeclaration obj = functionDeclarations[num];
					Identifier id = obj.Id;
					string text = ((id != null) ? id.Name : null) ?? "*default*";
					JintFunctionDefinition functionDeclaration = new JintFunctionDefinition((IFunction)(object)obj);
					moduleEnvironment.CreateMutableBinding(text, canBeDeleted: true);
					Function function = realm.Intrinsics.Function.InstantiateFunctionObject(functionDeclaration, moduleEnvironment, null);
					if (string.Equals(text, "*default*", StringComparison.Ordinal))
					{
						function.SetFunctionName("default");
					}
					moduleEnvironment.InitializeBinding(text, function);
				}
			}
			_engine.LeaveExecutionContext();
		}

		internal override Completion ExecuteModule(PromiseCapability? capability = null)
		{
			Jint.Runtime.Environments.ExecutionContext context = new Jint.Runtime.Environments.ExecutionContext(this, _environment, _environment, null, _realm, null, null, _parserOptions);
			if (!_hasTLA)
			{
				using (new StrictModeScope(strict: true, force: true))
				{
					_engine.EnterExecutionContext(in context);
					try
					{
						JintStatementList jintStatementList = new JintStatementList(null, ((Program)_source).Body);
						EvaluationContext context2 = _engine._activeEvaluationContext ?? new EvaluationContext(_engine);
						return jintStatementList.Execute(context2);
					}
					finally
					{
						_engine.LeaveExecutionContext();
					}
				}
			}
			ExceptionHelper.ThrowNotImplementedException("async modules not implemented");
			return default(Completion);
		}
	}
	public enum SpecifierType
	{
		Error,
		RelativeOrAbsolute,
		Bare
	}
	internal sealed class SyntheticModule : Module
	{
		private readonly JsValue _obj;

		private readonly ParserOptions? _parserOptions;

		private readonly List<string> _exportNames = new List<string>(1) { "default" };

		internal SyntheticModule(Engine engine, Realm realm, JsValue obj, string? location, ParserOptions? parserOptions = null)
			: base(engine, realm, location)
		{
			_obj = obj;
			ModuleEnvironment environment = JintEnvironment.NewModuleEnvironment(_engine, realm.GlobalEnv);
			_environment = environment;
			_parserOptions = parserOptions;
		}

		public override List<string> GetExportedNames(List<CyclicModule>? exportStarSet = null)
		{
			return _exportNames;
		}

		internal override ResolvedBinding? ResolveExport(string exportName, List<ExportResolveSetItem>? resolveSet = null)
		{
			if (!_exportNames.Contains(exportName))
			{
				return null;
			}
			return new ResolvedBinding(this, exportName);
		}

		public override void Link()
		{
		}

		public override JsValue Evaluate()
		{
			Realm realm = _realm;
			Jint.Runtime.Environments.ExecutionContext context = new Jint.Runtime.Environments.ExecutionContext(this, variableEnvironment: _environment, lexicalEnvironment: _environment, privateEnvironment: null, realm: realm, generator: null, function: null, parserOptions: _parserOptions);
			_engine.EnterExecutionContext(in context);
			_environment.SetMutableBinding(KnownKeys.Default, _obj, strict: true);
			_engine.LeaveExecutionContext();
			PromiseCapability promiseCapability = PromiseConstructor.NewPromiseCapability(_engine, _realm.Intrinsics.Promise);
			promiseCapability.Resolve.Call(JsValue.Undefined);
			return promiseCapability.PromiseInstance;
		}

		protected internal override int InnerModuleLinking(Stack<CyclicModule> stack, int index)
		{
			foreach (string exportName in _exportNames)
			{
				_environment.CreateMutableBinding(exportName);
				_environment.InitializeBinding(exportName, JsValue.Undefined);
			}
			return index;
		}

		protected internal override Completion InnerModuleEvaluation(Stack<CyclicModule> stack, int index, ref int asyncEvalOrder)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			_environment.SetMutableBinding(KnownKeys.Default, _obj, strict: true);
			return new Completion(CompletionType.Normal, index, (SyntaxElement)new Identifier(""));
		}
	}
}
namespace Jint.Runtime.Interpreter
{
	internal sealed class EvaluationContext
	{
		private readonly bool _shouldRunBeforeExecuteStatementChecks;

		public readonly Engine Engine;

		public readonly bool OperatorOverloadingAllowed;

		public string? Target;

		public CompletionType Completion;

		public bool DebugMode => Engine._isDebugMode;

		public SyntaxElement LastSyntaxElement
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return Engine.GetLastSyntaxElement();
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				Engine._lastSyntaxElement = value;
			}
		}

		public EvaluationContext(Engine engine)
		{
			Engine = engine;
			OperatorOverloadingAllowed = engine.Options.Interop.AllowOperatorOverloading;
			_shouldRunBeforeExecuteStatementChecks = engine._constraints.Length != 0 || engine._isDebugMode;
		}

		public EvaluationContext()
		{
			Engine = null;
			OperatorOverloadingAllowed = false;
			_shouldRunBeforeExecuteStatementChecks = false;
		}

		public void RunBeforeExecuteStatementChecks(StatementListItem statement)
		{
			if (_shouldRunBeforeExecuteStatementChecks)
			{
				Engine.RunBeforeExecuteStatementChecks(statement);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void PrepareFor(Node node)
		{
			LastSyntaxElement = (SyntaxElement)(object)node;
			Target = null;
			Completion = CompletionType.Normal;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsAbrupt()
		{
			return Completion != CompletionType.Normal;
		}
	}
	internal sealed class JintFunctionDefinition
	{
		internal sealed class State
		{
			internal struct VariableValuePair
			{
				public Key Name;

				public JsValue? InitialValue;
			}

			internal struct LexicalVariableDeclaration
			{
				public bool IsConstantDeclaration;

				public List<Key> BoundNames;
			}

			public bool HasRestParameter;

			public int Length;

			public Key[] ParameterNames;

			public bool HasDuplicates;

			public bool IsSimpleParameterList;

			public bool HasParameterExpressions;

			public bool ArgumentsObjectNeeded;

			public List<Key>? VarNames;

			public LinkedList<FunctionDeclaration>? FunctionsToInitialize;

			public readonly HashSet<Key> FunctionNames = new HashSet<Key>();

			public LexicalVariableDeclaration[] LexicalDeclarations = Array.Empty<LexicalVariableDeclaration>();

			public HashSet<Key>? ParameterBindings;

			public List<VariableValuePair>? VarsToInitialize;
		}

		private static class ArgumentsUsageAstVisitor
		{
			public static bool HasArgumentsReference(IFunction function)
			{
				if (HasArgumentsReference((Node)(object)function.Body))
				{
					return true;
				}
				ref NodeList<Node> reference = function.Params;
				for (int i = 0; i < reference.Count; i++)
				{
					if (HasArgumentsReference(reference[i]))
					{
						return true;
					}
				}
				return false;
			}

			private unsafe static bool HasArgumentsReference(Node node)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Invalid comparison between Unknown and I4
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Invalid comparison between Unknown and I4
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				ChildNodes childNodes = node.ChildNodes;
				Enumerator enumerator = ((ChildNodes)(ref childNodes)).GetEnumerator();
				try
				{
					while (((Enumerator)(ref enumerator)).MoveNext())
					{
						Node current = ((Enumerator)(ref enumerator)).Current;
						Nodes type = current.Type;
						if ((int)type == 32)
						{
							if (string.Equals(((Identifier)current).Name, "arguments", StringComparison.Ordinal))
							{
								return true;
							}
						}
						else if ((int)type != 30)
						{
							childNodes = current.ChildNodes;
							if (!((ChildNodes)(ref childNodes)).IsEmpty() && HasArgumentsReference(current))
							{
								return true;
							}
						}
					}
				}
				finally
				{
					((IDisposable)(*(Enumerator*)(&enumerator))/*cast due to .constrained prefix*/).Dispose();
				}
				return false;
			}
		}

		private JintExpression? _bodyExpression;

		private JintStatementList? _bodyStatementList;

		public readonly string? Name;

		public readonly IFunction Function;

		public bool Strict => Function.Strict;

		public FunctionThisMode ThisMode
		{
			get
			{
				if (!Function.Strict)
				{
					return FunctionThisMode.Global;
				}
				return FunctionThisMode.Strict;
			}
		}

		public JintFunctionDefinition(IFunction function)
		{
			Function = function;
			Identifier id = function.Id;
			Name = ((!string.IsNullOrEmpty((id != null) ? id.Name : null)) ? function.Id.Name : null);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
		internal Completion EvaluateBody(EvaluationContext context, Function functionObject, JsValue[] argumentsList)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			JsArguments jsArguments = null;
			Completion result;
			if (Function.Expression)
			{
				if (_bodyExpression == null)
				{
					_bodyExpression = JintExpression.Build((Expression)Function.Body);
				}
				if (Function.Async)
				{
					PromiseCapability promiseCapability = PromiseConstructor.NewPromiseCapability(context.Engine, context.Engine.Realm.Intrinsics.Promise);
					AsyncFunctionStart(context, promiseCapability, delegate(EvaluationContext evaluationContext)
					{
						evaluationContext.Engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
						evaluationContext.RunBeforeExecuteStatementChecks(Function.Body);
						JsValue value2 = _bodyExpression.GetValue(evaluationContext).Clone();
						return new Completion(CompletionType.Return, value2, (SyntaxElement)(object)_bodyExpression._expression);
					});
					result = new Completion(CompletionType.Return, promiseCapability.PromiseInstance, (SyntaxElement)(object)Function.Body);
				}
				else
				{
					jsArguments = context.Engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
					context.RunBeforeExecuteStatementChecks(Function.Body);
					JsValue value = _bodyExpression.GetValue(context).Clone();
					result = new Completion(CompletionType.Return, value, (SyntaxElement)(object)Function.Body);
				}
			}
			else if (Function.Generator)
			{
				result = EvaluateGeneratorBody(context, functionObject, argumentsList);
			}
			else if (Function.Async)
			{
				PromiseCapability promiseCapability2 = PromiseConstructor.NewPromiseCapability(context.Engine, context.Engine.Realm.Intrinsics.Promise);
				if (_bodyStatementList == null)
				{
					_bodyStatementList = new JintStatementList(Function);
				}
				AsyncFunctionStart(context, promiseCapability2, delegate(EvaluationContext evaluationContext)
				{
					evaluationContext.Engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
					return _bodyStatementList.Execute(evaluationContext);
				});
				result = new Completion(CompletionType.Return, promiseCapability2.PromiseInstance, (SyntaxElement)(object)Function.Body);
			}
			else
			{
				jsArguments = context.Engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
				if (_bodyStatementList == null)
				{
					_bodyStatementList = new JintStatementList(Function);
				}
				result = _bodyStatementList.Execute(context);
			}
			jsArguments?.FunctionWasCalled();
			return result;
		}

		private static void AsyncFunctionStart(EvaluationContext context, PromiseCapability promiseCapability, Func<EvaluationContext, Completion> asyncFunctionBody)
		{
			Jint.Runtime.Environments.ExecutionContext asyncContext = context.Engine.ExecutionContext;
			AsyncBlockStart(context, promiseCapability, asyncFunctionBody, in asyncContext);
		}

		private static void AsyncBlockStart(EvaluationContext context, PromiseCapability promiseCapability, Func<EvaluationContext, Completion> asyncBody, in Jint.Runtime.Environments.ExecutionContext asyncContext)
		{
			_ = ref context.Engine.ExecutionContext;
			Completion completion;
			try
			{
				completion = asyncBody(context);
			}
			catch (JavaScriptException ex)
			{
				promiseCapability.Reject.Call(JsValue.Undefined, ex.Error);
				return;
			}
			if (completion.Type == CompletionType.Normal)
			{
				promiseCapability.Resolve.Call(JsValue.Undefined, JsValue.Undefined);
			}
			else if (completion.Type == CompletionType.Return)
			{
				promiseCapability.Resolve.Call(JsValue.Undefined, completion.Value);
			}
			else
			{
				promiseCapability.Reject.Call(JsValue.Undefined, completion.Value);
			}
		}

		private Completion EvaluateGeneratorBody(EvaluationContext context, Function functionObject, JsValue[] argumentsList)
		{
			Engine engine = context.Engine;
			engine.FunctionDeclarationInstantiation(functionObject, argumentsList);
			GeneratorInstance generatorInstance = engine.Realm.Intrinsics.Function.OrdinaryCreateFromConstructor(functionObject, (Intrinsics intrinsics) => intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject, (Engine engine2, Realm _, object? _) => new GeneratorInstance(engine2));
			if (_bodyStatementList == null)
			{
				_bodyStatementList = new JintStatementList(Function);
			}
			_bodyStatementList.Reset();
			generatorInstance.GeneratorStart(_bodyStatementList);
			return new Completion(CompletionType.Return, generatorInstance, (SyntaxElement)(object)Function.Body);
		}

		internal State Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Node val = (Node)Function;
			return (State)(((SyntaxElement)val).AssociatedData ?? (((SyntaxElement)val).AssociatedData = BuildState(Function)));
		}

		internal static State BuildState(IFunction function)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			State state = new State();
			ProcessParameters(function, state, out var hasArguments);
			HoistingScope functionLevelDeclarations = HoistingScope.GetFunctionLevelDeclarations(function.Strict, function);
			List<FunctionDeclaration> functionDeclarations = functionLevelDeclarations._functionDeclarations;
			List<string> lexicalNames = functionLevelDeclarations._lexicalNames;
			state.VarNames = functionLevelDeclarations._varNames;
			LinkedList<FunctionDeclaration> linkedList = null;
			if (functionDeclarations != null)
			{
				linkedList = new LinkedList<FunctionDeclaration>();
				for (int num = functionDeclarations.Count - 1; num >= 0; num--)
				{
					FunctionDeclaration val = functionDeclarations[num];
					string name = val.Id.Name;
					if (state.FunctionNames.Add(name))
					{
						linkedList.AddFirst(val);
					}
				}
			}
			state.FunctionsToInitialize = linkedList;
			state.ArgumentsObjectNeeded = true;
			FunctionThisMode functionThisMode = (function.Strict ? FunctionThisMode.Strict : FunctionThisMode.Global);
			if ((int)function.Type == 3)
			{
				functionThisMode = FunctionThisMode.Lexical;
			}
			if (functionThisMode == FunctionThisMode.Lexical)
			{
				state.ArgumentsObjectNeeded = false;
			}
			else if (hasArguments)
			{
				state.ArgumentsObjectNeeded = false;
			}
			else if (!state.HasParameterExpressions && (state.FunctionNames.Contains("arguments") || (lexicalNames != null && lexicalNames.Contains("arguments"))))
			{
				state.ArgumentsObjectNeeded = false;
			}
			if (state.ArgumentsObjectNeeded)
			{
				state.ArgumentsObjectNeeded = ArgumentsUsageAstVisitor.HasArgumentsReference(function);
			}
			HashSet<Key> hashSet = new HashSet<Key>(state.ParameterNames);
			if (state.ArgumentsObjectNeeded)
			{
				hashSet.Add(KnownKeys.Arguments);
			}
			state.ParameterBindings = hashSet;
			List<State.VariableValuePair> list = new List<State.VariableValuePair>();
			if (!state.HasParameterExpressions)
			{
				HashSet<Key> hashSet2 = ((state.VarNames != null) ? new HashSet<Key>(state.ParameterBindings) : new HashSet<Key>());
				for (int i = 0; i < state.VarNames?.Count; i++)
				{
					Key key = state.VarNames[i];
					if (hashSet2.Add(key))
					{
						list.Add(new State.VariableValuePair
						{
							Name = key
						});
					}
				}
			}
			else
			{
				HashSet<Key> hashSet3 = ((state.VarNames != null) ? new HashSet<Key>(state.ParameterBindings) : null);
				for (int j = 0; j < state.VarNames?.Count; j++)
				{
					Key key2 = state.VarNames[j];
					if (hashSet3.Add(key2))
					{
						JsValue initialValue = null;
						if (!state.ParameterBindings.Contains(key2) || state.FunctionNames.Contains(key2))
						{
							initialValue = JsValue.Undefined;
						}
						list.Add(new State.VariableValuePair
						{
							Name = key2,
							InitialValue = initialValue
						});
					}
				}
			}
			state.VarsToInitialize = list;
			if (functionLevelDeclarations._lexicalDeclarations != null)
			{
				List<Declaration> lexicalDeclarations = functionLevelDeclarations._lexicalDeclarations;
				int count = lexicalDeclarations.Count;
				State.LexicalVariableDeclaration[] array = new State.LexicalVariableDeclaration[count];
				for (int k = 0; k < count; k++)
				{
					Declaration val2 = lexicalDeclarations[k];
					List<Key> list2 = new List<Key>();
					((Node?)(object)val2).GetBoundNames(list2);
					array[k] = new State.LexicalVariableDeclaration
					{
						IsConstantDeclaration = val2.IsConstantDeclaration(),
						BoundNames = list2
					};
				}
				state.LexicalDeclarations = array;
			}
			return state;
		}

		private static void GetBoundNames(Node? parameter, List<Key> target, bool checkDuplicates, ref bool _hasRestParameter, ref bool _hasParameterExpressions, ref bool _hasDuplicates, ref bool hasArguments)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			Identifier val = (Identifier)(object)((parameter is Identifier) ? parameter : null);
			if (val != null)
			{
				_hasDuplicates |= checkDuplicates && target.Contains(val.Name);
				target.Add(val.Name);
				hasArguments |= string.Equals(val.Name, "arguments", StringComparison.Ordinal);
				return;
			}
			while (true)
			{
				RestElement val2 = (RestElement)(object)((parameter is RestElement) ? parameter : null);
				if (val2 != null)
				{
					_hasRestParameter = true;
					_hasParameterExpressions = true;
					parameter = val2.Argument;
					continue;
				}
				ArrayPattern val3 = (ArrayPattern)(object)((parameter is ArrayPattern) ? parameter : null);
				if (val3 != null)
				{
					_hasParameterExpressions = true;
					ref NodeList<Node> elements = val3.Elements;
					for (int i = 0; i < elements.Count; i++)
					{
						GetBoundNames(elements[i], target, checkDuplicates, ref _hasRestParameter, ref _hasParameterExpressions, ref _hasDuplicates, ref hasArguments);
					}
					break;
				}
				ObjectPattern val4 = (ObjectPattern)(object)((parameter is ObjectPattern) ? parameter : null);
				if (val4 != null)
				{
					_hasParameterExpressions = true;
					ref NodeList<Node> properties = val4.Properties;
					for (int j = 0; j < properties.Count; j++)
					{
						Node val5 = properties[j];
						Property val6 = (Property)(object)((val5 is Property) ? val5 : null);
						if (val6 != null)
						{
							GetBoundNames(val6.Value, target, checkDuplicates, ref _hasRestParameter, ref _hasParameterExpressions, ref _hasDuplicates, ref hasArguments);
							continue;
						}
						_hasRestParameter = true;
						_hasParameterExpressions = true;
						parameter = ((RestElement)val5).Argument;
					}
					break;
				}
				AssignmentPattern val7 = (AssignmentPattern)(object)((parameter is AssignmentPattern) ? parameter : null);
				if (val7 != null)
				{
					_hasParameterExpressions = true;
					parameter = val7.Left;
					continue;
				}
				break;
			}
		}

		private static void ProcessParameters(IFunction function, State state, out bool hasArguments)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Invalid comparison between Unknown and I4
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Invalid comparison between Unknown and I4
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Invalid comparison between Unknown and I4
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Invalid comparison between Unknown and I4
			hasArguments = false;
			state.IsSimpleParameterList = true;
			bool flag = true;
			ref NodeList<Node> reference = function.Params;
			int count = reference.Count;
			List<Key> list = new List<Key>(count);
			for (int i = 0; i < count; i++)
			{
				Node val = reference[i];
				Nodes type = val.Type;
				if ((int)type == 32)
				{
					Identifier val2 = (Identifier)val;
					state.HasDuplicates |= list.Contains(val2.Name);
					hasArguments = string.Equals(val2.Name, "arguments", StringComparison.Ordinal);
					list.Add(val2.Name);
				}
				else if ((int)type != 41)
				{
					flag = flag && (int)type != 5;
					state.IsSimpleParameterList = false;
					GetBoundNames(val, list, checkDuplicates: true, ref state.HasRestParameter, ref state.HasParameterExpressions, ref state.HasDuplicates, ref hasArguments);
				}
				bool flag2 = flag;
				if (flag2)
				{
					bool flag3 = (((int)type == 2 || (int)type == 32 || (int)type == 48) ? true : false);
					flag2 = flag3;
				}
				if (flag2)
				{
					state.Length++;
				}
			}
			state.ParameterNames = list.ToArray();
		}
	}
	internal sealed class JintStatementList
	{
		private readonly record struct Pair(JintStatement Statement, JsValue? Value);

		private readonly Statement? _statement;

		private readonly NodeList<Statement> _statements;

		private Pair[]? _jintStatements;

		private bool _initialized;

		private uint _index;

		private readonly bool _generator;

		public bool Completed => _index == _jintStatements?.Length;

		public JintStatementList(IFunction function)
			: this((BlockStatement)function.Body)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			_generator = function.Generator;
		}

		public JintStatementList(BlockStatement blockStatement)
			: this((Statement?)(object)blockStatement, blockStatement.Body)
		{
		}

		public JintStatementList(Program program)
			: this(null, program.Body)
		{
		}

		public JintStatementList(Statement? statement, in NodeList<Statement> statements)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			_statement = statement;
			_statements = statements;
		}

		private void Initialize(EvaluationContext context)
		{
			Pair[] array = new Pair[_statements.Count];
			for (int i = 0; i < array.Length; i++)
			{
				Statement statement = _statements[i];
				JintStatement statement2 = JintStatement.Build(statement);
				JsValue value = (context.DebugMode ? null : JintStatement.FastResolve((StatementListItem)(object)statement));
				array[i] = new Pair(statement2, value);
			}
			_jintStatements = array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
		public Completion Execute(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize(context);
				_initialized = true;
			}
			if (_statement != null)
			{
				context.LastSyntaxElement = (SyntaxElement)(object)_statement;
				context.RunBeforeExecuteStatementChecks((StatementListItem)(object)_statement);
			}
			Completion completion = Completion.Empty();
			Completion completion2 = completion;
			JsValue value = JsEmpty.Instance;
			uint num = _index;
			Pair[] jintStatements = _jintStatements;
			try
			{
				for (; num < (uint)jintStatements.Length; num++)
				{
					ref Pair reference = ref jintStatements[num];
					if ((object)reference.Value == null)
					{
						completion = reference.Statement.Execute(context);
						if ((object)context.Engine._error != null)
						{
							completion = HandleError(context.Engine, reference.Statement);
							break;
						}
					}
					else
					{
						completion = new Completion(CompletionType.Return, reference.Value, (SyntaxElement)(object)reference.Statement._statement);
					}
					if (_generator && context.Engine.ExecutionContext.Suspended)
					{
						_index = num + 1;
						completion = new Completion(CompletionType.Return, completion.Value, (SyntaxElement)(object)reference.Statement._statement);
						break;
					}
					if (completion.Type != CompletionType.Normal)
					{
						return completion.UpdateEmpty(completion2.Value);
					}
					completion2 = completion;
					if (!completion.Value.IsEmpty)
					{
						value = completion.Value;
					}
				}
			}
			catch (Exception ex)
			{
				Reset();
				if (!(ex is JintException))
				{
					throw;
				}
				completion = HandleException(context, ex, jintStatements[num].Statement);
			}
			return completion.UpdateEmpty(value).UpdateEmpty(JsValue.Undefined);
		}

		internal static Completion HandleException(EvaluationContext context, Exception exception, JintStatement? s)
		{
			if (!(exception is JavaScriptException v))
			{
				if (!(exception is TypeErrorException ex))
				{
					if (exception is RangeErrorException e)
					{
						return CreateThrowCompletion(context.Engine.Realm.Intrinsics.RangeError, e, (SyntaxElement)(object)s._statement);
					}
					throw exception;
				}
				return CreateThrowCompletion(context.Engine.Realm.Intrinsics.TypeError, ex, (SyntaxElement)(((object)ex.Node) ?? ((object)s._statement)));
			}
			return CreateThrowCompletion(s, v);
		}

		internal static Completion HandleError(Engine engine, JintStatement? s)
		{
			ErrorDispatchInfo error = engine._error;
			engine._error = null;
			return CreateThrowCompletion(error.ErrorConstructor, error.Message, (SyntaxElement)(((object)engine._lastSyntaxElement) ?? ((object)s._statement)));
		}

		private static Completion CreateThrowCompletion(ErrorConstructor errorConstructor, string? message, SyntaxElement s)
		{
			ObjectInstance value = errorConstructor.Construct(message);
			return new Completion(CompletionType.Throw, value, s);
		}

		private static Completion CreateThrowCompletion(ErrorConstructor errorConstructor, Exception e, SyntaxElement s)
		{
			ObjectInstance value = errorConstructor.Construct(e.Message);
			return new Completion(CompletionType.Throw, value, s);
		}

		private static Completion CreateThrowCompletion(JintStatement? s, JavaScriptException v)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			SyntaxElement source = (SyntaxElement)(object)s._statement;
			ref readonly Location location = ref v.Location;
			Location val = default(Location);
			if ((ref location) != (ref val))
			{
				source = AstExtensions.CreateLocationNode(in v.Location);
			}
			return new Completion(CompletionType.Throw, v.Error, source);
		}

		internal static void BlockDeclarationInstantiation(Jint.Runtime.Environments.Environment env, List<Declaration> declarations)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			PrivateEnvironment privateEnvironment = env._engine.ExecutionContext.PrivateEnvironment;
			List<Key> list = new List<Key>();
			for (int i = 0; i < declarations.Count; i++)
			{
				Declaration val = declarations[i];
				list.Clear();
				((Node?)(object)val).GetBoundNames(list);
				for (int j = 0; j < list.Count; j++)
				{
					Key name = list[j];
					VariableDeclaration val2 = (VariableDeclaration)(object)((val is VariableDeclaration) ? val : null);
					if (val2 != null && (int)val2.Kind == 2)
					{
						env.CreateImmutableBinding(name);
					}
					else
					{
						env.CreateMutableBinding(name);
					}
				}
				FunctionDeclaration val3 = (FunctionDeclaration)(object)((val is FunctionDeclaration) ? val : null);
				if (val3 != null)
				{
					JintFunctionDefinition jintFunctionDefinition = new JintFunctionDefinition((IFunction)(object)val3);
					string name2 = jintFunctionDefinition.Name;
					Function value = env._engine.Realm.Intrinsics.Function.InstantiateFunctionObject(jintFunctionDefinition, env, privateEnvironment);
					env.InitializeBinding(name2, value);
				}
			}
		}

		public void Reset()
		{
			_index = 0u;
		}
	}
}
namespace Jint.Runtime.Interpreter.Statements
{
	internal sealed class ConstantStatement : JintStatement
	{
		private readonly JsValue _value;

		private CompletionType _completionType;

		public ConstantStatement(Statement statement, CompletionType completionType, JsValue value)
			: base(statement)
		{
			_completionType = completionType;
			_value = value;
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			return new Completion(_completionType, _value, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintBlockStatement : JintStatement<BlockStatement>
	{
		private JintStatementList? _statementList;

		private JintStatement? _singleStatement;

		private List<Declaration>? _lexicalDeclarations;

		public JintBlockStatement(BlockStatement blockStatement)
			: base(blockStatement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_lexicalDeclarations = HoistingScope.GetLexicalDeclarations(_statement);
			if (((NodeList<Statement>)_statement.Body).Count == 1)
			{
				_singleStatement = JintStatement.Build(((NodeList<Statement>)_statement.Body)[0]);
			}
			else
			{
				_statementList = new JintStatementList((Statement?)(object)_statement, _statement.Body);
			}
		}

		public Completion ExecuteBlock(EvaluationContext context)
		{
			if (_statementList == null && _singleStatement == null)
			{
				Initialize(context);
			}
			Jint.Runtime.Environments.Environment environment = null;
			Engine engine = context.Engine;
			if (_lexicalDeclarations != null)
			{
				environment = engine.ExecutionContext.LexicalEnvironment;
				DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(engine, engine.ExecutionContext.LexicalEnvironment);
				JintStatementList.BlockDeclarationInstantiation(declarativeEnvironment, _lexicalDeclarations);
				engine.UpdateLexicalEnvironment(declarativeEnvironment);
			}
			Completion result = ((_singleStatement == null) ? _statementList.Execute(context) : ExecuteSingle(context));
			if ((object)environment != null)
			{
				engine.UpdateLexicalEnvironment(environment);
			}
			return result;
		}

		private Completion ExecuteSingle(EvaluationContext context)
		{
			Completion result;
			try
			{
				result = _singleStatement.Execute(context);
				if ((object)context.Engine._error != null)
				{
					result = JintStatementList.HandleError(context.Engine, _singleStatement);
				}
			}
			catch (Exception ex)
			{
				if (!(ex is JintException))
				{
					throw;
				}
				result = JintStatementList.HandleException(context, ex, _singleStatement);
			}
			return result;
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			return ExecuteBlock(context);
		}
	}
	internal sealed class JintBreakStatement : JintStatement<BreakStatement>
	{
		public JintBreakStatement(BreakStatement statement)
			: base(statement)
		{
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			Identifier label = _statement.Label;
			context.Target = ((label != null) ? label.Name : null);
			return new Completion(CompletionType.Break, JsEmpty.Instance, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintClassDeclarationStatement : JintStatement<ClassDeclaration>
	{
		private readonly ClassDefinition _classDefinition;

		public JintClassDeclarationStatement(ClassDeclaration classDeclaration)
			: base(classDeclaration)
		{
			Identifier id = classDeclaration.Id;
			_classDefinition = new ClassDefinition((id != null) ? id.Name : null, classDeclaration.SuperClass, classDeclaration.Body);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			Jint.Runtime.Environments.Environment lexicalEnvironment = context.Engine.ExecutionContext.LexicalEnvironment;
			JsValue value = _classDefinition.BuildConstructor(context, lexicalEnvironment);
			if (context.IsAbrupt())
			{
				return new Completion(context.Completion, value, (SyntaxElement)(object)_statement);
			}
			string className = _classDefinition._className;
			if (className != null)
			{
				lexicalEnvironment.InitializeBinding(className, value);
			}
			return new Completion(CompletionType.Normal, JsEmpty.Instance, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintContinueStatement : JintStatement<ContinueStatement>
	{
		public JintContinueStatement(ContinueStatement statement)
			: base(statement)
		{
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			Identifier label = _statement.Label;
			context.Target = ((label != null) ? label.Name : null);
			return new Completion(CompletionType.Continue, JsEmpty.Instance, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintDebuggerStatement : JintStatement<DebuggerStatement>
	{
		public JintDebuggerStatement(DebuggerStatement statement)
			: base(statement)
		{
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			switch (context.Engine.Options.Debugger.StatementHandling)
			{
			case DebuggerStatementHandling.Clr:
				if (!System.Diagnostics.Debugger.IsAttached)
				{
					System.Diagnostics.Debugger.Launch();
				}
				System.Diagnostics.Debugger.Break();
				break;
			}
			return new Completion(CompletionType.Normal, JsEmpty.Instance, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintDoWhileStatement : JintStatement<DoWhileStatement>
	{
		private ProbablyBlockStatement _body;

		private string? _labelSetName;

		private JintExpression _test;

		public JintDoWhileStatement(DoWhileStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_body = new ProbablyBlockStatement(_statement.Body);
			_test = JintExpression.Build(_statement.Test);
			Identifier labelSet = ((Statement)_statement).LabelSet;
			_labelSetName = ((labelSet != null) ? labelSet.Name : null);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			JsValue value = JsValue.Undefined;
			do
			{
				Completion result = _body.Execute(context);
				if (!result.Value.IsEmpty)
				{
					value = result.Value;
				}
				if (result.Type != CompletionType.Continue || !string.Equals(context.Target, _labelSetName, StringComparison.Ordinal))
				{
					if (result.Type == CompletionType.Break && (context.Target == null || string.Equals(context.Target, _labelSetName, StringComparison.Ordinal)))
					{
						return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)_statement);
					}
					if (result.Type != CompletionType.Normal)
					{
						return result;
					}
				}
				if (context.DebugMode)
				{
					context.Engine.Debugger.OnStep((Node)(object)_test._expression);
				}
			}
			while (TypeConverter.ToBoolean(_test.GetValue(context)));
			return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)((JintStatement)this)._statement);
		}
	}
	internal sealed class JintEmptyStatement : JintStatement<EmptyStatement>
	{
		public JintEmptyStatement(EmptyStatement statement)
			: base(statement)
		{
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			return new Completion(CompletionType.Normal, JsEmpty.Instance, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintExportAllDeclaration : JintStatement<ExportAllDeclaration>
	{
		public JintExportAllDeclaration(ExportAllDeclaration statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			return Completion.Empty();
		}
	}
	internal sealed class JintExportDefaultDeclaration : JintStatement<ExportDefaultDeclaration>
	{
		private ClassDefinition? _classDefinition;

		private JintFunctionDeclarationStatement? _functionDeclaration;

		private JintExpression? _assignmentExpression;

		private JintExpression? _simpleExpression;

		public JintExportDefaultDeclaration(ExportDefaultDeclaration statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			StatementListItem declaration = _statement.Declaration;
			ClassDeclaration val = (ClassDeclaration)(object)((declaration is ClassDeclaration) ? declaration : null);
			if (val != null)
			{
				Identifier id = val.Id;
				_classDefinition = new ClassDefinition(((id != null) ? id.Name : null) ?? "default", val.SuperClass, val.Body);
				return;
			}
			StatementListItem declaration2 = _statement.Declaration;
			FunctionDeclaration val2 = (FunctionDeclaration)(object)((declaration2 is FunctionDeclaration) ? declaration2 : null);
			if (val2 != null)
			{
				_functionDeclaration = new JintFunctionDeclarationStatement(val2);
				return;
			}
			StatementListItem declaration3 = _statement.Declaration;
			AssignmentExpression val3 = (AssignmentExpression)(object)((declaration3 is AssignmentExpression) ? declaration3 : null);
			if (val3 != null)
			{
				_assignmentExpression = JintAssignmentExpression.Build(val3);
			}
			else
			{
				_simpleExpression = JintExpression.Build((Expression)_statement.Declaration);
			}
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			Jint.Runtime.Environments.Environment lexicalEnvironment = context.Engine.ExecutionContext.LexicalEnvironment;
			JsValue jsValue;
			if (_classDefinition == null)
			{
				jsValue = ((_functionDeclaration != null) ? _functionDeclaration.Execute(context).GetValueOrDefault() : ((_assignmentExpression == null) ? _simpleExpression.GetValue(context) : _assignmentExpression.GetValue(context)));
			}
			else
			{
				jsValue = _classDefinition.BuildConstructor(context, lexicalEnvironment);
				string className = _classDefinition._className;
				if (className != null)
				{
					lexicalEnvironment.CreateMutableBinding(className);
					lexicalEnvironment.InitializeBinding(className, jsValue);
				}
			}
			if (jsValue is Function function && string.IsNullOrWhiteSpace(function._nameDescriptor?._value?.ToString()))
			{
				function.SetFunctionName("default");
			}
			lexicalEnvironment.InitializeBinding("*default*", jsValue);
			return Completion.Empty();
		}

		private static void InitializeBoundName(string name, JsValue value, Jint.Runtime.Environments.Environment? environment)
		{
			if ((object)environment != null)
			{
				environment.InitializeBinding(name, value);
			}
			else
			{
				ExceptionHelper.ThrowNotImplementedException();
			}
		}
	}
	internal sealed class JintExportNamedDeclaration : JintStatement<ExportNamedDeclaration>
	{
		private JintStatement? _declarationStatement;

		public JintExportNamedDeclaration(ExportNamedDeclaration statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			if (_statement.Declaration != null)
			{
				_declarationStatement = JintStatement.Build((Statement)(object)_statement.Declaration);
			}
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			_declarationStatement?.Execute(context);
			return new Completion(CompletionType.Normal, JsValue.Undefined, (SyntaxElement)(object)((JintStatement)this)._statement);
		}
	}
	internal sealed class JintExpressionStatement : JintStatement<ExpressionStatement>
	{
		private JintExpression _expression;

		private JintIdentifierExpression? _identifierExpression;

		public JintExpressionStatement(ExpressionStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_expression = JintExpression.Build(_statement.Expression);
			_identifierExpression = _expression as JintIdentifierExpression;
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			JsValue value = ((_identifierExpression != null) ? _identifierExpression.GetValue(context) : _expression.GetValue(context));
			return new Completion(context.Completion, value, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintForInForOfStatement : JintStatement<Statement>
	{
		private enum LhsKind
		{
			Assignment,
			VarBinding,
			LexicalBinding
		}

		private enum IteratorKind
		{
			Sync,
			Async
		}

		private enum IterationKind
		{
			Enumerate,
			Iterate,
			AsyncIterate
		}

		private readonly Node _leftNode;

		private readonly Statement _forBody;

		private readonly Expression _rightExpression;

		private readonly IterationKind _iterationKind;

		private ProbablyBlockStatement _body;

		private JintExpression? _expr;

		private BindingPattern? _assignmentPattern;

		private JintExpression _right;

		private List<Key>? _tdzNames;

		private bool _destructuring;

		private LhsKind _lhsKind;

		public JintForInForOfStatement(ForInStatement statement)
			: base((Statement)(object)statement)
		{
			_leftNode = statement.Left;
			_rightExpression = statement.Right;
			_forBody = statement.Body;
			_iterationKind = IterationKind.Enumerate;
		}

		public JintForInForOfStatement(ForOfStatement statement)
			: base((Statement)(object)statement)
		{
			_leftNode = statement.Left;
			_rightExpression = statement.Right;
			_forBody = statement.Body;
			_iterationKind = IterationKind.Iterate;
		}

		protected override void Initialize(EvaluationContext context)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			_lhsKind = LhsKind.Assignment;
			_ = context.Engine;
			Node leftNode = _leftNode;
			VariableDeclaration val = (VariableDeclaration)(object)((leftNode is VariableDeclaration) ? leftNode : null);
			if (val != null)
			{
				_lhsKind = (((int)val.Kind == 0) ? LhsKind.VarBinding : LhsKind.LexicalBinding);
				Node id = ((NodeList<VariableDeclarator>)val.Declarations)[0].Id;
				if (_lhsKind == LhsKind.LexicalBinding)
				{
					_tdzNames = new List<Key>(1);
					id.GetBoundNames(_tdzNames);
				}
				BindingPattern val2 = (BindingPattern)(object)((id is BindingPattern) ? id : null);
				if (val2 != null)
				{
					_destructuring = true;
					_assignmentPattern = val2;
				}
				else
				{
					Identifier expression = (Identifier)id;
					_expr = new JintIdentifierExpression(expression);
				}
			}
			else
			{
				Node leftNode2 = _leftNode;
				BindingPattern val3 = (BindingPattern)(object)((leftNode2 is BindingPattern) ? leftNode2 : null);
				if (val3 != null)
				{
					_destructuring = true;
					_assignmentPattern = val3;
				}
				else
				{
					Node leftNode3 = _leftNode;
					MemberExpression val4 = (MemberExpression)(object)((leftNode3 is MemberExpression) ? leftNode3 : null);
					if (val4 != null)
					{
						_expr = new JintMemberExpression(val4);
					}
					else
					{
						_expr = new JintIdentifierExpression((Identifier)_leftNode);
					}
				}
			}
			_body = new ProbablyBlockStatement(_forBody);
			_right = JintExpression.Build(_rightExpression);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			if (!HeadEvaluation(context, out IteratorInstance result))
			{
				return new Completion(CompletionType.Normal, JsValue.Undefined, (SyntaxElement)(object)_statement);
			}
			return BodyEvaluation(context, _expr, in _body, result, IterationKind.Enumerate, _lhsKind);
		}

		private bool HeadEvaluation(EvaluationContext context, [NotNullWhen(true)] out IteratorInstance? result)
		{
			Engine engine = context.Engine;
			Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
			DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(engine, lexicalEnvironment);
			if (_tdzNames != null)
			{
				DeclarativeEnvironment declarativeEnvironment2 = declarativeEnvironment;
				foreach (Key tdzName in _tdzNames)
				{
					declarativeEnvironment2.CreateMutableBinding(tdzName);
				}
			}
			engine.UpdateLexicalEnvironment(declarativeEnvironment);
			JsValue value = _right.GetValue(context);
			engine.UpdateLexicalEnvironment(lexicalEnvironment);
			if (_iterationKind == IterationKind.Enumerate)
			{
				if (value.IsNullOrUndefined())
				{
					result = null;
					return false;
				}
				ObjectInstance objectInstance = TypeConverter.ToObject(engine.Realm, value);
				result = new IteratorInstance.EnumerableIterator(engine, objectInstance.GetKeys());
			}
			else
			{
				result = (value as IteratorInstance) ?? value.GetIterator(engine.Realm);
			}
			return true;
		}

		private Completion BodyEvaluation(EvaluationContext context, JintExpression? lhs, in ProbablyBlockStatement stmt, IteratorInstance iteratorRecord, IterationKind iterationKind, LhsKind lhsKind, IteratorKind iteratorKind = IteratorKind.Sync)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Invalid comparison between Unknown and I4
			Engine engine = context.Engine;
			Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
			JsValue value = JsValue.Undefined;
			bool destructuring = _destructuring;
			string text = null;
			CompletionType completionType = CompletionType.Normal;
			bool flag = false;
			try
			{
				Completion result;
				do
				{
					IL_0029:
					Jint.Runtime.Environments.Environment environment = null;
					if (!iteratorRecord.TryIteratorStep(out ObjectInstance nextItem))
					{
						flag = true;
						return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)_statement);
					}
					if (iteratorKind == IteratorKind.Async)
					{
						ExceptionHelper.ThrowNotImplementedException("await");
					}
					JsValue jsValue = nextItem.Get(CommonProperties.Value);
					flag = true;
					object obj = null;
					if (lhsKind != LhsKind.LexicalBinding)
					{
						if (!destructuring)
						{
							obj = lhs.Evaluate(context);
						}
					}
					else
					{
						environment = JintEnvironment.NewDeclarativeEnvironment(engine, lexicalEnvironment);
						if (_tdzNames != null)
						{
							BindingInstantiation(environment);
						}
						engine.UpdateLexicalEnvironment(environment);
						if (!destructuring)
						{
							Identifier val = (Identifier)((NodeList<VariableDeclarator>)((VariableDeclaration)_leftNode).Declarations)[0].Id;
							if (text == null)
							{
								text = val.Name;
							}
							obj = engine.ResolveBinding(text);
						}
					}
					if (context.DebugMode)
					{
						context.Engine.Debugger.OnStep(_leftNode);
					}
					CompletionType completionType2 = CompletionType.Normal;
					if (!destructuring)
					{
						if (context.IsAbrupt())
						{
							flag = true;
							completionType2 = context.Completion;
						}
						else
						{
							Reference reference = (Reference)obj;
							if (lhsKind == LhsKind.LexicalBinding || ((int)_leftNode.Type == 32 && !reference.IsUnresolvableReference))
							{
								reference.InitializeReferencedBinding(jsValue);
							}
							else
							{
								engine.PutValue(reference, jsValue);
							}
						}
					}
					else
					{
						jsValue = DestructuringPatternAssignmentExpression.ProcessPatterns(context, _assignmentPattern, jsValue, environment, _lhsKind != LhsKind.VarBinding);
						completionType2 = context.Completion;
						if (lhsKind != LhsKind.Assignment)
						{
							_ = 1;
						}
					}
					if (completionType2 != CompletionType.Normal)
					{
						engine.UpdateLexicalEnvironment(lexicalEnvironment);
						if (_iterationKind == IterationKind.AsyncIterate)
						{
							iteratorRecord.Close(completionType2);
							return new Completion(completionType2, jsValue, context.LastSyntaxElement);
						}
						if (iterationKind == IterationKind.Enumerate)
						{
							return new Completion(completionType2, jsValue, context.LastSyntaxElement);
						}
						iteratorRecord.Close(completionType2);
						return new Completion(completionType2, jsValue, context.LastSyntaxElement);
					}
					result = stmt.Execute(context);
					engine.UpdateLexicalEnvironment(lexicalEnvironment);
					if (!result.Value.IsEmpty)
					{
						value = result.Value;
					}
					if (result.Type == CompletionType.Break)
					{
						if (context.Target != null)
						{
							string? target = context.Target;
							Statement statement = _statement;
							object b;
							if (statement == null)
							{
								b = null;
							}
							else
							{
								Identifier labelSet = statement.LabelSet;
								b = ((labelSet != null) ? labelSet.Name : null);
							}
							if (!string.Equals(target, (string?)b, StringComparison.Ordinal))
							{
								goto IL_026f;
							}
						}
						completionType = CompletionType.Normal;
						return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)_statement);
					}
					goto IL_026f;
					IL_026f:
					if (result.Type == CompletionType.Continue)
					{
						if (context.Target == null)
						{
							goto IL_0029;
						}
						string? target2 = context.Target;
						Statement statement2 = _statement;
						object b2;
						if (statement2 == null)
						{
							b2 = null;
						}
						else
						{
							Identifier labelSet2 = statement2.LabelSet;
							b2 = ((labelSet2 != null) ? labelSet2.Name : null);
						}
						if (string.Equals(target2, (string?)b2, StringComparison.Ordinal))
						{
							goto IL_0029;
						}
					}
					completionType = result.Type;
				}
				while (!result.IsAbrupt());
				flag = true;
				return result;
			}
			catch
			{
				completionType = CompletionType.Throw;
				throw;
			}
			finally
			{
				if (flag)
				{
					try
					{
						iteratorRecord.Close(completionType);
					}
					catch
					{
						if (completionType != CompletionType.Throw)
						{
							throw;
						}
					}
				}
				engine.UpdateLexicalEnvironment(lexicalEnvironment);
			}
		}

		private void BindingInstantiation(Jint.Runtime.Environments.Environment environment)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			DeclarativeEnvironment declarativeEnvironment = (DeclarativeEnvironment)environment;
			VariableDeclaration val = (VariableDeclaration)_leftNode;
			List<Key> list = new List<Key>();
			val.GetBoundNames(list);
			for (int i = 0; i < list.Count; i++)
			{
				Key name = list[i];
				if ((int)val.Kind == 2)
				{
					declarativeEnvironment.CreateImmutableBinding(name);
				}
				else
				{
					declarativeEnvironment.CreateMutableBinding(name);
				}
			}
		}
	}
	internal sealed class JintForStatement : JintStatement<ForStatement>
	{
		private JintVariableDeclaration? _initStatement;

		private JintExpression? _initExpression;

		private JintExpression? _test;

		private JintExpression? _increment;

		private ProbablyBlockStatement _body;

		private List<Key>? _boundNames;

		private bool _shouldCreatePerIterationEnvironment;

		public JintForStatement(ForStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Invalid comparison between Unknown and I4
			_ = context.Engine;
			_body = new ProbablyBlockStatement(_statement.Body);
			if (_statement.Init != null)
			{
				if ((int)((Node)_statement.Init).Type == 69)
				{
					VariableDeclaration val = (VariableDeclaration)_statement.Init;
					if ((int)val.Kind != 0)
					{
						_boundNames = new List<Key>();
						val.GetBoundNames(_boundNames);
					}
					_initStatement = new JintVariableDeclaration(val);
					_shouldCreatePerIterationEnvironment = (int)val.Kind == 1;
				}
				else
				{
					_initExpression = JintExpression.Build((Expression)_statement.Init);
				}
			}
			if (_statement.Test != null)
			{
				_test = JintExpression.Build(_statement.Test);
			}
			if (_statement.Update != null)
			{
				_increment = JintExpression.Build(_statement.Update);
			}
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			Jint.Runtime.Environments.Environment environment = null;
			Jint.Runtime.Environments.Environment environment2 = null;
			Engine engine = context.Engine;
			if (_boundNames != null)
			{
				environment = engine.ExecutionContext.LexicalEnvironment;
				environment2 = JintEnvironment.NewDeclarativeEnvironment(engine, environment);
				Jint.Runtime.Environments.Environment environment3 = environment2;
				VariableDeclarationKind kind = _initStatement._statement.Kind;
				for (int i = 0; i < _boundNames.Count; i++)
				{
					Key name = _boundNames[i];
					if ((int)kind == 2)
					{
						environment3.CreateImmutableBinding(name);
					}
					else
					{
						environment3.CreateMutableBinding(name);
					}
				}
				engine.UpdateLexicalEnvironment(environment2);
			}
			try
			{
				if (_initExpression != null)
				{
					_initExpression?.GetValue(context);
				}
				else
				{
					_initStatement?.Execute(context);
				}
				return ForBodyEvaluation(context);
			}
			finally
			{
				if ((object)environment != null)
				{
					engine.UpdateLexicalEnvironment(environment);
				}
			}
		}

		private Completion ForBodyEvaluation(EvaluationContext context)
		{
			JsValue value = JsValue.Undefined;
			if (_shouldCreatePerIterationEnvironment)
			{
				CreatePerIterationEnvironment(context);
			}
			DebugHandler debugHandler = (context.DebugMode ? context.Engine.Debugger : null);
			Completion result;
			while (true)
			{
				if (_test != null)
				{
					debugHandler?.OnStep((Node)(object)_test._expression);
					if (!TypeConverter.ToBoolean(_test.GetValue(context)))
					{
						return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)((JintStatement)this)._statement);
					}
				}
				result = _body.Execute(context);
				if (!result.Value.IsEmpty)
				{
					value = result.Value;
				}
				if (result.Type == CompletionType.Break)
				{
					if (context.Target != null)
					{
						string? target = context.Target;
						ForStatement statement = _statement;
						object b;
						if (statement == null)
						{
							b = null;
						}
						else
						{
							Identifier labelSet = ((Statement)statement).LabelSet;
							b = ((labelSet != null) ? labelSet.Name : null);
						}
						if (!string.Equals(target, (string?)b, StringComparison.Ordinal))
						{
							goto IL_00da;
						}
					}
					return new Completion(CompletionType.Normal, result.Value, (SyntaxElement)(object)((JintStatement)this)._statement);
				}
				goto IL_00da;
				IL_00da:
				if (result.Type != CompletionType.Continue)
				{
					goto IL_0117;
				}
				if (context.Target != null)
				{
					string? target2 = context.Target;
					ForStatement statement2 = _statement;
					object b2;
					if (statement2 == null)
					{
						b2 = null;
					}
					else
					{
						Identifier labelSet2 = ((Statement)statement2).LabelSet;
						b2 = ((labelSet2 != null) ? labelSet2.Name : null);
					}
					if (!string.Equals(target2, (string?)b2, StringComparison.Ordinal))
					{
						goto IL_0117;
					}
				}
				goto IL_0121;
				IL_0117:
				if (result.Type != CompletionType.Normal)
				{
					break;
				}
				goto IL_0121;
				IL_0121:
				if (_shouldCreatePerIterationEnvironment)
				{
					CreatePerIterationEnvironment(context);
				}
				if (_increment != null)
				{
					debugHandler?.OnStep((Node)(object)_increment._expression);
					_increment.Evaluate(context);
				}
			}
			return result;
		}

		private void CreatePerIterationEnvironment(EvaluationContext context)
		{
			Engine engine = context.Engine;
			DeclarativeEnvironment declarativeEnvironment = (DeclarativeEnvironment)engine.ExecutionContext.LexicalEnvironment;
			DeclarativeEnvironment declarativeEnvironment2 = JintEnvironment.NewDeclarativeEnvironment(engine, declarativeEnvironment._outerEnv);
			declarativeEnvironment.TransferTo(_boundNames, declarativeEnvironment2);
			engine.UpdateLexicalEnvironment(declarativeEnvironment2);
		}
	}
	internal sealed class JintFunctionDeclarationStatement : JintStatement<FunctionDeclaration>
	{
		public JintFunctionDeclarationStatement(FunctionDeclaration statement)
			: base(statement)
		{
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			return new Completion(CompletionType.Normal, JsEmpty.Instance, (SyntaxElement)(object)((JintStatement)this)._statement);
		}
	}
	internal sealed class JintIfStatement : JintStatement<IfStatement>
	{
		private ProbablyBlockStatement _statementConsequent;

		private JintExpression _test;

		private ProbablyBlockStatement? _alternate;

		public JintIfStatement(IfStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_statementConsequent = new ProbablyBlockStatement(_statement.Consequent);
			_test = JintExpression.Build(_statement.Test);
			_alternate = ((_statement.Alternate != null) ? new ProbablyBlockStatement?(new ProbablyBlockStatement(_statement.Alternate)) : ((ProbablyBlockStatement?)null));
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			Completion completion = Completion.Empty();
			if (TypeConverter.ToBoolean(_test.GetValue(context)))
			{
				completion = _statementConsequent.Execute(context);
			}
			else if (_alternate.HasValue)
			{
				completion = _alternate.Value.Execute(context);
			}
			return completion.UpdateEmpty(JsValue.Undefined);
		}
	}
	internal sealed class JintImportDeclaration : JintStatement<ImportDeclaration>
	{
		public JintImportDeclaration(ImportDeclaration statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			context.Engine.GetActiveScriptOrModule().AsModule(context.Engine, in context.LastSyntaxElement.Location);
			return Completion.Empty();
		}
	}
	internal sealed class JintLabeledStatement : JintStatement<LabeledStatement>
	{
		private JintStatement _body;

		private string? _labelName;

		public JintLabeledStatement(LabeledStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_body = JintStatement.Build(_statement.Body);
			_labelName = _statement.Label.Name;
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			Completion result = _body.Execute(context);
			if (result.Type == CompletionType.Break && string.Equals(context.Target, _labelName, StringComparison.Ordinal))
			{
				JsValue value = result.Value;
				return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)_statement);
			}
			return result;
		}
	}
	internal sealed class JintReturnStatement : JintStatement<ReturnStatement>
	{
		private JintExpression? _argument;

		public JintReturnStatement(ReturnStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_argument = ((_statement.Argument != null) ? JintExpression.Build(_statement.Argument) : null);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			JsValue value = ((_argument != null) ? _argument.GetValue(context).Clone() : JsValue.Undefined);
			return new Completion(CompletionType.Return, value, (SyntaxElement)(object)_statement);
		}
	}
	internal sealed class JintScript
	{
		private readonly JintStatementList _list;

		public JintScript(Script script)
		{
			_list = new JintStatementList((Program)(object)script);
		}

		public Completion Execute(EvaluationContext context)
		{
			return _list.Execute(context);
		}
	}
	internal abstract class JintStatement<T> : JintStatement where T : Statement
	{
		internal new readonly T _statement;

		protected JintStatement(T statement)
			: base((Statement)(object)statement)
		{
			_statement = statement;
		}
	}
	internal abstract class JintStatement
	{
		internal readonly Statement _statement;

		private bool _initialized;

		public ref readonly Location Location => ref ((SyntaxElement)_statement).Location;

		protected JintStatement(Statement statement)
		{
			_statement = statement;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
		public Completion Execute(EvaluationContext context)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			if ((int)((Node)_statement).Type != 8)
			{
				context.PrepareFor((Node)(object)_statement);
				context.RunBeforeExecuteStatementChecks((StatementListItem)(object)_statement);
			}
			if (!_initialized)
			{
				Initialize(context);
				_initialized = true;
			}
			return ExecuteInternal(context);
		}

		protected abstract Completion ExecuteInternal(EvaluationContext context);

		protected virtual void Initialize(EvaluationContext context)
		{
		}

		protected internal static JintStatement Build(Statement statement)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected I4, but got Unknown
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected I4, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Expected O, but got Unknown
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Invalid comparison between Unknown and I4
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			if (((SyntaxElement)statement).AssociatedData is JintStatement result)
			{
				return result;
			}
			Nodes type = ((Node)statement).Type;
			JintStatement jintStatement;
			if ((int)type <= 54)
			{
				switch (type - 8)
				{
				case 0:
					goto IL_00ec;
				case 1:
					goto IL_011f;
				case 9:
					goto IL_0130;
				case 12:
					goto IL_0141;
				case 13:
					goto IL_0152;
				case 18:
					goto IL_0163;
				case 21:
					goto IL_0174;
				case 19:
					goto IL_0185;
				case 20:
					goto IL_0196;
				case 25:
					goto IL_01a7;
				case 32:
					goto IL_01b8;
				case 22:
					goto IL_01da;
				case 10:
					goto IL_0226;
				case 6:
					goto IL_0234;
				case 16:
					goto IL_0242;
				case 14:
					goto IL_0250;
				case 15:
					goto IL_025e;
				case 27:
					goto IL_026c;
				case 2:
				case 3:
				case 4:
				case 5:
				case 7:
				case 8:
				case 11:
				case 17:
				case 23:
				case 24:
				case 26:
				case 28:
				case 29:
				case 30:
				case 31:
					goto IL_027a;
				}
				if ((int)type != 54)
				{
					goto IL_027a;
				}
				jintStatement = new JintReturnStatement((ReturnStatement)statement);
			}
			else if ((int)type != 60)
			{
				switch (type - 65)
				{
				case 4:
					break;
				case 0:
					goto IL_01eb;
				case 1:
					goto IL_01fc;
				case 6:
					goto IL_020a;
				case 7:
					goto IL_0218;
				default:
					goto IL_027a;
				}
				jintStatement = new JintVariableDeclaration((VariableDeclaration)statement);
			}
			else
			{
				jintStatement = new JintSwitchStatement((SwitchStatement)statement);
			}
			goto IL_027c;
			IL_01da:
			jintStatement = new JintFunctionDeclarationStatement((FunctionDeclaration)statement);
			goto IL_027c;
			IL_01b8:
			jintStatement = new JintLabeledStatement((LabeledStatement)statement);
			goto IL_027c;
			IL_027c:
			JintStatement jintStatement2 = jintStatement;
			if (jintStatement2 == null)
			{
				ExceptionHelper.ThrowArgumentOutOfRangeException("Type", $"unsupported statement type '{((Node)statement).Type}'");
			}
			return jintStatement2;
			IL_027a:
			jintStatement = null;
			goto IL_027c;
			IL_01eb:
			jintStatement = new JintThrowStatement((ThrowStatement)statement);
			goto IL_027c;
			IL_01fc:
			jintStatement = new JintTryStatement((TryStatement)statement);
			goto IL_027c;
			IL_01a7:
			jintStatement = new JintIfStatement((IfStatement)statement);
			goto IL_027c;
			IL_020a:
			jintStatement = new JintWhileStatement((WhileStatement)statement);
			goto IL_027c;
			IL_0218:
			jintStatement = new JintWithStatement((WithStatement)statement);
			goto IL_027c;
			IL_026c:
			jintStatement = new JintImportDeclaration((ImportDeclaration)statement);
			goto IL_027c;
			IL_00ec:
			jintStatement = new JintBlockStatement((BlockStatement)statement);
			goto IL_027c;
			IL_011f:
			jintStatement = new JintBreakStatement((BreakStatement)statement);
			goto IL_027c;
			IL_0234:
			jintStatement = new JintClassDeclarationStatement((ClassDeclaration)statement);
			goto IL_027c;
			IL_0130:
			jintStatement = new JintContinueStatement((ContinueStatement)statement);
			goto IL_027c;
			IL_0226:
			jintStatement = new JintDebuggerStatement((DebuggerStatement)statement);
			goto IL_027c;
			IL_0141:
			jintStatement = new JintDoWhileStatement((DoWhileStatement)statement);
			goto IL_027c;
			IL_0152:
			jintStatement = new JintEmptyStatement((EmptyStatement)statement);
			goto IL_027c;
			IL_0250:
			jintStatement = new JintExportAllDeclaration((ExportAllDeclaration)statement);
			goto IL_027c;
			IL_025e:
			jintStatement = new JintExportDefaultDeclaration((ExportDefaultDeclaration)statement);
			goto IL_027c;
			IL_0242:
			jintStatement = new JintExportNamedDeclaration((ExportNamedDeclaration)statement);
			goto IL_027c;
			IL_0163:
			jintStatement = new JintExpressionStatement((ExpressionStatement)statement);
			goto IL_027c;
			IL_0185:
			jintStatement = new JintForInForOfStatement((ForInStatement)statement);
			goto IL_027c;
			IL_0196:
			jintStatement = new JintForInForOfStatement((ForOfStatement)statement);
			goto IL_027c;
			IL_0174:
			jintStatement = new JintForStatement((ForStatement)statement);
			goto IL_027c;
		}

		internal static JsValue? FastResolve(StatementListItem statement)
		{
			ReturnStatement val = (ReturnStatement)(object)((statement is ReturnStatement) ? statement : null);
			if (val != null)
			{
				Expression argument = val.Argument;
				Literal val2 = (Literal)(object)((argument is Literal) ? argument : null);
				if (val2 != null)
				{
					return JintLiteralExpression.ConvertToJsValue(val2);
				}
			}
			return null;
		}
	}
	internal sealed class JintSwitchBlock
	{
		private sealed class JintSwitchCase
		{
			internal readonly JintStatementList Consequent;

			internal readonly JintExpression? Test;

			internal readonly List<Declaration>? LexicalDeclarations;

			public JintSwitchCase(SwitchCase switchCase)
			{
				Consequent = new JintStatementList(null, switchCase.Consequent);
				LexicalDeclarations = HoistingScope.GetLexicalDeclarations(switchCase);
				if (switchCase.Test != null)
				{
					Test = JintExpression.Build(switchCase.Test);
				}
			}
		}

		private readonly NodeList<SwitchCase> _switchBlock;

		private JintSwitchCase[] _jintSwitchBlock = Array.Empty<JintSwitchCase>();

		private bool _initialized;

		public JintSwitchBlock(NodeList<SwitchCase> switchBlock)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			_switchBlock = switchBlock;
		}

		private void Initialize()
		{
			_jintSwitchBlock = new JintSwitchCase[_switchBlock.Count];
			for (int i = 0; i < _jintSwitchBlock.Length; i++)
			{
				_jintSwitchBlock[i] = new JintSwitchCase(_switchBlock[i]);
			}
		}

		public Completion Execute(EvaluationContext context, JsValue input)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			JsValue jsValue = JsValue.Undefined;
			SyntaxElement source = context.LastSyntaxElement;
			bool flag = false;
			int num = -1;
			int num2 = 0;
			Jint.Runtime.Environments.Environment environment = null;
			JintSwitchCase[] jintSwitchBlock = _jintSwitchBlock;
			DeclarativeEnvironment declarativeEnvironment = null;
			while (true)
			{
				if (num2 < jintSwitchBlock.Length)
				{
					JintSwitchCase jintSwitchCase = jintSwitchBlock[num2];
					if (jintSwitchCase.LexicalDeclarations != null && (object)environment == null)
					{
						environment = context.Engine.ExecutionContext.LexicalEnvironment;
						if ((object)declarativeEnvironment == null)
						{
							declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(context.Engine, environment);
						}
						declarativeEnvironment.Clear();
						JintStatementList.BlockDeclarationInstantiation(declarativeEnvironment, jintSwitchCase.LexicalDeclarations);
						context.Engine.UpdateLexicalEnvironment(declarativeEnvironment);
					}
					if (jintSwitchCase.Test == null)
					{
						num = num2;
						if (!flag)
						{
							goto IL_0134;
						}
					}
					if (jintSwitchCase.Test?.GetValue(context) == input)
					{
						flag = true;
					}
					if (!flag)
					{
						if ((object)environment != null)
						{
							context.Engine.UpdateLexicalEnvironment(environment);
							environment = null;
						}
					}
					else
					{
						Completion completion = jintSwitchCase.Consequent.Execute(context);
						if (completion.Type != CompletionType.Normal)
						{
							if ((object)environment != null)
							{
								context.Engine.UpdateLexicalEnvironment(environment);
							}
							return completion.UpdateEmpty(jsValue);
						}
						source = completion._source;
						jsValue = (completion.Value.IsUndefined() ? jsValue : completion.Value);
					}
					goto IL_0134;
				}
				if (flag || num == -1)
				{
					break;
				}
				flag = true;
				num2 = num;
				continue;
				IL_0134:
				num2++;
			}
			if ((object)environment != null)
			{
				context.Engine.UpdateLexicalEnvironment(environment);
			}
			return new Completion(CompletionType.Normal, jsValue, source);
		}
	}
	internal sealed class JintSwitchStatement : JintStatement<SwitchStatement>
	{
		private JintSwitchBlock _switchBlock;

		private JintExpression _discriminant;

		public JintSwitchStatement(SwitchStatement statement)
			: base(statement)
		{
		}

		protected unsafe override void Initialize(EvaluationContext context)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			_switchBlock = new JintSwitchBlock(Unsafe.Read<NodeList<SwitchCase>>((void*)_statement.Cases));
			_discriminant = JintExpression.Build(_statement.Discriminant);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			JsValue value = _discriminant.GetValue(context);
			Completion result = _switchBlock.Execute(context, value);
			if (result.Type == CompletionType.Break)
			{
				string? target = context.Target;
				Identifier labelSet = ((Statement)_statement).LabelSet;
				if (string.Equals(target, (labelSet != null) ? labelSet.Name : null, StringComparison.Ordinal))
				{
					return new Completion(CompletionType.Normal, result.Value, (SyntaxElement)(object)((JintStatement)this)._statement);
				}
			}
			return result;
		}
	}
	internal sealed class JintThrowStatement : JintStatement<ThrowStatement>
	{
		private JintExpression _argument;

		public JintThrowStatement(ThrowStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_argument = JintExpression.Build(_statement.Argument);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			return new Completion(CompletionType.Throw, _argument.GetValue(context), (SyntaxElement)(object)_argument._expression);
		}
	}
	internal sealed class JintTryStatement : JintStatement<TryStatement>
	{
		private JintBlockStatement _block;

		private JintBlockStatement? _catch;

		private JintBlockStatement? _finalizer;

		public JintTryStatement(TryStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_block = new JintBlockStatement(_statement.Block);
			if (_statement.Finalizer != null)
			{
				_finalizer = new JintBlockStatement(_statement.Finalizer);
			}
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			Engine engine = context.Engine;
			Completion completion = _block.Execute(context);
			if (completion.Type == CompletionType.Throw)
			{
				completion = ExecuteCatch(context, completion, engine);
			}
			if (_finalizer != null)
			{
				Completion completion2 = _finalizer.Execute(context);
				if (completion2.Type == CompletionType.Normal)
				{
					return completion;
				}
				return completion2.UpdateEmpty(JsValue.Undefined);
			}
			return completion.UpdateEmpty(JsValue.Undefined);
		}

		private Completion ExecuteCatch(EvaluationContext context, Completion b, Engine engine)
		{
			if (_statement.Handler != null)
			{
				if (_catch == null)
				{
					_catch = new JintBlockStatement(_statement.Handler.Body);
				}
				JsValue value = b.Value;
				Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
				DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(engine, lexicalEnvironment, catchEnvironment: true);
				List<Key> list = new List<Key>();
				_statement.Handler.Param.GetBoundNames(list);
				for (int i = 0; i < list.Count; i++)
				{
					declarativeEnvironment.CreateMutableBinding(list[i]);
				}
				engine.UpdateLexicalEnvironment(declarativeEnvironment);
				CatchClause handler = _statement.Handler;
				((handler != null) ? handler.Param : null).BindingInitialization(context, value, declarativeEnvironment);
				b = _catch.Execute(context);
				engine.UpdateLexicalEnvironment(lexicalEnvironment);
			}
			return b;
		}
	}
	internal sealed class JintVariableDeclaration : JintStatement<VariableDeclaration>
	{
		private sealed class ResolvedDeclaration
		{
			internal JintExpression? Left;

			internal BindingPattern? LeftPattern;

			internal JintExpression? Init;

			internal JintIdentifierExpression? LeftIdentifierExpression;

			internal bool EvalOrArguments;
		}

		private ResolvedDeclaration[] _declarations = Array.Empty<ResolvedDeclaration>();

		public JintVariableDeclaration(VariableDeclaration statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			_declarations = new ResolvedDeclaration[((NodeList<VariableDeclarator>)_statement.Declarations).Count];
			for (int i = 0; i < _declarations.Length; i++)
			{
				VariableDeclarator val = ((NodeList<VariableDeclarator>)_statement.Declarations)[i];
				JintExpression jintExpression = null;
				JintExpression init = null;
				BindingPattern leftPattern = null;
				Node id = val.Id;
				BindingPattern val2 = (BindingPattern)(object)((id is BindingPattern) ? id : null);
				if (val2 != null)
				{
					leftPattern = val2;
				}
				else
				{
					jintExpression = JintExpression.Build((Expression)(Identifier)val.Id);
				}
				if (val.Init != null)
				{
					init = JintExpression.Build(val.Init);
				}
				JintIdentifierExpression jintIdentifierExpression = jintExpression as JintIdentifierExpression;
				_declarations[i] = new ResolvedDeclaration
				{
					Left = jintExpression,
					LeftPattern = leftPattern,
					LeftIdentifierExpression = jintIdentifierExpression,
					EvalOrArguments = (jintIdentifierExpression?.HasEvalOrArguments ?? false),
					Init = init
				};
			}
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Invalid comparison between Unknown and I4
			Engine engine = context.Engine;
			ResolvedDeclaration[] declarations = _declarations;
			foreach (ResolvedDeclaration resolvedDeclaration in declarations)
			{
				if ((int)_statement.Kind != 0 && resolvedDeclaration.Left != null)
				{
					Reference reference = (Reference)resolvedDeclaration.Left.Evaluate(context);
					JsValue jsValue = JsValue.Undefined;
					if (resolvedDeclaration.Init != null)
					{
						jsValue = resolvedDeclaration.Init.GetValue(context).Clone();
						if (resolvedDeclaration.Init._expression.IsFunctionDefinition<Expression>())
						{
							((Function)jsValue).SetFunctionName(reference.ReferencedName);
						}
					}
					reference.InitializeReferencedBinding(jsValue);
					engine._referencePool.Return(reference);
				}
				else
				{
					if (resolvedDeclaration.Init == null)
					{
						continue;
					}
					if (resolvedDeclaration.LeftPattern != null)
					{
						Jint.Runtime.Environments.Environment environment = (((int)_statement.Kind != 0) ? engine.ExecutionContext.LexicalEnvironment : null);
						JsValue value = resolvedDeclaration.Init.GetValue(context);
						DestructuringPatternAssignmentExpression.ProcessPatterns(context, resolvedDeclaration.LeftPattern, value, environment, (int)_statement.Kind > 0);
					}
					else if (resolvedDeclaration.LeftIdentifierExpression == null || JintAssignmentExpression.SimpleAssignmentExpression.AssignToIdentifier(context, resolvedDeclaration.LeftIdentifierExpression, resolvedDeclaration.Init, resolvedDeclaration.EvalOrArguments) == null)
					{
						Reference reference2 = (Reference)resolvedDeclaration.Left.Evaluate(context);
						reference2.AssertValid(engine.Realm);
						JsValue jsValue2 = resolvedDeclaration.Init.GetValue(context).Clone();
						if (resolvedDeclaration.Init._expression.IsFunctionDefinition<Expression>())
						{
							((Function)jsValue2).SetFunctionName(reference2.ReferencedName);
						}
						engine.PutValue(reference2, jsValue2);
						engine._referencePool.Return(reference2);
					}
				}
			}
			return Completion.Empty();
		}
	}
	internal sealed class JintWhileStatement : JintStatement<WhileStatement>
	{
		private string? _labelSetName;

		private ProbablyBlockStatement _body;

		private JintExpression _test;

		public JintWhileStatement(WhileStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			Identifier labelSet = ((Statement)_statement).LabelSet;
			_labelSetName = ((labelSet != null) ? labelSet.Name : null);
			_body = new ProbablyBlockStatement(_statement.Body);
			_test = JintExpression.Build(_statement.Test);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			JsValue value = JsValue.Undefined;
			Completion result;
			while (true)
			{
				if (context.DebugMode)
				{
					context.Engine.Debugger.OnStep((Node)(object)_test._expression);
				}
				if (!TypeConverter.ToBoolean(_test.GetValue(context)))
				{
					return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)_statement);
				}
				result = _body.Execute(context);
				if (!result.Value.IsEmpty)
				{
					value = result.Value;
				}
				if (result.Type != CompletionType.Continue || !string.Equals(context.Target, _labelSetName, StringComparison.Ordinal))
				{
					if (result.Type == CompletionType.Break && (context.Target == null || string.Equals(context.Target, _labelSetName, StringComparison.Ordinal)))
					{
						return new Completion(CompletionType.Normal, value, (SyntaxElement)(object)_statement);
					}
					if (result.Type != CompletionType.Normal)
					{
						break;
					}
				}
			}
			return result;
		}
	}
	internal sealed class JintWithStatement : JintStatement<WithStatement>
	{
		private ProbablyBlockStatement _body;

		private JintExpression _object;

		public JintWithStatement(WithStatement statement)
			: base(statement)
		{
		}

		protected override void Initialize(EvaluationContext context)
		{
			_body = new ProbablyBlockStatement(_statement.Body);
			_object = JintExpression.Build(_statement.Object);
		}

		protected override Completion ExecuteInternal(EvaluationContext context)
		{
			JsValue value = _object.GetValue(context);
			Engine engine = context.Engine;
			ObjectInstance objectInstance = TypeConverter.ToObject(engine.Realm, value);
			Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
			ObjectEnvironment newEnv = JintEnvironment.NewObjectEnvironment(engine, objectInstance, lexicalEnvironment, provideThis: true, withEnvironment: true);
			engine.UpdateLexicalEnvironment(newEnv);
			try
			{
				return _body.Execute(context);
			}
			catch (JavaScriptException ex)
			{
				return new Completion(CompletionType.Throw, ex.Error, (SyntaxElement)(object)_statement);
			}
			finally
			{
				engine.UpdateLexicalEnvironment(lexicalEnvironment);
			}
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct ProbablyBlockStatement
	{
		private readonly JintStatement? _statement;

		private readonly JintBlockStatement? _blockStatement;

		public ProbablyBlockStatement(Statement statement)
		{
			_statement = null;
			_blockStatement = null;
			BlockStatement val = (BlockStatement)(object)((statement is BlockStatement) ? statement : null);
			if (val != null)
			{
				_blockStatement = new JintBlockStatement(val);
			}
			else
			{
				_statement = JintStatement.Build(statement);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Completion Execute(EvaluationContext context)
		{
			if (_blockStatement != null)
			{
				return _blockStatement.ExecuteBlock(context);
			}
			return _statement.Execute(context);
		}
	}
}
namespace Jint.Runtime.Interpreter.Expressions
{
	internal sealed class DestructuringPatternAssignmentExpression : JintExpression
	{
		private readonly BindingPattern _pattern;

		private JintExpression _right;

		private bool _initialized;

		public DestructuringPatternAssignmentExpression(AssignmentExpression expression)
			: base((Expression)(object)expression)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			_pattern = (BindingPattern)expression.Left;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized)
			{
				_right = JintExpression.Build(((AssignmentExpression)_expression).Right);
				_initialized = true;
			}
			JsValue value = _right.GetValue(context);
			if (context.IsAbrupt())
			{
				return value;
			}
			JsValue result = ProcessPatterns(context, _pattern, value, null);
			if (context.IsAbrupt())
			{
				return result;
			}
			return value;
		}

		internal static JsValue ProcessPatterns(EvaluationContext context, BindingPattern pattern, JsValue argument, Jint.Runtime.Environments.Environment? environment, bool checkPatternPropertyReference = true)
		{
			ArrayPattern val = (ArrayPattern)(object)((pattern is ArrayPattern) ? pattern : null);
			if (val != null)
			{
				return HandleArrayPattern(context, val, argument, environment, checkPatternPropertyReference);
			}
			ObjectPattern val2 = (ObjectPattern)(object)((pattern is ObjectPattern) ? pattern : null);
			if (val2 != null)
			{
				return HandleObjectPattern(context, val2, argument, environment, checkPatternPropertyReference);
			}
			ExceptionHelper.ThrowArgumentException("Not a pattern");
			return null;
		}

		private static bool ConsumeFromIterator(IteratorInstance it, out JsValue value, out bool done)
		{
			value = JsValue.Undefined;
			done = false;
			if (!it.TryIteratorStep(out ObjectInstance nextItem))
			{
				done = true;
				return false;
			}
			value = nextItem.Get(CommonProperties.Value);
			return true;
		}

		private static JsValue HandleArrayPattern(EvaluationContext context, ArrayPattern pattern, JsValue argument, Jint.Runtime.Environments.Environment? environment, bool checkReference)
		{
			Engine engine = context.Engine;
			Realm realm = engine.Realm;
			ObjectInstance objectInstance = TypeConverter.ToObject(realm, argument);
			ArrayOperations arrayOperations = null;
			IteratorInstance iteratorInstance = null;
			if (objectInstance.IsArrayLike && objectInstance.HasOriginalIterator)
			{
				arrayOperations = ArrayOperations.For(objectInstance, forWrite: false);
			}
			else
			{
				iteratorInstance = objectInstance.GetIterator(realm);
			}
			CompletionType completion = CompletionType.Normal;
			bool flag = false;
			bool done = false;
			uint num = 0u;
			try
			{
				for (ref NodeList<Node> elements = pattern.Elements; num < elements.Count; num++)
				{
					Node val = elements[(int)num];
					if (val == null)
					{
						JsValue value;
						if (arrayOperations != null)
						{
							arrayOperations.TryGetValue(num, out value);
						}
						else if (!ConsumeFromIterator(iteratorInstance, out value, out done))
						{
							break;
						}
						continue;
					}
					Identifier val2 = (Identifier)(object)((val is Identifier) ? val : null);
					if (val2 != null)
					{
						JsValue value2;
						if (arrayOperations != null)
						{
							arrayOperations.TryGetValue(num, out value2);
						}
						else
						{
							ConsumeFromIterator(iteratorInstance, out value2, out done);
						}
						AssignToIdentifier(engine, val2.Name, value2, environment, checkReference);
						continue;
					}
					MemberExpression val3 = (MemberExpression)(object)((val is MemberExpression) ? val : null);
					if (val3 != null)
					{
						flag = true;
						Reference referenceFromMember = GetReferenceFromMember(context, val3);
						JsValue value3;
						if (arrayOperations != null)
						{
							arrayOperations.TryGetValue(num, out value3);
						}
						else
						{
							ConsumeFromIterator(iteratorInstance, out value3, out done);
						}
						AssignToReference(engine, referenceFromMember, value3, environment);
						continue;
					}
					BindingPattern val4 = (BindingPattern)(object)((val is BindingPattern) ? val : null);
					if (val4 != null)
					{
						JsValue value4;
						if (arrayOperations != null)
						{
							arrayOperations.TryGetValue(num, out value4);
						}
						else
						{
							iteratorInstance.TryIteratorStep(out ObjectInstance nextItem);
							value4 = nextItem;
						}
						ProcessPatterns(context, val4, value4, environment);
						continue;
					}
					RestElement val5 = (RestElement)(object)((val is RestElement) ? val : null);
					if (val5 != null)
					{
						flag = true;
						Reference lhs = null;
						Node argument2 = val5.Argument;
						MemberExpression val6 = (MemberExpression)(object)((argument2 is MemberExpression) ? argument2 : null);
						if (val6 != null)
						{
							lhs = GetReferenceFromMember(context, val6);
						}
						JsArray jsArray;
						if (arrayOperations != null)
						{
							uint length = arrayOperations.GetLength();
							jsArray = engine.Realm.Intrinsics.Array.ArrayCreate(length - num);
							for (uint num2 = num; num2 < length; num2++)
							{
								arrayOperations.TryGetValue(num2, out JsValue value5);
								jsArray.SetIndexValue(num2 - num, value5, updateLength: false);
							}
						}
						else
						{
							jsArray = engine.Realm.Intrinsics.Array.ArrayCreate(0uL);
							uint num3 = 0u;
							done = true;
							ObjectInstance nextItem2;
							while (iteratorInstance.TryIteratorStep(out nextItem2))
							{
								JsValue value6 = nextItem2.Get(CommonProperties.Value);
								jsArray.SetIndexValue(num3++, value6, updateLength: false);
							}
							done = true;
							jsArray.SetLength(num3);
						}
						Node argument3 = val5.Argument;
						Identifier val7 = (Identifier)(object)((argument3 is Identifier) ? argument3 : null);
						if (val7 != null)
						{
							AssignToIdentifier(engine, val7.Name, jsArray, environment, checkReference);
							continue;
						}
						Node argument4 = val5.Argument;
						BindingPattern val8 = (BindingPattern)(object)((argument4 is BindingPattern) ? argument4 : null);
						if (val8 != null)
						{
							ProcessPatterns(context, val8, jsArray, environment);
						}
						else
						{
							AssignToReference(engine, lhs, jsArray, environment);
						}
						continue;
					}
					AssignmentPattern val9 = (AssignmentPattern)(object)((val is AssignmentPattern) ? val : null);
					if (val9 != null)
					{
						JsValue value7;
						if (arrayOperations != null)
						{
							arrayOperations.TryGetValue(num, out value7);
						}
						else
						{
							ConsumeFromIterator(iteratorInstance, out value7, out done);
						}
						if (value7.IsUndefined())
						{
							JsValue value8 = JintExpression.Build(val9.Right).GetValue(context);
							if (context.IsAbrupt())
							{
								return value8;
							}
							value7 = value8;
						}
						Node left = val9.Left;
						Identifier val10 = (Identifier)(object)((left is Identifier) ? left : null);
						if (val10 != null)
						{
							if (val9.Right.IsFunctionDefinition<Expression>())
							{
								((Function)value7).SetFunctionName(new JsString(val10.Name));
							}
							AssignToIdentifier(engine, val10.Name, value7, environment, checkReference);
							continue;
						}
						Node left2 = val9.Left;
						BindingPattern val11 = (BindingPattern)(object)((left2 is BindingPattern) ? left2 : null);
						if (val11 != null)
						{
							ProcessPatterns(context, val11, value7, environment);
						}
						continue;
					}
					ExceptionHelper.ThrowArgumentOutOfRangeException("pattern", $"Unable to determine how to handle array pattern element {val}");
					break;
				}
				flag = true;
			}
			catch
			{
				completion = CompletionType.Throw;
				throw;
			}
			finally
			{
				if (flag && !done)
				{
					iteratorInstance?.Close(completion);
				}
			}
			return JsValue.Undefined;
		}

		private static JsValue HandleObjectPattern(EvaluationContext context, ObjectPattern pattern, JsValue argument, Jint.Runtime.Environments.Environment? environment, bool checkReference)
		{
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Expected O, but got Unknown
			HashSet<JsValue> hashSet = ((((NodeList<Node>)pattern.Properties).Count > 0 && ((NodeList<Node>)pattern.Properties)[((NodeList<Node>)pattern.Properties).Count - 1] is RestElement) ? new HashSet<JsValue>() : null);
			ObjectInstance objectInstance = TypeConverter.ToObject(context.Engine.Realm, argument);
			for (int i = 0; i < ((NodeList<Node>)pattern.Properties).Count; i++)
			{
				Node obj = ((NodeList<Node>)pattern.Properties)[i];
				Property val = (Property)(object)((obj is Property) ? obj : null);
				if (val != null)
				{
					Expression key = val.Key;
					Identifier val2 = (Identifier)(object)((key is Identifier) ? key : null);
					JsValue jsValue;
					if (val2 == null || val.Computed)
					{
						JsValue value = JintExpression.Build(val.Key).GetValue(context);
						if (context.IsAbrupt())
						{
							return value;
						}
						jsValue = TypeConverter.ToPropertyKey(value);
					}
					else
					{
						jsValue = val2.Name;
					}
					hashSet?.Add(jsValue);
					Node value2 = val.Value;
					AssignmentPattern val3 = (AssignmentPattern)(object)((value2 is AssignmentPattern) ? value2 : null);
					if (val3 != null)
					{
						JsValue jsValue2 = objectInstance.Get(jsValue);
						if (jsValue2.IsUndefined())
						{
							JsValue value3 = JintExpression.Build(val3.Right).GetValue(context);
							if (context.IsAbrupt())
							{
								return value3;
							}
							jsValue2 = value3;
						}
						Node left = val3.Left;
						BindingPattern val4 = (BindingPattern)(object)((left is BindingPattern) ? left : null);
						if (val4 != null)
						{
							ProcessPatterns(context, val4, jsValue2, environment);
							continue;
						}
						Node left2 = val3.Left;
						Identifier val5 = (Identifier)(((object)((left2 is Identifier) ? left2 : null)) ?? ((object)val2));
						if (val3.Right.IsFunctionDefinition<Expression>())
						{
							((Function)jsValue2).SetFunctionName(val5.Name);
						}
						AssignToIdentifier(context.Engine, val5.Name, jsValue2, environment, checkReference);
						continue;
					}
					Node value4 = val.Value;
					BindingPattern val6 = (BindingPattern)(object)((value4 is BindingPattern) ? value4 : null);
					if (val6 != null)
					{
						JsValue argument2 = objectInstance.Get(jsValue);
						ProcessPatterns(context, val6, argument2, environment);
						continue;
					}
					Node value5 = val.Value;
					MemberExpression val7 = (MemberExpression)(object)((value5 is MemberExpression) ? value5 : null);
					if (val7 != null)
					{
						Reference referenceFromMember = GetReferenceFromMember(context, val7);
						JsValue v = objectInstance.Get(jsValue);
						AssignToReference(context.Engine, referenceFromMember, v, environment);
					}
					else
					{
						Node value6 = val.Value;
						Identifier val8 = (Identifier)(((object)((value6 is Identifier) ? value6 : null)) ?? ((object)val2));
						JsValue rval = objectInstance.Get(jsValue);
						AssignToIdentifier(context.Engine, val8.Name, rval, environment, checkReference);
					}
					continue;
				}
				RestElement val9 = (RestElement)((NodeList<Node>)pattern.Properties)[i];
				Node argument3 = val9.Argument;
				Identifier val10 = (Identifier)(object)((argument3 is Identifier) ? argument3 : null);
				if (val10 != null)
				{
					int propertyCount = Math.Max(0, objectInstance.Properties?.Count ?? 0) - hashSet.Count;
					ObjectInstance objectInstance2 = context.Engine.Realm.Intrinsics.Object.Construct(propertyCount);
					objectInstance.CopyDataProperties(objectInstance2, hashSet);
					AssignToIdentifier(context.Engine, val10.Name, objectInstance2, environment, checkReference);
					continue;
				}
				Node argument4 = val9.Argument;
				BindingPattern val11 = (BindingPattern)(object)((argument4 is BindingPattern) ? argument4 : null);
				if (val11 != null)
				{
					ProcessPatterns(context, val11, argument, environment);
					continue;
				}
				Node argument5 = val9.Argument;
				MemberExpression val12 = (MemberExpression)(object)((argument5 is MemberExpression) ? argument5 : null);
				if (val12 != null)
				{
					Reference referenceFromMember2 = GetReferenceFromMember(context, val12);
					ObjectInstance objectInstance3 = context.Engine.Realm.Intrinsics.Object.Construct(0);
					objectInstance.CopyDataProperties(objectInstance3, hashSet);
					AssignToReference(context.Engine, referenceFromMember2, objectInstance3, environment);
				}
				else
				{
					ExceptionHelper.ThrowArgumentException("cannot handle parameter type " + (object)val9.Argument);
				}
			}
			return JsValue.Undefined;
		}

		private static void AssignToReference(Engine engine, Reference lhs, JsValue v, Jint.Runtime.Environments.Environment? environment)
		{
			if ((object)environment == null)
			{
				engine.PutValue(lhs, v);
			}
			else
			{
				lhs.InitializeReferencedBinding(v);
			}
			engine._referencePool.Return(lhs);
		}

		private static Reference GetReferenceFromMember(EvaluationContext context, MemberExpression memberExpression)
		{
			Reference obj = new JintMemberExpression(memberExpression).Evaluate(context) as Reference;
			if (obj == null)
			{
				ExceptionHelper.ThrowReferenceError(context.Engine.Realm, "invalid reference");
			}
			obj.AssertValid(context.Engine.Realm);
			return obj;
		}

		private static void AssignToIdentifier(Engine engine, string name, JsValue rval, Jint.Runtime.Environments.Environment? environment, bool checkReference = true)
		{
			Reference reference = engine.ResolveBinding(name, environment);
			if ((object)environment != null)
			{
				reference.InitializeReferencedBinding(rval);
				return;
			}
			if (checkReference && reference.IsUnresolvableReference && StrictModeScope.IsStrictModeCode)
			{
				ExceptionHelper.ThrowReferenceError(engine.Realm, reference);
			}
			engine.PutValue(reference, rval);
		}
	}
	internal sealed class JintArrayExpression : JintExpression
	{
		private sealed class ArraySpreadProtocol : IteratorProtocol
		{
			private readonly JsArray _instance;

			private long _index;

			internal uint _addedCount;

			public ArraySpreadProtocol(Engine engine, JsArray instance, IteratorInstance iterator, long startIndex)
				: base(engine, iterator, 0)
			{
				_instance = instance;
				_index = startIndex - 1;
			}

			protected override void ProcessItem(JsValue[] arguments, JsValue currentValue)
			{
				_index++;
				_addedCount++;
				_instance.SetIndexValue((uint)_index, currentValue, updateLength: false);
			}
		}

		internal sealed class JintEmptyArrayExpression : JintExpression
		{
			public static JintEmptyArrayExpression Instance;

			private JintEmptyArrayExpression(Expression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				return new JsArray(context.Engine, Array.Empty<JsValue>());
			}

			public override JsValue GetValue(EvaluationContext context)
			{
				return new JsArray(context.Engine, Array.Empty<JsValue>());
			}

			static JintEmptyArrayExpression()
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				NodeList<Expression> val = NodeList.Create<Expression>(Enumerable.Empty<Expression>());
				Instance = new JintEmptyArrayExpression((Expression)new ArrayExpression(ref val));
			}
		}

		private JintExpression?[] _expressions = Array.Empty<JintExpression>();

		private bool _hasSpreads;

		private bool _initialized;

		private JintArrayExpression(ArrayExpression expression)
			: base((Expression)(object)expression)
		{
		}

		public static JintExpression Build(ArrayExpression expression)
		{
			if (((NodeList<Expression>)expression.Elements).Count != 0)
			{
				return new JintArrayExpression(expression);
			}
			return JintEmptyArrayExpression.Instance;
		}

		private void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			ref NodeList<Expression> elements = ((ArrayExpression)_expression).Elements;
			JintExpression[] array = (_expressions = new JintExpression[((NodeList<Expression>)((ArrayExpression)_expression).Elements).Count]);
			for (int i = 0; i < array.Length; i++)
			{
				Expression val = elements[i];
				if (val != null)
				{
					JintExpression jintExpression = JintExpression.Build(val);
					array[i] = jintExpression;
					_hasSpreads |= (int)((Node)val).Type == 56;
				}
			}
			_initialized = true;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			Engine engine = context.Engine;
			JsArray jsArray = engine.Realm.Intrinsics.Array.ArrayCreate((!_hasSpreads) ? ((uint)_expressions.Length) : 0u);
			uint num = 0u;
			JintExpression[] expressions = _expressions;
			foreach (JintExpression jintExpression in expressions)
			{
				if (jintExpression == null)
				{
					jsArray.SetIndexValue(num++, null, updateLength: false);
				}
				else if (_hasSpreads && jintExpression is JintSpreadExpression jintSpreadExpression)
				{
					jintSpreadExpression.GetValueAndCheckIterator(context, out JsValue instance, out IteratorInstance iterator);
					if (instance is JsArray jsArray2)
					{
						uint length = jsArray2.GetLength();
						uint num2 = num + length;
						jsArray.EnsureCapacity(num2);
						jsArray.CopyValues(jsArray2, 0u, num, length);
						num += length;
						jsArray.SetLength(num2);
					}
					else
					{
						ArraySpreadProtocol arraySpreadProtocol = new ArraySpreadProtocol(engine, jsArray, iterator, num);
						arraySpreadProtocol.Execute();
						num += arraySpreadProtocol._addedCount;
					}
				}
				else
				{
					JsValue value = jintExpression.GetValue(context);
					jsArray.SetIndexValue(num++, value, updateLength: false);
				}
			}
			if (_hasSpreads)
			{
				jsArray.SetLength(num);
			}
			return jsArray;
		}
	}
	internal sealed class JintArrowFunctionExpression : JintExpression
	{
		private readonly JintFunctionDefinition _function;

		public JintArrowFunctionExpression(ArrowFunctionExpression function)
			: base((Expression)(object)function)
		{
			_function = new JintFunctionDefinition((IFunction)(object)function);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			Engine engine = context.Engine;
			Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
			PrivateEnvironment privateEnvironment = engine.ExecutionContext.PrivateEnvironment;
			ObjectInstance functionPrototype = (_function.Function.Async ? ((ObjectInstance)engine.Realm.Intrinsics.AsyncFunction.PrototypeObject) : ((ObjectInstance)engine.Realm.Intrinsics.Function.PrototypeObject));
			ScriptFunction scriptFunction = engine.Realm.Intrinsics.Function.OrdinaryFunctionCreate(functionPrototype, _function, FunctionThisMode.Lexical, lexicalEnvironment, privateEnvironment);
			if (_function.Name == null)
			{
				scriptFunction.SetFunctionName(JsString.Empty);
			}
			return scriptFunction;
		}
	}
	internal sealed class JintAssignmentExpression : JintExpression
	{
		internal sealed class SimpleAssignmentExpression : JintExpression
		{
			private JintExpression _left;

			private JintExpression _right;

			private JintIdentifierExpression? _leftIdentifier;

			private bool _evalOrArguments;

			private bool _initialized;

			public SimpleAssignmentExpression(AssignmentExpression expression)
				: base((Expression)(object)expression)
			{
			}

			private void Initialize()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				AssignmentExpression val = (AssignmentExpression)_expression;
				_left = JintExpression.Build((Expression)val.Left);
				_leftIdentifier = _left as JintIdentifierExpression;
				_evalOrArguments = _leftIdentifier?.HasEvalOrArguments ?? false;
				_right = JintExpression.Build(val.Right);
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				if (!_initialized)
				{
					Initialize();
					_initialized = true;
				}
				object obj = null;
				if (_leftIdentifier != null)
				{
					obj = AssignToIdentifier(context, _leftIdentifier, _right, _evalOrArguments);
				}
				return obj ?? SetValue(context);
			}

			private JsValue SetValue(EvaluationContext context)
			{
				Engine engine = context.Engine;
				Reference reference = _left.Evaluate(context) as Reference;
				if (reference == null)
				{
					ExceptionHelper.ThrowReferenceError(engine.Realm, "not a valid reference");
				}
				reference.AssertValid(engine.Realm);
				JsValue value = _right.GetValue(context);
				engine.PutValue(reference, value);
				engine._referencePool.Return(reference);
				return value;
			}

			internal static object? AssignToIdentifier(EvaluationContext context, JintIdentifierExpression left, JintExpression right, bool hasEvalOrArguments)
			{
				Engine engine = context.Engine;
				Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
				bool isStrictModeCode = StrictModeScope.IsStrictModeCode;
				Jint.Runtime.Environments.Environment.BindingName identifier = left.Identifier;
				if (JintEnvironment.TryGetIdentifierEnvironmentWithBinding(lexicalEnvironment, identifier, out Jint.Runtime.Environments.Environment record))
				{
					if (isStrictModeCode && hasEvalOrArguments && identifier.Key != KnownKeys.Eval)
					{
						ExceptionHelper.ThrowSyntaxError(engine.Realm, "Invalid assignment target");
					}
					JsValue value = right.GetValue(context);
					if (context.IsAbrupt())
					{
						return value;
					}
					JsValue jsValue = value.Clone();
					if (right._expression.IsFunctionDefinition<Expression>())
					{
						((Function)jsValue).SetFunctionName(identifier.Value);
					}
					record.SetMutableBinding(identifier, jsValue, isStrictModeCode);
					return jsValue;
				}
				return null;
			}
		}

		private readonly JintExpression _left;

		private readonly JintIdentifierExpression? _leftIdentifier;

		private readonly JintExpression _right;

		private readonly AssignmentOperator _operator;

		private JintAssignmentExpression(AssignmentExpression expression)
			: base((Expression)(object)expression)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			_left = JintExpression.Build((Expression)expression.Left);
			_leftIdentifier = _left as JintIdentifierExpression;
			_right = JintExpression.Build(expression.Right);
			_operator = expression.Operator;
		}

		internal static JintExpression Build(AssignmentExpression expression)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)expression.Operator == 0)
			{
				if (expression.Left is BindingPattern)
				{
					return new DestructuringPatternAssignmentExpression(expression);
				}
				return new SimpleAssignmentExpression(expression);
			}
			return new JintAssignmentExpression(expression);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected I4, but got Unknown
			Engine engine = context.Engine;
			JsValue jsValue;
			Reference reference;
			if (_leftIdentifier != null && JintEnvironment.TryGetIdentifierEnvironmentWithBindingValue(engine.ExecutionContext.LexicalEnvironment, _leftIdentifier.Identifier, out Jint.Runtime.Environments.Environment record, out JsValue value))
			{
				jsValue = value;
				reference = engine._referencePool.Rent(record, _leftIdentifier.Identifier.Value, StrictModeScope.IsStrictModeCode, null);
			}
			else
			{
				reference = _left.Evaluate(context) as Reference;
				if (reference == null)
				{
					ExceptionHelper.ThrowReferenceError(context.Engine.Realm, "not a valid reference");
				}
				jsValue = context.Engine.GetValue(reference, returnReferenceToPool: false);
			}
			bool handledByOverload = false;
			JsValue jsValue2 = null;
			if (context.OperatorOverloadingAllowed)
			{
				jsValue2 = EvaluateOperatorOverloading(context, jsValue, jsValue2, ref handledByOverload);
			}
			bool flag = false;
			if (!handledByOverload)
			{
				AssignmentOperator val = _operator;
				switch (val - 1)
				{
				case 0:
				{
					JsValue value11 = _right.GetValue(context);
					if (JintExpression.AreIntegerOperands(jsValue, value11))
					{
						jsValue2 = (long)jsValue.AsInteger() + (long)value11.AsInteger();
						break;
					}
					JsValue jsValue3 = TypeConverter.ToPrimitive(jsValue);
					JsValue jsValue4 = TypeConverter.ToPrimitive(value11);
					if (jsValue3.IsString() || jsValue4.IsString())
					{
						flag = jsValue3 is JsString.ConcatenatedString;
						JsString jsString = jsValue3 as JsString;
						if ((object)jsString == null)
						{
							jsString = new JsString.ConcatenatedString(TypeConverter.ToString(jsValue3));
						}
						jsValue2 = jsString.Append(jsValue4);
					}
					else if (JintBinaryExpression.AreNonBigIntOperands(jsValue, value11))
					{
						jsValue2 = TypeConverter.ToNumber(jsValue3) + TypeConverter.ToNumber(jsValue4);
					}
					else
					{
						JintBinaryExpression.AssertValidBigIntArithmeticOperands(jsValue3, jsValue4);
						jsValue2 = JsBigInt.Create(TypeConverter.ToBigInt(jsValue3) + TypeConverter.ToBigInt(jsValue4));
					}
					break;
				}
				case 1:
				{
					JsValue value12 = _right.GetValue(context);
					if (JintExpression.AreIntegerOperands(jsValue, value12))
					{
						jsValue2 = JsNumber.Create(jsValue.AsInteger() - value12.AsInteger());
						break;
					}
					if (JintBinaryExpression.AreNonBigIntOperands(jsValue, value12))
					{
						jsValue2 = JsNumber.Create(TypeConverter.ToNumber(jsValue) - TypeConverter.ToNumber(value12));
						break;
					}
					JintBinaryExpression.AssertValidBigIntArithmeticOperands(jsValue, value12);
					jsValue2 = JsBigInt.Create(TypeConverter.ToBigInt(jsValue) - TypeConverter.ToBigInt(value12));
					break;
				}
				case 2:
				{
					JsValue value13 = _right.GetValue(context);
					if (JintExpression.AreIntegerOperands(jsValue, value13))
					{
						jsValue2 = (long)jsValue.AsInteger() * (long)value13.AsInteger();
						break;
					}
					if (jsValue.IsUndefined() || value13.IsUndefined())
					{
						jsValue2 = JsValue.Undefined;
						break;
					}
					if (JintBinaryExpression.AreNonBigIntOperands(jsValue, value13))
					{
						jsValue2 = TypeConverter.ToNumber(jsValue) * TypeConverter.ToNumber(value13);
						break;
					}
					JintBinaryExpression.AssertValidBigIntArithmeticOperands(jsValue, value13);
					jsValue2 = JsBigInt.Create(TypeConverter.ToBigInt(jsValue) * TypeConverter.ToBigInt(value13));
					break;
				}
				case 3:
				{
					JsValue value5 = _right.GetValue(context);
					jsValue2 = JintExpression.Divide(context, jsValue, value5);
					break;
				}
				case 4:
				{
					JsValue value10 = _right.GetValue(context);
					jsValue2 = ((!jsValue.IsUndefined() && !value10.IsUndefined()) ? ((JsValue)(TypeConverter.ToNumber(jsValue) % TypeConverter.ToNumber(value10))) : JsValue.Undefined);
					break;
				}
				case 5:
				{
					JsValue value9 = _right.GetValue(context);
					jsValue2 = TypeConverter.ToInt32(jsValue) & TypeConverter.ToInt32(value9);
					break;
				}
				case 6:
				{
					JsValue value6 = _right.GetValue(context);
					jsValue2 = TypeConverter.ToInt32(jsValue) | TypeConverter.ToInt32(value6);
					break;
				}
				case 7:
				{
					JsValue value7 = _right.GetValue(context);
					jsValue2 = TypeConverter.ToInt32(jsValue) ^ TypeConverter.ToInt32(value7);
					break;
				}
				case 8:
				{
					JsValue value8 = _right.GetValue(context);
					jsValue2 = TypeConverter.ToInt32(jsValue) << (int)(TypeConverter.ToUint32(value8) & 0x1F);
					break;
				}
				case 9:
				{
					JsValue value4 = _right.GetValue(context);
					jsValue2 = TypeConverter.ToInt32(jsValue) >> (int)(TypeConverter.ToUint32(value4) & 0x1F);
					break;
				}
				case 10:
				{
					JsValue value3 = _right.GetValue(context);
					jsValue2 = (uint)TypeConverter.ToInt32(jsValue) >> (int)(TypeConverter.ToUint32(value3) & 0x1F);
					break;
				}
				case 12:
					if (!jsValue.IsNullOrUndefined())
					{
						return jsValue;
					}
					jsValue2 = NamedEvaluation(context, _right);
					break;
				case 13:
					if (!TypeConverter.ToBoolean(jsValue))
					{
						return jsValue;
					}
					jsValue2 = NamedEvaluation(context, _right);
					break;
				case 14:
					if (TypeConverter.ToBoolean(jsValue))
					{
						return jsValue;
					}
					jsValue2 = NamedEvaluation(context, _right);
					break;
				case 11:
				{
					JsValue value2 = _right.GetValue(context);
					if (!jsValue.IsBigInt() && !value2.IsBigInt())
					{
						jsValue2 = JsNumber.Create(Math.Pow(TypeConverter.ToNumber(jsValue), TypeConverter.ToNumber(value2)));
						break;
					}
					BigInteger bigInteger = TypeConverter.ToBigInt(value2);
					if (bigInteger > 2147483647L || bigInteger < -2147483648L)
					{
						ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Cannot do exponentiation with exponent not fitting int32");
					}
					jsValue2 = JsBigInt.Create(BigInteger.Pow(TypeConverter.ToBigInt(jsValue), (int)bigInteger));
					break;
				}
				default:
					ExceptionHelper.ThrowNotImplementedException();
					return null;
				}
			}
			if (!flag || !(reference.Base is Jint.Runtime.Environments.Environment))
			{
				engine.PutValue(reference, jsValue2);
			}
			engine._referencePool.Return(reference);
			return jsValue2;
		}

		private JsValue? EvaluateOperatorOverloading(EvaluationContext context, JsValue originalLeftValue, JsValue? newLeftValue, ref bool handledByOverload)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected I4, but got Unknown
			string text = null;
			AssignmentOperator val = _operator;
			switch ((int)val)
			{
			case 1:
				text = "op_Addition";
				break;
			case 2:
				text = "op_Subtraction";
				break;
			case 3:
				text = "op_Multiply";
				break;
			case 4:
				text = "op_Division";
				break;
			case 5:
				text = "op_Modulus";
				break;
			case 6:
				text = "op_BitwiseAnd";
				break;
			case 7:
				text = "op_BitwiseOr";
				break;
			case 8:
				text = "op_ExclusiveOr";
				break;
			case 9:
				text = "op_LeftShift";
				break;
			case 10:
				text = "op_RightShift";
				break;
			case 11:
				text = "op_UnsignedRightShift";
				break;
			}
			if (text != null)
			{
				JsValue value = _right.GetValue(context);
				if (JintBinaryExpression.TryOperatorOverloading(context, originalLeftValue, value, text, out object result))
				{
					newLeftValue = JsValue.FromObject(context.Engine, result);
					handledByOverload = true;
				}
			}
			return newLeftValue;
		}

		private JsValue NamedEvaluation(EvaluationContext context, JintExpression expression)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			JsValue value = expression.GetValue(context);
			if (expression._expression.IsAnonymousFunctionDefinition<Expression>() && (int)((Node)_left._expression).Type == 32)
			{
				((Function)value).SetFunctionName(((Identifier)_left._expression).Name);
			}
			return value;
		}
	}
	internal sealed class JintAwaitExpression : JintExpression
	{
		private JintExpression _awaitExpression;

		private bool _initialized;

		public JintAwaitExpression(AwaitExpression expression)
			: base((Expression)(object)expression)
		{
			_initialized = false;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized)
			{
				_awaitExpression = JintExpression.Build(((AwaitExpression)_expression).Argument);
				_initialized = true;
			}
			Engine engine = context.Engine;
			_ = ref engine.ExecutionContext;
			try
			{
				JsValue jsValue = _awaitExpression.GetValue(context);
				if (!(jsValue is JsPromise))
				{
					JsPromise jsPromise = new JsPromise(engine);
					jsPromise.Resolve(jsValue);
					jsValue = jsPromise;
				}
				return jsValue.UnwrapIfPromise();
			}
			catch (PromiseRejectedException ex)
			{
				ExceptionHelper.ThrowJavaScriptException(engine, ex.RejectedValue, in ((SyntaxElement)_expression).Location);
				return null;
			}
		}
	}
	internal abstract class JintBinaryExpression : JintExpression
	{
		private readonly record struct OperatorKey(string? OperatorName, Type Left, Type Right);

		private sealed class StrictlyEqualBinaryExpression : JintBinaryExpression
		{
			public StrictlyEqualBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (!(value == value2))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
		}

		private sealed class StrictlyNotEqualBinaryExpression : JintBinaryExpression
		{
			public StrictlyNotEqualBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (!(value == value2))
				{
					return JsBoolean.True;
				}
				return JsBoolean.False;
			}
		}

		private sealed class LessBinaryExpression : JintBinaryExpression
		{
			public LessBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, "op_LessThan", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				JsValue jsValue = JintExpression.Compare(value, value2);
				if (jsValue._type != InternalTypes.Undefined)
				{
					return jsValue;
				}
				return JsBoolean.False;
			}
		}

		private sealed class GreaterBinaryExpression : JintBinaryExpression
		{
			public GreaterBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, "op_GreaterThan", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				JsValue jsValue = JintExpression.Compare(value2, value, leftFirst: false);
				if (jsValue._type != InternalTypes.Undefined)
				{
					return jsValue;
				}
				return JsBoolean.False;
			}
		}

		private sealed class PlusBinaryExpression : JintBinaryExpression
		{
			public PlusBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, "op_Addition", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				if (JintExpression.AreIntegerOperands(value, value2))
				{
					return JsNumber.Create((long)value.AsInteger() + (long)value2.AsInteger());
				}
				JsValue jsValue = TypeConverter.ToPrimitive(value);
				JsValue jsValue2 = TypeConverter.ToPrimitive(value2);
				if (jsValue.IsString() || jsValue2.IsString())
				{
					return JsString.Create(TypeConverter.ToString(jsValue) + TypeConverter.ToString(jsValue2));
				}
				if (AreNonBigIntOperands(value, value2))
				{
					return JsNumber.Create(TypeConverter.ToNumber(jsValue) + TypeConverter.ToNumber(jsValue2));
				}
				AssertValidBigIntArithmeticOperands(jsValue, jsValue2);
				return JsBigInt.Create(TypeConverter.ToBigInt(jsValue) + TypeConverter.ToBigInt(jsValue2));
			}
		}

		private sealed class MinusBinaryExpression : JintBinaryExpression
		{
			public MinusBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, "op_Subtraction", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				value = TypeConverter.ToNumeric(value);
				value2 = TypeConverter.ToNumeric(value2);
				if (JintExpression.AreIntegerOperands(value, value2))
				{
					return JsNumber.Create((long)value.AsInteger() - (long)value2.AsInteger());
				}
				if (AreNonBigIntOperands(value, value2))
				{
					return JsNumber.Create(value.AsNumber() - value2.AsNumber());
				}
				AssertValidBigIntArithmeticOperands(value, value2);
				return JsBigInt.Create(TypeConverter.ToBigInt(value) - TypeConverter.ToBigInt(value2));
			}
		}

		private sealed class TimesBinaryExpression : JintBinaryExpression
		{
			public TimesBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, "op_Multiply", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				if (JintExpression.AreIntegerOperands(value, value2))
				{
					return JsNumber.Create((long)value.AsInteger() * (long)value2.AsInteger());
				}
				JsValue jsValue = TypeConverter.ToNumeric(value);
				JsValue jsValue2 = TypeConverter.ToNumeric(value2);
				if (jsValue.IsNumber() && jsValue2.IsNumber())
				{
					return JsNumber.Create(jsValue.AsNumber() * jsValue2.AsNumber());
				}
				AssertValidBigIntArithmeticOperands(jsValue, jsValue2);
				return JsBigInt.Create(jsValue.AsBigInt() * jsValue2.AsBigInt());
			}
		}

		private sealed class DivideBinaryExpression : JintBinaryExpression
		{
			public DivideBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, "op_Division", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				value = TypeConverter.ToNumeric(value);
				value2 = TypeConverter.ToNumeric(value2);
				return JintExpression.Divide(context, value, value2);
			}
		}

		private sealed class EqualBinaryExpression : JintBinaryExpression
		{
			private readonly bool _invert;

			public EqualBinaryExpression(BinaryExpression expression, bool invert = false)
				: base(expression)
			{
				_invert = invert;
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, _invert ? "op_Inequality" : "op_Equality", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				if (((value.Type == value2.Type) ? value.Equals(value2) : value.IsLooselyEqual(value2)) != !_invert)
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
		}

		private sealed class CompareBinaryExpression : JintBinaryExpression
		{
			private readonly bool _leftFirst;

			public CompareBinaryExpression(BinaryExpression expression, bool leftFirst)
				: base(expression)
			{
				_leftFirst = leftFirst;
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, _leftFirst ? "op_GreaterThanOrEqual" : "op_LessThanOrEqual", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				JsValue x = (_leftFirst ? value : value2);
				JsValue y = (_leftFirst ? value2 : value);
				JsValue jsValue = JintExpression.Compare(x, y, _leftFirst);
				if (!jsValue.IsUndefined() && !((JsBoolean)jsValue)._value)
				{
					return JsBoolean.True;
				}
				return JsBoolean.False;
			}
		}

		private sealed class InstanceOfBinaryExpression : JintBinaryExpression
		{
			public InstanceOfBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (!value.InstanceofOperator(value2))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
		}

		private sealed class ExponentiationBinaryExpression : JintBinaryExpression
		{
			public ExponentiationBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				JsValue jsValue = TypeConverter.ToNumeric(value);
				JsValue jsValue2 = TypeConverter.ToNumeric(value2);
				if (AreNonBigIntOperands(jsValue, jsValue2))
				{
					JsNumber jsNumber = (JsNumber)jsValue;
					JsNumber jsNumber2 = (JsNumber)jsValue2;
					if (jsNumber2.IsNaN())
					{
						return JsNumber.DoubleNaN;
					}
					if (jsNumber2.IsZero())
					{
						return JsNumber.PositiveOne;
					}
					if (jsNumber.IsNaN())
					{
						return JsNumber.DoubleNaN;
					}
					double value3 = jsNumber2._value;
					if (jsNumber.IsPositiveInfinity())
					{
						if (!(value3 > 0.0))
						{
							return JsNumber.PositiveZero;
						}
						return JsNumber.DoublePositiveInfinity;
					}
					if (jsNumber.IsNegativeInfinity())
					{
						if (value3 > 0.0)
						{
							if (!IsOddIntegral(value3))
							{
								return JsNumber.DoublePositiveInfinity;
							}
							return JsNumber.DoubleNegativeInfinity;
						}
						if (!IsOddIntegral(value3))
						{
							return JsNumber.PositiveZero;
						}
						return JsNumber.NegativeZero;
					}
					if (jsNumber.IsPositiveZero())
					{
						if (!(value3 > 0.0))
						{
							return JsNumber.DoublePositiveInfinity;
						}
						return JsNumber.PositiveZero;
					}
					if (jsNumber.IsNegativeZero())
					{
						if (value3 > 0.0)
						{
							if (!IsOddIntegral(value3))
							{
								return JsNumber.PositiveZero;
							}
							return JsNumber.NegativeZero;
						}
						if (!IsOddIntegral(value3))
						{
							return JsNumber.DoublePositiveInfinity;
						}
						return JsNumber.DoubleNegativeInfinity;
					}
					double value4 = jsNumber._value;
					if (jsNumber2.IsPositiveInfinity())
					{
						if (Math.Abs(value4) > 1.0)
						{
							return JsNumber.DoublePositiveInfinity;
						}
						if (Math.Abs(value4) == 1.0)
						{
							return JsNumber.DoubleNaN;
						}
						return JsNumber.PositiveZero;
					}
					if (jsNumber2.IsNegativeInfinity())
					{
						if (Math.Abs(value4) > 1.0)
						{
							return JsNumber.PositiveZero;
						}
						if (Math.Abs(value4) == 1.0)
						{
							return JsNumber.DoubleNaN;
						}
						return JsNumber.DoublePositiveInfinity;
					}
					if (value4 < 0.0 && !TypeConverter.IsIntegralNumber(value3))
					{
						return JsNumber.DoubleNaN;
					}
					return JsNumber.Create(Math.Pow(jsNumber._value, value3));
				}
				AssertValidBigIntArithmeticOperands(jsValue, jsValue2);
				BigInteger bigInteger = jsValue2.AsBigInt();
				if (bigInteger < 0L)
				{
					ExceptionHelper.ThrowRangeError(context.Engine.Realm, "Exponent must be positive");
				}
				if (bigInteger > 2147483647L || bigInteger < -2147483648L)
				{
					ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Exponent does not fit 32bit range");
				}
				return JsBigInt.Create(BigInteger.Pow(jsValue.AsBigInt(), (int)bigInteger));
				static bool IsOddIntegral(double num)
				{
					if (TypeConverter.IsIntegralNumber(num))
					{
						return num % 2.0 != 0.0;
					}
					return false;
				}
			}
		}

		private sealed class InBinaryExpression : JintBinaryExpression
		{
			public InBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				ObjectInstance objectInstance = _right.GetValue(context) as ObjectInstance;
				if ((object)objectInstance == null)
				{
					ExceptionHelper.ThrowTypeError(context.Engine.Realm, "in can only be used with an object");
				}
				if (value.IsPrivateName())
				{
					PrivateName privateName = context.Engine.ExecutionContext.PrivateEnvironment.ResolvePrivateIdentifier(((PrivateName)value).ToString());
					if ((object)privateName == null || objectInstance.PrivateElementFind(privateName) == null)
					{
						return JsBoolean.False;
					}
					return JsBoolean.True;
				}
				if (!objectInstance.HasProperty(value))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
		}

		private sealed class ModuloBinaryExpression : JintBinaryExpression
		{
			public ModuloBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, "op_Modulus", out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				JsValue result2 = JsValue.Undefined;
				value = TypeConverter.ToNumeric(value);
				value2 = TypeConverter.ToNumeric(value2);
				if (JintExpression.AreIntegerOperands(value, value2))
				{
					int num = value.AsInteger();
					int num2 = value2.AsInteger();
					if (num2 == 0)
					{
						result2 = JsNumber.DoubleNaN;
					}
					else
					{
						int num3 = num % num2;
						result2 = ((num3 != 0 || num >= 0) ? JsNumber.Create(num3) : JsNumber.NegativeZero);
					}
				}
				else if (AreNonBigIntOperands(value, value2))
				{
					double num4 = value.AsNumber();
					double num5 = value2.AsNumber();
					result2 = ((!double.IsNaN(num4) && !double.IsNaN(num5) && !double.IsInfinity(num4)) ? (double.IsInfinity(num5) ? ((JsValue)num4) : ((!NumberInstance.IsPositiveZero(num5) && !NumberInstance.IsNegativeZero(num5)) ? ((!NumberInstance.IsPositiveZero(num4) && !NumberInstance.IsNegativeZero(num4)) ? JsNumber.Create(num4 % num5) : ((JsValue)num4)) : JsNumber.DoubleNaN)) : JsNumber.DoubleNaN);
				}
				else
				{
					AssertValidBigIntArithmeticOperands(value, value2);
					BigInteger bigInteger = TypeConverter.ToBigInt(value);
					BigInteger bigInteger2 = TypeConverter.ToBigInt(value2);
					if (!(bigInteger2 == 0L))
					{
						result2 = ((!(bigInteger == 0L)) ? JsBigInt.Create(bigInteger % bigInteger2) : JsBigInt.Zero);
					}
					else
					{
						ExceptionHelper.ThrowRangeError(context.Engine.Realm, "Division by zero");
					}
				}
				return result2;
			}
		}

		private sealed class BitwiseBinaryExpression : JintBinaryExpression
		{
			private readonly BinaryOperator _operator;

			private string? OperatorClrName
			{
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0028: Expected I4, but got Unknown
					BinaryOperator val = _operator;
					return (val - 13) switch
					{
						0 => "op_BitwiseAnd", 
						1 => "op_BitwiseOr", 
						2 => "op_ExclusiveOr", 
						3 => "op_LeftShift", 
						4 => "op_RightShift", 
						5 => "op_UnsignedRightShift", 
						_ => null, 
					};
				}
			}

			public BitwiseBinaryExpression(BinaryExpression expression)
				: base(expression)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				_operator = expression.Operator;
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected I4, but got Unknown
				EnsureInitialized();
				JsValue value = _left.GetValue(context);
				JsValue value2 = _right.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, value2, OperatorClrName, out object result))
				{
					return JsValue.FromObject(context.Engine, result);
				}
				JsValue jsValue = TypeConverter.ToNumeric(value);
				JsValue jsValue2 = TypeConverter.ToNumeric(value2);
				if (jsValue.Type != jsValue2.Type)
				{
					ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions", (Node?)(object)_left._expression);
				}
				if (JintExpression.AreIntegerOperands(jsValue, jsValue2))
				{
					int num = jsValue.AsInteger();
					int num2 = jsValue2.AsInteger();
					JsValue result2 = null;
					BinaryOperator val = _operator;
					switch (val - 13)
					{
					case 0:
						result2 = JsNumber.Create(num & num2);
						break;
					case 1:
						result2 = JsNumber.Create(num | num2);
						break;
					case 2:
						result2 = JsNumber.Create(num ^ num2);
						break;
					case 3:
						result2 = JsNumber.Create(num << (num2 & 0x1F));
						break;
					case 4:
						result2 = JsNumber.Create(num >> (num2 & 0x1F));
						break;
					case 5:
						result2 = JsNumber.Create((uint)num >> (num2 & 0x1F));
						break;
					default:
						ExceptionHelper.ThrowArgumentOutOfRangeException("_operator", "unknown shift operator");
						break;
					}
					return result2;
				}
				return EvaluateNonInteger(jsValue, jsValue2);
			}

			private JsValue EvaluateNonInteger(JsValue left, JsValue right)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected I4, but got Unknown
				BinaryOperator val = _operator;
				switch (val - 13)
				{
				case 0:
					if (!left.IsBigInt())
					{
						return JsNumber.Create(TypeConverter.ToInt32(left) & TypeConverter.ToInt32(right));
					}
					return JsBigInt.Create(TypeConverter.ToBigInt(left) & TypeConverter.ToBigInt(right));
				case 1:
					if (!left.IsBigInt())
					{
						return JsNumber.Create(TypeConverter.ToInt32(left) | TypeConverter.ToInt32(right));
					}
					return JsBigInt.Create(TypeConverter.ToBigInt(left) | TypeConverter.ToBigInt(right));
				case 2:
					if (!left.IsBigInt())
					{
						return JsNumber.Create(TypeConverter.ToInt32(left) ^ TypeConverter.ToInt32(right));
					}
					return JsBigInt.Create(TypeConverter.ToBigInt(left) ^ TypeConverter.ToBigInt(right));
				case 3:
					if (!left.IsBigInt())
					{
						return JsNumber.Create(TypeConverter.ToInt32(left) << (int)TypeConverter.ToUint32(right));
					}
					return JsBigInt.Create(TypeConverter.ToBigInt(left) << (int)TypeConverter.ToBigInt(right));
				case 4:
					if (!left.IsBigInt())
					{
						return JsNumber.Create(TypeConverter.ToInt32(left) >> (int)TypeConverter.ToUint32(right));
					}
					return JsBigInt.Create(TypeConverter.ToBigInt(left) >> (int)TypeConverter.ToBigInt(right));
				case 5:
					if (!left.IsBigInt())
					{
						return JsNumber.Create((uint)TypeConverter.ToInt32(left) >> (int)TypeConverter.ToUint32(right));
					}
					ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions", (Node?)(object)_left._expression);
					return null;
				default:
					ExceptionHelper.ThrowArgumentOutOfRangeException("_operator", "unknown shift operator");
					return null;
				}
			}
		}

		private static readonly ConcurrentDictionary<OperatorKey, MethodDescriptor> _knownOperators = new ConcurrentDictionary<OperatorKey, MethodDescriptor>();

		private JintExpression _left;

		private JintExpression _right;

		private bool _initialized;

		private JintBinaryExpression(BinaryExpression expression)
			: base((Expression)(object)expression)
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void EnsureInitialized()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (!_initialized)
			{
				BinaryExpression val = (BinaryExpression)_expression;
				_left = JintExpression.Build(val.Left);
				_right = JintExpression.Build(val.Right);
				_initialized = true;
			}
		}

		internal static bool TryOperatorOverloading(EvaluationContext context, JsValue leftValue, JsValue rightValue, string? clrName, [NotNullWhen(true)] out object? result)
		{
			object obj = leftValue.ToObject();
			object obj2 = rightValue.ToObject();
			if (obj != null && obj2 != null)
			{
				Type leftType = obj.GetType();
				Type rightType = obj2.GetType();
				JsValue[] arguments = new JsValue[2] { leftValue, rightValue };
				OperatorKey key = new OperatorKey(clrName, leftType, rightType);
				MethodDescriptor orAdd = _knownOperators.GetOrAdd(key, delegate
				{
					IEnumerable<MethodInfo> operatorOverloadMethods = leftType.GetOperatorOverloadMethods();
					IEnumerable<MethodInfo> operatorOverloadMethods2 = rightType.GetOperatorOverloadMethods();
					MethodDescriptor[] methods = MethodDescriptor.Build((from x in operatorOverloadMethods.Concat(operatorOverloadMethods2)
						where string.Equals(x.Name, clrName, StringComparison.Ordinal) && x.GetParameters().Length == 2
						select x).ToArray());
					return InteropHelper.FindBestMatch(context.Engine, methods, (MethodDescriptor methodDescriptor) => arguments).FirstOrDefault().Method;
				});
				if (orAdd != null)
				{
					try
					{
						result = orAdd.Call(context.Engine, null, arguments);
						return true;
					}
					catch (Exception ex)
					{
						ExceptionHelper.ThrowMeaningfulException(context.Engine, new TargetInvocationException(ex.InnerException));
						result = null;
						return false;
					}
				}
			}
			result = null;
			return false;
		}

		internal static JintExpression Build(BinaryExpression expression)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected I4, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Invalid comparison between Unknown and I4
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			JintBinaryExpression jintBinaryExpression = null;
			BinaryOperator val = expression.Operator;
			switch ((int)val)
			{
			case 11:
				jintBinaryExpression = new StrictlyEqualBinaryExpression(expression);
				break;
			case 12:
				jintBinaryExpression = new StrictlyNotEqualBinaryExpression(expression);
				break;
			case 9:
				jintBinaryExpression = new LessBinaryExpression(expression);
				break;
			case 7:
				jintBinaryExpression = new GreaterBinaryExpression(expression);
				break;
			case 0:
				jintBinaryExpression = new PlusBinaryExpression(expression);
				break;
			case 1:
				jintBinaryExpression = new MinusBinaryExpression(expression);
				break;
			case 2:
				jintBinaryExpression = new TimesBinaryExpression(expression);
				break;
			case 3:
				jintBinaryExpression = new DivideBinaryExpression(expression);
				break;
			case 5:
				jintBinaryExpression = new EqualBinaryExpression(expression);
				break;
			case 6:
				jintBinaryExpression = new EqualBinaryExpression(expression, invert: true);
				break;
			case 8:
				jintBinaryExpression = new CompareBinaryExpression(expression, leftFirst: true);
				break;
			case 10:
				jintBinaryExpression = new CompareBinaryExpression(expression, leftFirst: false);
				break;
			case 13:
			case 14:
			case 15:
			case 16:
			case 17:
			case 18:
				jintBinaryExpression = new BitwiseBinaryExpression(expression);
				break;
			case 19:
				jintBinaryExpression = new InstanceOfBinaryExpression(expression);
				break;
			case 23:
				jintBinaryExpression = new ExponentiationBinaryExpression(expression);
				break;
			case 4:
				jintBinaryExpression = new ModuloBinaryExpression(expression);
				break;
			case 20:
				jintBinaryExpression = new InBinaryExpression(expression);
				break;
			default:
				ExceptionHelper.ThrowArgumentOutOfRangeException("Operator", "cannot handle operator");
				break;
			}
			if ((int)expression.Operator != 19 && (int)expression.Operator != 20)
			{
				Expression left = expression.Left;
				Literal val2 = (Literal)(object)((left is Literal) ? left : null);
				if (val2 != null)
				{
					Expression right = expression.Right;
					Literal val3 = (Literal)(object)((right is Literal) ? right : null);
					if (val3 != null)
					{
						JsValue? jsValue = JintLiteralExpression.ConvertToJsValue(val2);
						JsValue jsValue2 = JintLiteralExpression.ConvertToJsValue(val3);
						if ((object)jsValue != null && (object)jsValue2 != null)
						{
							try
							{
								EvaluationContext context = new EvaluationContext();
								return new JintConstantExpression((Expression)(object)expression, (JsValue)jintBinaryExpression.EvaluateWithoutNodeTracking(context));
							}
							catch
							{
							}
						}
					}
				}
			}
			return jintBinaryExpression;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool AreNonBigIntOperands(JsValue left, JsValue right)
		{
			if (left._type != InternalTypes.BigInt)
			{
				return right._type != InternalTypes.BigInt;
			}
			return false;
		}

		internal static void AssertValidBigIntArithmeticOperands(JsValue left, JsValue right)
		{
			if (left.Type != right.Type)
			{
				ExceptionHelper.ThrowTypeErrorNoEngine("Cannot mix BigInt and other types, use explicit conversions");
			}
		}
	}
	internal sealed class JintCallExpression : JintExpression
	{
		private sealed class CachedArgumentsHolder
		{
			internal JintExpression[] JintArguments = Array.Empty<JintExpression>();

			internal JsValue[] CachedArguments = Array.Empty<JsValue>();
		}

		private CachedArgumentsHolder _cachedArguments;

		private bool _cached;

		private JintExpression _calleeExpression;

		private bool _hasSpreads;

		private bool _initialized;

		public JintCallExpression(CallExpression expression)
			: base((Expression)(object)expression)
		{
		}

		private void Initialize(EvaluationContext context)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Invalid comparison between Unknown and I4
			CallExpression val = (CallExpression)_expression;
			ref NodeList<Expression> arguments = val.Arguments;
			_calleeExpression = JintExpression.Build(val.Callee);
			CachedArgumentsHolder cachedArgumentsHolder = new CachedArgumentsHolder
			{
				JintArguments = new JintExpression[arguments.Count]
			};
			bool flag = true;
			for (int i = 0; i < arguments.Count; i++)
			{
				Expression val2 = arguments[i];
				cachedArgumentsHolder.JintArguments[i] = JintExpression.Build(val2);
				flag &= (int)((Node)val2).Type == 41;
				_hasSpreads |= CanSpread((Node?)(object)val2);
				ArrayExpression val3 = (ArrayExpression)(object)((val2 is ArrayExpression) ? val2 : null);
				if (val3 != null)
				{
					ref NodeList<Expression> elements = val3.Elements;
					for (int j = 0; j < elements.Count; j++)
					{
						_hasSpreads |= CanSpread((Node?)(object)elements[j]);
					}
				}
			}
			if (flag)
			{
				_cached = true;
				JsValue[] array = Array.Empty<JsValue>();
				if (cachedArgumentsHolder.JintArguments.Length != 0)
				{
					array = new JsValue[cachedArgumentsHolder.JintArguments.Length];
					JintExpression.BuildArguments(context, cachedArgumentsHolder.JintArguments, array);
				}
				cachedArgumentsHolder.CachedArguments = array;
			}
			_cachedArguments = cachedArgumentsHolder;
			static bool CanSpread(Node? e)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Invalid comparison between Unknown and I4
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Invalid comparison between Unknown and I4
				if (e == null)
				{
					return false;
				}
				if ((int)e.Type != 56)
				{
					AssignmentExpression val4 = (AssignmentExpression)(object)((e is AssignmentExpression) ? e : null);
					if (val4 != null)
					{
						Expression right = val4.Right;
						if (right != null)
						{
							return (int)((Node)right).Type == 56;
						}
					}
					return false;
				}
				return true;
			}
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			if (!_initialized)
			{
				Initialize(context);
				_initialized = true;
			}
			if (!context.Engine._stackGuard.TryEnterOnCurrentStack())
			{
				return StackGuard.RunOnEmptyStack(EvaluateInternal, context);
			}
			if ((int)((Node)_calleeExpression._expression).Type == 58)
			{
				return SuperCall(context);
			}
			object obj = _calleeExpression.Evaluate(context);
			if (obj == JsValue.Undefined)
			{
				return JsValue.Undefined;
			}
			Engine engine = context.Engine;
			JsValue value = engine.GetValue(obj, returnReferenceToPool: false);
			if (value.IsNullOrUndefined() && _expression.IsOptional<Expression>())
			{
				return JsValue.Undefined;
			}
			Reference reference = obj as Reference;
			if ((object)value == engine.Realm.Intrinsics.Eval && reference != null && !reference.IsPropertyReference && CommonProperties.Eval.Equals(reference.ReferencedName))
			{
				return HandleEval(context, value, engine, reference);
			}
			bool flag = IsInTailPosition((CallExpression)_expression);
			JsValue thisObject;
			if (reference != null)
			{
				if (reference.IsPropertyReference)
				{
					thisObject = reference.ThisValue;
				}
				else
				{
					JsValue jsValue = reference.Base;
					thisObject = ((!jsValue.IsNullOrUndefined() || !engine._referenceResolver.TryUnresolvableReference(engine, reference, out JsValue value2)) ? ((Jint.Runtime.Environments.Environment)jsValue).WithBaseObject() : value2);
				}
			}
			else
			{
				thisObject = JsValue.Undefined;
			}
			JsValue[] array = ArgumentListEvaluation(context);
			if (!value.IsObject() && !engine._referenceResolver.TryGetCallable(engine, obj, out value))
			{
				ThrowMemberIsNotFunction(reference, obj, engine);
			}
			ICallable callable = value as ICallable;
			if (callable == null)
			{
				ThrowReferenceNotFunction(reference, obj, engine);
			}
			JsValue result;
			if (callable is Function function)
			{
				JintCallStack callStack = engine.CallStack;
				if (callStack.Push(function, _calleeExpression, in engine.ExecutionContext) > engine.Options.Constraints.MaxRecursionDepth)
				{
					ExceptionHelper.ThrowRecursionDepthOverflowException(callStack);
				}
				try
				{
					result = function.Call(thisObject, array);
				}
				finally
				{
					if (callStack.Count > 0)
					{
						callStack.Pop();
					}
				}
			}
			else
			{
				result = callable.Call(thisObject, array);
			}
			if (!_cached && array.Length != 0)
			{
				engine._jsValueArrayPool.ReturnArray(array);
			}
			engine._referencePool.Return(reference);
			return result;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DoesNotReturn]
		private static void ThrowReferenceNotFunction(Reference? referenceRecord1, object reference, Engine engine)
		{
			string message = $"{referenceRecord1?.ReferencedName ?? reference} is not a function";
			ExceptionHelper.ThrowTypeError(engine.Realm, message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DoesNotReturn]
		private static void ThrowMemberIsNotFunction(Reference? referenceRecord1, object reference, Engine engine)
		{
			string message = ((referenceRecord1 == null) ? (reference?.ToString() + " is not a function") : $"Property '{referenceRecord1.ReferencedName}' of object is not a function");
			ExceptionHelper.ThrowTypeError(engine.Realm, message);
		}

		private JsValue HandleEval(EvaluationContext context, JsValue func, Engine engine, Reference referenceRecord)
		{
			JsValue[] array = ArgumentListEvaluation(context);
			if (array.Length == 0)
			{
				return JsValue.Undefined;
			}
			EvalFunction obj = (EvalFunction)func;
			JsValue x = array[0];
			bool isStrictModeCode = StrictModeScope.IsStrictModeCode;
			Realm realm = obj._realm;
			bool direct = !_expression.IsOptional<Expression>();
			JsValue result = obj.PerformEval(x, realm, isStrictModeCode, direct);
			engine._referencePool.Return(referenceRecord);
			return result;
		}

		private ObjectInstance SuperCall(EvaluationContext context)
		{
			Engine engine = context.Engine;
			FunctionEnvironment thisEnvironment = (FunctionEnvironment)engine.ExecutionContext.GetThisEnvironment();
			JsValue newTarget = engine.GetNewTarget(thisEnvironment);
			ObjectInstance superConstructor = GetSuperConstructor(thisEnvironment);
			if ((object)superConstructor == null || !superConstructor.IsConstructor)
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, "Not a constructor");
			}
			JsValue[] arguments = (((object)_expression == ClassDefinition._defaultSuperCall) ? DefaultSuperCallArgumentListEvaluation(context) : ArgumentListEvaluation(context));
			ObjectInstance objectInstance = ((IConstructor)superConstructor).Construct(arguments, newTarget);
			FunctionEnvironment obj = (FunctionEnvironment)engine.ExecutionContext.GetThisEnvironment();
			obj.BindThisValue(objectInstance);
			Function functionObject = obj._functionObject;
			objectInstance.InitializeInstanceElements((ScriptFunction)functionObject);
			return objectInstance;
		}

		private static ObjectInstance? GetSuperConstructor(FunctionEnvironment thisEnvironment)
		{
			return thisEnvironment._functionObject.GetPrototypeOf();
		}

		private static bool IsInTailPosition(CallExpression call)
		{
			return false;
		}

		private JsValue[] ArgumentListEvaluation(EvaluationContext context)
		{
			CachedArgumentsHolder cachedArguments = _cachedArguments;
			JsValue[] array = Array.Empty<JsValue>();
			if (_cached)
			{
				array = cachedArguments.CachedArguments;
			}
			else if (cachedArguments.JintArguments.Length != 0)
			{
				if (_hasSpreads)
				{
					array = JintExpression.BuildArgumentsWithSpreads(context, cachedArguments.JintArguments);
				}
				else
				{
					array = context.Engine._jsValueArrayPool.RentArray(cachedArguments.JintArguments.Length);
					JintExpression.BuildArguments(context, cachedArguments.JintArguments, array);
				}
			}
			return array;
		}

		private JsValue[] DefaultSuperCallArgumentListEvaluation(EvaluationContext context)
		{
			JsArray jsArray = (JsArray)((JintSpreadExpression)_cachedArguments.JintArguments[0])._argument.GetValue(context);
			uint length = jsArray.GetLength();
			List<JsValue> list = new List<JsValue>((int)length);
			for (uint num = 0u; num < length; num++)
			{
				jsArray.TryGetValue(num, out JsValue value);
				list.Add(value);
			}
			return list.ToArray();
		}
	}
	internal sealed class JintClassExpression : JintExpression
	{
		private readonly ClassDefinition _classDefinition;

		public JintClassExpression(ClassExpression expression)
			: base((Expression)(object)expression)
		{
			Identifier id = expression.Id;
			_classDefinition = new ClassDefinition((id != null) ? id.Name : null, expression.SuperClass, expression.Body);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			Jint.Runtime.Environments.Environment lexicalEnvironment = context.Engine.ExecutionContext.LexicalEnvironment;
			return _classDefinition.BuildConstructor(context, lexicalEnvironment);
		}
	}
	internal sealed class JintConditionalExpression : JintExpression
	{
		private readonly JintExpression _test;

		private readonly JintExpression _consequent;

		private readonly JintExpression _alternate;

		public JintConditionalExpression(ConditionalExpression expression)
			: base((Expression)(object)expression)
		{
			_test = JintExpression.Build(expression.Test);
			_consequent = JintExpression.Build(expression.Consequent);
			_alternate = JintExpression.Build(expression.Alternate);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!TypeConverter.ToBoolean(_test.GetValue(context)))
			{
				return _alternate.GetValue(context);
			}
			return _consequent.GetValue(context);
		}
	}
	internal sealed class JintConstantExpression : JintExpression
	{
		private readonly JsValue _value;

		public JsValue Value => _value;

		public JintConstantExpression(Expression expression, JsValue value)
			: base(expression)
		{
			_value = value;
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			return _value;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			return _value;
		}
	}
	internal abstract class JintExpression
	{
		private sealed class ArraySpreadProtocol : IteratorProtocol
		{
			private readonly List<JsValue> _instance;

			public ArraySpreadProtocol(Engine engine, List<JsValue> instance, IteratorInstance iterator)
				: base(engine, iterator, 0)
			{
				_instance = instance;
			}

			protected override void ProcessItem(JsValue[] arguments, JsValue currentValue)
			{
				_instance.Add(currentValue);
			}
		}

		protected internal readonly Expression _expression;

		internal string SourceText => ToString(_expression) ?? "*unknown*";

		protected JintExpression(Expression expression)
		{
			_expression = expression;
		}

		public virtual JsValue GetValue(EvaluationContext context)
		{
			object obj = Evaluate(context);
			if (!(obj is Reference reference))
			{
				return (JsValue)obj;
			}
			return context.Engine.GetValue(reference, returnReferenceToPool: true);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
		public object Evaluate(EvaluationContext context)
		{
			SyntaxElement lastSyntaxElement = context.LastSyntaxElement;
			context.PrepareFor((Node)(object)_expression);
			object result = EvaluateInternal(context);
			context.LastSyntaxElement = lastSyntaxElement;
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal object EvaluateWithoutNodeTracking(EvaluationContext context)
		{
			return EvaluateInternal(context);
		}

		protected abstract object EvaluateInternal(EvaluationContext context);

		internal static string? ToString(Expression expression)
		{
			while (true)
			{
				Literal val = (Literal)(object)((expression is Literal) ? expression : null);
				if (val != null)
				{
					return AstExtensions.LiteralKeyToString(val);
				}
				Identifier val2 = (Identifier)(object)((expression is Identifier) ? expression : null);
				if (val2 != null)
				{
					return val2.Name;
				}
				MemberExpression val3 = (MemberExpression)(object)((expression is MemberExpression) ? expression : null);
				if (val3 != null)
				{
					return ToString(val3.Object) + "." + ToString(val3.Property);
				}
				CallExpression val4 = (CallExpression)(object)((expression is CallExpression) ? expression : null);
				if (val4 == null)
				{
					break;
				}
				expression = val4.Callee;
			}
			return null;
		}

		protected internal static JintExpression Build(Expression expression)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected I4, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected I4, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Expected O, but got Unknown
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Expected O, but got Unknown
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Expected O, but got Unknown
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Expected O, but got Unknown
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Invalid comparison between Unknown and I4
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected I4, but got Unknown
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Expected O, but got Unknown
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Expected O, but got Unknown
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected I4, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			if (((SyntaxElement)expression).AssociatedData is JintExpression result)
			{
				return result;
			}
			Nodes type = ((Node)expression).Type;
			JintExpression jintExpression;
			if ((int)type <= 49)
			{
				switch (type - 1)
				{
				case 3:
					goto IL_0110;
				case 0:
					goto IL_0121;
				case 2:
					goto IL_0132;
				case 6:
					goto IL_0143;
				case 9:
					goto IL_0154;
				case 15:
					goto IL_0165;
				case 14:
					goto IL_02c0;
				case 11:
					goto IL_02fb;
				case 5:
					goto IL_033e;
				case 1:
				case 4:
				case 7:
				case 8:
				case 10:
				case 12:
				case 13:
					goto IL_035a;
				}
				switch (type - 31)
				{
				case 0:
					break;
				case 1:
					goto IL_0187;
				case 18:
					goto IL_0198;
				case 10:
					goto IL_01a9;
				case 11:
					goto IL_01ba;
				case 12:
					goto IL_0216;
				case 15:
					goto IL_0227;
				case 16:
					goto IL_0238;
				case 6:
					goto IL_02d1;
				case 13:
					goto IL_02ed;
				default:
					goto IL_035a;
				}
				jintExpression = new JintFunctionExpression((FunctionExpression)expression);
			}
			else
			{
				switch (type - 55)
				{
				case 0:
					goto IL_0249;
				case 9:
					goto IL_025a;
				case 13:
					goto IL_026b;
				case 12:
					goto IL_027c;
				case 1:
					goto IL_028d;
				case 8:
					goto IL_029e;
				case 6:
					goto IL_02af;
				case 3:
					goto IL_02df;
				case 2:
				case 4:
				case 5:
				case 7:
				case 10:
				case 11:
					goto IL_035a;
				}
				if ((int)type != 73)
				{
					goto IL_035a;
				}
				jintExpression = new JintYieldExpression((YieldExpression)expression);
			}
			goto IL_035c;
			IL_02d1:
			jintExpression = new JintImportExpression((ImportExpression)expression);
			goto IL_035c;
			IL_035c:
			JintExpression jintExpression2 = jintExpression;
			if (jintExpression2 == null)
			{
				ExceptionHelper.ThrowArgumentOutOfRangeException("expression", $"unsupported expression type '{((Node)expression).Type}'");
			}
			return jintExpression2;
			IL_0249:
			jintExpression = new JintSequenceExpression((SequenceExpression)expression);
			goto IL_035c;
			IL_028d:
			jintExpression = new JintSpreadExpression((SpreadElement)expression);
			goto IL_035c;
			IL_02df:
			jintExpression = new JintSuperExpression((Super)expression);
			goto IL_035c;
			IL_02af:
			jintExpression = new JintTaggedTemplateExpression((TaggedTemplateExpression)expression);
			goto IL_035c;
			IL_029e:
			jintExpression = new JintTemplateLiteralExpression((TemplateLiteral)expression);
			goto IL_035c;
			IL_025a:
			jintExpression = new JintThisExpression((ThisExpression)expression);
			goto IL_035c;
			IL_027c:
			jintExpression = JintUnaryExpression.Build((UnaryExpression)expression);
			goto IL_035c;
			IL_026b:
			jintExpression = new JintUpdateExpression((UpdateExpression)expression);
			goto IL_035c;
			IL_0227:
			jintExpression = new JintNewExpression((NewExpression)expression);
			goto IL_035c;
			IL_0238:
			jintExpression = JintObjectExpression.Build((ObjectExpression)expression);
			goto IL_035c;
			IL_01ba:
			BinaryOperator val = ((BinaryExpression)expression).Operator;
			jintExpression = (val - 21) switch
			{
				0 => new JintLogicalAndExpression((BinaryExpression)expression), 
				1 => new JintLogicalOrExpression((BinaryExpression)expression), 
				3 => new NullishCoalescingExpression((BinaryExpression)expression), 
				_ => null, 
			};
			goto IL_035c;
			IL_0121:
			jintExpression = JintArrayExpression.Build((ArrayExpression)expression);
			goto IL_035c;
			IL_0132:
			jintExpression = new JintArrowFunctionExpression((ArrowFunctionExpression)expression);
			goto IL_035c;
			IL_0110:
			jintExpression = JintAssignmentExpression.Build((AssignmentExpression)expression);
			goto IL_035c;
			IL_033e:
			jintExpression = new JintAwaitExpression((AwaitExpression)expression);
			goto IL_035c;
			IL_0143:
			jintExpression = JintBinaryExpression.Build((BinaryExpression)expression);
			goto IL_035c;
			IL_0154:
			jintExpression = new JintCallExpression((CallExpression)expression);
			goto IL_035c;
			IL_02fb:
			jintExpression = (((int)((Node)((ChainExpression)expression).Expression).Type == 10) ? ((JintExpression)new JintCallExpression((CallExpression)((ChainExpression)expression).Expression)) : ((JintExpression)new JintMemberExpression((MemberExpression)((ChainExpression)expression).Expression)));
			goto IL_035c;
			IL_02ed:
			jintExpression = new JintMetaPropertyExpression((MetaProperty)expression);
			goto IL_035c;
			IL_0216:
			jintExpression = new JintMemberExpression((MemberExpression)expression);
			goto IL_035c;
			IL_01a9:
			jintExpression = JintLiteralExpression.Build((Literal)expression);
			goto IL_035c;
			IL_02c0:
			jintExpression = new JintClassExpression((ClassExpression)expression);
			goto IL_035c;
			IL_0165:
			jintExpression = new JintConditionalExpression((ConditionalExpression)expression);
			goto IL_035c;
			IL_035a:
			jintExpression = null;
			goto IL_035c;
			IL_0198:
			jintExpression = new JintPrivateIdentifierExpression((PrivateIdentifier)expression);
			goto IL_035c;
			IL_0187:
			jintExpression = new JintIdentifierExpression((Identifier)expression);
			goto IL_035c;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected static JsValue Divide(EvaluationContext context, JsValue left, JsValue right)
		{
			if (AreIntegerOperands(left, right))
			{
				return DivideInteger(left, right);
			}
			if (JintBinaryExpression.AreNonBigIntOperands(left, right))
			{
				return DivideComplex(left, right);
			}
			JintBinaryExpression.AssertValidBigIntArithmeticOperands(left, right);
			BigInteger bigInteger = TypeConverter.ToBigInt(left);
			BigInteger bigInteger2 = TypeConverter.ToBigInt(right);
			if (bigInteger2 == 0L)
			{
				ExceptionHelper.ThrowRangeError(context.Engine.Realm, "Division by zero");
			}
			return JsBigInt.Create(bigInteger / bigInteger2);
		}

		private static JsValue DivideInteger(JsValue lval, JsValue rval)
		{
			int num = lval.AsInteger();
			int num2 = rval.AsInteger();
			if (num == 0 && num2 == 0)
			{
				return JsNumber.DoubleNaN;
			}
			if (num2 == 0)
			{
				return (num > 0) ? double.PositiveInfinity : double.NegativeInfinity;
			}
			if (num % num2 == 0 && (num != 0 || num2 > 0))
			{
				return JsNumber.Create(num / num2);
			}
			return (double)num / (double)num2;
		}

		private static JsValue DivideComplex(JsValue lval, JsValue rval)
		{
			if (lval.IsUndefined() || rval.IsUndefined())
			{
				return JsValue.Undefined;
			}
			double num = TypeConverter.ToNumber(lval);
			double num2 = TypeConverter.ToNumber(rval);
			if (double.IsNaN(num2) || double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (double.IsInfinity(num) && double.IsInfinity(num2))
			{
				return JsNumber.DoubleNaN;
			}
			if (double.IsInfinity(num) && num2 == 0.0)
			{
				if (NumberInstance.IsNegativeZero(num2))
				{
					return 0.0 - num;
				}
				return num;
			}
			if (num == 0.0 && num2 == 0.0)
			{
				return JsNumber.DoubleNaN;
			}
			if (num2 == 0.0)
			{
				if (NumberInstance.IsNegativeZero(num2))
				{
					return (num > 0.0) ? double.NegativeInfinity : double.PositiveInfinity;
				}
				return (num > 0.0) ? double.PositiveInfinity : double.NegativeInfinity;
			}
			return num / num2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected static JsValue Compare(JsValue x, JsValue y, bool leftFirst = true)
		{
			if (!x.IsNumber() || !y.IsNumber())
			{
				return CompareComplex(x, y, leftFirst);
			}
			return CompareNumber(x, y, leftFirst);
		}

		private static JsValue CompareNumber(JsValue x, JsValue y, bool leftFirst)
		{
			double num;
			double num2;
			if (leftFirst)
			{
				num = x.AsNumber();
				num2 = y.AsNumber();
			}
			else
			{
				num2 = y.AsNumber();
				num = x.AsNumber();
			}
			if (x.IsInteger() && y.IsInteger())
			{
				if ((int)num >= (int)num2)
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
			if (!double.IsInfinity(num) && !double.IsInfinity(num2) && !double.IsNaN(num) && !double.IsNaN(num2))
			{
				if (!(num < num2))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
			return CompareComplex(x, y, leftFirst);
		}

		private static JsValue CompareComplex(JsValue x, JsValue y, bool leftFirst)
		{
			JsValue jsValue;
			JsValue jsValue2;
			if (leftFirst)
			{
				jsValue = TypeConverter.ToPrimitive(x, Types.Number);
				jsValue2 = TypeConverter.ToPrimitive(y, Types.Number);
			}
			else
			{
				jsValue2 = TypeConverter.ToPrimitive(y, Types.Number);
				jsValue = TypeConverter.ToPrimitive(x, Types.Number);
			}
			Types type = jsValue.Type;
			Types type2 = jsValue2.Type;
			if (type != Types.String || type2 != Types.String)
			{
				if (type == Types.BigInt || type2 == Types.BigInt)
				{
					if (type == type2)
					{
						if (!(TypeConverter.ToBigInt(jsValue) < TypeConverter.ToBigInt(jsValue2)))
						{
							return JsBoolean.False;
						}
						return JsBoolean.True;
					}
					if (type == Types.BigInt)
					{
						if (jsValue2 is JsString jsString)
						{
							if (!TypeConverter.TryStringToBigInt(jsString.ToString(), out var result))
							{
								return JsValue.Undefined;
							}
							if (!(TypeConverter.ToBigInt(jsValue) < result))
							{
								return JsBoolean.False;
							}
							return JsBoolean.True;
						}
						double num = TypeConverter.ToNumber(jsValue2);
						if (double.IsNaN(num))
						{
							return JsValue.Undefined;
						}
						if (double.IsPositiveInfinity(num))
						{
							return JsBoolean.True;
						}
						if (double.IsNegativeInfinity(num))
						{
							return JsBoolean.False;
						}
						BigInteger bigInteger = new BigInteger(Math.Ceiling(num));
						if (!(TypeConverter.ToBigInt(jsValue) < bigInteger))
						{
							return JsBoolean.False;
						}
						return JsBoolean.True;
					}
					if (jsValue is JsString jsString2)
					{
						if (!TypeConverter.TryStringToBigInt(jsString2.ToString(), out var result2))
						{
							return JsValue.Undefined;
						}
						if (!(result2 < TypeConverter.ToBigInt(jsValue2)))
						{
							return JsBoolean.False;
						}
						return JsBoolean.True;
					}
					double d = TypeConverter.ToNumber(jsValue);
					if (double.IsNaN(d))
					{
						return JsValue.Undefined;
					}
					if (double.IsPositiveInfinity(d))
					{
						return JsBoolean.False;
					}
					if (double.IsNegativeInfinity(d))
					{
						return JsBoolean.True;
					}
					return new BigInteger(Math.Floor(d)) < TypeConverter.ToBigInt(jsValue2);
				}
				double num2 = TypeConverter.ToNumber(jsValue);
				double num3 = TypeConverter.ToNumber(jsValue2);
				if (double.IsNaN(num2) || double.IsNaN(num3))
				{
					return JsValue.Undefined;
				}
				if (num2 == num3)
				{
					return JsBoolean.False;
				}
				if (double.IsPositiveInfinity(num2))
				{
					return JsBoolean.False;
				}
				if (double.IsPositiveInfinity(num3))
				{
					return JsBoolean.True;
				}
				if (double.IsNegativeInfinity(num3))
				{
					return JsBoolean.False;
				}
				if (double.IsNegativeInfinity(num2))
				{
					return JsBoolean.True;
				}
				if (!(num2 < num3))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
			if (string.CompareOrdinal(TypeConverter.ToString(x), TypeConverter.ToString(y)) >= 0)
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected static void BuildArguments(EvaluationContext context, JintExpression[] jintExpressions, JsValue[] targetArray)
		{
			for (uint num = 0u; num < (uint)jintExpressions.Length; num++)
			{
				targetArray[num] = jintExpressions[num].GetValue(context).Clone();
			}
		}

		protected static JsValue[] BuildArgumentsWithSpreads(EvaluationContext context, JintExpression[] jintExpressions)
		{
			List<JsValue> list = new List<JsValue>(jintExpressions.Length);
			foreach (JintExpression jintExpression in jintExpressions)
			{
				if (jintExpression is JintSpreadExpression jintSpreadExpression)
				{
					jintSpreadExpression.GetValueAndCheckIterator(context, out JsValue instance, out IteratorInstance iterator);
					if (instance is JsArray { HasOriginalIterator: not false } jsArray)
					{
						uint length = jsArray.GetLength();
						for (uint num = 0u; num < length; num++)
						{
							jsArray.TryGetValue(num, out JsValue value);
							list.Add(value);
						}
					}
					else
					{
						new ArraySpreadProtocol(context.Engine, list, iterator).Execute();
					}
				}
				else
				{
					list.Add(jintExpression.GetValue(context).Clone());
				}
			}
			return list.ToArray();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected static bool AreIntegerOperands(JsValue left, JsValue right)
		{
			if (left._type == right._type)
			{
				return left._type == InternalTypes.Integer;
			}
			return false;
		}
	}
	internal sealed class JintFunctionExpression : JintExpression
	{
		private readonly JintFunctionDefinition _function;

		public JintFunctionExpression(FunctionExpression function)
			: base((Expression)(object)function)
		{
			_function = new JintFunctionDefinition((IFunction)(object)function);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			return GetValue(context);
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			string name = _function.Name ?? "";
			if (!_function.Function.Generator)
			{
				return _function.Function.Async ? InstantiateAsyncFunctionExpression(context, name) : InstantiateOrdinaryFunctionExpression(context, name);
			}
			return InstantiateGeneratorFunctionExpression(context, name);
		}

		private ScriptFunction InstantiateOrdinaryFunctionExpression(EvaluationContext context, string? name = "")
		{
			Engine engine = context.Engine;
			Jint.Runtime.Environments.ExecutionContext executionContext = engine.ExecutionContext;
			Jint.Runtime.Environments.Environment lexicalEnvironment = executionContext.LexicalEnvironment;
			DeclarativeEnvironment declarativeEnvironment = null;
			if (!string.IsNullOrWhiteSpace(name))
			{
				declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(engine, engine.ExecutionContext.LexicalEnvironment);
				declarativeEnvironment.CreateImmutableBinding(name, strict: false);
			}
			PrivateEnvironment privateEnvironment = executionContext.PrivateEnvironment;
			FunctionThisMode thisMode = (_function.Strict ? FunctionThisMode.Strict : FunctionThisMode.Global);
			Intrinsics intrinsics = engine.Realm.Intrinsics;
			ScriptFunction scriptFunction = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.Function.PrototypeObject, _function, thisMode, declarativeEnvironment ?? lexicalEnvironment, privateEnvironment);
			if (name != null)
			{
				scriptFunction.SetFunctionName(name);
			}
			scriptFunction.MakeConstructor();
			declarativeEnvironment?.InitializeBinding(name, scriptFunction);
			return scriptFunction;
		}

		private ScriptFunction InstantiateAsyncFunctionExpression(EvaluationContext context, string? name = "")
		{
			Engine engine = context.Engine;
			Jint.Runtime.Environments.ExecutionContext executionContext = engine.ExecutionContext;
			Jint.Runtime.Environments.Environment lexicalEnvironment = executionContext.LexicalEnvironment;
			DeclarativeEnvironment declarativeEnvironment = null;
			if (!string.IsNullOrWhiteSpace(name))
			{
				declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(engine, engine.ExecutionContext.LexicalEnvironment);
				declarativeEnvironment.CreateImmutableBinding(name, strict: false);
			}
			PrivateEnvironment privateEnvironment = executionContext.PrivateEnvironment;
			FunctionThisMode thisMode = (_function.Strict ? FunctionThisMode.Strict : FunctionThisMode.Global);
			Intrinsics intrinsics = engine.Realm.Intrinsics;
			ScriptFunction scriptFunction = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.AsyncFunction.PrototypeObject, _function, thisMode, declarativeEnvironment ?? lexicalEnvironment, privateEnvironment);
			scriptFunction.SetFunctionName(name ?? "");
			declarativeEnvironment?.InitializeBinding(name, scriptFunction);
			return scriptFunction;
		}

		private ScriptFunction InstantiateGeneratorFunctionExpression(EvaluationContext context, string? name)
		{
			Engine engine = context.Engine;
			Jint.Runtime.Environments.ExecutionContext executionContext = engine.ExecutionContext;
			Jint.Runtime.Environments.Environment lexicalEnvironment = executionContext.LexicalEnvironment;
			DeclarativeEnvironment declarativeEnvironment = null;
			if (!string.IsNullOrWhiteSpace(name))
			{
				declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(engine, engine.ExecutionContext.LexicalEnvironment);
				declarativeEnvironment.CreateImmutableBinding(name, strict: false);
			}
			PrivateEnvironment privateEnvironment = executionContext.PrivateEnvironment;
			FunctionThisMode thisMode = ((_function.Strict || engine._isStrict) ? FunctionThisMode.Strict : FunctionThisMode.Global);
			Intrinsics intrinsics = engine.Realm.Intrinsics;
			ScriptFunction scriptFunction = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.GeneratorFunction.PrototypeObject, _function, thisMode, declarativeEnvironment ?? lexicalEnvironment, privateEnvironment);
			if (name != null)
			{
				scriptFunction.SetFunctionName(name);
			}
			JsObject value = ObjectInstance.OrdinaryObjectCreate(engine, intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject);
			scriptFunction.DefinePropertyOrThrow(CommonProperties.Prototype, new PropertyDescriptor(value, PropertyFlag.Writable));
			declarativeEnvironment?.InitializeBinding(name, scriptFunction);
			return scriptFunction;
		}
	}
	internal sealed class JintIdentifierExpression : JintExpression
	{
		private readonly Jint.Runtime.Environments.Environment.BindingName _identifier;

		public Jint.Runtime.Environments.Environment.BindingName Identifier => _identifier;

		public bool HasEvalOrArguments
		{
			get
			{
				Key a = _identifier.Key;
				if (!(a == KnownKeys.Eval))
				{
					return a == KnownKeys.Arguments;
				}
				return true;
			}
		}

		public JintIdentifierExpression(Identifier expression)
			: this(expression, new Jint.Runtime.Environments.Environment.BindingName(expression.Name))
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			_identifier = new Jint.Runtime.Environments.Environment.BindingName(((Identifier)_expression).Name);
		}

		public JintIdentifierExpression(Identifier identifier, Jint.Runtime.Environments.Environment.BindingName bindingName)
			: base((Expression)(object)identifier)
		{
			_identifier = bindingName;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			Engine engine = context.Engine;
			Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
			bool isStrictModeCode = StrictModeScope.IsStrictModeCode;
			Jint.Runtime.Environments.Environment record;
			JsValue baseValue = (JintEnvironment.TryGetIdentifierEnvironmentWithBinding(lexicalEnvironment, _identifier, out record) ? record : JsValue.Undefined);
			return engine._referencePool.Rent(baseValue, _identifier.Value, isStrictModeCode, null);
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			context.LastSyntaxElement = (SyntaxElement)(object)_expression;
			Jint.Runtime.Environments.Environment.BindingName identifier = Identifier;
			if ((object)identifier.CalculatedValue != null)
			{
				return identifier.CalculatedValue;
			}
			Engine engine = context.Engine;
			if (JintEnvironment.TryGetIdentifierEnvironmentWithBindingValue(engine.ExecutionContext.LexicalEnvironment, identifier, out Jint.Runtime.Environments.Environment _, out JsValue value))
			{
				if ((object)value == null)
				{
					ThrowNotInitialized(engine);
				}
			}
			else
			{
				Reference reference = engine._referencePool.Rent(JsValue.Undefined, identifier.Value, StrictModeScope.IsStrictModeCode, null);
				value = engine.GetValue(reference, returnReferenceToPool: true);
			}
			if (value is JsArguments jsArguments)
			{
				jsArguments.Materialize();
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DoesNotReturn]
		private void ThrowNotInitialized(Engine engine)
		{
			ExceptionHelper.ThrowReferenceError(engine.Realm, _identifier.Key.Name + " has not been initialized");
		}
	}
	internal sealed class JintImportExpression : JintExpression
	{
		private JintExpression _specifierExpression;

		private bool _initialized;

		private JintExpression? _optionsExpression;

		public JintImportExpression(ImportExpression expression)
			: base((Expression)(object)expression)
		{
			_specifierExpression = null;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			if (!_initialized)
			{
				ImportExpression val = (ImportExpression)_expression;
				_specifierExpression = JintExpression.Build(val.Source);
				_optionsExpression = ((val.Options != null) ? JintExpression.Build(val.Options) : null);
				_initialized = true;
			}
			IScriptOrModule activeScriptOrModule = context.Engine.GetActiveScriptOrModule();
			JsValue value = _specifierExpression.GetValue(context);
			JsValue jsValue = _optionsExpression?.GetValue(context) ?? JsValue.Undefined;
			PromiseCapability promiseCapability = PromiseConstructor.NewPromiseCapability(context.Engine, context.Engine.Realm.Intrinsics.Promise);
			try
			{
				string specifier = TypeConverter.ToString(value);
				List<ModuleImportAttribute> list = new List<ModuleImportAttribute>();
				if (!jsValue.IsUndefined())
				{
					if (!jsValue.IsObject())
					{
						ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Invalid options object");
						return JsValue.Undefined;
					}
					JsValue jsValue2 = jsValue.Get("with");
					if (!jsValue2.IsUndefined())
					{
						if (!(jsValue2 is ObjectInstance objectInstance))
						{
							ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Invalid options.with object");
							return JsValue.Undefined;
						}
						JsArray jsArray = objectInstance.EnumerableOwnProperties(ObjectInstance.EnumerableOwnPropertyNamesKind.KeyValue);
						list.Capacity = (int)jsArray.GetLength();
						foreach (JsValue item in jsArray)
						{
							JsValue jsValue3 = item.Get("0");
							JsValue jsValue4 = item.Get("1");
							if (!jsValue4.IsString())
							{
								ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Invalid option value " + jsValue4);
								return JsValue.Undefined;
							}
							list.Add(new ModuleImportAttribute(jsValue3.ToString(), TypeConverter.ToString(jsValue4)));
						}
						if (!AllImportAttributesSupported(context.Engine._host, list))
						{
							ExceptionHelper.ThrowTypeError(context.Engine.Realm, "Unsupported import attributes detected");
						}
						list.Sort((ModuleImportAttribute item1, ModuleImportAttribute item2) => StringComparer.Ordinal.Compare(item1.Key, item2.Key));
					}
				}
				ModuleRequest moduleRequest = new ModuleRequest(specifier, list.ToArray());
				context.Engine._host.LoadImportedModule(activeScriptOrModule, moduleRequest, promiseCapability);
			}
			catch (JavaScriptException ex)
			{
				promiseCapability.Reject.Call(JsValue.Undefined, ex.Error);
			}
			return promiseCapability.PromiseInstance;
		}

		private static bool AllImportAttributesSupported(Host host, List<ModuleImportAttribute> attributes)
		{
			List<string> supportedImportAttributes = host.GetSupportedImportAttributes();
			foreach (ModuleImportAttribute attribute in attributes)
			{
				if (!supportedImportAttributes.Contains(attribute.Key))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal sealed class JintLiteralExpression : JintExpression
	{
		private static readonly object _nullMarker = new object();

		private JintLiteralExpression(Literal expression)
			: base((Expression)(object)expression)
		{
		}

		internal static JintExpression Build(Literal expression)
		{
			object obj = ((SyntaxElement)expression).AssociatedData;
			if (obj == null)
			{
				object obj2 = ConvertToJsValue(expression) ?? _nullMarker;
				object obj3 = obj2;
				((SyntaxElement)expression).AssociatedData = obj2;
				obj = obj3;
			}
			if (obj is JsValue value)
			{
				return new JintConstantExpression((Expression)(object)expression, value);
			}
			return new JintLiteralExpression(expression);
		}

		internal static JsValue? ConvertToJsValue(Literal literal)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected I4, but got Unknown
			TokenType tokenType = literal.TokenType;
			switch (tokenType - 1)
			{
			case 0:
				if (!literal.BooleanValue.Value)
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			case 4:
				return JsValue.Null;
			case 5:
			{
				double num = (double)literal.Value;
				int num2 = (int)num;
				if (num != (double)num2 || (num2 == 0 && BitConverter.DoubleToInt64Bits(num) == JsNumber.NegativeZeroBits))
				{
					return JsNumber.Create(num);
				}
				return JsNumber.Create(num2);
			}
			case 7:
				return JsString.Create((string)literal.Value);
			case 10:
				return JsBigInt.Create((BigInteger)literal.Value);
			default:
				return null;
			}
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			context.LastSyntaxElement = (SyntaxElement)(object)_expression;
			return ResolveValue(context);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			return ResolveValue(context);
		}

		private JsValue ResolveValue(EvaluationContext context)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			Literal val = (Literal)_expression;
			if ((int)val.TokenType == 9)
			{
				RegExpLiteral val2 = (RegExpLiteral)val;
				RegExpParseResult parseResult = val2.ParseResult;
				if (((RegExpParseResult)(ref parseResult)).Success)
				{
					Regex regExp = (((SyntaxElement)val2).AssociatedData as Regex) ?? ((RegExpParseResult)(ref parseResult)).Regex;
					return context.Engine.Realm.Intrinsics.RegExp.Construct(regExp, val2.Regex.Pattern, val2.Regex.Flags, parseResult);
				}
				ExceptionHelper.ThrowSyntaxError(context.Engine.Realm, "Unsupported regular expression. " + ((RegExpParseResult)(ref parseResult)).ConversionError.Description);
			}
			return JsValue.FromObject(context.Engine, val.Value);
		}
	}
	internal sealed class JintLogicalAndExpression : JintExpression
	{
		private JintExpression _left;

		private JintExpression _right;

		private bool _initialized;

		public JintLogicalAndExpression(BinaryExpression expression)
			: base((Expression)(object)expression)
		{
		}

		private void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			BinaryExpression val = (BinaryExpression)_expression;
			_left = JintExpression.Build(val.Left);
			_right = JintExpression.Build(val.Right);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			JsValue value = _left.GetValue(context);
			if (value is JsBoolean { _value: false } jsBoolean)
			{
				return jsBoolean;
			}
			if (!TypeConverter.ToBoolean(value))
			{
				return value;
			}
			return _right.GetValue(context);
		}
	}
	internal sealed class JintLogicalOrExpression : JintExpression
	{
		private readonly JintExpression _left;

		private readonly JintExpression _right;

		public JintLogicalOrExpression(BinaryExpression expression)
			: base((Expression)(object)expression)
		{
			_left = JintExpression.Build(expression.Left);
			_right = JintExpression.Build(expression.Right);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			JsValue value = _left.GetValue(context);
			if (value is JsBoolean { _value: not false } jsBoolean)
			{
				return jsBoolean;
			}
			if (TypeConverter.ToBoolean(value))
			{
				return value;
			}
			return _right.GetValue(context);
		}
	}
	internal sealed class JintMemberExpression : JintExpression
	{
		private readonly MemberExpression _memberExpression;

		private JintExpression _objectExpression;

		private JintExpression? _propertyExpression;

		private JsValue? _determinedProperty;

		private bool _initialized;

		private static readonly JsValue _nullMarker = new JsString("NULL MARKER");

		public JintMemberExpression(MemberExpression expression)
			: base((Expression)(object)expression)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			_memberExpression = (MemberExpression)_expression;
		}

		internal static JsValue InitializeDeterminedProperty(MemberExpression expression, bool cache)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			JsValue jsValue = null;
			if (!expression.Computed)
			{
				Expression property = expression.Property;
				Identifier val = (Identifier)(object)((property is Identifier) ? property : null);
				if (val != null)
				{
					jsValue = (cache ? JsString.CachedCreate(val.Name) : JsString.Create(val.Name));
				}
			}
			else if ((int)((Node)expression.Property).Type == 41)
			{
				jsValue = JintLiteralExpression.ConvertToJsValue((Literal)expression.Property);
			}
			return jsValue ?? _nullMarker;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				_objectExpression = JintExpression.Build(_memberExpression.Object);
				if ((object)_determinedProperty == null)
				{
					_determinedProperty = (((SyntaxElement)_expression).AssociatedData as JsValue) ?? InitializeDeterminedProperty(_memberExpression, cache: false);
				}
				if ((object)_determinedProperty == _nullMarker)
				{
					_propertyExpression = JintExpression.Build(_memberExpression.Property);
					_determinedProperty = null;
				}
				_initialized = true;
			}
			JsValue thisValue = null;
			object obj = null;
			JsValue value = null;
			Engine engine = context.Engine;
			if (_objectExpression is JintIdentifierExpression jintIdentifierExpression)
			{
				Jint.Runtime.Environments.Environment.BindingName identifier = jintIdentifierExpression.Identifier;
				obj = identifier.Key.Name;
				JintEnvironment.TryGetIdentifierEnvironmentWithBindingValue(engine.ExecutionContext.LexicalEnvironment, identifier, out Jint.Runtime.Environments.Environment _, out value);
			}
			else if (_objectExpression is JintThisExpression jintThisExpression)
			{
				value = jintThisExpression.GetValue(context);
			}
			else if (_objectExpression is JintSuperExpression)
			{
				FunctionEnvironment obj2 = (FunctionEnvironment)engine.ExecutionContext.GetThisEnvironment();
				thisValue = obj2.GetThisBinding();
				value = obj2.GetSuperBase();
			}
			if ((object)value == null)
			{
				object obj3 = _objectExpression.Evaluate(context);
				if (JsValue.Undefined == obj3)
				{
					return JsValue.Undefined;
				}
				if (obj3 is Reference reference)
				{
					obj = reference.ReferencedName;
					value = engine.GetValue(reference, returnReferenceToPool: true);
				}
				else
				{
					value = engine.GetValue(obj3, returnReferenceToPool: false);
				}
			}
			if (value.IsNullOrUndefined() && (_memberExpression.Optional || _objectExpression._expression.IsOptional<Expression>()))
			{
				return JsValue.Undefined;
			}
			JsValue jsValue = _determinedProperty ?? _propertyExpression.GetValue(context);
			if (value.IsNullOrUndefined())
			{
				string referenceName = (jsValue.IsPrimitive() ? TypeConverter.ToString(jsValue) : (_determinedProperty?.ToString() ?? obj?.ToString()));
				TypeConverter.CheckObjectCoercible(engine, value, (Node)(object)_memberExpression.Property, referenceName);
			}
			if (jsValue.IsPrivateName())
			{
				return MakePrivateReference(engine, value, jsValue);
			}
			return context.Engine._referencePool.Rent(value, jsValue, StrictModeScope.IsStrictModeCode, thisValue);
		}

		private static Reference MakePrivateReference(Engine engine, JsValue baseValue, JsValue privateIdentifier)
		{
			PrivateName name = engine.ExecutionContext.PrivateEnvironment.ResolvePrivateIdentifier(privateIdentifier.ToString());
			return engine._referencePool.Rent(baseValue, name, strict: true, null);
		}
	}
	internal sealed class JintMetaPropertyExpression : JintExpression
	{
		public JintMetaPropertyExpression(MetaProperty expression)
			: base((Expression)(object)expression)
		{
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			MetaProperty val = (MetaProperty)_expression;
			if (string.Equals(val.Meta.Name, "new", StringComparison.Ordinal) && string.Equals(val.Property.Name, "target", StringComparison.Ordinal))
			{
				return context.Engine.GetNewTarget();
			}
			if (string.Equals(val.Meta.Name, "import", StringComparison.Ordinal) && string.Equals(val.Property.Name, "meta", StringComparison.Ordinal))
			{
				SourceTextModule sourceTextModule = (SourceTextModule)context.Engine.ExecutionContext.ScriptOrModule;
				ObjectInstance objectInstance = sourceTextModule.ImportMeta;
				if ((object)objectInstance == null)
				{
					objectInstance = context.Engine.Realm.Intrinsics.Object.Construct(0);
					foreach (KeyValuePair<JsValue, JsValue> importMetaProperty in context.Engine._host.GetImportMetaProperties(sourceTextModule))
					{
						objectInstance.CreateDataPropertyOrThrow(importMetaProperty.Key, importMetaProperty.Value);
					}
					context.Engine._host.FinalizeImportMeta(objectInstance, sourceTextModule);
					sourceTextModule.ImportMeta = objectInstance;
				}
				return objectInstance;
			}
			ExceptionHelper.ThrowNotImplementedException();
			return null;
		}
	}
	internal sealed class JintNewExpression : JintExpression
	{
		private JintExpression _calleeExpression;

		private JintExpression[] _jintArguments = Array.Empty<JintExpression>();

		private bool _hasSpreads;

		private bool _initialized;

		public JintNewExpression(NewExpression expression)
			: base((Expression)(object)expression)
		{
		}

		private void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			NewExpression val = (NewExpression)_expression;
			_calleeExpression = JintExpression.Build(val.Callee);
			if (((NodeList<Expression>)val.Arguments).Count > 0)
			{
				_jintArguments = new JintExpression[((NodeList<Expression>)val.Arguments).Count];
				for (int i = 0; i < _jintArguments.Length; i++)
				{
					Expression val2 = ((NodeList<Expression>)val.Arguments)[i];
					_jintArguments[i] = JintExpression.Build(val2);
					_hasSpreads |= (int)((Node)val2).Type == 56;
				}
			}
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			Engine engine = context.Engine;
			JsValue value = _calleeExpression.GetValue(context);
			JsValue[] array;
			if (_jintArguments.Length == 0)
			{
				array = Array.Empty<JsValue>();
			}
			else if (_hasSpreads)
			{
				array = JintExpression.BuildArgumentsWithSpreads(context, _jintArguments);
			}
			else
			{
				array = engine._jsValueArrayPool.RentArray(_jintArguments.Length);
				JintExpression.BuildArguments(context, _jintArguments, array);
			}
			context.LastSyntaxElement = (SyntaxElement)(object)_expression;
			if (!value.IsConstructor)
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, _calleeExpression.SourceText + " is not a constructor");
			}
			ObjectInstance result = engine.Construct(value, array, value, _calleeExpression);
			engine._jsValueArrayPool.ReturnArray(array);
			return result;
		}
	}
	internal sealed class JintObjectExpression : JintExpression
	{
		private sealed class ObjectProperty
		{
			internal readonly string? _key;

			private JsString? _keyJsString;

			internal readonly Property _value;

			private JintFunctionDefinition? _functionDefinition;

			public JsString? KeyJsString => _keyJsString ?? (_keyJsString = ((_key != null) ? JsString.Create(_key) : null));

			public ObjectProperty(string? key, Property property)
			{
				_key = key;
				_value = property;
			}

			public JintFunctionDefinition GetFunctionDefinition(Engine engine)
			{
				if (_functionDefinition != null)
				{
					return _functionDefinition;
				}
				Node value = _value.Value;
				IFunction val = (IFunction)(object)((value is IFunction) ? value : null);
				if (val == null)
				{
					ExceptionHelper.ThrowSyntaxError(engine.Realm);
				}
				_functionDefinition = new JintFunctionDefinition(val);
				return _functionDefinition;
			}
		}

		internal sealed class JintEmptyObjectExpression : JintExpression
		{
			public static JintEmptyObjectExpression Instance;

			private JintEmptyObjectExpression(Expression expression)
				: base(expression)
			{
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				return new JsObject(context.Engine);
			}

			public override JsValue GetValue(EvaluationContext context)
			{
				return new JsObject(context.Engine);
			}

			static JintEmptyObjectExpression()
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				NodeList<Node> val = NodeList.Create<Node>(Enumerable.Empty<Node>());
				Instance = new JintEmptyObjectExpression((Expression)new ObjectExpression(ref val));
			}
		}

		private JintExpression[] _valueExpressions = Array.Empty<JintExpression>();

		private ObjectProperty?[] _properties = Array.Empty<ObjectProperty>();

		private bool _canBuildFast;

		private bool _initialized;

		private JintObjectExpression(ObjectExpression expression)
			: base((Expression)(object)expression)
		{
		}

		public static JintExpression Build(ObjectExpression expression)
		{
			if (((NodeList<Node>)expression.Properties).Count != 0)
			{
				return new JintObjectExpression(expression);
			}
			return JintEmptyObjectExpression.Instance;
		}

		private void Initialize()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			_canBuildFast = true;
			ref NodeList<Node> properties = ((ObjectExpression)_expression).Properties;
			_valueExpressions = new JintExpression[properties.Count];
			_properties = new ObjectProperty[properties.Count];
			for (int i = 0; i < _properties.Length; i++)
			{
				string text = null;
				Node val = properties[i];
				Property val2 = (Property)(object)((val is Property) ? val : null);
				if (val2 != null)
				{
					Expression key = val2.Key;
					Literal val3 = (Literal)(object)((key is Literal) ? key : null);
					if (val3 != null)
					{
						text = AstExtensions.LiteralKeyToString(val3);
					}
					if (!val2.Computed)
					{
						Expression key2 = val2.Key;
						Identifier val4 = (Identifier)(object)((key2 is Identifier) ? key2 : null);
						if (val4 != null)
						{
							text = val4.Name;
							_canBuildFast &= !string.Equals(text, "__proto__", StringComparison.Ordinal);
						}
					}
					_properties[i] = new ObjectProperty(text, val2);
					if ((int)val2.Kind == 3)
					{
						Node value = val2.Value;
						_valueExpressions[i] = JintExpression.Build((Expression)value);
						_canBuildFast &= !value.IsFunctionDefinition<Node>();
					}
					else
					{
						_canBuildFast = false;
					}
				}
				else
				{
					SpreadElement val5 = (SpreadElement)(object)((val is SpreadElement) ? val : null);
					if (val5 != null)
					{
						_canBuildFast = false;
						_properties[i] = null;
						_valueExpressions[i] = JintExpression.Build(val5.Argument);
					}
					else
					{
						ExceptionHelper.ThrowArgumentOutOfRangeException("property", "cannot handle property " + (object)val);
					}
				}
				_canBuildFast &= text != null;
			}
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			if (!_canBuildFast)
			{
				return BuildObjectNormal(context);
			}
			return BuildObjectFast(context);
		}

		private JsObject BuildObjectFast(EvaluationContext context)
		{
			JsObject jsObject = new JsObject(context.Engine);
			PropertyDictionary propertyDictionary = new PropertyDictionary(_properties.Length, checkExistingKeys: true);
			for (int i = 0; i < _properties.Length; i++)
			{
				ObjectProperty objectProperty = _properties[i];
				JsValue value = _valueExpressions[i].GetValue(context).Clone();
				propertyDictionary[objectProperty._key] = new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable);
			}
			jsObject.SetProperties(propertyDictionary);
			return jsObject;
		}

		private object BuildObjectNormal(EvaluationContext context)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Invalid comparison between Unknown and I4
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Invalid comparison between Unknown and I4
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Invalid comparison between Unknown and I4
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Invalid comparison between Unknown and I4
			Engine engine = context.Engine;
			ObjectInstance objectInstance = engine.Realm.Intrinsics.Object.Construct(_properties.Length);
			for (int i = 0; i < _properties.Length; i++)
			{
				ObjectProperty objectProperty = _properties[i];
				if (objectProperty == null)
				{
					if (_valueExpressions[i].GetValue(context) is ObjectInstance objectInstance2)
					{
						objectInstance2.CopyDataProperties(objectInstance, null);
					}
					continue;
				}
				Property value = objectProperty._value;
				if (value.Method)
				{
					ClassDefinition.MethodDefinitionEvaluation<Property>(engine, objectInstance, value, enumerable: true);
					continue;
				}
				JsValue jsValue = objectProperty.KeyJsString;
				if ((object)jsValue == null)
				{
					JsValue jsValue2 = value.TryGetKey<Property>(engine);
					if (context.IsAbrupt())
					{
						return jsValue2;
					}
					jsValue = TypeConverter.ToPropertyKey(jsValue2);
				}
				if ((int)value.Kind == 3)
				{
					JintExpression jintExpression = _valueExpressions[i];
					JsValue value2 = jintExpression.GetValue(context);
					if (context.IsAbrupt())
					{
						return value2;
					}
					JsValue jsValue3 = value2.Clone();
					if (string.Equals(objectProperty._key, "__proto__", StringComparison.Ordinal) && !objectProperty._value.Computed && !objectProperty._value.Shorthand)
					{
						if (jsValue3.IsObject() || jsValue3.IsNull())
						{
							objectInstance.SetPrototypeOf(jsValue3);
						}
						continue;
					}
					if (jintExpression._expression.IsAnonymousFunctionDefinition<Expression>())
					{
						((Function)jsValue3).SetFunctionName(jsValue);
					}
					objectInstance.CreateDataPropertyOrThrow(jsValue, jsValue3);
				}
				else
				{
					PropertyKind kind = value.Kind;
					if (kind - 1 <= 1)
					{
						JintFunctionDefinition functionDefinition = objectProperty.GetFunctionDefinition(engine);
						ScriptFunction scriptFunction = engine.Realm.Intrinsics.Function.OrdinaryFunctionCreate(engine.Realm.Intrinsics.Function.PrototypeObject, functionDefinition, functionDefinition.ThisMode, engine.ExecutionContext.LexicalEnvironment, engine.ExecutionContext.PrivateEnvironment);
						scriptFunction.SetFunctionName(jsValue, ((int)value.Kind == 1) ? "get" : "set");
						scriptFunction.MakeMethod(objectInstance);
						GetSetPropertyDescriptor desc = new GetSetPropertyDescriptor(((int)value.Kind == 1) ? scriptFunction : null, ((int)value.Kind == 2) ? scriptFunction : null, PropertyFlag.Enumerable | PropertyFlag.Configurable);
						objectInstance.DefinePropertyOrThrow(jsValue, desc);
					}
				}
			}
			return objectInstance;
		}
	}
	internal sealed class JintPrivateIdentifierExpression : JintExpression
	{
		private readonly string _privateIdentifierString;

		public JintPrivateIdentifierExpression(PrivateIdentifier expression)
			: base((Expression)(object)expression)
		{
			_privateIdentifierString = expression.Name;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			Engine engine = context.Engine;
			PrivateName privateName = engine.ExecutionContext.PrivateEnvironment.ResolvePrivateIdentifier(_privateIdentifierString);
			if ((object)privateName != null)
			{
				return privateName;
			}
			ExceptionHelper.ThrowReferenceError(engine.Realm, "TODO Not found!!");
			return null;
		}
	}
	internal sealed class JintSequenceExpression : JintExpression
	{
		private JintExpression[] _expressions = Array.Empty<JintExpression>();

		private bool _initialized;

		public JintSequenceExpression(SequenceExpression expression)
			: base((Expression)(object)expression)
		{
		}

		private void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ref NodeList<Expression> expressions = ((SequenceExpression)_expression).Expressions;
			JintExpression[] array = new JintExpression[expressions.Count];
			for (int i = 0; i < (uint)array.Length; i++)
			{
				array[i] = JintExpression.Build(expressions[i]);
			}
			_expressions = array;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			JsValue result = JsValue.Undefined;
			JintExpression[] expressions = _expressions;
			for (int i = 0; i < expressions.Length; i++)
			{
				result = expressions[i].GetValue(context);
			}
			return result;
		}
	}
	internal sealed class JintSpreadExpression : JintExpression
	{
		internal readonly JintExpression _argument;

		private readonly string? _argumentName;

		public JintSpreadExpression(SpreadElement expression)
			: base((Expression)(object)expression)
		{
			_argument = JintExpression.Build(expression.Argument);
			Expression argument = expression.Argument;
			Expression obj = ((argument is Identifier) ? argument : null);
			_argumentName = ((obj != null) ? ((Identifier)obj).Name : null);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			GetValueAndCheckIterator(context, out JsValue instance, out IteratorInstance _);
			return instance;
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			context.LastSyntaxElement = (SyntaxElement)(object)_expression;
			GetValueAndCheckIterator(context, out JsValue instance, out IteratorInstance _);
			return instance;
		}

		internal void GetValueAndCheckIterator(EvaluationContext context, out JsValue instance, out IteratorInstance? iterator)
		{
			instance = _argument.GetValue(context);
			if ((object)instance == null || !instance.TryGetIterator(context.Engine.Realm, out iterator))
			{
				iterator = null;
				ExceptionHelper.ThrowTypeError(context.Engine.Realm, _argumentName + " is not iterable");
			}
		}
	}
	internal sealed class JintSuperExpression : JintExpression
	{
		public JintSuperExpression(Super expression)
			: base((Expression)(object)expression)
		{
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			return ((FunctionEnvironment)context.Engine.ExecutionContext.GetThisEnvironment())._functionObject.GetPrototypeOf();
		}
	}
	internal sealed class JintTaggedTemplateExpression : JintExpression
	{
		internal static readonly JsString PropertyRaw = new JsString("raw");

		private JintExpression _tagIdentifier;

		private JintTemplateLiteralExpression _quasi;

		private bool _initialized;

		public JintTaggedTemplateExpression(TaggedTemplateExpression expression)
			: base((Expression)(object)expression)
		{
		}

		private void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			TaggedTemplateExpression val = (TaggedTemplateExpression)_expression;
			_tagIdentifier = JintExpression.Build(val.Tag);
			_quasi = new JintTemplateLiteralExpression(val.Quasi);
			_quasi.DoInitialize();
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			Engine engine = context.Engine;
			object obj = _tagIdentifier.Evaluate(context);
			ICallable callable = engine.GetValue(obj) as ICallable;
			if (callable == null)
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, "Argument must be callable");
			}
			ref JintExpression[] expressions = ref _quasi._expressions;
			JsValue[] array = engine._jsValueArrayPool.RentArray(expressions.Length + 1);
			JsArray templateObject = GetTemplateObject(context);
			array[0] = templateObject;
			for (int i = 0; i < expressions.Length; i++)
			{
				array[i + 1] = expressions[i].GetValue(context);
			}
			JsValue thisObject = ((obj is Reference { IsPropertyReference: not false } reference) ? reference.Base : JsValue.Undefined);
			JsValue result = callable.Call(thisObject, array);
			engine._jsValueArrayPool.ReturnArray(array);
			return result;
		}

		private JsArray GetTemplateObject(EvaluationContext context)
		{
			Realm realm = context.Engine.Realm;
			if (realm._templateMap.TryGetValue((Node)(object)_expression, out JsArray value))
			{
				return value;
			}
			ref NodeList<TemplateElement> quasis = _quasi._templateLiteralExpression.Quasis;
			uint count = (uint)quasis.Count;
			JsArray jsArray = new JsArray(context.Engine, count, count);
			JsArray jsArray2 = new JsArray(context.Engine, count, count);
			for (uint num = 0u; num < quasis.Count; num++)
			{
				TemplateElementValue value2 = quasis[(int)num].Value;
				jsArray.SetIndexValue(num, value2.Cooked, updateLength: false);
				jsArray2.SetIndexValue(num, value2.Raw, updateLength: false);
			}
			jsArray2.SetIntegrityLevel(ObjectInstance.IntegrityLevel.Frozen);
			jsArray.DefineOwnProperty(PropertyRaw, new PropertyDescriptor(jsArray2, PropertyFlag.OnlyWritable));
			jsArray.SetIntegrityLevel(ObjectInstance.IntegrityLevel.Frozen);
			realm._templateMap[(Node)(object)_expression] = jsArray;
			return jsArray;
		}
	}
	internal sealed class JintTemplateLiteralExpression : JintExpression
	{
		internal readonly TemplateLiteral _templateLiteralExpression;

		internal JintExpression[] _expressions = Array.Empty<JintExpression>();

		private bool _initialized;

		public JintTemplateLiteralExpression(TemplateLiteral expression)
			: base((Expression)(object)expression)
		{
			_templateLiteralExpression = expression;
		}

		private void Initialize()
		{
			DoInitialize();
		}

		internal void DoInitialize()
		{
			ref NodeList<Expression> expressions = _templateLiteralExpression.Expressions;
			_expressions = new JintExpression[expressions.Count];
			for (int i = 0; i < expressions.Count; i++)
			{
				_expressions[i] = JintExpression.Build(expressions[i]);
			}
			_initialized = true;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			using System.Text.ValueStringBuilder valueStringBuilder = default(System.Text.ValueStringBuilder);
			ref NodeList<TemplateElement> quasis = _templateLiteralExpression.Quasis;
			for (int i = 0; i < quasis.Count; i++)
			{
				TemplateElement val = quasis[i];
				valueStringBuilder.Append(val.Value.Cooked);
				if (i < _expressions.Length)
				{
					JsValue value = _expressions[i].GetValue(context);
					valueStringBuilder.Append(TypeConverter.ToString(value));
				}
			}
			return JsString.Create(valueStringBuilder.ToString());
		}
	}
	internal sealed class JintThisExpression : JintExpression
	{
		public JintThisExpression(ThisExpression expression)
			: base((Expression)(object)expression)
		{
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			return context.Engine.ResolveThisBinding();
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			context.LastSyntaxElement = (SyntaxElement)(object)_expression;
			return context.Engine.ResolveThisBinding();
		}
	}
	internal sealed class JintUnaryExpression : JintExpression
	{
		private readonly record struct OperatorKey(string OperatorName, Type Operand);

		private sealed class JintTypeOfExpression : JintExpression
		{
			private readonly JintExpression _argument;

			public JintTypeOfExpression(UnaryExpression expression)
				: base((Expression)(object)expression)
			{
				_argument = JintExpression.Build(expression.Argument);
			}

			public override JsValue GetValue(EvaluationContext context)
			{
				context.LastSyntaxElement = (SyntaxElement)(object)_expression;
				return (JsValue)EvaluateInternal(context);
			}

			protected override object EvaluateInternal(EvaluationContext context)
			{
				Engine engine = context.Engine;
				object obj = _argument.Evaluate(context);
				JsValue v;
				if (obj is Reference reference)
				{
					if (reference.IsUnresolvableReference)
					{
						engine._referencePool.Return(reference);
						return JsString.UndefinedString;
					}
					v = engine.GetValue(reference, returnReferenceToPool: true);
				}
				else
				{
					v = (JsValue)obj;
				}
				return GetTypeOfString(v);
			}

			private static JsString GetTypeOfString(JsValue v)
			{
				if (v.IsUndefined())
				{
					return JsString.UndefinedString;
				}
				if (v.IsNull())
				{
					return JsString.ObjectString;
				}
				switch (v.Type)
				{
				case Types.Boolean:
					return JsString.BooleanString;
				case Types.Number:
					return JsString.NumberString;
				case Types.BigInt:
					return JsString.BigIntString;
				case Types.String:
					return JsString.StringString;
				case Types.Symbol:
					return JsString.SymbolString;
				default:
					if (v.IsCallable)
					{
						return JsString.FunctionString;
					}
					return JsString.ObjectString;
				}
			}
		}

		private static readonly ConcurrentDictionary<OperatorKey, MethodDescriptor?> _knownOperators = new ConcurrentDictionary<OperatorKey, MethodDescriptor>();

		private readonly JintExpression _argument;

		private readonly UnaryOperator _operator;

		private JintUnaryExpression(UnaryExpression expression)
			: base((Expression)(object)expression)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			_argument = JintExpression.Build(expression.Argument);
			_operator = expression.Operator;
		}

		internal static JintExpression Build(UnaryExpression expression)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)expression.Operator == 6)
			{
				return new JintTypeOfExpression(expression);
			}
			return BuildConstantExpression(expression) ?? new JintUnaryExpression(expression);
		}

		internal static JintExpression? BuildConstantExpression(UnaryExpression expression)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (expression != null && (int)expression.Operator == 1)
			{
				Expression argument = expression.Argument;
				Literal val = (Literal)(object)((argument is Literal) ? argument : null);
				if (val != null)
				{
					JsValue jsValue = JintLiteralExpression.ConvertToJsValue(val);
					if ((object)jsValue != null)
					{
						JsValue value = EvaluateMinus(jsValue);
						return new JintConstantExpression((Expression)(object)expression, value);
					}
				}
			}
			return null;
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			context.LastSyntaxElement = (SyntaxElement)(object)_expression;
			return EvaluateJsValue(context);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			return EvaluateJsValue(context);
		}

		private JsValue EvaluateJsValue(EvaluationContext context)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected I4, but got Unknown
			Engine engine = context.Engine;
			UnaryOperator val = _operator;
			switch ((int)val)
			{
			case 0:
			{
				JsValue value = _argument.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value, "op_UnaryPlus", out JsValue result))
				{
					return result;
				}
				return TypeConverter.ToNumber(value);
			}
			case 1:
			{
				JsValue value3 = _argument.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value3, "op_UnaryNegation", out JsValue result3))
				{
					return result3;
				}
				return EvaluateMinus(value3);
			}
			case 2:
			{
				JsValue value4 = _argument.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value4, "op_OnesComplement", out JsValue result4))
				{
					return result4;
				}
				JsValue jsValue = TypeConverter.ToNumeric(value4);
				if (jsValue.IsNumber())
				{
					return JsNumber.Create(~TypeConverter.ToInt32(jsValue));
				}
				return JsBigInt.Create(~jsValue.AsBigInt());
			}
			case 3:
			{
				JsValue value2 = _argument.GetValue(context);
				if (context.OperatorOverloadingAllowed && TryOperatorOverloading(context, value2, "op_LogicalNot", out JsValue result2))
				{
					return result2;
				}
				if (TypeConverter.ToBoolean(value2))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
			case 4:
			{
				if (!(_argument.Evaluate(context) is Reference reference))
				{
					return JsBoolean.True;
				}
				if (reference.IsUnresolvableReference)
				{
					if (reference.Strict)
					{
						ExceptionHelper.ThrowSyntaxError(engine.Realm, "Delete of an unqualified identifier in strict mode.");
					}
					engine._referencePool.Return(reference);
					return JsBoolean.True;
				}
				if (reference.IsPropertyReference)
				{
					if (reference.IsSuperReference)
					{
						ExceptionHelper.ThrowReferenceError(engine.Realm, reference);
					}
					ObjectInstance objectInstance = TypeConverter.ToObject(engine.Realm, reference.Base);
					reference.EvaluateAndCachePropertyKey();
					bool num = objectInstance.Delete(reference.ReferencedName);
					if (!num)
					{
						if (reference.Strict)
						{
							ExceptionHelper.ThrowTypeError(engine.Realm, $"Cannot delete property '{reference.ReferencedName}' of {objectInstance}");
						}
						if (StrictModeScope.IsStrictModeCode && !reference.Base.AsObject().GetOwnProperty(reference.ReferencedName).Configurable)
						{
							ExceptionHelper.ThrowTypeError(engine.Realm, $"Cannot delete property '{reference.ReferencedName}' of {objectInstance}");
						}
					}
					engine._referencePool.Return(reference);
					if (!num)
					{
						return JsBoolean.False;
					}
					return JsBoolean.True;
				}
				if (reference.Strict)
				{
					ExceptionHelper.ThrowSyntaxError(engine.Realm);
				}
				Jint.Runtime.Environments.Environment obj = (Jint.Runtime.Environments.Environment)reference.Base;
				engine._referencePool.Return(reference);
				if (!obj.DeleteBinding(reference.ReferencedName.ToString()))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
			case 5:
				_argument.GetValue(context);
				return JsValue.Undefined;
			default:
				ExceptionHelper.ThrowArgumentException();
				return null;
			}
		}

		internal static JsValue EvaluateMinus(JsValue value)
		{
			if (value.IsInteger())
			{
				int num = value.AsInteger();
				if (num != 0)
				{
					return JsNumber.Create(num * -1);
				}
			}
			value = TypeConverter.ToNumeric(value);
			if (value.IsNumber())
			{
				double value2 = ((JsNumber)value)._value;
				if (!double.IsNaN(value2))
				{
					return JsNumber.Create(value2 * -1.0);
				}
				return JsNumber.DoubleNaN;
			}
			return JsBigInt.Create(BigInteger.Negate(value.AsBigInt()));
		}

		internal static bool TryOperatorOverloading(EvaluationContext context, JsValue value, string clrName, [NotNullWhen(true)] out JsValue? result)
		{
			object obj = value.ToObject();
			if (obj != null)
			{
				Type operandType = obj.GetType();
				JsValue[] arguments = new JsValue[1] { value };
				OperatorKey key = new OperatorKey(clrName, operandType);
				MethodDescriptor orAdd = _knownOperators.GetOrAdd(key, delegate
				{
					MethodInfo methodInfo = null;
					foreach (MethodInfo operatorOverloadMethod in operandType.GetOperatorOverloadMethods())
					{
						if (string.Equals(operatorOverloadMethod.Name, clrName, StringComparison.Ordinal) && operatorOverloadMethod.GetParameters().Length == 1)
						{
							methodInfo = operatorOverloadMethod;
							break;
						}
					}
					return (methodInfo != null) ? new MethodDescriptor(methodInfo) : null;
				});
				if (orAdd != null)
				{
					result = orAdd.Call(context.Engine, null, arguments);
					return true;
				}
			}
			result = null;
			return false;
		}
	}
	internal sealed class JintUpdateExpression : JintExpression
	{
		private JintExpression _argument;

		private int _change;

		private bool _prefix;

		private JintIdentifierExpression? _leftIdentifier;

		private bool _evalOrArguments;

		private bool _initialized;

		public JintUpdateExpression(UpdateExpression expression)
			: base((Expression)(object)expression)
		{
		}

		private void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			UpdateExpression val = (UpdateExpression)_expression;
			_prefix = ((UnaryExpression)val).Prefix;
			_argument = JintExpression.Build(((UnaryExpression)val).Argument);
			if ((int)((UnaryExpression)val).Operator == 7)
			{
				_change = 1;
			}
			else if ((int)((UnaryExpression)val).Operator == 8)
			{
				_change = -1;
			}
			else
			{
				ExceptionHelper.ThrowArgumentException();
			}
			_leftIdentifier = _argument as JintIdentifierExpression;
			_evalOrArguments = _leftIdentifier?.HasEvalOrArguments ?? false;
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			if (!_initialized)
			{
				Initialize();
				_initialized = true;
			}
			return ((_leftIdentifier != null) ? UpdateIdentifier(context) : null) ?? UpdateNonIdentifier(context);
		}

		private JsValue UpdateNonIdentifier(EvaluationContext context)
		{
			Engine engine = context.Engine;
			Reference reference = _argument.Evaluate(context) as Reference;
			if (reference == null)
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, "Invalid left-hand side expression");
			}
			reference.AssertValid(engine.Realm);
			JsValue value = engine.GetValue(reference, returnReferenceToPool: false);
			bool flag = value._type == InternalTypes.Integer;
			JsValue jsValue = null;
			bool flag2 = false;
			if (context.OperatorOverloadingAllowed && JintUnaryExpression.TryOperatorOverloading(context, _argument.GetValue(context), (_change > 0) ? "op_Increment" : "op_Decrement", out JsValue result))
			{
				flag2 = true;
				jsValue = result;
			}
			if (!flag2)
			{
				jsValue = (flag ? JsNumber.Create(value.AsInteger() + _change) : (value.IsBigInt() ? ((JsValue)JsBigInt.Create(TypeConverter.ToBigInt(value) + _change)) : ((JsValue)JsNumber.Create(TypeConverter.ToNumber(value) + (double)_change))));
			}
			engine.PutValue(reference, jsValue);
			engine._referencePool.Return(reference);
			if (_prefix)
			{
				return jsValue;
			}
			if (flag || flag2)
			{
				return value;
			}
			if (!value.IsBigInt())
			{
				return JsNumber.Create(TypeConverter.ToNumber(value));
			}
			return JsBigInt.Create(value);
		}

		private JsValue? UpdateIdentifier(EvaluationContext context)
		{
			Jint.Runtime.Environments.Environment.BindingName identifier = _leftIdentifier.Identifier;
			if (JintEnvironment.TryGetIdentifierEnvironmentWithBindingValue(context.Engine.ExecutionContext.LexicalEnvironment, identifier, out Jint.Runtime.Environments.Environment record, out JsValue value))
			{
				if (_evalOrArguments && StrictModeScope.IsStrictModeCode)
				{
					ExceptionHelper.ThrowSyntaxError(context.Engine.Realm);
				}
				bool flag = value._type == InternalTypes.Integer;
				JsValue jsValue = null;
				bool flag2 = false;
				if (context.OperatorOverloadingAllowed && JintUnaryExpression.TryOperatorOverloading(context, _argument.GetValue(context), (_change > 0) ? "op_Increment" : "op_Decrement", out JsValue result))
				{
					flag2 = true;
					jsValue = result;
				}
				if (!flag2)
				{
					jsValue = (flag ? JsNumber.Create(value.AsInteger() + _change) : ((value._type == InternalTypes.BigInt) ? ((JsValue)JsBigInt.Create(TypeConverter.ToBigInt(value) + _change)) : ((JsValue)JsNumber.Create(TypeConverter.ToNumber(value) + (double)_change))));
				}
				record.SetMutableBinding(identifier.Key, jsValue, StrictModeScope.IsStrictModeCode);
				if (_prefix)
				{
					return jsValue;
				}
				if (!value.IsBigInt() && !value.IsNumber() && !flag2)
				{
					return JsNumber.Create(TypeConverter.ToNumber(value));
				}
				return value;
			}
			return null;
		}
	}
	internal sealed class JintYieldExpression : JintExpression
	{
		public JintYieldExpression(YieldExpression expression)
			: base((Expression)(object)expression)
		{
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if (!context.Engine.Options.ExperimentalFeatures.HasFlag(ExperimentalFeature.Generators))
			{
				ExceptionHelper.ThrowJavaScriptException(context.Engine.Intrinsics.Error, "Yield expressions are not supported in the engine, you can enable the experimental feature 'Generators' in engine options to use them.");
			}
			YieldExpression val = (YieldExpression)_expression;
			JsValue jsValue = (((object)context.Engine.ExecutionContext.Generator?._nextValue != null) ? context.Engine.ExecutionContext.Generator._nextValue : ((val.Argument == null) ? JsValue.Undefined : JintExpression.Build(val.Argument).GetValue(context)));
			if (val.Delegate)
			{
				jsValue = YieldDelegate(context, jsValue);
			}
			return Yield(context, jsValue);
		}

		private JsValue YieldDelegate(EvaluationContext context, JsValue value)
		{
			Engine engine = context.Engine;
			GeneratorKind generatorKind = engine.ExecutionContext.GetGeneratorKind();
			IteratorInstance iterator = value.GetIterator(engine.Realm, generatorKind);
			IteratorInstance iteratorInstance = iterator;
			Completion completion = new Completion(CompletionType.Normal, JsValue.Undefined, (SyntaxElement)(object)_expression);
			JsValue jsValue2;
			while (true)
			{
				if (completion.Type == CompletionType.Normal)
				{
					iterator.TryIteratorStep(out ObjectInstance nextItem);
					if (generatorKind == GeneratorKind.Async)
					{
						nextItem = Await(nextItem);
					}
					if (!(nextItem is IteratorResult))
					{
						ExceptionHelper.ThrowTypeError(engine.Realm);
					}
					if (IteratorComplete(nextItem))
					{
						return IteratorValue(nextItem);
					}
					completion = ((generatorKind != GeneratorKind.Async) ? GeneratorYield(nextItem) : AsyncGeneratorYield(IteratorValue(nextItem)));
					continue;
				}
				if (completion.Type == CompletionType.Throw)
				{
					ICallable method = iterator.GetMethod("throw");
					if (method != null)
					{
						JsValue jsValue = method.Call(iterator, completion.Value);
						if (generatorKind == GeneratorKind.Async)
						{
							jsValue = Await(jsValue);
						}
						if (!(jsValue is ObjectInstance))
						{
							ExceptionHelper.ThrowTypeError(engine.Realm);
						}
						if (IteratorComplete(jsValue))
						{
							IteratorValue(jsValue);
						}
						completion = ((generatorKind != GeneratorKind.Async) ? GeneratorYield(jsValue) : AsyncGeneratorYield(IteratorValue(jsValue)));
					}
					else
					{
						new Completion(CompletionType.Normal, null, (SyntaxElement)(object)_expression);
						if (generatorKind == GeneratorKind.Async)
						{
							AsyncIteratorClose(iteratorInstance, CompletionType.Normal);
						}
						else
						{
							iteratorInstance.Close(CompletionType.Normal);
						}
						ExceptionHelper.ThrowTypeError(engine.Realm, "Iterator does not have close method");
					}
					continue;
				}
				ICallable method2 = iterator.GetMethod("return");
				if (method2 == null)
				{
					JsValue result = completion.Value;
					if (generatorKind == GeneratorKind.Async)
					{
						result = Await(completion.Value);
					}
					return result;
				}
				jsValue2 = method2.Call(iterator, completion.Value);
				if (generatorKind == GeneratorKind.Async)
				{
					jsValue2 = Await(jsValue2);
				}
				if (!(jsValue2 is ObjectInstance))
				{
					ExceptionHelper.ThrowTypeError(engine.Realm);
				}
				if (IteratorComplete(jsValue2))
				{
					break;
				}
				completion = ((generatorKind != GeneratorKind.Async) ? GeneratorYield(jsValue2) : AsyncGeneratorYield(IteratorValue(jsValue2)));
			}
			return IteratorValue(jsValue2);
		}

		private Completion GeneratorYield(JsValue innerResult)
		{
			throw new NotImplementedException();
		}

		private static bool IteratorComplete(JsValue iterResult)
		{
			return TypeConverter.ToBoolean(iterResult.Get(CommonProperties.Done));
		}

		private static JsValue IteratorValue(JsValue iterResult)
		{
			return iterResult.Get(CommonProperties.Value);
		}

		private static void AsyncIteratorClose(object iteratorRecord, CompletionType closeCompletion)
		{
			ExceptionHelper.ThrowNotImplementedException("async");
		}

		private static Completion AsyncGeneratorYield(object iteratorValue)
		{
			ExceptionHelper.ThrowNotImplementedException("async");
			return default(Completion);
		}

		private static ObjectInstance Await(JsValue innerResult)
		{
			ExceptionHelper.ThrowNotImplementedException("await");
			return null;
		}

		private static JsValue Yield(EvaluationContext context, JsValue iterNextObj)
		{
			Engine engine = context.Engine;
			if (engine.ExecutionContext.GetGeneratorKind() == GeneratorKind.Async)
			{
				ExceptionHelper.ThrowNotImplementedException("async not implemented");
			}
			engine.ExecutionContext.Generator._generatorState = GeneratorState.SuspendedYield;
			return iterNextObj;
		}
	}
	internal sealed class NullishCoalescingExpression : JintExpression
	{
		private readonly JintExpression _left;

		private readonly JintExpression? _right;

		private readonly JsValue? _constant;

		public NullishCoalescingExpression(BinaryExpression expression)
			: base((Expression)(object)expression)
		{
			_left = JintExpression.Build(expression.Left);
			Expression right = expression.Right;
			Literal val = (Literal)(object)((right is Literal) ? right : null);
			if (val != null)
			{
				_constant = JintLiteralExpression.ConvertToJsValue(val);
			}
			else
			{
				_right = JintExpression.Build(expression.Right);
			}
		}

		public override JsValue GetValue(EvaluationContext context)
		{
			context.LastSyntaxElement = (SyntaxElement)(object)_expression;
			return EvaluateConstantOrExpression(context);
		}

		protected override object EvaluateInternal(EvaluationContext context)
		{
			return EvaluateConstantOrExpression(context);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private JsValue EvaluateConstantOrExpression(EvaluationContext context)
		{
			JsValue value = _left.GetValue(context);
			JsValue jsValue;
			if (value.IsNullOrUndefined())
			{
				jsValue = _constant;
				if ((object)jsValue == null)
				{
					return _right.GetValue(context);
				}
			}
			else
			{
				jsValue = value;
			}
			return jsValue;
		}
	}
}
namespace Jint.Runtime.Interop
{
	public sealed class ClrFunction : Function, IEquatable<ClrFunction>
	{
		internal readonly Func<JsValue, JsValue[], JsValue> _func;

		private readonly bool _bubbleExceptions;

		public ClrFunction(Engine engine, string name, Func<JsValue, JsValue[], JsValue> func, int length = 0, PropertyFlag lengthFlags = PropertyFlag.AllForbidden)
			: base(engine, engine.Realm, JsString.CachedCreate(name))
		{
			_func = func;
			_prototype = engine._originalIntrinsics.Function.PrototypeObject;
			_length = ((lengthFlags == PropertyFlag.AllForbidden) ? PropertyDescriptor.AllForbiddenDescriptor.ForNumber(length) : new PropertyDescriptor(JsNumber.Create(length), lengthFlags));
			_bubbleExceptions = _engine.Options.Interop.ExceptionHandler == Options.InteropOptions._defaultExceptionHandler;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			if (!_bubbleExceptions)
			{
				return CallSlow(thisObject, arguments);
			}
			return _func(thisObject, arguments);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private JsValue CallSlow(JsValue thisObject, JsValue[] arguments)
		{
			try
			{
				return _func(thisObject, arguments);
			}
			catch (Exception ex) when (!(ex is JavaScriptException))
			{
				if (_engine.Options.Interop.ExceptionHandler(ex))
				{
					ExceptionHelper.ThrowJavaScriptException(_realm.Intrinsics.Error, ex.Message);
				}
				else
				{
					ExceptionDispatchInfo.Capture(ex).Throw();
				}
				return JsValue.Undefined;
			}
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as ClrFunction);
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as ClrFunction);
		}

		public bool Equals(ClrFunction? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			if (_func == other._func)
			{
				return true;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _func.GetHashCode();
		}
	}
	internal sealed class ClrHelper
	{
		private readonly Options.InteropOptions _interopOptions;

		internal ClrHelper(Options.InteropOptions interopOptions)
		{
			_interopOptions = interopOptions;
		}

		public JsValue ToString(JsValue value)
		{
			return value.ToString();
		}

		public JsValue Unwrap(ObjectWrapper obj)
		{
			return ObjectWrapper.Create(obj.Engine, obj.Target);
		}

		public JsValue Wrap(ObjectWrapper obj, TypeReference type)
		{
			if (!type.ReferenceType.IsInstanceOfType(obj.Target))
			{
				ExceptionHelper.ThrowTypeError(type.Engine.Realm, "Argument obj must be an instance of type");
			}
			return ObjectWrapper.Create(obj.Engine, obj.Target, type.ReferenceType);
		}

		public JsValue TypeOf(ObjectWrapper obj)
		{
			MustAllowGetType();
			return TypeReference.CreateTypeReference(obj.Engine, obj.ClrType);
		}

		public JsValue TypeToObject(TypeReference type)
		{
			MustAllowGetType();
			Engine engine = type.Engine;
			return engine.Options.Interop.WrapObjectHandler(engine, type.ReferenceType, null) ?? JsValue.Undefined;
		}

		public JsValue ObjectToType(ObjectWrapper obj)
		{
			MustAllowGetType();
			if (obj.Target is Type type)
			{
				return TypeReference.CreateTypeReference(obj.Engine, type);
			}
			ExceptionHelper.ThrowArgumentException("Must be an ObjectWrapper of Type", "obj");
			return JsValue.Undefined;
		}

		private void MustAllowGetType()
		{
			if (!_interopOptions.AllowGetType)
			{
				ExceptionHelper.ThrowInvalidOperationException("Invalid when Engine.Options.Interop.AllowGetType == false");
			}
		}
	}
	public class DefaultTypeConverter : ITypeConverter
	{
		private readonly record struct TypeConversionKey(Type Source, Type Target);

		private readonly Engine _engine;

		private static readonly ConcurrentDictionary<TypeConversionKey, MethodInfo?> _knownCastOperators = new ConcurrentDictionary<TypeConversionKey, MethodInfo>();

		private static readonly Type intType = typeof(int);

		private static readonly Type iCallableType = typeof(Func<JsValue, JsValue[], JsValue>);

		private static readonly Type jsValueType = typeof(JsValue);

		private static readonly Type objectType = typeof(object);

		private static readonly Type engineType = typeof(Engine);

		private static readonly Type typeType = typeof(Type);

		private static readonly MethodInfo convertChangeType = typeof(Convert).GetMethod("ChangeType", new Type[3]
		{
			objectType,
			typeType,
			typeof(IFormatProvider)
		});

		private static readonly MethodInfo jsValueFromObject = jsValueType.GetMethod("FromObject");

		private static readonly MethodInfo jsValueToObject = jsValueType.GetMethod("ToObject");

		public DefaultTypeConverter(Engine engine)
		{
			_engine = engine;
		}

		public virtual object? Convert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)] Type type, IFormatProvider formatProvider)
		{
			if (!TryConvert(value, type, formatProvider, propagateException: true, out object converted, out string problemMessage))
			{
				ExceptionHelper.ThrowError(_engine, problemMessage ?? $"Unable to convert {value} to type {type}");
			}
			return converted;
		}

		public virtual bool TryConvert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)] Type type, IFormatProvider formatProvider, [NotNullWhen(true)] out object? converted)
		{
			string problemMessage;
			return TryConvert(value, type, formatProvider, propagateException: false, out converted, out problemMessage);
		}

		private bool TryConvert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] Type type, IFormatProvider formatProvider, bool propagateException, out object? converted, out string? problemMessage)
		{
			converted = null;
			problemMessage = null;
			if (value == null)
			{
				if (InteropHelper.TypeIsNullable(type))
				{
					return true;
				}
				problemMessage = "Unable to convert null to '" + type.FullName + "'";
				return false;
			}
			if (type.IsInstanceOfType(value))
			{
				converted = value;
				return true;
			}
			if (type.IsGenericType && InteropHelper.IsAssignableToGenericType(value.GetType(), type).IsAssignable)
			{
				converted = value;
				return true;
			}
			if (type.IsNullable())
			{
				type = Nullable.GetUnderlyingType(type);
			}
			if (type.IsEnum)
			{
				object obj = System.Convert.ChangeType(value, intType, formatProvider);
				if (obj == null)
				{
					ExceptionHelper.ThrowArgumentOutOfRangeException();
				}
				converted = Enum.ToObject(type, obj);
				return true;
			}
			Type type2 = value.GetType();
			if (type2 == iCallableType && typeof(Delegate).IsAssignableFrom(type) && !type.IsAbstract)
			{
				string name = "__jint_delegate_" + type.GUID;
				Func<JsValue, JsValue[], JsValue> func = (Func<JsValue, JsValue[], JsValue>)value;
				Function function = func.Target as Function;
				Delegate obj2 = function?.GetHiddenClrObjectProperty(name) as Delegate;
				if ((object)obj2 == null)
				{
					obj2 = BuildDelegate(type, func);
					function?.SetHiddenClrObjectProperty(name, obj2);
				}
				converted = obj2;
				return true;
			}
			if (type.IsArray)
			{
				if (!(value is object[] array))
				{
					problemMessage = $"Value of object[] type is expected, but actual type is {value.GetType()}";
					return false;
				}
				Type elementType = type.GetElementType();
				object[] array2 = new object[array.Length];
				for (int i = 0; i < array.Length; i++)
				{
					array2[i] = Convert(array[i], elementType, formatProvider);
				}
				Array array3 = Array.CreateInstance(elementType, array.Length);
				array2.CopyTo(array3, 0);
				converted = array3;
				return true;
			}
			TypeDescriptor typeDescriptor = TypeDescriptor.Get(type2);
			if (typeDescriptor.IsStringKeyedGenericDictionary)
			{
				ConstructorInfo[] constructors = type.GetConstructors();
				if (type.IsValueType && constructors.Length != 0)
				{
					problemMessage = $"No valid constructors found for {type}";
					return false;
				}
				object[] args = Array.Empty<object>();
				if (!type.IsValueType)
				{
					bool flag = false;
					ConstructorInfo[] array4 = constructors;
					foreach (ConstructorInfo constructorInfo in array4)
					{
						if (constructorInfo.GetParameters().Length == 0 && constructorInfo.IsPublic)
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						array4 = constructors;
						foreach (ConstructorInfo constructorInfo2 in array4)
						{
							ParameterInfo[] parameters = constructorInfo2.GetParameters();
							if (parameters.All((ParameterInfo p) => p.IsOptional) && constructorInfo2.IsPublic)
							{
								args = new object[parameters.Length];
								flag = true;
								break;
							}
						}
					}
					if (!flag)
					{
						problemMessage = $"No valid constructors found for type {type}";
						return false;
					}
				}
				object obj3 = Activator.CreateInstance(type, args);
				MemberInfo[] members = type.GetMembers();
				foreach (MemberInfo memberInfo in members)
				{
					if ((memberInfo.MemberType == MemberTypes.Property || memberInfo.MemberType == MemberTypes.Field) && (typeDescriptor.TryGetValue(value, memberInfo.Name, out object o) || typeDescriptor.TryGetValue(value, memberInfo.Name.UpperToLowerCamelCase(), out o)))
					{
						object value2 = Convert(o, memberInfo.GetDefinedType(), formatProvider);
						memberInfo.SetValue(obj3, value2);
					}
				}
				converted = obj3;
				return true;
			}
			try
			{
				converted = System.Convert.ChangeType(value, type, formatProvider);
				return true;
			}
			catch (Exception ex)
			{
				if (TryCastWithOperators(value, type, type2, out object converted2))
				{
					converted = converted2;
					return true;
				}
				if (propagateException && !_engine.Options.Interop.ExceptionHandler(ex))
				{
					throw;
				}
				problemMessage = ex.Message;
				return false;
			}
		}

		private Delegate BuildDelegate([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] Type type, Func<JsValue, JsValue[], JsValue> function)
		{
			MethodInfo method = type.GetMethod("Invoke");
			ParameterInfo[] parameters = method.GetParameters();
			ParameterExpression[] array = new ParameterExpression[parameters.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = Expression.Parameter(parameters[i].ParameterType, parameters[i].Name);
			}
			List<MethodCallExpression> list = new List<MethodCallExpression>(array.Length);
			for (int j = 0; j < array.Length; j++)
			{
				ParameterExpression parameterExpression = array[j];
				if (parameterExpression.Type.IsValueType)
				{
					UnaryExpression arg = Expression.Convert(parameterExpression, objectType);
					list.Add(Expression.Call(null, jsValueFromObject, Expression.Constant(_engine, engineType), arg));
				}
				else if (parameterExpression.Type.IsArray && parameters[j].GetCustomAttribute<ParamArrayAttribute>() != null && function.Target is Function function2)
				{
					for (int k = 0; k < function2.GetLength(); k++)
					{
						LabelTarget target = Expression.Label(typeof(object));
						BlockExpression arg2 = Expression.Block(Expression.IfThen(Expression.GreaterThanOrEqual(Expression.Property(parameterExpression, "Length"), Expression.Constant(k)), Expression.Return(target, Expression.ArrayAccess(parameterExpression, Expression.Constant(k)))), Expression.Label(target, Expression.Constant(JsValue.Undefined)));
						list.Add(Expression.Call(null, jsValueFromObject, Expression.Constant(_engine, engineType), arg2));
					}
				}
				else
				{
					list.Add(Expression.Call(null, jsValueFromObject, Expression.Constant(_engine, engineType), parameterExpression));
				}
			}
			NewArrayExpression arg3 = Expression.NewArrayInit(jsValueType, list);
			MethodCallExpression methodCallExpression = Expression.Call(Expression.Constant(function.Target), function.Method, Expression.Constant(JsValue.Undefined, jsValueType), arg3);
			if (method.ReturnType != typeof(void))
			{
				return Expression.Lambda(type, Expression.Convert(Expression.Call(null, convertChangeType, Expression.Call(methodCallExpression, jsValueToObject), Expression.Constant(method.ReturnType), Expression.Constant(CultureInfo.InvariantCulture, typeof(IFormatProvider))), method.ReturnType), new ReadOnlyCollection<ParameterExpression>(array)).Compile();
			}
			return Expression.Lambda(type, methodCallExpression, new ReadOnlyCollection<ParameterExpression>(array)).Compile();
		}

		private static bool TryCastWithOperators(object value, Type type, Type valueType, [NotNullWhen(true)] out object? converted)
		{
			TypeConversionKey key = new TypeConversionKey(valueType, type);
			MethodInfo orAdd = _knownCastOperators.GetOrAdd(key, CreateValueFactory);
			if (orAdd != null)
			{
				try
				{
					converted = orAdd.Invoke(null, new object[1] { value });
					return converted != null;
				}
				catch
				{
					converted = null;
					return false;
				}
			}
			converted = null;
			return false;
			static MethodInfo? CreateValueFactory(TypeConversionKey k)
			{
				TypeConversionKey typeConversionKey = k;
				var (type4, type5) = (TypeConversionKey)(ref typeConversionKey);
				foreach (MethodInfo item in type4.GetOperatorOverloadMethods().Concat(type5.GetOperatorOverloadMethods()))
				{
					bool flag = !type5.IsAssignableFrom(item.ReturnType);
					if (!flag)
					{
						string name = item.Name;
						bool flag2 = ((name == "op_Implicit" || name == "op_Explicit") ? true : false);
						flag = !flag2;
					}
					if (!flag)
					{
						ParameterInfo[] parameters = item.GetParameters();
						if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type4))
						{
							return item;
						}
					}
				}
				return null;
			}
		}
	}
	internal static class ObjectExtensions
	{
		public static object? GetHiddenClrObjectProperty(this ObjectInstance obj, string name)
		{
			return (obj.Get(name) as IObjectWrapper)?.Target;
		}

		public static void SetHiddenClrObjectProperty(this ObjectInstance obj, string name, object value)
		{
			obj.SetOwnProperty(name, new PropertyDescriptor(ObjectWrapper.Create(obj.Engine, value), PropertyFlag.AllForbidden));
		}
	}
	internal sealed class DelegateWrapper : Function
	{
		private static readonly JsString _name = new JsString("delegate");

		private readonly Delegate _d;

		private readonly bool _delegateContainsParamsArgument;

		public DelegateWrapper(Engine engine, Delegate d)
			: base(engine, engine.Realm, _name, FunctionThisMode.Global, ObjectClass.Function)
		{
			_d = d;
			_prototype = engine.Realm.Intrinsics.Function.PrototypeObject;
			ParameterInfo[] parameters = _d.Method.GetParameters();
			_delegateContainsParamsArgument = false;
			ParameterInfo[] array = parameters;
			for (int i = 0; i < array.Length; i++)
			{
				if (Attribute.IsDefined(array[i], typeof(ParamArrayAttribute)))
				{
					_delegateContainsParamsArgument = true;
					break;
				}
			}
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			ParameterInfo[] parameters = _d.Method.GetParameters();
			int num = parameters.Length;
			int num2 = (_delegateContainsParamsArgument ? (num - 1) : num);
			int num3 = arguments.Length;
			int num4 = Math.Min(num3, num2);
			ITypeConverter typeConverter = base.Engine.TypeConverter;
			ValueCoercionType valueCoercion = base.Engine.Options.Interop.ValueCoercion;
			object[] array = new object[num];
			for (int i = 0; i < num4; i++)
			{
				Type parameterType = parameters[i].ParameterType;
				JsValue jsValue = arguments[i];
				object converted;
				if (parameterType == typeof(JsValue))
				{
					converted = jsValue;
				}
				else if (!ReflectionExtensions.TryConvertViaTypeCoercion(parameterType, valueCoercion, jsValue, out converted))
				{
					converted = typeConverter.Convert(jsValue.ToObject(), parameterType, CultureInfo.InvariantCulture);
				}
				array[i] = converted;
			}
			for (int j = num4; j < num2; j++)
			{
				if (parameters[j].ParameterType.IsValueType)
				{
					array[j] = Activator.CreateInstance(parameters[j].ParameterType);
				}
				else
				{
					array[j] = null;
				}
			}
			if (_delegateContainsParamsArgument)
			{
				int num5 = num - 1;
				int length = Math.Max(0, num3 - num2);
				Type elementType = parameters[num5].ParameterType.GetElementType();
				Array array2 = Array.CreateInstance(elementType, length);
				for (int k = num5; k < num3; k++)
				{
					int index = k - num5;
					JsValue jsValue2 = arguments[k];
					object converted2;
					if (elementType == typeof(JsValue))
					{
						converted2 = jsValue2;
					}
					else if (!ReflectionExtensions.TryConvertViaTypeCoercion(elementType, valueCoercion, jsValue2, out converted2))
					{
						converted2 = base.Engine.TypeConverter.Convert(jsValue2.ToObject(), elementType, CultureInfo.InvariantCulture);
					}
					array2.SetValue(converted2, index);
				}
				array[num5] = array2;
			}
			try
			{
				object obj = _d.DynamicInvoke(array);
				if (!IsAwaitable(obj))
				{
					return JsValue.FromObject(base.Engine, obj);
				}
				return JsValue.ConvertAwaitableToPromise(base.Engine, obj);
			}
			catch (TargetInvocationException exception)
			{
				ExceptionHelper.ThrowMeaningfulException(base.Engine, exception);
				throw;
			}
		}

		private static bool IsAwaitable(object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (obj is Task)
			{
				return true;
			}
			if (obj is ValueTask)
			{
				return true;
			}
			Type type = obj.GetType();
			if (!type.IsGenericType)
			{
				return false;
			}
			return type.GetGenericTypeDefinition() == typeof(ValueTask<>);
		}
	}
	internal sealed class GetterFunction : Function
	{
		private static readonly JsString _name = new JsString("get");

		private readonly Func<JsValue, JsValue> _getter;

		public GetterFunction(Engine engine, Func<JsValue, JsValue> getter)
			: base(engine, engine.Realm, _name, FunctionThisMode.Global, ObjectClass.Function)
		{
			_getter = getter;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return _getter(thisObject);
		}
	}
	internal sealed class InteropHelper
	{
		internal readonly record struct AssignableResult(int Score, Type MatchingGivenType)
		{
			public bool IsAssignable => Score >= 0;
		}

		internal readonly record struct MethodMatch(MethodDescriptor Method, JsValue[] Arguments, int Score = 0) : IComparable<MethodMatch>
		{
			public int CompareTo(MethodMatch other)
			{
				return Score.CompareTo(other.Score);
			}
		}

		internal const DynamicallyAccessedMemberTypes DefaultDynamicallyAccessedMemberTypes = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents;

		internal static AssignableResult IsAssignableToGenericType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.Interfaces)] Type givenType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.Interfaces)] Type genericType)
		{
			if ((object)givenType == null)
			{
				return new AssignableResult(-1, typeof(void));
			}
			if (!genericType.IsConstructedGenericType)
			{
				return new AssignableResult(2, givenType);
			}
			Type[] interfaces = givenType.GetInterfaces();
			foreach (Type type in interfaces)
			{
				if (type.IsGenericType)
				{
					Type genericTypeDefinition = type.GetGenericTypeDefinition();
					if (genericTypeDefinition == genericType)
					{
						return new AssignableResult(0, type);
					}
					if (genericType.IsGenericType && genericTypeDefinition == genericType.GetGenericTypeDefinition())
					{
						return new AssignableResult(0, type);
					}
				}
			}
			if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType)
			{
				return new AssignableResult(0, givenType);
			}
			Type baseType = givenType.BaseType;
			if (baseType == null)
			{
				return new AssignableResult(-1, givenType);
			}
			return IsAssignableToGenericType(baseType, genericType);
		}

		private static int CalculateMethodParameterScore(Engine engine, ParameterInfo parameter, JsValue parameterValue)
		{
			Type parameterType = parameter.ParameterType;
			object obj = parameterValue.ToObject();
			Type type = obj?.GetType();
			if (type == parameterType)
			{
				return 0;
			}
			if (obj == null)
			{
				if (!parameter.IsOptional && !TypeIsNullable(parameterType))
				{
					return -1;
				}
				return 0;
			}
			if (parameterType == typeof(JsValue))
			{
				return 1;
			}
			if (parameterType == typeof(object))
			{
				return 5;
			}
			if (parameterType == typeof(int) && parameterValue.IsInteger())
			{
				return 0;
			}
			if (parameterType == typeof(float) && type == typeof(double))
			{
				if (!parameterValue.IsInteger())
				{
					return 2;
				}
				return 1;
			}
			if (parameterType.IsEnum && parameterValue is JsNumber value && value.IsInteger() && parameterType.GetEnumUnderlyingType() == typeof(int) && Enum.IsDefined(parameterType, value.AsInteger()))
			{
				return 0;
			}
			if (parameterType.IsAssignableFrom(type))
			{
				return 1;
			}
			if (parameterValue.IsArray() && parameterType.IsArray)
			{
				return 2;
			}
			if (parameterType.IsGenericParameter)
			{
				AssignableResult assignableResult = IsAssignableToGenericType(type, parameterType);
				if (assignableResult.Score != -1)
				{
					return assignableResult.Score;
				}
			}
			if (CanChangeType(obj, parameterType))
			{
				return 3;
			}
			foreach (MethodInfo operatorOverloadMethod in type.GetOperatorOverloadMethods())
			{
				bool flag = parameterType.IsAssignableFrom(operatorOverloadMethod.ReturnType);
				if (flag)
				{
					string name = operatorOverloadMethod.Name;
					bool flag2 = ((name == "op_Implicit" || name == "op_Explicit") ? true : false);
					flag = flag2;
				}
				if (flag)
				{
					return 3;
				}
			}
			if (ReflectionExtensions.TryConvertViaTypeCoercion(parameterType, engine.Options.Interop.ValueCoercion, parameterValue, out object _))
			{
				return 10;
			}
			return 100;
		}

		private static int CalculateMethodScore(Engine engine, MethodDescriptor method, JsValue[] arguments)
		{
			if (method.Parameters.Length == 0 && arguments.Length == 0)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < arguments.Length; i++)
			{
				JsValue parameterValue = arguments[i];
				int num2 = CalculateMethodParameterScore(engine, method.Parameters[i], parameterValue);
				if (num2 < 0)
				{
					return num2;
				}
				num += num2;
			}
			return num;
		}

		private static bool CanChangeType(object value, Type targetType)
		{
			if (value == null && !targetType.IsValueType)
			{
				return true;
			}
			if (!(value is IConvertible))
			{
				return false;
			}
			try
			{
				Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture);
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static bool TypeIsNullable(Type type)
		{
			if (type.IsValueType)
			{
				return Nullable.GetUnderlyingType(type) != null;
			}
			return true;
		}

		internal static IEnumerable<MethodMatch> FindBestMatch(Engine engine, MethodDescriptor[] methods, Func<MethodDescriptor, JsValue[]> argumentProvider)
		{
			List<MethodMatch> list = null;
			foreach (MethodDescriptor methodDescriptor in methods)
			{
				ParameterInfo[] parameters = methodDescriptor.Parameters;
				JsValue[] array = argumentProvider(methodDescriptor);
				if (array.Length > parameters.Length || array.Length < parameters.Length - methodDescriptor.ParameterDefaultValuesCount)
				{
					continue;
				}
				int num = CalculateMethodScore(engine, methodDescriptor, array);
				if (num == 0)
				{
					yield return new MethodMatch(methodDescriptor, array);
					yield break;
				}
				if (num >= 0)
				{
					if (list == null)
					{
						list = new List<MethodMatch>();
					}
					list.Add(new MethodMatch(methodDescriptor, array, num));
				}
			}
			if (list == null)
			{
				yield break;
			}
			if (list.Count > 1)
			{
				list.Sort();
			}
			foreach (MethodMatch item in list)
			{
				yield return item;
			}
		}
	}
	public interface IObjectConverter
	{
		bool TryConvert(Engine engine, object value, [NotNullWhen(true)] out JsValue? result);
	}
	public interface IObjectWrapper
	{
		object Target { get; }
	}
	public interface IReferenceResolver
	{
		bool TryUnresolvableReference(Engine engine, Reference reference, out JsValue value);

		bool TryPropertyReference(Engine engine, Reference reference, ref JsValue value);

		bool TryGetCallable(Engine engine, object callee, out JsValue value);

		bool CheckCoercible(JsValue value);
	}
	public interface ITypeConverter
	{
		object? Convert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)] Type type, IFormatProvider formatProvider);

		bool TryConvert(object? value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)] Type type, IFormatProvider formatProvider, [NotNullWhen(true)] out object? converted);
	}
	internal sealed class MethodDescriptor
	{
		public MethodBase Method { get; }

		public ParameterInfo[] Parameters { get; }

		public bool HasParams { get; }

		public int ParameterDefaultValuesCount { get; }

		public bool IsExtensionMethod { get; }

		internal MethodDescriptor(MethodBase method)
		{
			Method = method;
			Parameters = method.GetParameters();
			IsExtensionMethod = method.IsDefined(typeof(ExtensionAttribute), inherit: true);
			ParameterInfo[] parameters = Parameters;
			foreach (ParameterInfo parameterInfo in parameters)
			{
				if (Attribute.IsDefined(parameterInfo, typeof(ParamArrayAttribute)))
				{
					HasParams = true;
					break;
				}
				if (parameterInfo.HasDefaultValue)
				{
					int parameterDefaultValuesCount = ParameterDefaultValuesCount;
					ParameterDefaultValuesCount = parameterDefaultValuesCount + 1;
				}
			}
		}

		public static MethodDescriptor[] Build<T>(List<T> source) where T : MethodBase
		{
			MethodDescriptor[] array = new MethodDescriptor[source.Count];
			for (int i = 0; i < source.Count; i++)
			{
				array[i] = new MethodDescriptor(source[i]);
			}
			return Prioritize(array);
		}

		public static MethodDescriptor[] Build<T>(T[] source) where T : MethodBase
		{
			MethodDescriptor[] array = new MethodDescriptor[source.Length];
			for (int i = 0; i < source.Length; i++)
			{
				array[i] = new MethodDescriptor(source[i]);
			}
			return Prioritize(array);
		}

		private static MethodDescriptor[] Prioritize(MethodDescriptor[] descriptors)
		{
			Array.Sort(descriptors, CreateComparison);
			return descriptors;
			static int CreateComparison(MethodDescriptor d1, MethodDescriptor d2)
			{
				if (d1.Method.IsGenericMethod && !d2.Method.IsGenericMethod)
				{
					return 1;
				}
				if (d2.Method.IsGenericMethod && !d1.Method.IsGenericMethod)
				{
					return -1;
				}
				if (d1.HasParams && !d2.HasParams)
				{
					return 1;
				}
				if (d2.HasParams && !d1.HasParams)
				{
					return -1;
				}
				if (d1.Parameters.Length > d2.Parameters.Length)
				{
					return 1;
				}
				if (d2.Parameters.Length > d1.Parameters.Length)
				{
					return -1;
				}
				return 0;
			}
		}

		public JsValue Call(Engine engine, object? instance, JsValue[] arguments)
		{
			object[] array = new object[arguments.Length];
			ParameterInfo[] parameters = Parameters;
			ValueCoercionType valueCoercion = engine.Options.Interop.ValueCoercion;
			try
			{
				for (int i = 0; i < arguments.Length; i++)
				{
					ParameterInfo parameterInfo = parameters[i];
					Type parameterType = parameterInfo.ParameterType;
					JsValue jsValue = arguments[i];
					object converted;
					if (typeof(JsValue).IsAssignableFrom(parameterType))
					{
						converted = jsValue;
					}
					else if (jsValue.IsUndefined() && parameterInfo.IsOptional)
					{
						converted = parameterInfo.DefaultValue;
					}
					else if (!ReflectionExtensions.TryConvertViaTypeCoercion(parameterType, valueCoercion, jsValue, out converted))
					{
						converted = engine.TypeConverter.Convert(jsValue.ToObject(), parameterType, CultureInfo.InvariantCulture);
					}
					array[i] = converted;
				}
				if (Method is MethodInfo methodInfo)
				{
					object value = methodInfo.Invoke(instance, array);
					return JsValue.FromObject(engine, value);
				}
				if (Method is ConstructorInfo constructorInfo)
				{
					object value2 = constructorInfo.Invoke(array);
					return JsValue.FromObject(engine, value2);
				}
				throw new NotSupportedException("Method is unknown type");
			}
			catch (TargetInvocationException exception)
			{
				ExceptionHelper.ThrowMeaningfulException(engine, exception);
				return null;
			}
		}
	}
	internal sealed class MethodInfoFunction : Function
	{
		private readonly Type _targetType;

		private readonly object? _target;

		private readonly string _name;

		private readonly MethodDescriptor[] _methods;

		private readonly ClrFunction? _fallbackClrFunctionInstance;

		public MethodInfoFunction(Engine engine, Type targetType, object? target, string name, MethodDescriptor[] methods, ClrFunction? fallbackClrFunctionInstance = null)
			: base(engine, engine.Realm, new JsString(name))
		{
			_targetType = targetType;
			_target = target;
			_name = name;
			_methods = methods;
			_fallbackClrFunctionInstance = fallbackClrFunctionInstance;
			_prototype = engine.Realm.Intrinsics.Function.PrototypeObject;
		}

		private static bool IsGenericParameter(object? argObj, Type parameterType)
		{
			if (argObj == null)
			{
				return false;
			}
			if (InteropHelper.IsAssignableToGenericType(argObj.GetType(), parameterType).Score < 0)
			{
				return false;
			}
			if (parameterType.IsGenericParameter || parameterType.IsGenericType)
			{
				return true;
			}
			return false;
		}

		private static void HandleGenericParameter(object? argObj, Type parameterType, Type[] genericArgTypes)
		{
			if (argObj == null)
			{
				return;
			}
			InteropHelper.AssignableResult assignableResult = InteropHelper.IsAssignableToGenericType(argObj.GetType(), parameterType);
			if (assignableResult.Score < 0)
			{
				return;
			}
			if (parameterType.IsGenericParameter)
			{
				int genericParameterPosition = parameterType.GenericParameterPosition;
				if (genericParameterPosition >= 0)
				{
					genericArgTypes[genericParameterPosition] = argObj.GetType();
				}
			}
			else
			{
				if (!parameterType.IsGenericType)
				{
					return;
				}
				Type[] genericArguments = parameterType.GetGenericArguments();
				for (int i = 0; i < genericArguments.Length; i++)
				{
					Type type = genericArguments[i];
					if (type.IsGenericParameter)
					{
						int genericParameterPosition2 = type.GenericParameterPosition;
						if (genericParameterPosition2 >= 0)
						{
							Type[] genericArguments2 = assignableResult.MatchingGivenType.GetGenericArguments();
							genericArgTypes[genericParameterPosition2] = genericArguments2[i];
						}
					}
				}
			}
		}

		private static MethodBase ResolveMethod(MethodBase method, ParameterInfo[] methodParameters, JsValue[] arguments)
		{
			if (!method.IsGenericMethod)
			{
				return method;
			}
			if (!method.IsGenericMethodDefinition)
			{
				return method;
			}
			MethodInfo methodInfo = method as MethodInfo;
			if (methodInfo == null)
			{
				return method;
			}
			Type[] array = new Type[method.GetGenericArguments().Length];
			for (int i = 0; i < methodParameters.Length; i++)
			{
				Type parameterType = methodParameters[i].ParameterType;
				HandleGenericParameter((i < arguments.Length) ? arguments[i].ToObject() : typeof(object), parameterType, array);
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (array[j] == null)
				{
					array[j] = typeof(object);
				}
			}
			return methodInfo.MakeGenericMethod(array);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] jsArguments)
		{
			ITypeConverter typeConverter = base.Engine.TypeConverter;
			object obj = thisObject.ToObject() ?? _target;
			object[] array = null;
			foreach (InteropHelper.MethodMatch item in InteropHelper.FindBestMatch(_engine, _methods, ArgumentProvider))
			{
				item.Deconstruct(out MethodDescriptor Method, out JsValue[] Arguments, out int _);
				MethodDescriptor methodDescriptor = Method;
				JsValue[] array2 = Arguments;
				ParameterInfo[] parameters = methodDescriptor.Parameters;
				if (array == null || array.Length != parameters.Length)
				{
					array = new object[parameters.Length];
				}
				bool flag = true;
				MethodBase methodBase = ResolveMethod(methodDescriptor.Method, parameters, array2);
				parameters = methodBase.GetParameters();
				for (int i = 0; i < array.Length; i++)
				{
					Type parameterType = parameters[i].ParameterType;
					JsValue jsValue = ((array2.Length > i) ? array2[i] : null);
					if (typeof(JsValue).IsAssignableFrom(parameterType))
					{
						array[i] = jsValue;
					}
					else if ((object)jsValue == null)
					{
						array[i] = System.Type.Missing;
					}
					else if (IsGenericParameter(jsValue.ToObject(), parameterType))
					{
						array[i] = jsValue.ToObject();
					}
					else if (parameterType == typeof(JsValue[]) && jsValue.IsArray())
					{
						JsArray jsArray = jsValue.AsArray();
						int num = TypeConverter.ToInt32(jsArray.Get(CommonProperties.Length, this));
						JsValue[] array3 = new JsValue[num];
						for (uint num2 = 0u; num2 < num; num2++)
						{
							array3[num2] = (jsArray.TryGetValue(num2, out JsValue value) ? value : JsValue.Undefined);
						}
						array[i] = array3;
					}
					else
					{
						if (!ReflectionExtensions.TryConvertViaTypeCoercion(parameterType, _engine.Options.Interop.ValueCoercion, jsValue, out array[i]) && !typeConverter.TryConvert(jsValue.ToObject(), parameterType, CultureInfo.InvariantCulture, out array[i]))
						{
							flag = false;
							break;
						}
						if (array[i] is LambdaExpression lambdaExpression)
						{
							array[i] = lambdaExpression.Compile();
						}
					}
				}
				if (!flag)
				{
					continue;
				}
				try
				{
					MethodBase method = methodDescriptor.Method;
					if (method is MethodInfo && method.IsGenericMethodDefinition)
					{
						object value2 = methodBase.Invoke(obj, array);
						return JsValue.FromObjectWithType(base.Engine, value2, (methodBase as MethodInfo)?.ReturnType);
					}
					return JsValue.FromObjectWithType(base.Engine, methodDescriptor.Method.Invoke(obj, array), (methodDescriptor.Method as MethodInfo)?.ReturnType);
				}
				catch (TargetInvocationException exception)
				{
					ExceptionHelper.ThrowMeaningfulException(_engine, exception);
				}
			}
			if ((object)_fallbackClrFunctionInstance != null)
			{
				return _fallbackClrFunctionInstance.Call(thisObject, jsArguments);
			}
			ExceptionHelper.ThrowTypeError(_engine.Realm, "No public methods with the specified arguments were found.");
			return null;
			JsValue[] ArgumentProvider(MethodDescriptor methodDescriptor2)
			{
				if (methodDescriptor2.IsExtensionMethod)
				{
					JsValue[] array4 = new JsValue[1 + jsArguments.Length];
					array4[0] = thisObject;
					Array.Copy(jsArguments, 0, array4, 1, jsArguments.Length);
					if (!methodDescriptor2.HasParams)
					{
						return array4;
					}
					return ProcessParamsArrays(array4, methodDescriptor2);
				}
				if (!methodDescriptor2.HasParams)
				{
					return jsArguments;
				}
				return ProcessParamsArrays(jsArguments, methodDescriptor2);
			}
		}

		private JsValue[] ProcessParamsArrays(JsValue[] jsArguments, MethodDescriptor methodInfo)
		{
			int num = methodInfo.Parameters.Length - 1;
			if (jsArguments.Length < num)
			{
				return jsArguments;
			}
			JsValue[] array = jsArguments.Skip(num);
			if (array.Length == 1 && array[0].IsArray())
			{
				return jsArguments;
			}
			JsArray jsArray = new JsArray(_engine, array);
			JsValue[] array2 = new JsValue[num + 1];
			for (int i = 0; i < num; i++)
			{
				array2[i] = jsArguments[i];
			}
			array2[num] = jsArray;
			return array2;
		}

		public override string ToString()
		{
			return $"function {_targetType}.{_name}() {{ [native code] }}";
		}
	}
	[RequiresUnreferencedCode("Dynamic loading")]
	public class NamespaceReference : ObjectInstance, ICallable
	{
		private readonly string? _path;

		public NamespaceReference(Engine engine, string? path)
			: base(engine)
		{
			_path = path;
		}

		public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			return false;
		}

		public override bool Delete(JsValue property)
		{
			return false;
		}

		JsValue ICallable.Call(JsValue thisObject, JsValue[] arguments)
		{
			Type[] array = new Type[arguments.Length];
			for (int i = 0; i < arguments.Length; i++)
			{
				JsValue value = arguments[i];
				if (value.IsUndefined() || !value.IsObject() || !(value.AsObject() is TypeReference typeReference))
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm, "Invalid generic type parameter on " + _path + ", if this is not a generic type / method, are you missing a lookup assembly?");
					return null;
				}
				array[i] = typeReference.ReferenceType;
			}
			TypeReference typeReference2 = GetPath(_path + "`" + arguments.Length.ToString(CultureInfo.InvariantCulture)).As<TypeReference>();
			if ((object)typeReference2 == null)
			{
				return JsValue.Undefined;
			}
			try
			{
				Type type = typeReference2.ReferenceType.MakeGenericType(array);
				return TypeReference.CreateTypeReference(base.Engine, type);
			}
			catch (Exception exception)
			{
				ExceptionHelper.ThrowInvalidOperationException("Invalid generic type parameter on " + _path + ", if this is not a generic type / method, are you missing a lookup assembly?", exception);
				return null;
			}
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			string path = (string.IsNullOrEmpty(_path) ? property.ToString() : $"{_path}.{property}");
			return GetPath(path);
		}

		[RequiresUnreferencedCode("Dynamic loading")]
		public JsValue GetPath(string path)
		{
			if (_engine.TypeCache.TryGetValue(path, out Type value))
			{
				if (value == null)
				{
					return new NamespaceReference(_engine, path);
				}
				return TypeReference.CreateTypeReference(_engine, value);
			}
			Assembly[] array = new Assembly[2]
			{
				Assembly.GetCallingAssembly(),
				Assembly.GetExecutingAssembly()
			};
			for (int i = 0; i < array.Length; i++)
			{
				value = array[i].GetType(path);
				if (value != null)
				{
					_engine.TypeCache.Add(path, value);
					return TypeReference.CreateTypeReference(_engine, value);
				}
			}
			string text = path.Replace('+', '.');
			foreach (Assembly allowedAssembly in _engine.Options.Interop.AllowedAssemblies)
			{
				value = allowedAssembly.GetType(path);
				if (value != null)
				{
					_engine.TypeCache.Add(path, value);
					return TypeReference.CreateTypeReference(_engine, value);
				}
				int num = path.LastIndexOf('.');
				if (num != -1)
				{
					string typeName = path.Substring(0, num);
					value = GetType(allowedAssembly, typeName);
				}
				if (!(value != null))
				{
					continue;
				}
				Type[] allNestedTypes = GetAllNestedTypes(value);
				foreach (Type type in allNestedTypes)
				{
					if (type.FullName != null && type.FullName.Replace('+', '.').Equals(text, StringComparison.Ordinal))
					{
						_engine.TypeCache.Add(text, type);
						return TypeReference.CreateTypeReference(_engine, type);
					}
				}
			}
			value = System.Type.GetType(path);
			if (value != null)
			{
				_engine.TypeCache.Add(path, value);
				return TypeReference.CreateTypeReference(_engine, value);
			}
			_engine.TypeCache.Add(path, null);
			return new NamespaceReference(_engine, path);
		}

		[RequiresUnreferencedCode("Assembly type loading")]
		private static Type? GetType(Assembly assembly, string typeName)
		{
			string b = typeName.Replace('+', '.');
			Type[] types = assembly.GetTypes();
			foreach (Type type in types)
			{
				if (string.Equals(type.FullName?.Replace('+', '.'), b, StringComparison.Ordinal))
				{
					return type;
				}
			}
			return null;
		}

		private static Type[] GetAllNestedTypes(Type type)
		{
			List<Type> list = new List<Type>();
			AddNestedTypesRecursively(list, type);
			return list.ToArray();
		}

		private static void AddNestedTypesRecursively(List<Type> types, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicNestedTypes)] Type type)
		{
			Type[] nestedTypes = type.GetNestedTypes(BindingFlags.Public);
			foreach (Type type2 in nestedTypes)
			{
				types.Add(type2);
				AddNestedTypesRecursively(types, type2);
			}
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			return PropertyDescriptor.Undefined;
		}

		public override string ToString()
		{
			return "[CLR namespace: " + _path + "]";
		}
	}
	public class ObjectWrapper : ObjectInstance, IObjectWrapper, IEquatable<ObjectWrapper>
	{
		private sealed class DictionaryIterator : IteratorInstance
		{
			private readonly ObjectWrapper _target;

			private readonly IEnumerator<JsValue> _enumerator;

			public DictionaryIterator(Engine engine, ObjectWrapper target)
				: base(engine)
			{
				_target = target;
				_enumerator = target.EnumerateOwnPropertyKeys(Types.String).GetEnumerator();
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (_enumerator.MoveNext())
				{
					JsValue current = _enumerator.Current;
					JsValue value = _target.Get(current);
					nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine, current, value);
					return true;
				}
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		private sealed class EnumerableIterator : IteratorInstance
		{
			private readonly IEnumerator _enumerator;

			public EnumerableIterator(Engine engine, IEnumerable target)
				: base(engine)
			{
				_enumerator = target.GetEnumerator();
			}

			public override void Close(CompletionType completion)
			{
				(_enumerator as IDisposable)?.Dispose();
				base.Close(completion);
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (_enumerator.MoveNext())
				{
					object current = _enumerator.Current;
					nextItem = IteratorResult.CreateValueIteratorPosition(_engine, JsValue.FromObject(_engine, current));
					return true;
				}
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		internal readonly TypeDescriptor _typeDescriptor;

		public object Target { get; }

		internal Type ClrType { get; }

		internal override bool IsArrayLike => _typeDescriptor.IsArrayLike;

		internal override bool HasOriginalIterator => IsArrayLike;

		internal override bool IsIntegerIndexedArray => _typeDescriptor.IsIntegerIndexed;

		[Obsolete("Use ObjectWrapper.Create instead of calling constructor directly")]
		public ObjectWrapper(Engine engine, object obj, Type? type = null)
			: base(engine)
		{
			Target = obj;
			ClrType = GetClrType(obj, type);
			_typeDescriptor = TypeDescriptor.Get(ClrType);
			if ((object)_typeDescriptor.LengthProperty != null)
			{
				GetSetPropertyDescriptor value = new GetSetPropertyDescriptor(new ClrFunction(engine, "length", GetLength), JsValue.Undefined, PropertyFlag.Configurable);
				SetProperty(KnownKeys.Length, value);
				if (_typeDescriptor.IsArrayLike && engine.Options.Interop.AttachArrayPrototype)
				{
					_prototype = engine.Intrinsics.Array.PrototypeObject;
				}
			}
		}

		public static ObjectInstance Create(Engine engine, object target, Type? type = null)
		{
			if (target == null)
			{
				ExceptionHelper.ThrowArgumentNullException("target");
			}
			if (string.Equals(type?.FullName, "System.Text.Json.Nodes.JsonNode", StringComparison.Ordinal))
			{
				type = target.GetType();
			}
			if ((object)type == null)
			{
				type = target.GetType();
			}
			if (TryBuildArrayLikeWrapper(engine, target, type, out ArrayLikeWrapper result))
			{
				return result;
			}
			return new ObjectWrapper(engine, target, type);
		}

		private static bool TryBuildArrayLikeWrapper(Engine engine, object target, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type type, [NotNullWhen(true)] out ArrayLikeWrapper? result)
		{
			result = null;
			Type[] interfaces = type.GetInterfaces();
			foreach (Type type2 in interfaces)
			{
				if (type2.IsGenericType)
				{
					Type type3 = type2.GenericTypeArguments[0];
					if (type2.GetGenericTypeDefinition() == typeof(IList<>))
					{
						Type type4 = typeof(GenericListWrapper<>).MakeGenericType(type3);
						result = (ArrayLikeWrapper)Activator.CreateInstance(type4, engine, target, type);
						break;
					}
					if (type2.GetGenericTypeDefinition() == typeof(IReadOnlyList<>))
					{
						Type type5 = typeof(ReadOnlyListWrapper<>).MakeGenericType(type3);
						result = (ArrayLikeWrapper)Activator.CreateInstance(type5, engine, target, type);
						break;
					}
				}
			}
			if ((object)result == null && target is IList target2)
			{
				result = new ListWrapper(engine, target2, type);
			}
			return (object)result != null;
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			if (property is JsString jsString)
			{
				string text = jsString.ToString();
				if (_properties == null || !_properties.ContainsKey(text))
				{
					ReflectionAccessor accessor = _engine.Options.Interop.TypeResolver.GetAccessor(_engine, ClrType, text, mustBeReadable: false, mustBeWritable: true);
					if (accessor == ConstantValueAccessor.NullAccessor)
					{
						return base.Set(property, value, receiver);
					}
					if (!accessor.Writable || !_engine.Options.Interop.AllowWrite)
					{
						return false;
					}
					accessor.SetValue(_engine, Target, text, value);
					return true;
				}
			}
			else if (property is JsSymbol property2)
			{
				if (_engine.Options.Interop.AllowWrite)
				{
					return base.Set((JsValue)property2, value, receiver);
				}
				return false;
			}
			return SetSlow(property, value);
		}

		private bool SetSlow(JsValue property, JsValue value)
		{
			if (!CanPut(property))
			{
				return false;
			}
			GetOwnProperty(property).Value = value;
			return true;
		}

		public override object ToObject()
		{
			return Target;
		}

		public override void RemoveOwnProperty(JsValue property)
		{
			if (_engine.Options.Interop.AllowWrite && property is JsString jsString && (object)_typeDescriptor.RemoveMethod != null)
			{
				_typeDescriptor.RemoveMethod.Invoke(Target, new object[1] { jsString.ToString() });
			}
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			if (!_typeDescriptor.IsDictionary && Target is ICollection collection && CommonProperties.Length.Equals(property))
			{
				return JsNumber.Create(collection.Count);
			}
			PropertyDescriptor ownProperty = GetOwnProperty(property, mustBeReadable: true, mustBeWritable: false);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				return ObjectInstance.UnwrapJsValue(ownProperty, receiver);
			}
			return base.Prototype?.Get(property, receiver) ?? JsValue.Undefined;
		}

		public override List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			return new List<JsValue>(EnumerateOwnPropertyKeys(types));
		}

		public override IEnumerable<KeyValuePair<JsValue, PropertyDescriptor>> GetOwnProperties()
		{
			foreach (JsValue item in EnumerateOwnPropertyKeys(Types.String | Types.Symbol))
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(item, GetOwnProperty(item));
			}
		}

		private IEnumerable<JsValue> EnumerateOwnPropertyKeys(Types types)
		{
			bool flag = (types & Types.String) != 0;
			if (flag && _typeDescriptor.IsStringKeyedGenericDictionary)
			{
				ICollection<string> collection = (ICollection<string>)_typeDescriptor.KeysAccessor.GetValue(Target);
				foreach (string item in collection)
				{
					yield return JsString.Create(item);
				}
			}
			else if (flag && Target is IDictionary dictionary)
			{
				foreach (object key in dictionary.Keys)
				{
					object converted = key as string;
					if (converted != null || _engine.TypeConverter.TryConvert(key, typeof(string), CultureInfo.InvariantCulture, out converted))
					{
						yield return JsString.Create((string)converted);
					}
				}
			}
			else
			{
				if (!flag)
				{
					yield break;
				}
				PropertyInfo[] properties = ClrType.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (propertyInfo.GetIndexParameters().Length == 0)
					{
						yield return JsString.Create(propertyInfo.Name);
					}
				}
				FieldInfo[] fields = ClrType.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
				for (int i = 0; i < fields.Length; i++)
				{
					yield return JsString.Create(fields[i].Name);
				}
			}
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			return GetOwnProperty(property, mustBeReadable: false, mustBeWritable: false);
		}

		private PropertyDescriptor GetOwnProperty(JsValue property, bool mustBeReadable, bool mustBeWritable)
		{
			if (TryGetProperty(property, out PropertyDescriptor descriptor))
			{
				return descriptor;
			}
			if (property.IsSymbol())
			{
				if (property == GlobalSymbolRegistry.Iterator && _typeDescriptor.Iterable)
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(new ClrFunction(base.Engine, "iterator", Iterator, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
					SetProperty(GlobalSymbolRegistry.Iterator, propertyDescriptor);
					return propertyDescriptor;
				}
				return PropertyDescriptor.Undefined;
			}
			string text = property.ToString();
			bool isStringKeyedGenericDictionary = _typeDescriptor.IsStringKeyedGenericDictionary;
			if (isStringKeyedGenericDictionary && _typeDescriptor.TryGetValue(Target, text, out object o))
			{
				PropertyFlag propertyFlag = PropertyFlag.Enumerable;
				if (_engine.Options.Interop.AllowWrite)
				{
					propertyFlag |= PropertyFlag.Configurable;
				}
				return new PropertyDescriptor(JsValue.FromObject(_engine, o), propertyFlag);
			}
			JsValue jsValue = base.Engine.Options.Interop.MemberAccessor(base.Engine, Target, text);
			if ((object)jsValue != null)
			{
				return new PropertyDescriptor(jsValue, PropertyFlag.OnlyEnumerable);
			}
			ReflectionAccessor accessor = _engine.Options.Interop.TypeResolver.GetAccessor(_engine, ClrType, text, mustBeReadable, mustBeWritable);
			PropertyDescriptor propertyDescriptor2 = accessor.CreatePropertyDescriptor(_engine, Target, text, !isStringKeyedGenericDictionary);
			if (!isStringKeyedGenericDictionary && propertyDescriptor2 != PropertyDescriptor.Undefined && (!mustBeReadable || accessor.Readable) && (!mustBeWritable || accessor.Writable))
			{
				SetProperty(text, propertyDescriptor2);
			}
			return propertyDescriptor2;
		}

		public static PropertyDescriptor GetPropertyDescriptor(Engine engine, object target, MemberInfo member)
		{
			return engine.Options.Interop.TypeResolver.GetAccessor(engine, target.GetType(), member.Name, mustBeReadable: false, mustBeWritable: false, Factory).CreatePropertyDescriptor(engine, target, member.Name);
			ReflectionAccessor? Factory()
			{
				if (member is PropertyInfo propertyInfo)
				{
					return new PropertyAccessor(propertyInfo);
				}
				if (member is MethodBase methodBase)
				{
					return new MethodAccessor(target.GetType(), MethodDescriptor.Build(new MethodBase[1] { methodBase }));
				}
				if (member is FieldInfo fieldInfo)
				{
					return new FieldAccessor(fieldInfo);
				}
				return null;
			}
		}

		internal static Type GetClrType(object obj, Type? type)
		{
			if ((object)type == null || type == typeof(object))
			{
				return obj.GetType();
			}
			Type underlyingType = Nullable.GetUnderlyingType(type);
			if ((object)underlyingType != null)
			{
				return underlyingType;
			}
			return type;
		}

		private static JsValue Iterator(JsValue thisObject, JsValue[] arguments)
		{
			ObjectWrapper objectWrapper = (ObjectWrapper)thisObject;
			if (!objectWrapper._typeDescriptor.IsDictionary)
			{
				return new EnumerableIterator(objectWrapper._engine, (IEnumerable)objectWrapper.Target);
			}
			return new DictionaryIterator(objectWrapper._engine, objectWrapper);
		}

		private static JsNumber GetLength(JsValue thisObject, JsValue[] arguments)
		{
			ObjectWrapper objectWrapper = (ObjectWrapper)thisObject;
			return JsNumber.Create((int)(objectWrapper._typeDescriptor.LengthProperty?.GetValue(objectWrapper.Target) ?? ((object)0)));
		}

		internal override ulong GetSmallestIndex(ulong length)
		{
			if (!(Target is ICollection))
			{
				return base.GetSmallestIndex(length);
			}
			return 0uL;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as ObjectWrapper);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as ObjectWrapper);
		}

		public bool Equals(ObjectWrapper? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			return object.Equals(Target, other.Target);
		}

		public override int GetHashCode()
		{
			return Target.GetHashCode();
		}
	}
	internal abstract class ArrayLikeWrapper : ObjectWrapper
	{
		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)]
		private Type ItemType { get; }

		public abstract int Length { get; }

		protected ArrayLikeWrapper(Engine engine, object obj, Type itemType, Type? type = null)
			: base(engine, obj, type)
		{
			ItemType = itemType;
			if (engine.Options.Interop.AttachArrayPrototype)
			{
				base.Prototype = engine.Intrinsics.Array.PrototypeObject;
			}
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			if (property.IsInteger())
			{
				return JsValue.FromObject(_engine, GetAt(property.AsInteger()));
			}
			return base.Get(property, receiver);
		}

		public override bool HasProperty(JsValue property)
		{
			if (property.IsNumber())
			{
				double value = ((JsNumber)property)._value;
				if (TypeConverter.IsIntegralNumber(value))
				{
					int num = (int)value;
					if (base.Target is ICollection collection && num < collection.Count)
					{
						return true;
					}
				}
			}
			return base.HasProperty(property);
		}

		public override bool Delete(JsValue property)
		{
			if (!_engine.Options.Interop.AllowWrite)
			{
				return false;
			}
			if (property.IsNumber())
			{
				double value = ((JsNumber)property)._value;
				if (TypeConverter.IsIntegralNumber(value))
				{
					DoSetAt((int)value, null);
					return true;
				}
			}
			return base.Delete(property);
		}

		public abstract object? GetAt(int index);

		public void SetAt(int index, JsValue value)
		{
			if (_engine.Options.Interop.AllowWrite)
			{
				EnsureCapacity(index);
				DoSetAt(index, ConvertToItemType(value));
			}
		}

		protected abstract void DoSetAt(int index, object? value);

		public abstract void AddDefault();

		public abstract void Add(JsValue value);

		public abstract void RemoveAt(int index);

		public virtual void EnsureCapacity(int capacity)
		{
			while (Length < capacity)
			{
				AddDefault();
			}
		}

		protected object? ConvertToItemType(JsValue value)
		{
			object converted;
			if (ItemType == typeof(JsValue))
			{
				converted = value;
			}
			else if (!ReflectionExtensions.TryConvertViaTypeCoercion(ItemType, base.Engine.Options.Interop.ValueCoercion, value, out converted))
			{
				converted = value.ToObject();
				if (converted != null && converted.GetType() != ItemType)
				{
					converted = base.Engine.TypeConverter.Convert(converted, ItemType, CultureInfo.InvariantCulture);
				}
			}
			return converted;
		}
	}
	internal class ListWrapper : ArrayLikeWrapper
	{
		private readonly IList? _list;

		public override int Length => _list?.Count ?? 0;

		internal ListWrapper(Engine engine, IList target, Type type)
			: base(engine, target, typeof(object), type)
		{
			_list = target;
		}

		public override object? GetAt(int index)
		{
			if (_list != null && index >= 0 && index < _list.Count)
			{
				return _list[index];
			}
			return null;
		}

		protected override void DoSetAt(int index, object? value)
		{
			if (_list != null)
			{
				_list[index] = value;
			}
		}

		public override void AddDefault()
		{
			_list?.Add(null);
		}

		public override void Add(JsValue value)
		{
			_list?.Add(ConvertToItemType(value));
		}

		public override void RemoveAt(int index)
		{
			_list?.RemoveAt(index);
		}
	}
	internal class GenericListWrapper<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)] T> : ArrayLikeWrapper
	{
		private readonly IList<T> _list;

		public override int Length => _list.Count;

		public GenericListWrapper(Engine engine, IList<T> target, Type? type)
			: base(engine, target, typeof(T), type)
		{
			_list = target;
		}

		public override object? GetAt(int index)
		{
			if (index >= 0 && index < _list.Count)
			{
				return _list[index];
			}
			return null;
		}

		protected override void DoSetAt(int index, object? value)
		{
			_list[index] = (T)value;
		}

		public override void AddDefault()
		{
			_list.Add(default(T));
		}

		public override void Add(JsValue value)
		{
			object obj = ConvertToItemType(value);
			_list.Add((T)obj);
		}

		public override void RemoveAt(int index)
		{
			_list.RemoveAt(index);
		}
	}
	internal sealed class ReadOnlyListWrapper<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)] T> : ArrayLikeWrapper
	{
		private readonly IReadOnlyList<T> _list;

		public override int Length => _list.Count;

		public ReadOnlyListWrapper(Engine engine, IReadOnlyList<T> target, Type type)
			: base(engine, target, typeof(T), type)
		{
			_list = target;
		}

		public override object? GetAt(int index)
		{
			if (index >= 0 && index < _list.Count)
			{
				return _list[index];
			}
			return null;
		}

		public override void AddDefault()
		{
			ExceptionHelper.ThrowNotSupportedException();
		}

		protected override void DoSetAt(int index, object? value)
		{
			ExceptionHelper.ThrowNotSupportedException();
		}

		public override void Add(JsValue value)
		{
			ExceptionHelper.ThrowNotSupportedException();
		}

		public override void RemoveAt(int index)
		{
			ExceptionHelper.ThrowNotSupportedException();
		}

		public override void EnsureCapacity(int capacity)
		{
			ExceptionHelper.ThrowNotSupportedException();
		}
	}
	internal sealed class SetterFunction : Function
	{
		private static readonly JsString _name = new JsString("set");

		private readonly Action<JsValue, JsValue> _setter;

		public SetterFunction(Engine engine, Action<JsValue, JsValue> setter)
			: base(engine, engine.Realm, _name)
		{
			_setter = setter;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			_setter(thisObject, arguments[0]);
			return JsValue.Null;
		}
	}
	internal sealed class TypeDescriptor
	{
		private static readonly ConcurrentDictionary<Type, TypeDescriptor> _cache = new ConcurrentDictionary<Type, TypeDescriptor>();

		private static readonly Type _listType = typeof(IList);

		private static readonly PropertyInfo _listIndexer = typeof(IList).GetProperty("Item");

		private static readonly Type _genericDictionaryType = typeof(IDictionary<, >);

		private static readonly Type _stringType = typeof(string);

		private readonly MethodInfo? _tryGetValueMethod;

		private readonly MethodInfo? _removeMethod;

		private readonly PropertyInfo? _keysAccessor;

		private readonly Type? _valueType;

		public bool IsArrayLike { get; }

		public bool IsIntegerIndexed => (object)IntegerIndexerProperty != null;

		public PropertyInfo? IntegerIndexerProperty { get; }

		public bool IsDictionary { get; }

		public bool IsStringKeyedGenericDictionary => (object)_tryGetValueMethod != null;

		public bool IsEnumerable { get; }

		public PropertyInfo? LengthProperty { get; }

		public bool Iterable
		{
			get
			{
				if (!IsArrayLike && !IsDictionary)
				{
					return IsEnumerable;
				}
				return true;
			}
		}

		public MethodInfo? RemoveMethod => _removeMethod;

		public PropertyInfo? KeysAccessor => _keysAccessor;

		private TypeDescriptor([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.Interfaces)] Type type)
		{
			Analyze(type, out bool isCollection, out bool isEnumerable, out bool isDictionary, out _tryGetValueMethod, out _removeMethod, out _keysAccessor, out _valueType, out PropertyInfo lengthProperty, out PropertyInfo integerIndexer);
			IntegerIndexerProperty = integerIndexer;
			IsDictionary = (object)_tryGetValueMethod != null || isDictionary;
			IsArrayLike = !IsDictionary && isCollection;
			IsEnumerable = isEnumerable;
			if (IsArrayLike)
			{
				LengthProperty = lengthProperty;
			}
		}

		public static TypeDescriptor Get([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.Interfaces)] Type type)
		{
			return _cache.GetOrAdd(type, (Type t) => new TypeDescriptor(t));
		}

		private static void Analyze([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.Interfaces)] Type type, out bool isCollection, out bool isEnumerable, out bool isDictionary, out MethodInfo? tryGetValueMethod, out MethodInfo? removeMethod, out PropertyInfo? keysAccessor, out Type? valueType, out PropertyInfo? lengthProperty, out PropertyInfo? integerIndexer)
		{
			AnalyzeType(type, out isCollection, out isEnumerable, out isDictionary, out tryGetValueMethod, out removeMethod, out keysAccessor, out valueType, out lengthProperty, out integerIndexer);
			Type[] interfaces = type.GetInterfaces();
			for (int i = 0; i < interfaces.Length; i++)
			{
				AnalyzeType(interfaces[i], out bool isCollection2, out bool isEnumerable2, out bool isDictionary2, out MethodInfo tryGetValueMethod2, out MethodInfo removeMethod2, out PropertyInfo keysAccessor2, out Type valueType2, out PropertyInfo lengthProperty2, out PropertyInfo integerIndexer2);
				isCollection |= isCollection2;
				isEnumerable |= isEnumerable2;
				isDictionary |= isDictionary2;
				if ((object)tryGetValueMethod == null)
				{
					tryGetValueMethod = tryGetValueMethod2;
				}
				if ((object)removeMethod == null)
				{
					removeMethod = removeMethod2;
				}
				if ((object)keysAccessor == null)
				{
					keysAccessor = keysAccessor2;
				}
				if ((object)valueType == null)
				{
					valueType = valueType2;
				}
				if ((object)lengthProperty == null)
				{
					lengthProperty = lengthProperty2;
				}
				if ((object)integerIndexer == null)
				{
					integerIndexer = integerIndexer2;
				}
			}
		}

		private static void AnalyzeType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties)] Type type, out bool isCollection, out bool isEnumerable, out bool isDictionary, out MethodInfo? tryGetValueMethod, out MethodInfo? removeMethod, out PropertyInfo? keysAccessor, out Type? valueType, out PropertyInfo? lengthProperty, out PropertyInfo? integerIndexer)
		{
			isCollection = typeof(ICollection).IsAssignableFrom(type);
			isEnumerable = typeof(IEnumerable).IsAssignableFrom(type);
			integerIndexer = (_listType.IsAssignableFrom(type) ? _listIndexer : null);
			isDictionary = typeof(IDictionary).IsAssignableFrom(type);
			lengthProperty = type.GetProperty("Count") ?? type.GetProperty("Length");
			tryGetValueMethod = null;
			removeMethod = null;
			keysAccessor = null;
			valueType = null;
			if (type.IsGenericType)
			{
				Type genericTypeDefinition = type.GetGenericTypeDefinition();
				if (genericTypeDefinition == _genericDictionaryType && type.GenericTypeArguments[0] == _stringType)
				{
					tryGetValueMethod = type.GetMethod("TryGetValue");
					removeMethod = type.GetMethod("Remove");
					keysAccessor = type.GetProperty("Keys");
					valueType = type.GenericTypeArguments[1];
				}
				isCollection |= genericTypeDefinition == typeof(IReadOnlyCollection<>) || genericTypeDefinition == typeof(ICollection<>);
				if (genericTypeDefinition == typeof(IList<>) && (object)integerIndexer == null)
				{
					integerIndexer = type.GetProperty("Item");
				}
				isDictionary |= genericTypeDefinition == _genericDictionaryType;
			}
		}

		public bool TryGetValue(object target, string member, [NotNullWhen(true)] out object? o)
		{
			if (!IsStringKeyedGenericDictionary)
			{
				ExceptionHelper.ThrowInvalidOperationException("Not a string-keyed dictionary");
			}
			try
			{
				object[] array = new object[2]
				{
					member,
					_valueType.IsValueType ? Activator.CreateInstance(_valueType) : null
				};
				bool result = (bool)_tryGetValueMethod.Invoke(target, array);
				o = array[1];
				return result;
			}
			catch (TargetInvocationException ex) when (ex.InnerException is KeyNotFoundException)
			{
				o = null;
				return false;
			}
		}
	}
	public sealed class TypeReference : Constructor, IObjectWrapper
	{
		private readonly record struct MemberAccessorKey(Type Type, string PropertyName);

		private readonly record struct ObjectCreateState(TypeReference TypeReference, JsValue[] Arguments);

		private static readonly JsString _name = new JsString("typereference");

		private static readonly ConcurrentDictionary<Type, MethodDescriptor[]> _constructorCache = new ConcurrentDictionary<Type, MethodDescriptor[]>();

		private static readonly ConcurrentDictionary<MemberAccessorKey, ReflectionAccessor> _memberAccessors = new ConcurrentDictionary<MemberAccessorKey, ReflectionAccessor>();

		public Type ReferenceType { get; }

		public object Target => ReferenceType;

		private TypeReference(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] Type type)
			: base(engine, engine.Realm, _name)
		{
			ReferenceType = type;
			_prototype = engine.Realm.Intrinsics.Function.PrototypeObject;
			_length = PropertyDescriptor.AllForbiddenDescriptor.NumberZero;
			TypeReferencePrototype value = new TypeReferencePrototype(engine, this);
			_prototypeDescriptor = new PropertyDescriptor(value, PropertyFlag.AllForbidden);
			PreventExtensions();
		}

		public static TypeReference CreateTypeReference<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] T>(Engine engine)
		{
			return CreateTypeReference(engine, typeof(T));
		}

		public static TypeReference CreateTypeReference(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents)] Type type)
		{
			TypeReference typeReference = new TypeReference(engine, type);
			engine.RegisterTypeReference(typeReference);
			return typeReference;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, JsValue.Undefined);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Object.PrototypeObject, ObjectCreator, new ObjectCreateState(this, arguments));
			static ObjectInstance ObjectCreator(Engine engine, Realm realm, ObjectCreateState state)
			{
				JsValue[] arguments2 = state.Arguments;
				Type referenceType = state.TypeReference.ReferenceType;
				object obj = engine.Options.Interop.CreateTypeReferenceObject(engine, referenceType, arguments2);
				ObjectInstance objectInstance = null;
				if (obj != null)
				{
					objectInstance = TypeConverter.ToObject(realm, JsValue.FromObject(engine, obj));
				}
				else if (arguments2.Length == 0 && referenceType.IsValueType)
				{
					object value = Activator.CreateInstance(referenceType);
					objectInstance = TypeConverter.ToObject(realm, JsValue.FromObject(engine, value));
				}
				else
				{
					MethodDescriptor[] orAdd = _constructorCache.GetOrAdd(referenceType, (Type t) => MethodDescriptor.Build(t.GetConstructors(BindingFlags.Instance | BindingFlags.Public)));
					Func<MethodDescriptor, JsValue[]> argumentProvider = delegate(MethodDescriptor method)
					{
						ParameterInfo[] parameters = method.Parameters;
						if (parameters.Length == 0)
						{
							return arguments2;
						}
						JsValue[] array = new JsValue[parameters.Length];
						ParameterInfo parameterInfo = parameters[^1];
						bool flag = parameterInfo.ParameterType.IsArray && parameterInfo.GetCustomAttribute(typeof(ParamArrayAttribute)) != null;
						if (flag && arguments2.Length >= parameters.Length - 1)
						{
							JsValue jsValue = JsValue.Undefined;
							if (arguments2.Length > parameters.Length - 1)
							{
								jsValue = arguments2[parameters.Length - 1];
							}
							if (jsValue.IsArray())
							{
								return arguments2;
							}
							Array.Copy(arguments2, 0, array, 0, parameters.Length - 1);
							if (jsValue.IsNullOrUndefined() && parameters.Length == arguments2.Length)
							{
								array[parameters.Length - 1] = new JsArray(engine);
								return array;
							}
							JsValue[] array2 = new JsValue[Math.Max(0, arguments2.Length - (parameters.Length - 1))];
							if (array2.Length != 0)
							{
								Array.Copy(arguments2, parameters.Length - 1, array2, 0, array2.Length);
							}
							array[parameters.Length - 1] = new JsArray(engine, array2);
							return array;
						}
						if (flag && arguments2.Length < parameters.Length - 1)
						{
							return arguments2;
						}
						if (parameters.Length > arguments2.Length)
						{
							for (int i = parameters.Length - arguments2.Length; i < parameters.Length; i++)
							{
								if (!parameters[i].IsOptional)
								{
									return arguments2;
								}
							}
							Array.Copy(arguments2, 0, array, 0, arguments2.Length);
							for (int num = parameters.Length - 1; num >= 0; num--)
							{
								parameterInfo = parameters[num];
								if (num >= arguments2.Length - 1)
								{
									if (!parameterInfo.IsOptional)
									{
										break;
									}
									if (arguments2.Length - 1 < num || arguments2[num].IsUndefined())
									{
										array[num] = JsValue.FromObject(engine, parameterInfo.DefaultValue);
									}
								}
							}
							return array;
						}
						return arguments2;
					};
					using IEnumerator<InteropHelper.MethodMatch> enumerator = InteropHelper.FindBestMatch(engine, orAdd, argumentProvider).GetEnumerator();
					if (enumerator.MoveNext())
					{
						enumerator.Current.Deconstruct(out MethodDescriptor Method, out JsValue[] Arguments, out int _);
						JsValue value2 = Method.Call(arguments: Arguments, engine: engine, instance: null);
						objectInstance = TypeConverter.ToObject(realm, value2);
					}
				}
				if ((object)objectInstance == null)
				{
					ExceptionHelper.ThrowTypeError(realm, $"Could not resolve a constructor for type {referenceType} for given arguments");
				}
				objectInstance.SetPrototypeOf(state.TypeReference);
				return objectInstance;
			}
		}

		public override bool Equals(JsValue? other)
		{
			if (other is TypeReference typeReference)
			{
				return ReferenceType == typeReference.ReferenceType;
			}
			return base.Equals(other);
		}

		internal override bool OrdinaryHasInstance(JsValue v)
		{
			if (v is IObjectWrapper objectWrapper)
			{
				return objectWrapper.Target.GetType() == ReferenceType;
			}
			return base.OrdinaryHasInstance(v);
		}

		public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			return false;
		}

		public override bool Delete(JsValue property)
		{
			return false;
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			if (!CanPut(property))
			{
				return false;
			}
			GetOwnProperty(property).Value = value;
			return true;
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (!(property is JsString jsString))
			{
				if (property == GlobalSymbolRegistry.HasInstance)
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.hasInstance]", HasInstance, 1, PropertyFlag.Configurable), PropertyFlag.AllForbidden);
					SetProperty(GlobalSymbolRegistry.HasInstance, propertyDescriptor);
					return propertyDescriptor;
				}
			}
			else
			{
				string value = jsString._value;
				PropertyDictionary? properties = _properties;
				if (properties == null || !properties.TryGetValue(value, out PropertyDescriptor value2))
				{
					value2 = CreatePropertyDescriptor(value);
					if (value2 != PropertyDescriptor.Undefined)
					{
						if (_properties == null)
						{
							_properties = new PropertyDictionary();
						}
						_properties[value] = value2;
						return value2;
					}
				}
			}
			return base.GetOwnProperty(property);
		}

		private PropertyDescriptor CreatePropertyDescriptor(string name)
		{
			MemberAccessorKey key = new MemberAccessorKey(ReferenceType, name);
			return _memberAccessors.GetOrAdd(key, (MemberAccessorKey x) => ResolveMemberAccessor(_engine, x.Type, x.PropertyName)).CreatePropertyDescriptor(_engine, ReferenceType, name);
		}

		private static ReflectionAccessor ResolveMemberAccessor(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicNestedTypes | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.Interfaces)] Type type, string name)
		{
			TypeResolver typeResolver = engine.Options.Interop.TypeResolver;
			if (type.IsEnum)
			{
				StringComparer memberNameComparer = typeResolver.MemberNameComparer;
				Func<MemberInfo, IEnumerable<string>> memberNameCreator = typeResolver.MemberNameCreator;
				Array values = Enum.GetValues(type);
				string[] names = Enum.GetNames(type);
				for (int i = 0; i < values.Length; i++)
				{
					string name2 = names.GetValue(i)?.ToString() ?? "";
					MemberInfo arg = type.GetMember(name2)[0];
					foreach (string item in memberNameCreator(arg))
					{
						if (memberNameComparer.Equals(name, item))
						{
							return new ConstantValueAccessor(JsNumber.Create(values.GetValue(i)));
						}
					}
				}
				return ConstantValueAccessor.NullAccessor;
			}
			if (!typeResolver.TryFindMemberAccessor(engine, type, name, BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, out ReflectionAccessor accessor))
			{
				return ConstantValueAccessor.NullAccessor;
			}
			return accessor;
		}

		private static JsBoolean HasInstance(JsValue thisObject, JsValue[] arguments)
		{
			TypeReference typeReference = thisObject as TypeReference;
			JsValue jsValue = arguments.At(0);
			if ((object)typeReference == null)
			{
				return JsBoolean.False;
			}
			Type referenceType = typeReference.ReferenceType;
			Type type = ((jsValue is IObjectWrapper objectWrapper) ? objectWrapper.Target.GetType() : ((!(jsValue is TypeReferencePrototype typeReferencePrototype)) ? null : typeReferencePrototype.TypeReference.ReferenceType));
			Type type2 = type;
			if (!(type2 != null) || !(referenceType != null) || (!(type2 == referenceType) && !type2.IsSubclassOf(referenceType)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		public override string ToString()
		{
			return "[CLR type: " + ReferenceType?.ToString() + "]";
		}
	}
	internal sealed class TypeReferencePrototype : ObjectInstance
	{
		public TypeReference TypeReference { get; }

		public TypeReferencePrototype(Engine engine, TypeReference typeReference)
			: base(engine)
		{
			TypeReference = typeReference;
			_prototype = engine.Realm.Intrinsics.Object.PrototypeObject;
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			PropertyDescriptor ownProperty = TypeReference.GetOwnProperty(property);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				return ownProperty;
			}
			return base.GetOwnProperty(property);
		}
	}
	public sealed class TypeResolver
	{
		private sealed class DefaultMemberNameComparer : StringComparer
		{
			public static readonly StringComparer Instance = new DefaultMemberNameComparer();

			public override int Compare(string? x, string? y)
			{
				throw new NotImplementedException();
			}

			public override bool Equals(string? x, string? y)
			{
				if ((object)x == y)
				{
					return true;
				}
				if (x == null || y == null)
				{
					return false;
				}
				if (x.Length != y.Length)
				{
					return false;
				}
				bool flag = false;
				if (x.Length > 0)
				{
					flag = char.ToLowerInvariant(x[0]) == char.ToLowerInvariant(y[0]);
				}
				if (flag && x.Length > 1)
				{
					flag = x.AsSpan(1).SequenceEqual(y.AsSpan(1));
				}
				return flag;
			}

			public override int GetHashCode(string obj)
			{
				throw new NotImplementedException();
			}
		}

		public static readonly TypeResolver Default = new TypeResolver();

		public Predicate<MemberInfo> MemberFilter { get; set; } = (MemberInfo _) => true;

		public Func<MemberInfo, IEnumerable<string>> MemberNameCreator { get; set; } = NameCreator;

		public StringComparer MemberNameComparer { get; set; } = DefaultMemberNameComparer.Instance;

		internal bool Filter(Engine engine, Type targetType, MemberInfo m)
		{
			if (string.Equals(m.Name, "Item", StringComparison.Ordinal) && m is PropertyInfo propertyInfo)
			{
				ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
				if (indexParameters.Length == 1)
				{
					ParameterInfo parameterInfo = indexParameters[0];
					if (string.Equals(m.DeclaringType?.FullName, "System.Text.Json.Nodes.JsonNode", StringComparison.Ordinal))
					{
						if (!(parameterInfo.ParameterType == typeof(string)) || !string.Equals(targetType.FullName, "System.Text.Json.Nodes.JsonObject", StringComparison.Ordinal))
						{
							if (parameterInfo.ParameterType == typeof(int))
							{
								return string.Equals(targetType.FullName, "System.Text.Json.Nodes.JsonArray", StringComparison.Ordinal);
							}
							return false;
						}
						return true;
					}
					if (string.Equals(targetType.FullName, "Newtonsoft.Json.Linq.JArray", StringComparison.Ordinal))
					{
						return parameterInfo.ParameterType == typeof(int);
					}
				}
			}
			if (engine.Options.Interop.AllowGetType || !string.Equals(m.Name, "GetType", StringComparison.Ordinal))
			{
				return MemberFilter(m);
			}
			return false;
		}

		private static IEnumerable<string> NameCreator(MemberInfo info)
		{
			yield return info.Name;
		}

		internal ReflectionAccessor GetAccessor(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.Interfaces)] Type type, string member, bool mustBeReadable, bool mustBeWritable, Func<ReflectionAccessor?>? accessorFactory = null)
		{
			Engine.ClrPropertyDescriptorFactoriesKey clrPropertyDescriptorFactoriesKey = new Engine.ClrPropertyDescriptorFactoriesKey(type, member);
			Dictionary<Engine.ClrPropertyDescriptorFactoriesKey, ReflectionAccessor> reflectionAccessors = engine._reflectionAccessors;
			if (reflectionAccessors.TryGetValue(clrPropertyDescriptorFactoriesKey, out var value))
			{
				return value;
			}
			value = accessorFactory?.Invoke() ?? ResolvePropertyDescriptorFactory(engine, type, member, mustBeReadable, mustBeWritable);
			if (uint.TryParse(member, out var _))
			{
				return value;
			}
			Interlocked.CompareExchange(ref engine._reflectionAccessors, new Dictionary<Engine.ClrPropertyDescriptorFactoriesKey, ReflectionAccessor>(reflectionAccessors) { [clrPropertyDescriptorFactoriesKey] = value }, reflectionAccessors);
			return value;
		}

		private ReflectionAccessor ResolvePropertyDescriptorFactory(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.Interfaces)] Type type, string memberName, bool mustBeReadable, bool mustBeWritable)
		{
			long result;
			bool flag = long.TryParse(memberName, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
			IndexerAccessor.TryFindIndexer(engine, type, memberName, out IndexerAccessor indexerAccessor, out PropertyInfo indexer);
			if (!flag && TryFindMemberAccessor(engine, type, memberName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, indexer, out ReflectionAccessor accessor) && (!mustBeReadable || accessor.Readable) && (!mustBeWritable || accessor.Writable))
			{
				return accessor;
			}
			if (typeof(DynamicObject).IsAssignableFrom(type))
			{
				return new DynamicObjectAccessor(type);
			}
			StringComparer memberNameComparer = MemberNameComparer;
			Func<MemberInfo, IEnumerable<string>> memberNameCreator = MemberNameCreator;
			if (!flag)
			{
				List<PropertyInfo> list = null;
				Type[] interfaces = type.GetInterfaces();
				for (int i = 0; i < interfaces.Length; i++)
				{
					PropertyInfo[] properties = interfaces[i].GetProperties();
					foreach (PropertyInfo propertyInfo in properties)
					{
						if (!Filter(engine, type, propertyInfo) || (string.Equals(propertyInfo.Name, "Item", StringComparison.Ordinal) && propertyInfo.GetIndexParameters().Length == 1))
						{
							continue;
						}
						foreach (string item in memberNameCreator(propertyInfo))
						{
							if (memberNameComparer.Equals(item, memberName))
							{
								if (list == null)
								{
									list = new List<PropertyInfo>();
								}
								list.Add(propertyInfo);
							}
						}
					}
				}
				if (list != null && list.Count == 1)
				{
					return new PropertyAccessor(list[0]);
				}
				List<MethodInfo> list2 = null;
				interfaces = type.GetInterfaces();
				for (int i = 0; i < interfaces.Length; i++)
				{
					MethodInfo[] methods = interfaces[i].GetMethods();
					foreach (MethodInfo methodInfo in methods)
					{
						if (!Filter(engine, type, methodInfo))
						{
							continue;
						}
						foreach (string item2 in memberNameCreator(methodInfo))
						{
							if (memberNameComparer.Equals(item2, memberName))
							{
								if (list2 == null)
								{
									list2 = new List<MethodInfo>();
								}
								list2.Add(methodInfo);
							}
						}
					}
				}
				if (list2 != null && list2.Count > 0)
				{
					return new MethodAccessor(type, MethodDescriptor.Build(list2));
				}
			}
			int num = int.MaxValue;
			if (indexerAccessor != null)
			{
				num = CalculateIndexerScore(indexerAccessor.FirstIndexParameter, flag);
			}
			if (num != 0)
			{
				Type[] interfaces = type.GetInterfaces();
				foreach (Type targetType in interfaces)
				{
					if (IndexerAccessor.TryFindIndexer(engine, targetType, memberName, out IndexerAccessor indexerAccessor2, out PropertyInfo _) && Filter(engine, type, indexerAccessor2.Indexer))
					{
						int num2 = CalculateIndexerScore(indexerAccessor2.FirstIndexParameter, flag);
						if (num2 < num)
						{
							indexerAccessor = indexerAccessor2;
							num = num2;
						}
					}
				}
			}
			if (indexerAccessor != null)
			{
				return indexerAccessor;
			}
			if (!flag && engine._extensionMethods.TryGetExtensionMethods(type, out MethodInfo[] methods2))
			{
				List<MethodInfo> list3 = new List<MethodInfo>();
				MethodInfo[] methods = methods2;
				foreach (MethodInfo methodInfo2 in methods)
				{
					if (!Filter(engine, type, methodInfo2))
					{
						continue;
					}
					foreach (string item3 in memberNameCreator(methodInfo2))
					{
						if (memberNameComparer.Equals(item3, memberName))
						{
							list3.Add(methodInfo2);
						}
					}
				}
				if (list3.Count > 0)
				{
					return new MethodAccessor(type, MethodDescriptor.Build(list3));
				}
			}
			if (engine.Options.Interop.ThrowOnUnresolvedMember)
			{
				throw new MissingMemberException("Cannot access property '" + memberName + "' on type '" + type.FullName);
			}
			return ConstantValueAccessor.NullAccessor;
		}

		private static int CalculateIndexerScore(ParameterInfo parameter, bool isInteger)
		{
			Type parameterType = parameter.ParameterType;
			if (parameterType == typeof(int))
			{
				if (!isInteger)
				{
					return 10;
				}
				return 0;
			}
			if (parameterType == typeof(string))
			{
				return 1;
			}
			return 5;
		}

		internal bool TryFindMemberAccessor(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicEvents | DynamicallyAccessedMemberTypes.Interfaces)] Type type, string memberName, BindingFlags bindingFlags, PropertyInfo? indexerToTry, [NotNullWhen(true)] out ReflectionAccessor? accessor)
		{
			PropertyInfo property = null;
			StringComparer memberNameComparer = MemberNameComparer;
			Func<MemberInfo, IEnumerable<string>> typeResolverMemberNameCreator = MemberNameCreator;
			property = GetProperty(type);
			Type[] interfaces;
			if ((object)property == null && type.IsInterface)
			{
				interfaces = type.GetInterfaces();
				foreach (Type t in interfaces)
				{
					property = GetProperty(t);
					if ((object)property != null)
					{
						break;
					}
				}
			}
			if ((object)property != null)
			{
				accessor = new PropertyAccessor(property, indexerToTry);
				return true;
			}
			FieldInfo fieldInfo = null;
			FieldInfo[] fields = type.GetFields(bindingFlags);
			foreach (FieldInfo fieldInfo2 in fields)
			{
				if (!Filter(engine, type, fieldInfo2))
				{
					continue;
				}
				foreach (string item in typeResolverMemberNameCreator(fieldInfo2))
				{
					if (memberNameComparer.Equals(item, memberName))
					{
						fieldInfo = fieldInfo2;
						break;
					}
				}
			}
			if ((object)fieldInfo != null)
			{
				accessor = new FieldAccessor(fieldInfo, indexerToTry);
				return true;
			}
			List<MethodInfo> methods = null;
			MethodInfo[] methods2 = type.GetMethods(bindingFlags);
			foreach (MethodInfo m in methods2)
			{
				AddMethod(m);
			}
			interfaces = type.GetInterfaces();
			for (int i = 0; i < interfaces.Length; i++)
			{
				methods2 = interfaces[i].GetMethods();
				foreach (MethodInfo m2 in methods2)
				{
					AddMethod(m2);
				}
			}
			if (engine._extensionMethods.TryGetExtensionMethods(type, out MethodInfo[] methods3))
			{
				methods2 = methods3;
				foreach (MethodInfo m3 in methods2)
				{
					AddMethod(m3);
				}
			}
			if (type.IsInterface)
			{
				methods2 = typeof(object).GetMethods(bindingFlags);
				foreach (MethodInfo m4 in methods2)
				{
					AddMethod(m4);
				}
			}
			List<MethodInfo> list = methods;
			if (list != null && list.Count > 0)
			{
				accessor = new MethodAccessor(type, MethodDescriptor.Build(methods));
				return true;
			}
			Type nestedType = type.GetNestedType(memberName, bindingFlags);
			if (nestedType != null)
			{
				TypeReference typeReference = TypeReference.CreateTypeReference(engine, nestedType);
				accessor = new NestedTypeAccessor(typeReference);
				return true;
			}
			accessor = null;
			return false;
			void AddMethod(MethodInfo methodInfo)
			{
				if (!Filter(engine, type, methodInfo))
				{
					return;
				}
				foreach (string item2 in typeResolverMemberNameCreator(methodInfo))
				{
					if (memberNameComparer.Equals(item2, memberName))
					{
						if (methods == null)
						{
							methods = new List<MethodInfo>();
						}
						methods.Add(methodInfo);
					}
				}
			}
			PropertyInfo? GetProperty([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type2)
			{
				PropertyInfo[] properties = type2.GetProperties(bindingFlags);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (Filter(engine, type, propertyInfo) && (!string.Equals(propertyInfo.Name, "Item", StringComparison.Ordinal) || propertyInfo.GetIndexParameters().Length != 1))
					{
						foreach (string item3 in typeResolverMemberNameCreator(propertyInfo))
						{
							if (memberNameComparer.Equals(item3, memberName))
							{
								property = propertyInfo;
								break;
							}
						}
					}
				}
				return property;
			}
		}
	}
}
namespace Jint.Runtime.Interop.Reflection
{
	internal sealed class ConstantValueAccessor : ReflectionAccessor
	{
		public static readonly ConstantValueAccessor NullAccessor = new ConstantValueAccessor(null);

		public override bool Writable => false;

		protected override JsValue? ConstantValue { get; }

		public ConstantValueAccessor(JsValue? value)
			: base(null)
		{
			ConstantValue = value;
		}

		protected override object? DoGetValue(object target, string memberName)
		{
			return ConstantValue;
		}

		protected override void DoSetValue(object target, string memberName, object? value)
		{
			throw new InvalidOperationException();
		}

		public override PropertyDescriptor CreatePropertyDescriptor(Engine engine, object target, string memberName, bool enumerable = true)
		{
			if ((object)ConstantValue != null)
			{
				return new PropertyDescriptor(ConstantValue, PropertyFlag.AllForbidden);
			}
			return PropertyDescriptor.Undefined;
		}
	}
	internal sealed class DynamicObjectAccessor : ReflectionAccessor
	{
		private sealed class JintGetMemberBinder : GetMemberBinder
		{
			public JintGetMemberBinder(string name, bool ignoreCase)
				: base(name, ignoreCase)
			{
			}

			public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject? errorSuggestion)
			{
				throw new NotImplementedException("FallbackGetMember not implemented");
			}
		}

		private sealed class JintSetMemberBinder : SetMemberBinder
		{
			public JintSetMemberBinder(string name, bool ignoreCase)
				: base(name, ignoreCase)
			{
			}

			public override DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject? errorSuggestion)
			{
				throw new NotImplementedException("FallbackSetMember not implemented");
			}
		}

		private JintSetMemberBinder? _setter;

		private JintGetMemberBinder? _getter;

		public override bool Writable => true;

		public DynamicObjectAccessor(Type memberType, PropertyInfo? indexer = null)
			: base(memberType, indexer)
		{
		}

		protected override object? DoGetValue(object target, string memberName)
		{
			DynamicObject obj = (DynamicObject)target;
			JintGetMemberBinder binder = _getter ?? (_getter = new JintGetMemberBinder(memberName, ignoreCase: true));
			obj.TryGetMember(binder, out object result);
			return result;
		}

		protected override void DoSetValue(object target, string memberName, object? value)
		{
			DynamicObject obj = (DynamicObject)target;
			JintSetMemberBinder binder = _setter ?? (_setter = new JintSetMemberBinder(memberName, ignoreCase: true));
			obj.TrySetMember(binder, value);
		}

		protected override object? ConvertValueToSet(Engine engine, object value)
		{
			if (!(value is JsBoolean jsBoolean))
			{
				if (!(value is JsString jsString))
				{
					if (!(value is JsNumber jsNumber))
					{
						if (!(value is JsNull))
						{
							if (value is JsUndefined)
							{
								return null;
							}
							return value;
						}
						return null;
					}
					return jsNumber._value;
				}
				return jsString.ToString();
			}
			return jsBoolean._value ? JsBoolean.BoxedTrue : JsBoolean.BoxedFalse;
		}
	}
	internal sealed class ExtensionMethodCache
	{
		internal static readonly ExtensionMethodCache Empty = new ExtensionMethodCache(new Dictionary<Type, MethodInfo[]>());

		private readonly Dictionary<Type, MethodInfo[]> _allExtensionMethods;

		private Dictionary<Type, MethodInfo[]> _extensionMethods = new Dictionary<Type, MethodInfo[]>();

		public bool HasMethods => _allExtensionMethods.Count > 0;

		private ExtensionMethodCache(Dictionary<Type, MethodInfo[]> extensionMethods)
		{
			_allExtensionMethods = extensionMethods;
		}

		internal static ExtensionMethodCache Build(List<Type> extensionMethodContainerTypes)
		{
			if (extensionMethodContainerTypes.Count == 0)
			{
				return Empty;
			}
			return new ExtensionMethodCache((from x in extensionMethodContainerTypes.SelectMany((Type x) => x.GetExtensionMethods())
				group x by GetTypeDefinition(x.GetParameters()[0].ParameterType)).ToDictionary((IGrouping<Type, MethodInfo> x) => x.Key, (IGrouping<Type, MethodInfo> x) => x.ToArray()));
			static Type GetTypeDefinition(Type type)
			{
				if (!type.IsConstructedGenericType || !type.GenericTypeArguments.Any((Type x) => x.IsGenericParameter))
				{
					return type;
				}
				return type.GetGenericTypeDefinition();
			}
		}

		public bool TryGetExtensionMethods(Type objectType, [NotNullWhen(true)] out MethodInfo[]? methods)
		{
			if (_allExtensionMethods.Count == 0)
			{
				methods = Array.Empty<MethodInfo>();
				return false;
			}
			Dictionary<Type, MethodInfo[]> extensionMethods = _extensionMethods;
			if (extensionMethods.TryGetValue(objectType, out methods))
			{
				return methods.Length != 0;
			}
			List<MethodInfo> list = new List<MethodInfo>();
			if (_allExtensionMethods.TryGetValue(objectType, out MethodInfo[] value))
			{
				list.AddRange(value);
			}
			foreach (Type parentType in GetParentTypes(objectType))
			{
				if (_allExtensionMethods.TryGetValue(parentType, out MethodInfo[] value2))
				{
					list.AddRange(value2);
				}
			}
			methods = list.ToArray();
			Interlocked.CompareExchange(ref _extensionMethods, new Dictionary<Type, MethodInfo[]>(extensionMethods) { [objectType] = methods }, extensionMethods);
			return methods.Length != 0;
		}

		private static IEnumerable<Type> GetParentTypes(Type type)
		{
			if (type == null)
			{
				yield break;
			}
			Type[] interfaces = type.GetInterfaces();
			foreach (Type i2 in interfaces)
			{
				yield return i2;
				if (i2.IsConstructedGenericType)
				{
					yield return i2.GetGenericTypeDefinition();
				}
			}
			Type currentBaseType = type.BaseType;
			while (currentBaseType != null)
			{
				yield return currentBaseType;
				if (currentBaseType.IsConstructedGenericType)
				{
					yield return currentBaseType.GetGenericTypeDefinition();
				}
				currentBaseType = currentBaseType.BaseType;
			}
		}
	}
	internal sealed class FieldAccessor : ReflectionAccessor
	{
		private readonly FieldInfo _fieldInfo;

		public override bool Writable => !_fieldInfo.Attributes.HasFlag(FieldAttributes.InitOnly);

		public FieldAccessor(FieldInfo fieldInfo, PropertyInfo? indexer = null)
			: base(fieldInfo.FieldType, indexer)
		{
			_fieldInfo = fieldInfo;
		}

		protected override object? DoGetValue(object target, string memberName)
		{
			return _fieldInfo.GetValue(target);
		}

		protected override void DoSetValue(object target, string memberName, object? value)
		{
			_fieldInfo.SetValue(target, value);
		}
	}
	internal sealed class IndexerAccessor : ReflectionAccessor
	{
		private readonly object _key;

		private readonly MethodInfo? _getter;

		private readonly MethodInfo? _setter;

		private readonly MethodInfo? _containsKey;

		internal PropertyInfo Indexer { get; }

		internal ParameterInfo FirstIndexParameter { get; }

		public override bool Readable => Indexer.CanRead;

		public override bool Writable => Indexer.CanWrite;

		private IndexerAccessor(PropertyInfo indexer, MethodInfo? containsKey, object key)
			: base(indexer.PropertyType)
		{
			Indexer = indexer;
			FirstIndexParameter = indexer.GetIndexParameters()[0];
			_containsKey = containsKey;
			_key = key;
			_getter = indexer.GetGetMethod();
			_setter = indexer.GetSetMethod();
		}

		internal static bool TryFindIndexer(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties)] Type targetType, string propertyName, [NotNullWhen(true)] out IndexerAccessor? indexerAccessor, [NotNullWhen(true)] out PropertyInfo? indexer)
		{
			indexerAccessor = null;
			indexer = null;
			Type[] paramTypeArray = new Type[1];
			int? integerKey = null;
			if (int.TryParse(propertyName, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				integerKey = result;
			}
			Func<MemberInfo, bool> func = (MemberInfo m) => engine.Options.Interop.TypeResolver.Filter(engine, targetType, m);
			TypeDescriptor typeDescriptor = TypeDescriptor.Get(targetType);
			if ((object)typeDescriptor.IntegerIndexerProperty != null && !func(typeDescriptor.IntegerIndexerProperty))
			{
				indexerAccessor = ComposeIndexerFactory(engine, targetType, typeDescriptor.IntegerIndexerProperty, typeof(int), propertyName, integerKey, paramTypeArray);
				if (indexerAccessor != null)
				{
					indexer = typeDescriptor.IntegerIndexerProperty;
					return true;
				}
			}
			PropertyInfo propertyInfo = null;
			PropertyInfo[] properties = targetType.GetProperties();
			foreach (PropertyInfo propertyInfo2 in properties)
			{
				if (!func(propertyInfo2))
				{
					continue;
				}
				ParameterInfo[] indexParameters = propertyInfo2.GetIndexParameters();
				if (indexParameters.Length != 1 || (!(propertyInfo2.GetGetMethod() != null) && !(propertyInfo2.GetSetMethod() != null)))
				{
					continue;
				}
				Type parameterType = indexParameters[0].ParameterType;
				indexerAccessor = ComposeIndexerFactory(engine, targetType, propertyInfo2, parameterType, propertyName, integerKey, paramTypeArray);
				if (indexerAccessor != null)
				{
					if (parameterType != typeof(string) || !integerKey.HasValue)
					{
						indexer = propertyInfo2;
						return true;
					}
					if ((object)propertyInfo == null)
					{
						propertyInfo = propertyInfo2;
					}
				}
			}
			if ((object)propertyInfo != null)
			{
				indexer = propertyInfo;
				if (indexerAccessor == null)
				{
					indexerAccessor = new IndexerAccessor(indexer, null, null);
				}
				return true;
			}
			indexerAccessor = null;
			indexer = null;
			return false;
		}

		private static IndexerAccessor? ComposeIndexerFactory(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties)] Type targetType, PropertyInfo candidate, Type paramType, string propertyName, int? integerKey, Type[] paramTypeArray)
		{
			object converted = null;
			if (paramType == typeof(int))
			{
				if (integerKey.HasValue)
				{
					converted = integerKey;
				}
			}
			else
			{
				engine.TypeConverter.TryConvert(propertyName, paramType, CultureInfo.InvariantCulture, out converted);
			}
			if (converted != null)
			{
				paramTypeArray[0] = paramType;
				MethodInfo method = targetType.GetMethod("ContainsKey", paramTypeArray);
				if ((object)method == null && targetType.IsAssignableFrom(typeof(IDictionary)))
				{
					paramTypeArray[0] = typeof(object);
					method = targetType.GetMethod("Contains", paramTypeArray);
				}
				return new IndexerAccessor(candidate, method, converted);
			}
			return null;
		}

		protected override object? DoGetValue(object target, string memberName)
		{
			if ((object)_getter == null)
			{
				ExceptionHelper.ThrowInvalidOperationException("Indexer has no public getter.");
				return null;
			}
			object[] parameters = new object[1] { _key };
			if (_containsKey != null && _containsKey.Invoke(target, parameters) as bool? != true)
			{
				return JsValue.Undefined;
			}
			try
			{
				return _getter.Invoke(target, parameters);
			}
			catch (TargetInvocationException ex) when (ex.InnerException is KeyNotFoundException)
			{
				return JsValue.Undefined;
			}
		}

		protected override void DoSetValue(object target, string memberName, object? value)
		{
			if ((object)_setter == null)
			{
				ExceptionHelper.ThrowInvalidOperationException("Indexer has no public setter.");
			}
			object[] parameters = new object[2] { _key, value };
			_setter.Invoke(target, parameters);
		}

		public override PropertyDescriptor CreatePropertyDescriptor(Engine engine, object target, string memberName, bool enumerable = true)
		{
			if (_containsKey != null && _containsKey.Invoke(target, new object[1] { _key }) as bool? != true)
			{
				return PropertyDescriptor.Undefined;
			}
			return new ReflectionDescriptor(engine, this, target, memberName, enumerable: true);
		}
	}
	internal sealed class MethodAccessor : ReflectionAccessor
	{
		private readonly Type _targetType;

		private readonly MethodDescriptor[] _methods;

		public override bool Writable => false;

		public MethodAccessor(Type targetType, MethodDescriptor[] methods)
			: base(null)
		{
			_targetType = targetType;
			_methods = methods;
		}

		protected override object? DoGetValue(object target, string memberName)
		{
			return null;
		}

		protected override void DoSetValue(object target, string memberName, object? value)
		{
		}

		public override PropertyDescriptor CreatePropertyDescriptor(Engine engine, object target, string memberName, bool enumerable = true)
		{
			return new PropertyDescriptor(new MethodInfoFunction(engine, _targetType, target, memberName, _methods), PropertyFlag.AllForbidden);
		}
	}
	internal sealed class NestedTypeAccessor : ReflectionAccessor
	{
		private readonly TypeReference _typeReference;

		public override bool Writable => false;

		public NestedTypeAccessor(TypeReference typeReference)
			: base(typeof(Type))
		{
			_typeReference = typeReference;
		}

		protected override object? DoGetValue(object target, string memberName)
		{
			return null;
		}

		protected override void DoSetValue(object target, string memberName, object? value)
		{
		}

		public override PropertyDescriptor CreatePropertyDescriptor(Engine engine, object target, string memberName, bool enumerable = true)
		{
			return new PropertyDescriptor(_typeReference, PropertyFlag.AllForbidden);
		}
	}
	internal sealed class PropertyAccessor : ReflectionAccessor
	{
		private readonly PropertyInfo _propertyInfo;

		public override bool Readable => _propertyInfo.CanRead;

		public override bool Writable => _propertyInfo.CanWrite;

		public PropertyAccessor(PropertyInfo propertyInfo, PropertyInfo? indexerToTry = null)
			: base(propertyInfo.PropertyType, indexerToTry)
		{
			_propertyInfo = propertyInfo;
		}

		protected override object? DoGetValue(object target, string memberName)
		{
			return _propertyInfo.GetValue(target, null);
		}

		protected override void DoSetValue(object target, string memberName, object? value)
		{
			_propertyInfo.SetValue(target, value, null);
		}
	}
	internal abstract class ReflectionAccessor
	{
		private readonly Type _memberType;

		private readonly PropertyInfo? _indexer;

		public Type MemberType => _memberType;

		public virtual bool Readable => true;

		public abstract bool Writable { get; }

		protected virtual JsValue? ConstantValue => null;

		protected ReflectionAccessor(Type memberType, PropertyInfo? indexer = null)
		{
			_memberType = memberType;
			_indexer = indexer;
		}

		protected abstract object? DoGetValue(object target, string memberName);

		protected abstract void DoSetValue(object target, string memberName, object? value);

		public object? GetValue(Engine engine, object target, string memberName)
		{
			JsValue constantValue = ConstantValue;
			if ((object)constantValue != null)
			{
				return constantValue;
			}
			object obj = TryReadFromIndexer(target, memberName);
			if (obj == null)
			{
				try
				{
					obj = DoGetValue(target, memberName);
				}
				catch (TargetInvocationException exception)
				{
					ExceptionHelper.ThrowMeaningfulException(engine, exception);
				}
			}
			return obj;
		}

		private object? TryReadFromIndexer(object target, string memberName)
		{
			MethodInfo methodInfo = _indexer?.GetGetMethod();
			if ((object)methodInfo == null)
			{
				return null;
			}
			try
			{
				object[] parameters = new object[1] { memberName };
				return methodInfo.Invoke(target, parameters);
			}
			catch
			{
				return null;
			}
		}

		public void SetValue(Engine engine, object target, string memberName, JsValue value)
		{
			object converted;
			if (_memberType == typeof(JsValue))
			{
				converted = value;
			}
			else if (!ReflectionExtensions.TryConvertViaTypeCoercion(_memberType, engine.Options.Interop.ValueCoercion, value, out converted))
			{
				converted = value.ToObject();
				if (converted != null && converted.GetType() != _memberType)
				{
					converted = ConvertValueToSet(engine, converted);
				}
			}
			try
			{
				DoSetValue(target, memberName, converted);
			}
			catch (TargetInvocationException exception)
			{
				ExceptionHelper.ThrowMeaningfulException(engine, exception);
			}
		}

		protected virtual object? ConvertValueToSet(Engine engine, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields)] object value)
		{
			return engine.TypeConverter.Convert(value, _memberType, CultureInfo.InvariantCulture);
		}

		public virtual PropertyDescriptor CreatePropertyDescriptor(Engine engine, object target, string memberName, bool enumerable = true)
		{
			return new ReflectionDescriptor(engine, this, target, memberName, enumerable);
		}
	}
}
namespace Jint.Runtime.Environments
{
	[DebuggerDisplay("Mutable: {Mutable}, Strict: {Strict}, CanBeDeleted: {CanBeDeleted}, Value: {Value}")]
	internal readonly struct Binding
	{
		public readonly JsValue Value;

		public readonly bool CanBeDeleted;

		public readonly bool Mutable;

		public readonly bool Strict;

		public Binding(JsValue value, bool canBeDeleted, bool mutable, bool strict)
		{
			Value = value;
			CanBeDeleted = canBeDeleted;
			Mutable = mutable;
			Strict = strict;
		}

		public Binding ChangeValue(JsValue argument)
		{
			return new Binding(argument, CanBeDeleted, Mutable, Strict);
		}

		public bool IsInitialized()
		{
			return (object)Value != null;
		}
	}
	internal class DeclarativeEnvironment : Environment
	{
		internal HybridDictionary<Binding>? _dictionary;

		internal readonly bool _catchEnvironment;

		public DeclarativeEnvironment(Engine engine, bool catchEnvironment = false)
			: base(engine)
		{
			_catchEnvironment = catchEnvironment;
		}

		internal sealed override bool HasBinding(BindingName name)
		{
			return HasBinding(name.Key);
		}

		internal sealed override bool HasBinding(Key name)
		{
			if (_dictionary != null)
			{
				return _dictionary.ContainsKey(name);
			}
			return false;
		}

		internal override bool TryGetBinding(BindingName name, [NotNullWhen(true)] out JsValue? value)
		{
			HybridDictionary<Binding>? dictionary = _dictionary;
			if (dictionary != null && dictionary.TryGetValue(name.Key, out var value2))
			{
				value = value2.Value;
				return true;
			}
			value = null;
			return false;
		}

		internal void CreateMutableBindingAndInitialize(Key name, bool canBeDeleted, JsValue value)
		{
			if (_dictionary == null)
			{
				_dictionary = new HybridDictionary<Binding>();
			}
			_dictionary[name] = new Binding(value, canBeDeleted, mutable: true, strict: false);
		}

		internal void CreateImmutableBindingAndInitialize(Key name, bool strict, JsValue value)
		{
			if (_dictionary == null)
			{
				_dictionary = new HybridDictionary<Binding>();
			}
			_dictionary[name] = new Binding(value, canBeDeleted: false, mutable: false, strict);
		}

		internal sealed override void CreateMutableBinding(Key name, bool canBeDeleted = false)
		{
			if (_dictionary == null)
			{
				_dictionary = new HybridDictionary<Binding>();
			}
			_dictionary[name] = new Binding(null, canBeDeleted, mutable: true, strict: false);
		}

		internal sealed override void CreateImmutableBinding(Key name, bool strict = true)
		{
			if (_dictionary == null)
			{
				_dictionary = new HybridDictionary<Binding>();
			}
			_dictionary[name] = new Binding(null, canBeDeleted: false, mutable: false, strict);
		}

		internal sealed override void InitializeBinding(Key name, JsValue value)
		{
			if (_dictionary == null)
			{
				_dictionary = new HybridDictionary<Binding>();
			}
			_dictionary.SetOrUpdateValue(name, (Binding current, JsValue argument) => current.ChangeValue(argument), value);
		}

		internal sealed override void SetMutableBinding(BindingName name, JsValue value, bool strict)
		{
			SetMutableBinding(name.Key, value, strict);
		}

		internal sealed override void SetMutableBinding(Key name, JsValue value, bool strict)
		{
			if (_dictionary == null || !_dictionary.TryGetValue(name, out var value2))
			{
				if (strict)
				{
					ExceptionHelper.ThrowReferenceNameError(_engine.Realm, name);
				}
				CreateMutableBindingAndInitialize(name, canBeDeleted: true, value);
				return;
			}
			if (value2.Strict)
			{
				strict = true;
			}
			if (!value2.IsInitialized())
			{
				ThrowUninitializedBindingError(name);
			}
			if (value2.Mutable)
			{
				_dictionary[name] = value2.ChangeValue(value);
			}
			else if (strict)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Assignment to constant variable.");
			}
		}

		internal override JsValue GetBindingValue(Key name, bool strict)
		{
			if (_dictionary != null && _dictionary.TryGetValue(name, out var value) && value.IsInitialized())
			{
				return value.Value;
			}
			ThrowUninitializedBindingError(name);
			return null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void ThrowUninitializedBindingError(string name)
		{
			ExceptionHelper.ThrowReferenceError(_engine.Realm, "Cannot access '" + name + "' before initialization");
		}

		internal sealed override bool DeleteBinding(Key name)
		{
			if (_dictionary == null || !_dictionary.TryGetValue(name, out var value))
			{
				return true;
			}
			if (!value.CanBeDeleted)
			{
				return false;
			}
			_dictionary.Remove(name);
			return true;
		}

		internal override bool HasThisBinding()
		{
			return false;
		}

		internal override bool HasSuperBinding()
		{
			return false;
		}

		internal sealed override JsValue WithBaseObject()
		{
			return JsValue.Undefined;
		}

		internal sealed override bool HasBindings()
		{
			HybridDictionary<Binding>? dictionary = _dictionary;
			if (dictionary == null)
			{
				return false;
			}
			return dictionary.Count > 0;
		}

		internal sealed override string[] GetAllBindingNames()
		{
			if (_dictionary == null)
			{
				return Array.Empty<string>();
			}
			string[] array = new string[_dictionary.Count];
			int num = 0;
			foreach (KeyValuePair<Key, Binding> item in (IEnumerable<KeyValuePair<Key, Binding>>)_dictionary)
			{
				array[num++] = item.Key;
			}
			return array;
		}

		internal override JsValue GetThisBinding()
		{
			return JsValue.Undefined;
		}

		public void Clear()
		{
			_dictionary = null;
		}

		internal void TransferTo(List<Key> names, DeclarativeEnvironment env)
		{
			HybridDictionary<Binding> dictionary = _dictionary;
			HybridDictionary<Binding> hybridDictionary = env._dictionary ?? (env._dictionary = new HybridDictionary<Binding>(names.Count, checkExistingKeys: true));
			for (int i = 0; i < names.Count; i++)
			{
				Key key = names[i];
				dictionary.TryGetValue(key, out var value);
				hybridDictionary[key] = new Binding(value.Value, canBeDeleted: false, mutable: true, strict: false);
			}
		}
	}
	[DebuggerTypeProxy(typeof(EnvironmentDebugView))]
	internal abstract class Environment : JsValue
	{
		[DebuggerDisplay("\"{Key.Name}\"")]
		internal sealed class BindingName
		{
			public readonly Key Key;

			public readonly JsString Value;

			public readonly JsValue? CalculatedValue;

			public BindingName(string value)
			{
				Key a = (Key = value);
				Value = JsString.Create(value);
				if (a == KnownKeys.Undefined)
				{
					CalculatedValue = JsValue.Undefined;
				}
			}

			public BindingName(JsString value)
			{
				Key a = (Key = value.ToString());
				Value = value;
				if (a == KnownKeys.Undefined)
				{
					CalculatedValue = JsValue.Undefined;
				}
			}
		}

		private sealed class EnvironmentDebugView
		{
			private readonly Environment _record;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public KeyValuePair<JsValue, JsValue>[] Entries
			{
				get
				{
					string[] allBindingNames = _record.GetAllBindingNames();
					KeyValuePair<JsValue, JsValue>[] array = new KeyValuePair<JsValue, JsValue>[allBindingNames.Length];
					int num = 0;
					string[] array2 = allBindingNames;
					foreach (string text in array2)
					{
						array[num++] = new KeyValuePair<JsValue, JsValue>(text, _record.GetBindingValue(text, strict: false));
					}
					return array;
				}
			}

			public EnvironmentDebugView(Environment record)
			{
				_record = record;
			}
		}

		protected internal readonly Engine _engine;

		protected internal Environment? _outerEnv;

		internal JsValue? NewTarget { get; set; }

		protected Environment(Engine engine)
			: base(InternalTypes.ObjectEnvironmentRecord)
		{
			_engine = engine;
		}

		internal abstract bool HasBinding(Key name);

		internal abstract bool HasBinding(BindingName name);

		internal abstract bool TryGetBinding(BindingName name, [NotNullWhen(true)] out JsValue? value);

		internal abstract void CreateMutableBinding(Key name, bool canBeDeleted = false);

		internal abstract void CreateImmutableBinding(Key name, bool strict = true);

		internal abstract void InitializeBinding(Key name, JsValue value);

		internal abstract void SetMutableBinding(Key name, JsValue value, bool strict);

		internal abstract void SetMutableBinding(BindingName name, JsValue value, bool strict);

		internal abstract JsValue GetBindingValue(Key name, bool strict);

		internal abstract bool DeleteBinding(Key name);

		internal abstract bool HasThisBinding();

		internal abstract bool HasSuperBinding();

		internal abstract JsValue WithBaseObject();

		internal abstract bool HasBindings();

		internal abstract string[] GetAllBindingNames();

		public override object ToObject()
		{
			ExceptionHelper.ThrowNotSupportedException();
			return null;
		}

		public override bool Equals(JsValue? other)
		{
			ExceptionHelper.ThrowNotSupportedException();
			return false;
		}

		internal abstract JsValue GetThisBinding();
	}
	internal readonly struct ExecutionContext
	{
		public readonly IScriptOrModule? ScriptOrModule;

		public readonly Environment LexicalEnvironment;

		public readonly Environment VariableEnvironment;

		public readonly PrivateEnvironment? PrivateEnvironment;

		public readonly Realm Realm;

		public readonly Function? Function;

		public readonly GeneratorInstance? Generator;

		public readonly ParserOptions? ParserOptions;

		public bool Suspended
		{
			get
			{
				GeneratorInstance? generator = Generator;
				if ((object)generator == null)
				{
					return false;
				}
				return generator._generatorState == GeneratorState.SuspendedYield;
			}
		}

		internal ExecutionContext(IScriptOrModule? scriptOrModule, Environment lexicalEnvironment, Environment variableEnvironment, PrivateEnvironment? privateEnvironment, Realm realm, GeneratorInstance? generator = null, Function? function = null, ParserOptions? parserOptions = null)
		{
			ScriptOrModule = scriptOrModule;
			LexicalEnvironment = lexicalEnvironment;
			VariableEnvironment = variableEnvironment;
			PrivateEnvironment = privateEnvironment;
			Realm = realm;
			Function = function;
			Generator = generator;
			ParserOptions = parserOptions;
		}

		public ExecutionContext UpdateLexicalEnvironment(Environment lexicalEnvironment)
		{
			return new ExecutionContext(ScriptOrModule, lexicalEnvironment, VariableEnvironment, PrivateEnvironment, Realm, Generator, Function);
		}

		public ExecutionContext UpdateVariableEnvironment(Environment variableEnvironment)
		{
			return new ExecutionContext(ScriptOrModule, LexicalEnvironment, variableEnvironment, PrivateEnvironment, Realm, Generator, Function);
		}

		public ExecutionContext UpdatePrivateEnvironment(PrivateEnvironment? privateEnvironment)
		{
			return new ExecutionContext(ScriptOrModule, LexicalEnvironment, VariableEnvironment, privateEnvironment, Realm, Generator, Function);
		}

		public ExecutionContext UpdateGenerator(GeneratorInstance generator)
		{
			return new ExecutionContext(ScriptOrModule, LexicalEnvironment, VariableEnvironment, PrivateEnvironment, Realm, generator, Function);
		}

		internal Environment GetThisEnvironment()
		{
			Environment environment = LexicalEnvironment;
			while (true)
			{
				if ((object)environment != null)
				{
					if (environment.HasThisBinding())
					{
						break;
					}
					environment = environment._outerEnv;
				}
			}
			return environment;
		}

		internal GeneratorKind GetGeneratorKind()
		{
			if ((object)Generator == null)
			{
				return GeneratorKind.NonGenerator;
			}
			return GeneratorKind.Sync;
		}
	}
	internal sealed class FunctionEnvironment : DeclarativeEnvironment
	{
		private enum ThisBindingStatus
		{
			Lexical,
			Initialized,
			Uninitialized
		}

		private sealed class ArrayPatternProtocol : IteratorProtocol
		{
			private readonly JsArray _instance;

			private readonly int _max;

			private long _index;

			protected override bool ShouldContinue => _index < _max;

			public ArrayPatternProtocol(Engine engine, JsArray instance, IteratorInstance iterator, int max)
				: base(engine, iterator, 0)
			{
				_instance = instance;
				_max = max;
			}

			protected override void ProcessItem(JsValue[] arguments, JsValue currentValue)
			{
				_instance.SetIndexValue((uint)_index, currentValue, updateLength: false);
				_index++;
			}

			protected override void IterationEnd()
			{
				if (_index > 0)
				{
					_instance.SetLength((uint)_index);
					IteratorClose(CompletionType.Normal);
				}
			}
		}

		private JsValue? _thisValue;

		private ThisBindingStatus _thisBindingStatus;

		internal readonly Function _functionObject;

		public FunctionEnvironment(Engine engine, Function functionObject, JsValue newTarget)
			: base(engine)
		{
			_functionObject = functionObject;
			base.NewTarget = newTarget;
			if (functionObject._functionDefinition?.Function is ArrowFunctionExpression)
			{
				_thisBindingStatus = ThisBindingStatus.Lexical;
			}
			else
			{
				_thisBindingStatus = ThisBindingStatus.Uninitialized;
			}
		}

		internal override bool HasThisBinding()
		{
			return _thisBindingStatus != ThisBindingStatus.Lexical;
		}

		internal override bool HasSuperBinding()
		{
			if (_thisBindingStatus != ThisBindingStatus.Lexical)
			{
				return !_functionObject._homeObject.IsUndefined();
			}
			return false;
		}

		public JsValue BindThisValue(JsValue value)
		{
			if (_thisBindingStatus != ThisBindingStatus.Initialized)
			{
				_thisValue = value;
				_thisBindingStatus = ThisBindingStatus.Initialized;
				return value;
			}
			ExceptionHelper.ThrowReferenceError(_functionObject._realm, "'this' has already been bound");
			return null;
		}

		internal override JsValue GetThisBinding()
		{
			if (_thisBindingStatus != ThisBindingStatus.Uninitialized)
			{
				return _thisValue;
			}
			ThrowUninitializedThis();
			return null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void ThrowUninitializedThis()
		{
			string message = "Cannot access uninitialized 'this'";
			if (base.NewTarget is ScriptFunction { _isClassConstructor: not false, _constructorKind: ConstructorKind.Derived })
			{
				message = "Must call super constructor in derived class before accessing 'this' or returning from derived constructor";
			}
			ExceptionHelper.ThrowReferenceError(_engine.ExecutionContext.Realm, message);
		}

		public JsValue GetSuperBase()
		{
			JsValue homeObject = _functionObject._homeObject;
			object obj;
			if (!homeObject.IsUndefined())
			{
				obj = ((ObjectInstance)homeObject).GetPrototypeOf();
				if (obj == null)
				{
					return JsValue.Null;
				}
			}
			else
			{
				obj = JsValue.Undefined;
			}
			return (JsValue)obj;
		}

		internal void InitializeParameters(Key[] parameterNames, bool hasDuplicates, JsValue[]? arguments)
		{
			if (parameterNames.Length == 0)
			{
				return;
			}
			JsValue jsValue = (hasDuplicates ? JsValue.Undefined : null);
			bool flag = !hasDuplicates && (_dictionary == null || _dictionary.Count == 0);
			for (uint num = 0u; num < (uint)parameterNames.Length; num++)
			{
				Key key = parameterNames[num];
				if (flag || _dictionary == null || !_dictionary.ContainsKey(key))
				{
					JsValue value = jsValue;
					if (arguments != null)
					{
						value = ((num < (uint)arguments.Length) ? arguments[num] : JsValue.Undefined);
					}
					if (_dictionary == null)
					{
						_dictionary = new HybridDictionary<Binding>();
					}
					_dictionary[key] = new Binding(value, canBeDeleted: false, mutable: true, strict: false);
				}
			}
		}

		internal void AddFunctionParameters(EvaluationContext context, IFunction functionDeclaration, JsValue[] arguments)
		{
			bool initiallyEmpty = _dictionary == null || _dictionary.Count == 0;
			ref NodeList<Node> reference = functionDeclaration.Params;
			int count = reference.Count;
			for (int i = 0; i < count; i++)
			{
				SetFunctionParameter(context, reference[i], arguments, i, initiallyEmpty);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void SetFunctionParameter(EvaluationContext context, Node? parameter, JsValue[] arguments, int index, bool initiallyEmpty)
		{
			Identifier val = (Identifier)(object)((parameter is Identifier) ? parameter : null);
			if (val != null)
			{
				JsValue argument = arguments.At(index);
				SetItemSafely(val.Name, argument, initiallyEmpty);
			}
			else
			{
				SetFunctionParameterUnlikely(context, parameter, arguments, index, initiallyEmpty);
			}
		}

		private void SetFunctionParameterUnlikely(EvaluationContext context, Node? parameter, JsValue[] arguments, int index, bool initiallyEmpty)
		{
			JsValue argument = arguments.At(index);
			RestElement val = (RestElement)(object)((parameter is RestElement) ? parameter : null);
			if (val != null)
			{
				HandleRestElementArray(context, val, arguments, index, initiallyEmpty);
				return;
			}
			ArrayPattern val2 = (ArrayPattern)(object)((parameter is ArrayPattern) ? parameter : null);
			if (val2 != null)
			{
				HandleArrayPattern(context, initiallyEmpty, argument, val2);
				return;
			}
			ObjectPattern val3 = (ObjectPattern)(object)((parameter is ObjectPattern) ? parameter : null);
			if (val3 != null)
			{
				HandleObjectPattern(context, initiallyEmpty, argument, val3);
				return;
			}
			AssignmentPattern val4 = (AssignmentPattern)(object)((parameter is AssignmentPattern) ? parameter : null);
			if (val4 != null)
			{
				HandleAssignmentPatternOrExpression(context, val4.Left, (Node)(object)val4.Right, argument, initiallyEmpty);
				return;
			}
			AssignmentExpression val5 = (AssignmentExpression)(object)((parameter is AssignmentExpression) ? parameter : null);
			if (val5 != null)
			{
				HandleAssignmentPatternOrExpression(context, val5.Left, (Node)(object)val5.Right, argument, initiallyEmpty);
			}
		}

		private void HandleObjectPattern(EvaluationContext context, bool initiallyEmpty, JsValue argument, ObjectPattern objectPattern)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			if (argument.IsNullOrUndefined())
			{
				ExceptionHelper.ThrowTypeError(_functionObject._realm, "Destructed parameter is null or undefined");
			}
			ObjectInstance objectInstance = TypeConverter.ToObject(_engine.Realm, argument);
			ref NodeList<Node> properties = objectPattern.Properties;
			HashSet<JsValue> hashSet = ((properties.Count > 0 && properties[properties.Count - 1] is RestElement) ? new HashSet<JsValue>() : null);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(1);
			Enumerator<Node> enumerator = properties.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Node current = enumerator.Current;
					Environment lexicalEnvironment = _engine.ExecutionContext.LexicalEnvironment;
					DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(_engine, lexicalEnvironment);
					PrivateEnvironment privateEnvironment = null;
					_engine.EnterExecutionContext(declarativeEnvironment, declarativeEnvironment, _engine.ExecutionContext.Realm, privateEnvironment);
					try
					{
						Property val = (Property)(object)((current is Property) ? current : null);
						if (val != null)
						{
							JsValue key = val.GetKey<Property>(_engine);
							hashSet?.Add(key.ToString());
							array[0] = objectInstance.Get(key);
							SetFunctionParameter(context, val.Value, array, 0, initiallyEmpty);
							continue;
						}
						Node argument2 = ((RestElement)current).Argument;
						Identifier val2 = (Identifier)(object)((argument2 is Identifier) ? argument2 : null);
						if (val2 != null)
						{
							ObjectInstance objectInstance2 = _engine.Realm.Intrinsics.Object.Construct((objectInstance.Properties?.Count ?? 0) - hashSet.Count);
							objectInstance.CopyDataProperties(objectInstance2, hashSet);
							SetItemSafely(val2.Name, objectInstance2, initiallyEmpty);
						}
						else
						{
							ExceptionHelper.ThrowSyntaxError(_functionObject._realm, "Object rest parameter can only be objects");
						}
					}
					finally
					{
						_engine.LeaveExecutionContext();
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			_engine._jsValueArrayPool.ReturnArray(array);
		}

		private void HandleArrayPattern(EvaluationContext context, bool initiallyEmpty, JsValue argument, ArrayPattern arrayPattern)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			if (argument.IsNull())
			{
				ExceptionHelper.ThrowTypeError(_functionObject._realm, "Destructed parameter is null");
			}
			JsArray jsArray2;
			if (argument is JsArray { HasOriginalIterator: not false } jsArray)
			{
				jsArray2 = jsArray;
			}
			else
			{
				if (!argument.TryGetIterator(_functionObject._realm, out IteratorInstance iterator))
				{
					ExceptionHelper.ThrowTypeError(context.Engine.Realm, "object is not iterable");
				}
				jsArray2 = _engine.Realm.Intrinsics.Array.ArrayCreate(0uL);
				int num = ((NodeList<Node>)arrayPattern.Elements).Count;
				if (num > 0)
				{
					Node obj = ((NodeList<Node>)arrayPattern.Elements)[num - 1];
					if (obj != null && (int)obj.Type == 53)
					{
						num = int.MaxValue;
					}
				}
				new ArrayPatternProtocol(_engine, jsArray2, iterator, num).Execute();
			}
			JsValue[] arguments = jsArray2.ToArray();
			for (int i = 0; i < ((NodeList<Node>)arrayPattern.Elements).Count; i++)
			{
				SetFunctionParameter(context, ((NodeList<Node>)arrayPattern.Elements)[i], arguments, i, initiallyEmpty);
			}
		}

		private void HandleRestElementArray(EvaluationContext context, RestElement restElement, JsValue[] arguments, int index, bool initiallyEmpty)
		{
			int num = arguments.Length - (index + 1) + 1;
			int num2 = ((num > 0) ? num : 0);
			uint num3 = 0u;
			JsValue[] array = new JsValue[num2];
			for (int i = index; i < arguments.Length; i++)
			{
				array[num3++] = arguments[i];
			}
			JsArray jsArray = new JsArray(_engine, array);
			Node argument = restElement.Argument;
			Identifier val = (Identifier)(object)((argument is Identifier) ? argument : null);
			if (val != null)
			{
				SetItemSafely(val.Name, jsArray, initiallyEmpty);
				return;
			}
			Node argument2 = restElement.Argument;
			BindingPattern val2 = (BindingPattern)(object)((argument2 is BindingPattern) ? argument2 : null);
			if (val2 != null)
			{
				SetFunctionParameter(context, (Node?)(object)val2, new JsValue[1] { jsArray }, 0, initiallyEmpty);
			}
			else
			{
				ExceptionHelper.ThrowSyntaxError(_functionObject._realm, "Rest parameters can only be identifiers or arrays");
			}
		}

		private void HandleAssignmentPatternOrExpression(EvaluationContext context, Node left, Node right, JsValue argument, bool initiallyEmpty)
		{
			Identifier val = (Identifier)(object)((left is Identifier) ? left : null);
			if (val != null)
			{
				Identifier val2 = (Identifier)(object)((right is Identifier) ? right : null);
				if (val2 != null && string.Equals(val.Name, val2.Name, StringComparison.Ordinal))
				{
					ExceptionHelper.ThrowReferenceNameError(_functionObject._realm, val2.Name);
				}
			}
			if (argument.IsUndefined())
			{
				JintExpression jintExpression = JintExpression.Build(NodeExtensions.As<Expression>(right));
				Environment lexicalEnvironment = _engine.ExecutionContext.LexicalEnvironment;
				DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(_engine, lexicalEnvironment);
				_engine.EnterExecutionContext(new ExecutionContext(null, declarativeEnvironment, declarativeEnvironment, null, _engine.Realm));
				try
				{
					argument = jintExpression.GetValue(context);
				}
				finally
				{
					_engine.LeaveExecutionContext();
				}
				if (val != null && right.IsFunctionDefinition<Node>())
				{
					((Function)argument).SetFunctionName(val.Name);
				}
			}
			SetFunctionParameter(context, left, new JsValue[1] { argument }, 0, initiallyEmpty);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void SetItemSafely(Key name, JsValue argument, bool initiallyEmpty)
		{
			if (initiallyEmpty)
			{
				if (_dictionary == null)
				{
					_dictionary = new HybridDictionary<Binding>();
				}
				_dictionary[name] = new Binding(argument, canBeDeleted: false, mutable: true, strict: false);
			}
			else
			{
				SetItemCheckExisting(name, argument);
			}
		}

		private void SetItemCheckExisting(Key name, JsValue argument)
		{
			if (_dictionary == null)
			{
				_dictionary = new HybridDictionary<Binding>();
			}
			if (!_dictionary.TryGetValue(name, out var value))
			{
				_dictionary[name] = new Binding(argument, canBeDeleted: false, mutable: true, strict: false);
			}
			else if (value.Mutable)
			{
				_dictionary[name] = value.ChangeValue(argument);
			}
			else
			{
				ExceptionHelper.ThrowTypeError(_functionObject._realm, "Can't update the value of an immutable binding.");
			}
		}
	}
	internal sealed class GlobalEnvironment : Environment
	{
		internal sealed class GlobalDeclarativeEnvironment : DeclarativeEnvironment
		{
			public GlobalDeclarativeEnvironment(Engine engine)
				: base(engine)
			{
			}
		}

		internal readonly ObjectInstance _global;

		private readonly GlobalObject? _globalObject;

		internal readonly GlobalDeclarativeEnvironment _declarativeRecord;

		public ObjectInstance GlobalThisValue => _global;

		public GlobalEnvironment(Engine engine, ObjectInstance global)
			: base(engine)
		{
			_global = global;
			_globalObject = global as GlobalObject;
			_declarativeRecord = new GlobalDeclarativeEnvironment(engine);
		}

		internal override bool HasBinding(Key name)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				return true;
			}
			if ((object)_globalObject != null)
			{
				return _globalObject.HasProperty(name);
			}
			return _global.HasProperty(new JsString(name));
		}

		internal override bool HasBinding(BindingName name)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				return true;
			}
			if ((object)_globalObject != null)
			{
				return _globalObject.HasProperty(name.Key);
			}
			return _global.HasProperty(name.Value);
		}

		internal override bool TryGetBinding(BindingName name, [NotNullWhen(true)] out JsValue? value)
		{
			if (_declarativeRecord._dictionary != null && _declarativeRecord.TryGetBinding(name, out value))
			{
				return true;
			}
			value = null;
			if (_global._properties._dictionary.TryGetValue(name.Key, out PropertyDescriptor value2) && value2 != PropertyDescriptor.Undefined)
			{
				value = ObjectInstance.UnwrapJsValue(value2, _global);
				return true;
			}
			if ((object)_global._prototype != null)
			{
				return TryGetBindingForGlobalParent(name, out value);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private bool TryGetBindingForGlobalParent(BindingName name, [NotNullWhen(true)] out JsValue? value)
		{
			value = null;
			PropertyDescriptor ownProperty = _global._prototype.GetOwnProperty(name.Value);
			if (ownProperty == PropertyDescriptor.Undefined)
			{
				return false;
			}
			value = ObjectInstance.UnwrapJsValue(ownProperty, _global);
			return true;
		}

		internal override void CreateMutableBinding(Key name, bool canBeDeleted = false)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				ThrowAlreadyDeclaredException(name);
			}
			_declarativeRecord.CreateMutableBinding(name, canBeDeleted);
		}

		internal override void CreateImmutableBinding(Key name, bool strict = true)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				ThrowAlreadyDeclaredException(name);
			}
			_declarativeRecord.CreateImmutableBinding(name, strict);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void ThrowAlreadyDeclaredException(Key name)
		{
			ExceptionHelper.ThrowTypeError(_engine.Realm, $"{name} has already been declared");
		}

		internal override void InitializeBinding(Key name, JsValue value)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				_declarativeRecord.InitializeBinding(name, value);
			}
			else
			{
				_global._properties[name].Value = value;
			}
		}

		internal override void SetMutableBinding(Key name, JsValue value, bool strict)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				_declarativeRecord.SetMutableBinding(name, value, strict);
			}
			else if ((object)_globalObject != null)
			{
				if (!_globalObject.SetFromMutableBinding(name, value, strict) && strict)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
			}
			else
			{
				SetMutableBindingUnlikely(name, value, strict);
			}
		}

		internal override void SetMutableBinding(BindingName name, JsValue value, bool strict)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				_declarativeRecord.SetMutableBinding(name, value, strict);
			}
			else if ((object)_globalObject != null)
			{
				if (!_globalObject.SetFromMutableBinding(name.Key, value, strict) && strict)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
			}
			else
			{
				SetMutableBindingUnlikely(name.Key, value, strict);
			}
		}

		private void SetMutableBindingUnlikely(Key name, JsValue value, bool strict)
		{
			JsString property = new JsString(name.Name);
			if (strict && !_global.HasProperty(property))
			{
				ExceptionHelper.ThrowReferenceNameError(_engine.Realm, name);
			}
			_global.Set(property, value);
		}

		internal override JsValue GetBindingValue(Key name, bool strict)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				return _declarativeRecord.GetBindingValue(name, strict);
			}
			PropertyDescriptor value = PropertyDescriptor.Undefined;
			if ((object)_globalObject != null)
			{
				PropertyDictionary? properties = _globalObject._properties;
				if (properties != null && !properties.TryGetValue(name, out value))
				{
					value = PropertyDescriptor.Undefined;
				}
			}
			else
			{
				value = _global.GetOwnProperty(name.Name);
			}
			if (strict && value == PropertyDescriptor.Undefined)
			{
				ExceptionHelper.ThrowReferenceNameError(_engine.Realm, name);
			}
			return ObjectInstance.UnwrapJsValue(value, _global);
		}

		internal override bool DeleteBinding(Key name)
		{
			if (_declarativeRecord.HasBinding(name))
			{
				return _declarativeRecord.DeleteBinding(name);
			}
			JsString property = JsString.Create(name.Name);
			if (_global.HasOwnProperty(property))
			{
				return _global.Delete(property);
			}
			return true;
		}

		internal override bool HasThisBinding()
		{
			return true;
		}

		internal override bool HasSuperBinding()
		{
			return false;
		}

		internal override JsValue WithBaseObject()
		{
			return JsValue.Undefined;
		}

		internal override JsValue GetThisBinding()
		{
			return _global;
		}

		internal bool HasLexicalDeclaration(Key name)
		{
			return _declarativeRecord.HasBinding(name);
		}

		internal bool HasRestrictedGlobalProperty(Key name)
		{
			if ((object)_globalObject != null)
			{
				PropertyDictionary? properties = _globalObject._properties;
				if (properties != null && properties.TryGetValue(name, out PropertyDescriptor value))
				{
					return !value.Configurable;
				}
				return false;
			}
			PropertyDescriptor ownProperty = _global.GetOwnProperty(name.Name);
			if (ownProperty == PropertyDescriptor.Undefined)
			{
				return false;
			}
			return !ownProperty.Configurable;
		}

		public bool CanDeclareGlobalVar(Key name)
		{
			if (_global._properties.ContainsKey(name))
			{
				return true;
			}
			return _global.Extensible;
		}

		public bool CanDeclareGlobalFunction(Key name)
		{
			if (!_global._properties.TryGetValue(name, out PropertyDescriptor value) || value == PropertyDescriptor.Undefined)
			{
				return _global.Extensible;
			}
			if (value.Configurable)
			{
				return true;
			}
			if (value.IsDataDescriptor() && value.Writable && value.Enumerable)
			{
				return true;
			}
			return false;
		}

		public void CreateGlobalVarBinding(Key name, bool canBeDeleted)
		{
			if (_global.Extensible)
			{
				_global._properties.TryAdd(name, new PropertyDescriptor(JsValue.Undefined, canBeDeleted ? (PropertyFlag.ConfigurableEnumerableWritable | PropertyFlag.MutableBinding) : (PropertyFlag.NonConfigurable | PropertyFlag.MutableBinding)));
			}
		}

		internal void CreateGlobalVarBindings(List<Key> names, bool canBeDeleted)
		{
			if (_global.Extensible)
			{
				for (int i = 0; i < names.Count; i++)
				{
					Key key = names[i];
					_global._properties.TryAdd(key, new PropertyDescriptor(JsValue.Undefined, canBeDeleted ? (PropertyFlag.ConfigurableEnumerableWritable | PropertyFlag.MutableBinding) : (PropertyFlag.NonConfigurable | PropertyFlag.MutableBinding)));
				}
			}
		}

		public void CreateGlobalFunctionBinding(Key name, JsValue value, bool canBeDeleted)
		{
			JsString jsString = new JsString(name);
			PropertyDescriptor ownProperty = _global.GetOwnProperty(jsString);
			PropertyDescriptor desc = ((ownProperty != PropertyDescriptor.Undefined && !ownProperty.Configurable) ? new PropertyDescriptor(value, PropertyFlag.None) : new PropertyDescriptor(value, true, true, canBeDeleted));
			_global.DefinePropertyOrThrow(jsString, desc);
			_global.Set(jsString, value, throwOnError: false);
		}

		internal override bool HasBindings()
		{
			if (!_declarativeRecord.HasBindings())
			{
				GlobalObject? globalObject = _globalObject;
				if ((object)globalObject == null || !(globalObject._properties?.Count > 0))
				{
					PropertyDictionary? properties = _global._properties;
					if (properties == null)
					{
						return false;
					}
					return properties.Count > 0;
				}
			}
			return true;
		}

		internal override string[] GetAllBindingNames()
		{
			PropertyDictionary? properties = _global._properties;
			int capacity;
			if (properties == null)
			{
				int? num = _declarativeRecord._dictionary?.Count;
				int? num2 = num;
				capacity = num2.GetValueOrDefault();
			}
			else
			{
				capacity = properties.Count;
			}
			List<string> list = new List<string>(capacity);
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in _global.GetOwnProperties())
			{
				list.Add(ownProperty.Key.ToString());
			}
			string[] allBindingNames = _declarativeRecord.GetAllBindingNames();
			foreach (string item in allBindingNames)
			{
				list.Add(item);
			}
			return list.ToArray();
		}

		public override bool Equals(JsValue? other)
		{
			return (object)this == other;
		}
	}
	internal static class JintEnvironment
	{
		internal static bool TryGetIdentifierEnvironmentWithBinding(Environment env, Environment.BindingName name, [NotNullWhen(true)] out Environment? record)
		{
			record = env;
			if ((object)env._outerEnv == null)
			{
				return env.HasBinding(name);
			}
			while ((object)record != null)
			{
				if (record.HasBinding(name))
				{
					return true;
				}
				record = record._outerEnv;
			}
			return false;
		}

		internal static bool TryGetIdentifierEnvironmentWithBindingValue(Environment env, Environment.BindingName name, [NotNullWhen(true)] out Environment? record, [NotNullWhen(true)] out JsValue? value)
		{
			record = env;
			value = null;
			if ((object)env._outerEnv == null)
			{
				return ((GlobalEnvironment)env).TryGetBinding(name, out value);
			}
			while ((object)record != null)
			{
				if (record.TryGetBinding(name, out value))
				{
					return true;
				}
				record = record._outerEnv;
			}
			return false;
		}

		internal static DeclarativeEnvironment NewDeclarativeEnvironment(Engine engine, Environment? outer, bool catchEnvironment = false)
		{
			return new DeclarativeEnvironment(engine, catchEnvironment)
			{
				_outerEnv = outer
			};
		}

		internal static FunctionEnvironment NewFunctionEnvironment(Engine engine, Function f, JsValue newTarget)
		{
			return new FunctionEnvironment(engine, f, newTarget)
			{
				_outerEnv = f._environment
			};
		}

		internal static GlobalEnvironment NewGlobalEnvironment(Engine engine, ObjectInstance objectInstance, JsValue thisValue)
		{
			return new GlobalEnvironment(engine, objectInstance)
			{
				_outerEnv = null
			};
		}

		internal static ObjectEnvironment NewObjectEnvironment(Engine engine, ObjectInstance objectInstance, Environment outer, bool provideThis, bool withEnvironment = false)
		{
			return new ObjectEnvironment(engine, objectInstance, provideThis, withEnvironment)
			{
				_outerEnv = outer
			};
		}

		internal static PrivateEnvironment NewPrivateEnvironment(Engine engine, PrivateEnvironment? outerPriv)
		{
			return new PrivateEnvironment(outerPriv);
		}

		internal static ModuleEnvironment NewModuleEnvironment(Engine engine, Environment outer)
		{
			return new ModuleEnvironment(engine)
			{
				_outerEnv = outer
			};
		}
	}
	internal sealed class ModuleEnvironment : DeclarativeEnvironment
	{
		private readonly record struct IndirectBinding(Jint.Runtime.Modules.Module Module, string BindingName);

		private readonly HybridDictionary<IndirectBinding> _importBindings = new HybridDictionary<IndirectBinding>();

		internal ModuleEnvironment(Engine engine)
			: base(engine)
		{
		}

		internal override JsValue GetThisBinding()
		{
			return JsValue.Undefined;
		}

		public void CreateImportBinding(string importName, Jint.Runtime.Modules.Module module, string name)
		{
			_importBindings[importName] = new IndirectBinding(module, name);
			CreateImmutableBindingAndInitialize(importName, strict: true, JsValue.Undefined);
		}

		internal override JsValue GetBindingValue(Key name, bool strict)
		{
			if (_importBindings.TryGetValue(name, out var value))
			{
				return value.Module._environment.GetBindingValue(value.BindingName, strict: true);
			}
			return base.GetBindingValue(name, strict);
		}

		internal override bool TryGetBinding(BindingName name, [NotNullWhen(true)] out JsValue? value)
		{
			if (_importBindings.TryGetValue(name.Key, out var value2))
			{
				value = value2.Module._environment.GetBindingValue(value2.BindingName, strict: true);
				return true;
			}
			return base.TryGetBinding(name, out value);
		}

		internal override bool HasThisBinding()
		{
			return true;
		}
	}
	internal sealed class ObjectEnvironment : Environment
	{
		internal readonly ObjectInstance _bindingObject;

		private readonly bool _provideThis;

		private readonly bool _withEnvironment;

		public ObjectEnvironment(Engine engine, ObjectInstance bindingObject, bool provideThis, bool withEnvironment)
			: base(engine)
		{
			_bindingObject = bindingObject;
			_provideThis = provideThis;
			_withEnvironment = withEnvironment;
		}

		internal override bool HasBinding(Key name)
		{
			JsString property = new JsString(name.Name);
			if (!HasProperty(property))
			{
				return false;
			}
			if (!_withEnvironment)
			{
				return true;
			}
			return !IsBlocked(property);
		}

		internal override bool HasBinding(BindingName name)
		{
			if (!HasProperty(name.Value))
			{
				return false;
			}
			if (!_withEnvironment)
			{
				return true;
			}
			return !IsBlocked(name.Value);
		}

		private bool HasProperty(JsValue property)
		{
			return _bindingObject.HasProperty(property);
		}

		internal override bool TryGetBinding(BindingName name, [NotNullWhen(true)] out JsValue? value)
		{
			if (!HasProperty(name.Value))
			{
				value = null;
				return false;
			}
			if (_withEnvironment && IsBlocked(name.Value))
			{
				value = null;
				return false;
			}
			value = _bindingObject.Get(name.Value);
			return true;
		}

		private bool IsBlocked(JsValue property)
		{
			if (_bindingObject.Get(GlobalSymbolRegistry.Unscopables) is ObjectInstance objectInstance && TypeConverter.ToBoolean(objectInstance.Get(property)))
			{
				return true;
			}
			return false;
		}

		internal override void CreateMutableBinding(Key name, bool canBeDeleted = false)
		{
			_bindingObject.DefinePropertyOrThrow(name.Name, new PropertyDescriptor(JsValue.Undefined, canBeDeleted ? (PropertyFlag.ConfigurableEnumerableWritable | PropertyFlag.MutableBinding) : (PropertyFlag.NonConfigurable | PropertyFlag.MutableBinding)));
		}

		internal override void CreateImmutableBinding(Key name, bool strict = true)
		{
			ExceptionHelper.ThrowInvalidOperationException("The concrete Environment Record method CreateImmutableBinding is never used within this specification in association with Object Environment Records.");
		}

		internal override void InitializeBinding(Key name, JsValue value)
		{
			SetMutableBinding(name, value, strict: false);
		}

		internal override void SetMutableBinding(Key name, JsValue value, bool strict)
		{
			JsString property = new JsString(name);
			if (strict && !_bindingObject.HasProperty(property))
			{
				ExceptionHelper.ThrowReferenceNameError(_engine.Realm, name);
			}
			_bindingObject.Set(property, value);
		}

		internal override void SetMutableBinding(BindingName name, JsValue value, bool strict)
		{
			if (strict && !_bindingObject.HasProperty(name.Value))
			{
				ExceptionHelper.ThrowReferenceNameError(_engine.Realm, name.Key);
			}
			_bindingObject.Set(name.Value, value);
		}

		internal override JsValue GetBindingValue(Key name, bool strict)
		{
			if (!_bindingObject.TryGetValue(name.Name, out JsValue value) && strict)
			{
				ExceptionHelper.ThrowReferenceNameError(_engine.Realm, name.Name);
			}
			return value;
		}

		internal override bool DeleteBinding(Key name)
		{
			return _bindingObject.Delete(name.Name);
		}

		internal override bool HasThisBinding()
		{
			return false;
		}

		internal override bool HasSuperBinding()
		{
			return false;
		}

		internal override JsValue WithBaseObject()
		{
			if (!_withEnvironment)
			{
				return JsValue.Undefined;
			}
			return _bindingObject;
		}

		internal override bool HasBindings()
		{
			PropertyDictionary? properties = _bindingObject._properties;
			if (properties == null)
			{
				return false;
			}
			return properties.Count > 0;
		}

		internal override string[] GetAllBindingNames()
		{
			if ((object)_bindingObject != null)
			{
				List<string> list = new List<string>(_bindingObject._properties?.Count ?? 0);
				foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in _bindingObject.GetOwnProperties())
				{
					list.Add(ownProperty.Key.ToString());
				}
				return list.ToArray();
			}
			return Array.Empty<string>();
		}

		public override bool Equals(JsValue? other)
		{
			return (object)_bindingObject == other;
		}

		internal override JsValue GetThisBinding()
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class PrivateEnvironment
	{
		public PrivateEnvironment? OuterPrivateEnvironment { get; }

		public Dictionary<PrivateIdentifier, PrivateName> Names { get; } = new Dictionary<PrivateIdentifier, PrivateName>();

		public PrivateEnvironment(PrivateEnvironment? outerPrivEnv)
		{
			OuterPrivateEnvironment = outerPrivEnv;
		}

		public PrivateName? ResolvePrivateIdentifier(string identifier)
		{
			foreach (KeyValuePair<PrivateIdentifier, PrivateName> name in Names)
			{
				if (string.Equals(name.Value.Description, identifier, StringComparison.Ordinal))
				{
					return name.Value;
				}
			}
			return OuterPrivateEnvironment?.ResolvePrivateIdentifier(identifier);
		}
	}
}
namespace Jint.Runtime.Descriptors
{
	public sealed class GetSetPropertyDescriptor : PropertyDescriptor
	{
		internal sealed class ThrowerPropertyDescriptor : PropertyDescriptor
		{
			private readonly Engine _engine;

			private JsValue? _thrower;

			public override JsValue Get => _thrower ?? (_thrower = _engine.Realm.Intrinsics.ThrowTypeError);

			public override JsValue Set => _thrower ?? (_thrower = _engine.Realm.Intrinsics.ThrowTypeError);

			protected internal override JsValue? CustomValue
			{
				set
				{
					ExceptionHelper.ThrowInvalidOperationException("making changes to throw type error property's descriptor is not allowed");
				}
			}

			public ThrowerPropertyDescriptor(Engine engine, PropertyFlag flags)
				: base(flags | PropertyFlag.CustomJsValue)
			{
				_flags |= PropertyFlag.NonData;
				_engine = engine;
			}
		}

		private JsValue? _get;

		private JsValue? _set;

		public override JsValue? Get => _get;

		public override JsValue? Set => _set;

		public GetSetPropertyDescriptor(JsValue? get, JsValue? set, bool? enumerable = null, bool? configurable = null)
			: base(null, null, enumerable, configurable)
		{
			_flags |= PropertyFlag.NonData;
			_get = get;
			_set = set;
		}

		internal GetSetPropertyDescriptor(JsValue? get, JsValue? set, PropertyFlag flags)
			: base(null, flags)
		{
			_flags |= PropertyFlag.NonData;
			_flags &= ~PropertyFlag.WritableSet;
			_flags &= ~PropertyFlag.Writable;
			_get = get;
			_set = set;
		}

		public GetSetPropertyDescriptor(PropertyDescriptor descriptor)
			: base(descriptor)
		{
			_flags |= PropertyFlag.NonData;
			_flags &= ~PropertyFlag.WritableSet;
			_flags &= ~PropertyFlag.Writable;
			_get = descriptor.Get;
			_set = descriptor.Set;
		}

		internal void SetGet(JsValue getter)
		{
			_get = getter;
		}

		internal void SetSet(JsValue setter)
		{
			_set = setter;
		}
	}
	[DebuggerDisplay("Value: {Value}, Flags: {Flags}")]
	public class PropertyDescriptor
	{
		private sealed class UndefinedPropertyDescriptor : PropertyDescriptor
		{
			protected internal override JsValue? CustomValue
			{
				set
				{
					ExceptionHelper.ThrowInvalidOperationException("making changes to undefined property's descriptor is not allowed");
				}
			}

			public UndefinedPropertyDescriptor()
				: base(PropertyFlag.CustomJsValue)
			{
			}
		}

		internal sealed class AllForbiddenDescriptor : PropertyDescriptor
		{
			private static readonly PropertyDescriptor[] _cache;

			public static readonly AllForbiddenDescriptor NumberZero;

			public static readonly AllForbiddenDescriptor NumberOne;

			public static readonly AllForbiddenDescriptor BooleanFalse;

			public static readonly AllForbiddenDescriptor BooleanTrue;

			static AllForbiddenDescriptor()
			{
				NumberZero = new AllForbiddenDescriptor(JsNumber.Create(0));
				NumberOne = new AllForbiddenDescriptor(JsNumber.Create(1));
				BooleanFalse = new AllForbiddenDescriptor(JsBoolean.False);
				BooleanTrue = new AllForbiddenDescriptor(JsBoolean.True);
				_cache = new PropertyDescriptor[10];
				for (int i = 0; i < _cache.Length; i++)
				{
					_cache[i] = new AllForbiddenDescriptor(JsNumber.Create(i));
				}
			}

			private AllForbiddenDescriptor(JsValue value)
				: base(PropertyFlag.AllForbidden)
			{
				_value = value;
			}

			public static PropertyDescriptor ForNumber(int number)
			{
				PropertyDescriptor[] cache = _cache;
				if ((uint)number >= cache.Length)
				{
					return new PropertyDescriptor(number, PropertyFlag.AllForbidden);
				}
				return cache[number];
			}
		}

		public static readonly PropertyDescriptor Undefined = new UndefinedPropertyDescriptor();

		internal PropertyFlag _flags;

		internal JsValue? _value;

		public virtual JsValue? Get => null;

		public virtual JsValue? Set => null;

		public bool Enumerable
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_flags & PropertyFlag.Enumerable) != 0;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				_flags |= PropertyFlag.EnumerableSet;
				if (value)
				{
					_flags |= PropertyFlag.Enumerable;
				}
				else
				{
					_flags &= ~PropertyFlag.Enumerable;
				}
			}
		}

		public bool EnumerableSet
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_flags & (PropertyFlag.Enumerable | PropertyFlag.EnumerableSet)) != 0;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set
			{
				if (value)
				{
					_flags |= PropertyFlag.EnumerableSet;
				}
				else
				{
					_flags &= ~PropertyFlag.EnumerableSet;
				}
			}
		}

		public bool Writable
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_flags & PropertyFlag.Writable) != 0;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				_flags |= PropertyFlag.WritableSet;
				if (value)
				{
					_flags |= PropertyFlag.Writable;
				}
				else
				{
					_flags &= ~PropertyFlag.Writable;
				}
			}
		}

		public bool WritableSet
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_flags & (PropertyFlag.Writable | PropertyFlag.WritableSet)) != 0;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set
			{
				if (value)
				{
					_flags |= PropertyFlag.WritableSet;
				}
				else
				{
					_flags &= ~PropertyFlag.WritableSet;
				}
			}
		}

		public bool Configurable
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_flags & PropertyFlag.Configurable) != 0;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				_flags |= PropertyFlag.ConfigurableSet;
				if (value)
				{
					_flags |= PropertyFlag.Configurable;
				}
				else
				{
					_flags &= ~PropertyFlag.Configurable;
				}
			}
		}

		public bool ConfigurableSet
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_flags & (PropertyFlag.Configurable | PropertyFlag.ConfigurableSet)) != 0;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private set
			{
				if (value)
				{
					_flags |= PropertyFlag.ConfigurableSet;
				}
				else
				{
					_flags &= ~PropertyFlag.ConfigurableSet;
				}
			}
		}

		public JsValue Value
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if ((_flags & PropertyFlag.CustomJsValue) != PropertyFlag.None)
				{
					return CustomValue;
				}
				return _value;
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				if ((_flags & PropertyFlag.CustomJsValue) != PropertyFlag.None)
				{
					CustomValue = value;
				}
				_value = value;
			}
		}

		protected internal virtual JsValue? CustomValue
		{
			get
			{
				return null;
			}
			set
			{
				ExceptionHelper.ThrowNotImplementedException();
			}
		}

		internal PropertyFlag Flags
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _flags;
			}
		}

		public PropertyDescriptor()
			: this(PropertyFlag.None)
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected PropertyDescriptor(PropertyFlag flags)
		{
			_flags = flags & ~PropertyFlag.NonData;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected internal PropertyDescriptor(JsValue? value, PropertyFlag flags)
			: this(flags)
		{
			if ((_flags & PropertyFlag.CustomJsValue) != PropertyFlag.None)
			{
				CustomValue = value;
			}
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public PropertyDescriptor(JsValue? value, bool? writable, bool? enumerable, bool? configurable)
		{
			if ((_flags & PropertyFlag.CustomJsValue) != PropertyFlag.None)
			{
				CustomValue = value;
			}
			_value = value;
			if (writable.HasValue)
			{
				Writable = writable.Value;
				WritableSet = true;
			}
			if (enumerable.HasValue)
			{
				Enumerable = enumerable.Value;
				EnumerableSet = true;
			}
			if (configurable.HasValue)
			{
				Configurable = configurable.Value;
				ConfigurableSet = true;
			}
		}

		public PropertyDescriptor(PropertyDescriptor descriptor)
		{
			Value = descriptor.Value;
			Enumerable = descriptor.Enumerable;
			EnumerableSet = descriptor.EnumerableSet;
			Configurable = descriptor.Configurable;
			ConfigurableSet = descriptor.ConfigurableSet;
			Writable = descriptor.Writable;
			WritableSet = descriptor.WritableSet;
		}

		public static PropertyDescriptor ToPropertyDescriptor(Realm realm, JsValue o)
		{
			if (!(o is ObjectInstance objectInstance))
			{
				ExceptionHelper.ThrowTypeError(realm);
				return null;
			}
			bool? flag = null;
			bool flag2 = objectInstance.HasProperty(CommonProperties.Enumerable);
			if (flag2)
			{
				flag = TypeConverter.ToBoolean(objectInstance.Get(CommonProperties.Enumerable));
			}
			bool? flag3 = null;
			bool num = objectInstance.HasProperty(CommonProperties.Configurable);
			if (num)
			{
				flag3 = TypeConverter.ToBoolean(objectInstance.Get(CommonProperties.Configurable));
			}
			JsValue value = null;
			bool flag4 = objectInstance.HasProperty(CommonProperties.Value);
			if (flag4)
			{
				value = objectInstance.Get(CommonProperties.Value);
			}
			bool? flag5 = null;
			bool flag6 = objectInstance.HasProperty(CommonProperties.Writable);
			if (flag6)
			{
				flag5 = TypeConverter.ToBoolean(objectInstance.Get(CommonProperties.Writable));
			}
			JsValue jsValue = null;
			bool flag7 = objectInstance.HasProperty(CommonProperties.Get);
			if (flag7)
			{
				jsValue = objectInstance.Get(CommonProperties.Get);
			}
			JsValue jsValue2 = null;
			bool flag8 = objectInstance.HasProperty(CommonProperties.Set);
			if (flag8)
			{
				jsValue2 = objectInstance.Get(CommonProperties.Set);
			}
			if ((flag4 || flag6) && (flag7 || flag8))
			{
				ExceptionHelper.ThrowTypeError(realm, "Invalid property descriptor. Cannot both specify accessors and a value or writable attribute");
			}
			PropertyDescriptor propertyDescriptor = ((flag7 || flag8) ? new GetSetPropertyDescriptor(null, null, PropertyFlag.None) : new PropertyDescriptor(PropertyFlag.None));
			if (flag2)
			{
				propertyDescriptor.Enumerable = flag.Value;
				propertyDescriptor.EnumerableSet = true;
			}
			if (num)
			{
				propertyDescriptor.Configurable = flag3.Value;
				propertyDescriptor.ConfigurableSet = true;
			}
			if (flag4)
			{
				propertyDescriptor.Value = value;
			}
			if (flag6)
			{
				propertyDescriptor.Writable = TypeConverter.ToBoolean(flag5.Value);
				propertyDescriptor.WritableSet = true;
			}
			if (flag7)
			{
				if (!jsValue.IsUndefined() && jsValue.TryCast<ICallable>() == null)
				{
					ExceptionHelper.ThrowTypeError(realm);
				}
				((GetSetPropertyDescriptor)propertyDescriptor).SetGet(jsValue);
			}
			if (flag8)
			{
				if (!jsValue2.IsUndefined() && jsValue2.TryCast<ICallable>() == null)
				{
					ExceptionHelper.ThrowTypeError(realm);
				}
				((GetSetPropertyDescriptor)propertyDescriptor).SetSet(jsValue2);
			}
			if ((flag8 || flag7) && (flag4 || flag6))
			{
				ExceptionHelper.ThrowTypeError(realm);
			}
			return propertyDescriptor;
		}

		public static JsValue FromPropertyDescriptor(Engine engine, PropertyDescriptor desc, bool strictUndefined = false)
		{
			if (desc == Undefined)
			{
				return JsValue.Undefined;
			}
			ObjectInstance objectInstance = engine.Realm.Intrinsics.Object.Construct(Arguments.Empty);
			PropertyDictionary propertyDictionary = new PropertyDictionary(4, checkExistingKeys: false);
			if (desc.IsDataDescriptor())
			{
				propertyDictionary["value"] = new PropertyDescriptor(desc.Value ?? JsValue.Undefined, PropertyFlag.ConfigurableEnumerableWritable);
				if (desc._flags != PropertyFlag.None || desc.WritableSet)
				{
					propertyDictionary["writable"] = new PropertyDescriptor(desc.Writable, PropertyFlag.ConfigurableEnumerableWritable);
				}
			}
			else
			{
				propertyDictionary["get"] = new PropertyDescriptor(desc.Get ?? JsValue.Undefined, PropertyFlag.ConfigurableEnumerableWritable);
				propertyDictionary["set"] = new PropertyDescriptor(desc.Set ?? JsValue.Undefined, PropertyFlag.ConfigurableEnumerableWritable);
			}
			if (!strictUndefined || desc.EnumerableSet)
			{
				propertyDictionary["enumerable"] = new PropertyDescriptor(desc.Enumerable, PropertyFlag.ConfigurableEnumerableWritable);
			}
			if (!strictUndefined || desc.ConfigurableSet)
			{
				propertyDictionary["configurable"] = new PropertyDescriptor(desc.Configurable, PropertyFlag.ConfigurableEnumerableWritable);
			}
			objectInstance.SetProperties(propertyDictionary);
			return objectInstance;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsAccessorDescriptor()
		{
			if ((object)Get == null)
			{
				return (object)Set != null;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsDataDescriptor()
		{
			if (_flags.HasFlag(PropertyFlag.NonData))
			{
				return false;
			}
			if ((_flags & (PropertyFlag.Writable | PropertyFlag.WritableSet)) == 0 && ((_flags & PropertyFlag.CustomJsValue) == 0 || (object)CustomValue == null))
			{
				return (object)_value != null;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsGenericDescriptor()
		{
			if (!IsDataDescriptor())
			{
				return !IsAccessorDescriptor();
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool TryGetValue(ObjectInstance thisArg, out JsValue value)
		{
			value = JsValue.Undefined;
			if ((_flags & (PropertyFlag.Writable | PropertyFlag.WritableSet)) != PropertyFlag.None)
			{
				JsValue jsValue = (((_flags & PropertyFlag.CustomJsValue) != PropertyFlag.None) ? CustomValue : _value);
				if ((object)jsValue != null)
				{
					value = jsValue;
					return true;
				}
			}
			if (this == Undefined)
			{
				return false;
			}
			JsValue get = Get;
			if ((object)get != null && !get.IsUndefined())
			{
				ICallable callable = (ICallable)get;
				value = callable.Call(thisArg, Arguments.Empty);
			}
			return true;
		}
	}
	[Flags]
	public enum PropertyFlag
	{
		None = 0,
		Enumerable = 1,
		EnumerableSet = 2,
		Writable = 4,
		WritableSet = 8,
		Configurable = 0x10,
		ConfigurableSet = 0x20,
		CustomJsValue = 0x100,
		MutableBinding = 0x200,
		NonData = 0x400,
		AllForbidden = 0x2A,
		ConfigurableEnumerableWritable = 0x15,
		NonConfigurable = 0x25,
		OnlyEnumerable = 0x29,
		NonEnumerable = 0x16,
		OnlyWritable = 0x26
	}
}
namespace Jint.Runtime.Descriptors.Specialized
{
	internal sealed class ClrAccessDescriptor : PropertyDescriptor
	{
		private readonly DeclarativeEnvironment _env;

		private readonly Engine _engine;

		private readonly Jint.Runtime.Environments.Environment.BindingName _name;

		private GetterFunction? _get;

		private SetterFunction? _set;

		public override JsValue Get => _get ?? (_get = new GetterFunction(_engine, DoGet));

		public override JsValue Set => _set ?? (_set = new SetterFunction(_engine, DoSet));

		public ClrAccessDescriptor(DeclarativeEnvironment env, Engine engine, string name)
			: base(null, PropertyFlag.Configurable)
		{
			_flags |= PropertyFlag.NonData;
			_env = env;
			_engine = engine;
			_name = new Jint.Runtime.Environments.Environment.BindingName(name);
		}

		private JsValue DoGet(JsValue n)
		{
			if (!_env.TryGetBinding(_name, out JsValue value))
			{
				return JsValue.Undefined;
			}
			return value;
		}

		private void DoSet(JsValue n, JsValue o)
		{
			_env.SetMutableBinding(_name.Key, o, strict: true);
		}
	}
	internal sealed class LazyPropertyDescriptor : PropertyDescriptor
	{
		private readonly object? _state;

		private readonly Func<object?, JsValue> _resolver;

		protected internal override JsValue? CustomValue
		{
			get
			{
				return _value ?? (_value = _resolver(_state));
			}
			set
			{
				_value = value;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal LazyPropertyDescriptor(object? state, Func<object?, JsValue> resolver, PropertyFlag flags)
			: base(null, flags | PropertyFlag.CustomJsValue)
		{
			_flags &= ~PropertyFlag.NonData;
			_state = state;
			_resolver = resolver;
		}
	}
	internal sealed class ReflectionDescriptor : PropertyDescriptor
	{
		private readonly Engine _engine;

		private readonly ReflectionAccessor _reflectionAccessor;

		private readonly object _target;

		private readonly string _propertyName;

		private JsValue? _get;

		private JsValue? _set;

		public override JsValue? Get
		{
			get
			{
				if (_reflectionAccessor.Readable)
				{
					return _get ?? (_get = new GetterFunction(_engine, DoGet));
				}
				return null;
			}
		}

		public override JsValue? Set
		{
			get
			{
				if (_reflectionAccessor.Writable && _engine.Options.Interop.AllowWrite)
				{
					return _set ?? (_set = new SetterFunction(_engine, DoSet));
				}
				return null;
			}
		}

		protected internal override JsValue? CustomValue
		{
			get
			{
				return DoGet(null);
			}
			set
			{
				DoSet(null, value);
			}
		}

		public ReflectionDescriptor(Engine engine, ReflectionAccessor reflectionAccessor, object target, string propertyName, bool enumerable)
			: base((PropertyFlag)((enumerable ? 1 : 0) | 0x100))
		{
			_flags |= PropertyFlag.NonData;
			_engine = engine;
			_reflectionAccessor = reflectionAccessor;
			_target = target;
			_propertyName = propertyName;
		}

		private JsValue DoGet(JsValue? thisObj)
		{
			object value = _reflectionAccessor.GetValue(_engine, _target, _propertyName);
			Type memberType = _reflectionAccessor.MemberType;
			return JsValue.FromObjectWithType(_engine, value, memberType);
		}

		private void DoSet(JsValue? thisObj, JsValue? v)
		{
			try
			{
				_reflectionAccessor.SetValue(_engine, _target, _propertyName, v);
			}
			catch (TargetInvocationException exception)
			{
				ExceptionHelper.ThrowMeaningfulException(_engine, exception);
			}
		}
	}
}
namespace Jint.Runtime.Debugger
{
	public sealed record BreakLocation
	{
		public string? Source { get; }

		public int Line { get; }

		public int Column { get; }

		public BreakLocation(string? source, int line, int column)
		{
			Source = source;
			Line = line;
			Column = column;
		}

		public BreakLocation(int line, int column)
			: this(null, line, column)
		{
		}

		public BreakLocation(string? source, Position position)
			: this(source, position.Line, position.Column)
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)

	}
	public class BreakPoint
	{
		public BreakLocation Location { get; }

		public string? Condition { get; }

		public BreakPoint(string? source, int line, int column, string? condition = null)
		{
			Location = new BreakLocation(source, line, column);
			Condition = condition;
		}

		public BreakPoint(int line, int column, string? condition = null)
			: this(null, line, column, condition)
		{
		}
	}
	public sealed class BreakPointCollection : IEnumerable<BreakPoint>, IEnumerable
	{
		private readonly Dictionary<BreakLocation, BreakPoint> _breakPoints = new Dictionary<BreakLocation, BreakPoint>(new OptionalSourceBreakLocationEqualityComparer());

		public bool Active { get; set; } = true;

		public int Count => _breakPoints.Count;

		public void Set(BreakPoint breakPoint)
		{
			_breakPoints[breakPoint.Location] = breakPoint;
		}

		public bool RemoveAt(BreakLocation location)
		{
			return _breakPoints.Remove(location);
		}

		public bool Contains(BreakLocation location)
		{
			return _breakPoints.ContainsKey(location);
		}

		public void Clear()
		{
			_breakPoints.Clear();
		}

		internal BreakPoint? FindMatch(DebugHandler debugger, BreakLocation location)
		{
			if (!Active)
			{
				return null;
			}
			if (!_breakPoints.TryGetValue(location, out BreakPoint value))
			{
				return null;
			}
			if (!string.IsNullOrEmpty(value.Condition))
			{
				try
				{
					if (!TypeConverter.ToBoolean(debugger.Evaluate(value.Condition)))
					{
						return null;
					}
				}
				catch (Exception ex) when (ex is JavaScriptException || ex is DebugEvaluationException)
				{
					return null;
				}
			}
			return value;
		}

		public IEnumerator<BreakPoint> GetEnumerator()
		{
			return _breakPoints.Values.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _breakPoints.GetEnumerator();
		}
	}
	public sealed class CallFrame
	{
		private readonly CallStackExecutionContext _context;

		private readonly CallStackElement? _element;

		private readonly Lazy<DebugScopes> _scopeChain;

		private Jint.Runtime.Environments.Environment Environment => _context.LexicalEnvironment;

		public string FunctionName => _element?.ToString() ?? "(anonymous)";

		public Location? FunctionLocation
		{
			get
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				IFunction obj = _element?.Function._functionDefinition?.Function;
				return ((SyntaxElement)(((obj is Node) ? obj : null)?)).Location;
			}
		}

		public Location Location { get; }

		public DebugScopes ScopeChain => _scopeChain.Value;

		public JsValue This => _context.GetThisEnvironment().GetThisBinding();

		public JsValue? ReturnValue { get; }

		internal CallFrame(CallStackElement? element, in CallStackExecutionContext context, in Location location, JsValue? returnValue)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			_element = element;
			_context = context;
			Location = location;
			ReturnValue = returnValue;
			_scopeChain = new Lazy<DebugScopes>(() => new DebugScopes(Environment));
		}
	}
	public sealed class DebugCallStack : IReadOnlyList<CallFrame>, IEnumerable<CallFrame>, IEnumerable, IReadOnlyCollection<CallFrame>
	{
		private readonly List<CallFrame> _stack;

		public CallFrame this[int index] => _stack[index];

		public int Count => _stack.Count;

		internal DebugCallStack(Engine engine, Location location, JintCallStack callStack, JsValue? returnValue)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			_stack = new List<CallFrame>(callStack.Count + 1);
			CallStackExecutionContext context = new CallStackExecutionContext(in engine.ExecutionContext);
			foreach (CallStackElement item in callStack.Stack)
			{
				_stack.Add(new CallFrame(item, in context, in location, returnValue));
				location = item.Location;
				returnValue = null;
				context = item.CallingExecutionContext;
			}
			_stack.Add(new CallFrame(null, in context, in location, null));
		}

		public IEnumerator<CallFrame> GetEnumerator()
		{
			return _stack.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public sealed class DebugEvaluationException : JintException
	{
		public DebugEvaluationException(string message)
			: base(message)
		{
		}

		public DebugEvaluationException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	public enum DebuggerStatementHandling
	{
		Ignore,
		Clr,
		Script
	}
	public enum PauseType
	{
		Skip,
		Step,
		Break,
		DebuggerStatement
	}
	public class DebugHandler
	{
		public delegate void BeforeEvaluateEventHandler(object sender, Program ast);

		public delegate StepMode DebugEventHandler(object sender, DebugInformation e);

		private readonly Engine _engine;

		private bool _paused;

		private int _steppingDepth;

		private bool IsStepping => _engine.CallStack.Count <= _steppingDepth;

		public Location? CurrentLocation { get; private set; }

		public BreakPointCollection BreakPoints { get; } = new BreakPointCollection();

		public event BeforeEvaluateEventHandler? BeforeEvaluate;

		public event DebugEventHandler? Step;

		public event DebugEventHandler? Break;

		public event DebugEventHandler? Skip;

		internal DebugHandler(Engine engine, StepMode initialStepMode)
		{
			_engine = engine;
			HandleNewStepMode(initialStepMode);
		}

		public JsValue Evaluate(in Prepared<Script> preparedScript)
		{
			if (!preparedScript.IsValid)
			{
				ExceptionHelper.ThrowInvalidPreparedScriptArgumentException("preparedScript");
			}
			EvaluationContext activeEvaluationContext = _engine._activeEvaluationContext;
			if (activeEvaluationContext == null)
			{
				throw new DebugEvaluationException("Jint has no active evaluation context");
			}
			int count = _engine.CallStack.Count;
			JintStatementList jintStatementList = new JintStatementList(null, ((Program)preparedScript.Program).Body);
			Completion completion;
			try
			{
				completion = jintStatementList.Execute(activeEvaluationContext);
			}
			catch (Exception innerException)
			{
				throw new DebugEvaluationException("An error occurred during debugger evaluation", innerException);
			}
			finally
			{
				while (_engine.CallStack.Count > count)
				{
					_engine.CallStack.Pop();
				}
			}
			if (completion.Type == CompletionType.Throw)
			{
				JavaScriptException innerException2 = new JavaScriptException(completion.GetValueOrDefault()).SetJavaScriptCallstack(_engine, in completion.Location);
				throw new DebugEvaluationException("An error occurred during debugger evaluation", innerException2);
			}
			return completion.GetValueOrDefault();
		}

		public JsValue Evaluate(string sourceText, ScriptParsingOptions? parsingOptions = null)
		{
			//IL_004d: Expected O, but got Unknown
			ParserOptions parserOptions = parsingOptions?.GetParserOptions() ?? _engine.GetActiveParserOptions();
			JavaScriptParser parserFor = _engine.GetParserFor(parserOptions);
			try
			{
				Script program = parserFor.ParseScript(sourceText, "evaluation", false);
				return Evaluate(new Prepared<Script>(program, parserOptions));
			}
			catch (ParserException ex)
			{
				ParserException innerException = ex;
				throw new DebugEvaluationException("An error occurred during debugger expression parsing", (Exception)(object)innerException);
			}
		}

		internal void OnBeforeEvaluate(Program ast)
		{
			if (ast != null)
			{
				this.BeforeEvaluate?.Invoke(_engine, ast);
			}
		}

		internal void OnStep(Node node)
		{
			if (!_paused)
			{
				_paused = true;
				CheckBreakPointAndPause(node, in ((SyntaxElement)node).Location);
			}
		}

		internal void OnReturnPoint(Node functionBody, JsValue returnValue)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!_paused)
			{
				_paused = true;
				Location location = ((SyntaxElement)functionBody).Location;
				Position end = location.End;
				CheckBreakPointAndPause(null, Location.From(end, end, location.Source), returnValue);
			}
		}

		private void CheckBreakPointAndPause(Node? node, in Location location, JsValue? returnValue = null)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			CurrentLocation = location;
			BreakLocation location2 = new BreakLocation(location.Source, location.Start);
			BreakPoint breakPoint = BreakPoints.FindMatch(this, location2);
			PauseType type = (IsStepping ? PauseType.Step : ((breakPoint != null) ? PauseType.Break : ((node != null && (int)node.Type == 18 && _engine.Options.Debugger.StatementHandling == DebuggerStatementHandling.Script) ? PauseType.DebuggerStatement : PauseType.Skip)));
			Pause(type, node, in location, returnValue, breakPoint);
			_paused = false;
		}

		private void Pause(PauseType type, Node? node, in Location location, JsValue? returnValue = null, BreakPoint? breakPoint = null)
		{
			DebugInformation e = new DebugInformation(_engine, node, in location, returnValue, _engine.CurrentMemoryUsage, type, breakPoint);
			HandleNewStepMode(type switch
			{
				PauseType.Skip => this.Skip?.Invoke(_engine, e), 
				PauseType.Step => this.Step?.Invoke(_engine, e), 
				PauseType.Break => this.Break?.Invoke(_engine, e), 
				PauseType.DebuggerStatement => this.Break?.Invoke(_engine, e), 
				_ => throw new ArgumentException("Invalid pause type", "type"), 
			});
		}

		private void HandleNewStepMode(StepMode? newStepMode)
		{
			if (newStepMode.HasValue)
			{
				_steppingDepth = newStepMode switch
				{
					StepMode.Over => _engine.CallStack.Count, 
					StepMode.Out => _engine.CallStack.Count - 1, 
					StepMode.None => int.MinValue, 
					_ => int.MaxValue, 
				};
			}
		}
	}
	public sealed class DebugInformation : EventArgs
	{
		private readonly Engine _engine;

		private readonly Location _currentLocation;

		private readonly JsValue? _returnValue;

		private DebugCallStack? _callStack;

		public PauseType PauseType { get; }

		public BreakPoint? BreakPoint { get; }

		public DebugCallStack CallStack => _callStack ?? (_callStack = new DebugCallStack(_engine, _currentLocation, _engine.CallStack, _returnValue));

		public Node? CurrentNode { get; }

		public Location Location => CurrentCallFrame.Location;

		public long CurrentMemoryUsage { get; }

		public CallFrame CurrentCallFrame => CallStack[0];

		public DebugScopes CurrentScopeChain => CurrentCallFrame.ScopeChain;

		public JsValue? ReturnValue => CurrentCallFrame.ReturnValue;

		internal DebugInformation(Engine engine, Node? currentNode, in Location currentLocation, JsValue? returnValue, long currentMemoryUsage, PauseType pauseType, BreakPoint? breakPoint)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			_engine = engine;
			CurrentNode = currentNode;
			_currentLocation = currentLocation;
			_returnValue = returnValue;
			CurrentMemoryUsage = currentMemoryUsage;
			PauseType = pauseType;
			BreakPoint = breakPoint;
		}
	}
	public sealed class DebugScope
	{
		private readonly Jint.Runtime.Environments.Environment _record;

		private string[]? _bindingNames;

		public DebugScopeType ScopeType { get; }

		public bool IsTopLevel { get; }

		public IReadOnlyList<string> BindingNames => _bindingNames ?? (_bindingNames = _record.GetAllBindingNames());

		public ObjectInstance? BindingObject { get; }

		internal DebugScope(DebugScopeType type, Jint.Runtime.Environments.Environment record, bool isTopLevel)
		{
			ScopeType = type;
			_record = record;
			BindingObject = ((record is ObjectEnvironment objectEnvironment) ? objectEnvironment._bindingObject : null);
			IsTopLevel = isTopLevel;
		}

		public JsValue? GetBindingValue(string name)
		{
			_record.TryGetBinding(new Jint.Runtime.Environments.Environment.BindingName(name), out JsValue value);
			return value;
		}

		public void SetBindingValue(string name, JsValue value)
		{
			_record.SetMutableBinding(name, value, strict: true);
		}
	}
	public sealed class DebugScopes : IReadOnlyList<DebugScope>, IEnumerable<DebugScope>, IEnumerable, IReadOnlyCollection<DebugScope>
	{
		private readonly List<DebugScope> _scopes = new List<DebugScope>();

		public DebugScope this[int index] => _scopes[index];

		public int Count => _scopes.Count;

		internal DebugScopes(Jint.Runtime.Environments.Environment environment)
		{
			Populate(environment);
		}

		private void Populate(Jint.Runtime.Environments.Environment? environment)
		{
			bool flag = true;
			while ((object)environment != null)
			{
				Jint.Runtime.Environments.Environment environment2 = environment;
				if (!(environment2 is GlobalEnvironment globalEnvironment))
				{
					if (!(environment2 is FunctionEnvironment))
					{
						if (!(environment2 is ObjectEnvironment))
						{
							if (!(environment2 is ModuleEnvironment))
							{
								if (environment2 is DeclarativeEnvironment declarativeEnvironment)
								{
									if (declarativeEnvironment._catchEnvironment)
									{
										AddScope(DebugScopeType.Catch, environment2);
									}
									else
									{
										bool isTopLevel = environment._outerEnv is FunctionEnvironment;
										AddScope(DebugScopeType.Block, environment2, isTopLevel);
									}
								}
							}
							else
							{
								AddScope(DebugScopeType.Module, environment2);
							}
						}
						else
						{
							AddScope(DebugScopeType.With, environment2);
						}
					}
					else
					{
						AddScope(flag ? DebugScopeType.Local : DebugScopeType.Closure, environment2);
						flag = false;
					}
				}
				else
				{
					AddScope(DebugScopeType.Script, globalEnvironment._declarativeRecord);
					AddScope(DebugScopeType.Global, new ObjectEnvironment(environment._engine, globalEnvironment._global, provideThis: false, withEnvironment: false));
				}
				environment = environment._outerEnv;
			}
		}

		private void AddScope(DebugScopeType type, Jint.Runtime.Environments.Environment record, bool isTopLevel = false)
		{
			if (record.HasBindings())
			{
				DebugScope item = new DebugScope(type, record, isTopLevel);
				_scopes.Add(item);
			}
		}

		public IEnumerator<DebugScope> GetEnumerator()
		{
			return _scopes.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return _scopes.GetEnumerator();
		}
	}
	public enum DebugScopeType
	{
		Global,
		Script,
		Local,
		Block,
		Catch,
		Closure,
		With,
		Eval,
		Module,
		WasmExpressionStack
	}
	internal sealed class OptionalSourceBreakLocationEqualityComparer : IEqualityComparer<BreakLocation>
	{
		public bool Equals(BreakLocation? x, BreakLocation? y)
		{
			if ((object)x == y)
			{
				return true;
			}
			if ((object)x == null || (object)y == null)
			{
				return false;
			}
			if (x.Line == y.Line && x.Column == y.Column)
			{
				if (x.Source != null && y.Source != null)
				{
					return string.Equals(x.Source, y.Source, StringComparison.Ordinal);
				}
				return true;
			}
			return false;
		}

		public int GetHashCode(BreakLocation? obj)
		{
			if (obj == null)
			{
				return 0;
			}
			return (17 * 33 + obj.Line.GetHashCode()) * 33 + obj.Column.GetHashCode();
		}
	}
	public enum StepMode
	{
		None,
		Over,
		Into,
		Out
	}
}
namespace Jint.Runtime.CallStack
{
	internal readonly struct CallStackElement : IEquatable<CallStackElement>
	{
		public readonly Function Function;

		public readonly JintExpression? Expression;

		public readonly CallStackExecutionContext CallingExecutionContext;

		public Location Location
		{
			get
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				Location? val = ((SyntaxElement)Expression?._expression).Location;
				if (val.HasValue)
				{
					Location value = val.Value;
					Location val2 = default(Location);
					if ((ref value) != (ref val2))
					{
						return val.Value;
					}
				}
				Node val3 = (Node)(Function._functionDefinition?.Function);
				if ((int)val3 == 0)
				{
					return default(Location);
				}
				return ((SyntaxElement)val3).Location;
			}
		}

		public unsafe NodeList<Node>? Arguments
		{
			get
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				JintFunctionDefinition functionDefinition = Function._functionDefinition;
				if (functionDefinition == null)
				{
					return null;
				}
				return Unsafe.Read<NodeList<Node>>((void*)functionDefinition.Function.Params);
			}
		}

		public CallStackElement(Function function, JintExpression? expression, in CallStackExecutionContext callingExecutionContext)
		{
			Function = function;
			Expression = expression;
			CallingExecutionContext = callingExecutionContext;
		}

		public override string ToString()
		{
			string text = TypeConverter.ToString(Function.Get(CommonProperties.Name));
			if (string.IsNullOrWhiteSpace(text) && Expression != null)
			{
				text = JintExpression.ToString(Expression._expression);
			}
			return text ?? "(anonymous)";
		}

		public bool Equals(CallStackElement other)
		{
			if (Function.Equals(other.Function))
			{
				return object.Equals(Expression, other.Expression);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (Function.GetHashCode() * 397) ^ ((Expression != null) ? Expression.GetHashCode() : 0);
		}
	}
	internal sealed class CallStackElementComparer : IEqualityComparer<CallStackElement>
	{
		public static readonly CallStackElementComparer Instance = new CallStackElementComparer();

		private CallStackElementComparer()
		{
		}

		public bool Equals(CallStackElement x, CallStackElement y)
		{
			if (x.Function._functionDefinition != null)
			{
				return x.Function._functionDefinition == y.Function._functionDefinition;
			}
			return (object)x.Function == y.Function;
		}

		public int GetHashCode(CallStackElement obj)
		{
			if (obj.Function._functionDefinition != null)
			{
				return obj.Function._functionDefinition.GetHashCode();
			}
			return obj.Function.GetHashCode();
		}
	}
	internal readonly record struct CallStackExecutionContext
	{
		internal readonly Jint.Runtime.Environments.Environment LexicalEnvironment;

		public CallStackExecutionContext(in Jint.Runtime.Environments.ExecutionContext context)
		{
			LexicalEnvironment = context.LexicalEnvironment;
		}

		internal Jint.Runtime.Environments.Environment GetThisEnvironment()
		{
			Jint.Runtime.Environments.Environment environment = LexicalEnvironment;
			while (true)
			{
				if ((object)environment != null)
				{
					if (environment.HasThisBinding())
					{
						break;
					}
					environment = environment._outerEnv;
				}
			}
			return environment;
		}

		[CompilerGenerated]
		private bool PrintMembers(StringBuilder builder)
		{
			return false;
		}
	}
	internal sealed class JintCallStack
	{
		private readonly RefStack<CallStackElement> _stack = new RefStack<CallStackElement>();

		private readonly Dictionary<CallStackElement, int>? _statistics;

		internal RefStack<CallStackElement> Stack => _stack;

		public int Count => _stack._size;

		public JintCallStack(bool trackRecursionDepth)
		{
			if (trackRecursionDepth)
			{
				_statistics = new Dictionary<CallStackElement, int>(CallStackElementComparer.Instance);
			}
		}

		public int Push(Function function, JintExpression? expression, in Jint.Runtime.Environments.ExecutionContext executionContext)
		{
			CallStackElement item = new CallStackElement(function, expression, new CallStackExecutionContext(in executionContext));
			_stack.Push(in item);
			if (_statistics != null)
			{
				if (_statistics.ContainsKey(item))
				{
					return ++_statistics[item];
				}
				_statistics.Add(item, 0);
				return 0;
			}
			return -1;
		}

		public CallStackElement Pop()
		{
			ref readonly CallStackElement reference = ref _stack.Pop();
			if (_statistics != null)
			{
				if (_statistics[reference] == 0)
				{
					_statistics.Remove(reference);
				}
				else
				{
					_statistics[reference]--;
				}
			}
			return reference;
		}

		public bool TryPeek([NotNullWhen(true)] out CallStackElement item)
		{
			return _stack.TryPeek(out item);
		}

		public void Clear()
		{
			_stack.Clear();
			_statistics?.Clear();
		}

		public override string ToString()
		{
			return string.Join("->", _stack.Select((CallStackElement cse) => cse.ToString()).Reverse());
		}

		internal string BuildCallStackString(Location location, int excludeTop = 0)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			System.Text.ValueStringBuilder sb = default(System.Text.ValueStringBuilder);
			int num = _stack._size - 1 - excludeTop;
			CallStackElement? element = ((num >= 0) ? new CallStackElement?(_stack[num]) : ((CallStackElement?)null));
			string shortDescription = element?.ToString() ?? "";
			AppendLocation(ref sb, shortDescription, in location, in element);
			location = (Location)(((??)element?.Location) ?? default(Location));
			for (num--; num >= -1; num--)
			{
				element = ((num >= 0) ? new CallStackElement?(_stack[num]) : ((CallStackElement?)null));
				shortDescription = element?.ToString() ?? "";
				AppendLocation(ref sb, shortDescription, in location, in element);
				location = (Location)(((??)element?.Location) ?? default(Location));
			}
			string result = sb.AsSpan().TrimEnd().ToString();
			sb.Dispose();
			return result;
			static void AppendLocation(ref System.Text.ValueStringBuilder reference, string text, in Location loc, in CallStackElement? reference2)
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				reference.Append("   at");
				if (!string.IsNullOrWhiteSpace(text))
				{
					reference.Append(' ');
					reference.Append(text);
				}
				if ((reference2?.Arguments).HasValue)
				{
					reference.Append(" (");
					for (int i = 0; i < reference2.Value.Arguments.Value.Count; i++)
					{
						if (i != 0)
						{
							reference.Append(", ");
						}
						Node expression = reference2.Value.Arguments.Value[i];
						reference.Append(GetPropertyKey(expression));
					}
					reference.Append(')');
				}
				reference.Append(' ');
				reference.Append(loc.Source);
				reference.Append(':');
				reference.Append(loc.End.Line.ToString(CultureInfo.InvariantCulture));
				reference.Append(':');
				reference.Append((loc.Start.Column + 1).ToString(CultureInfo.InvariantCulture));
				reference.Append(System.Environment.NewLine);
			}
		}

		private static string GetPropertyKey(Node expression)
		{
			Literal val = (Literal)(object)((expression is Literal) ? expression : null);
			if (val != null)
			{
				return AstExtensions.LiteralKeyToString(val);
			}
			Identifier val2 = (Identifier)(object)((expression is Identifier) ? expression : null);
			if (val2 != null)
			{
				return val2.Name ?? "";
			}
			StaticMemberExpression val3 = (StaticMemberExpression)(object)((expression is StaticMemberExpression) ? expression : null);
			if (val3 != null)
			{
				return GetPropertyKey((Node)(object)((MemberExpression)val3).Object) + "." + GetPropertyKey((Node)(object)((MemberExpression)val3).Property);
			}
			return "?";
		}
	}
	internal sealed class StackGuard
	{
		public const int Disabled = -1;

		private readonly Engine _engine;

		public StackGuard(Engine engine)
		{
			_engine = engine;
		}

		public bool TryEnterOnCurrentStack()
		{
			if (_engine.Options.Constraints.MaxExecutionStackCount == -1)
			{
				return true;
			}
			if (RuntimeHelpers.TryEnsureSufficientExecutionStack())
			{
				return true;
			}
			if (_engine.CallStack.Count > _engine.Options.Constraints.MaxExecutionStackCount)
			{
				ExceptionHelper.ThrowRangeError(_engine.Realm, "Maximum call stack size exceeded");
			}
			return false;
		}

		public static TR RunOnEmptyStack<T1, TR>(Func<T1, TR> action, T1 arg1)
		{
			return RunOnEmptyStackCore(delegate(object s)
			{
				(Func<T1, TR>, T1) tuple = ((Func<T1, TR>, T1))s;
				return tuple.Item1(tuple.Item2);
			}, (action, arg1));
		}

		private static R RunOnEmptyStackCore<R>(Func<object, R> action, object state)
		{
			Task<R> task = Task.Factory.StartNew(action, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
			if (!task.IsCompleted)
			{
				((IAsyncResult)task).AsyncWaitHandle.WaitOne();
			}
			return task.GetAwaiter().GetResult();
		}
	}
}
namespace Jint.Pooling
{
	internal sealed class ArgumentsInstancePool
	{
		private const int PoolSize = 10;

		private readonly Engine _engine;

		private readonly ObjectPool<JsArguments> _pool;

		public ArgumentsInstancePool(Engine engine)
		{
			_engine = engine;
			_pool = new ObjectPool<JsArguments>(Factory, 10);
		}

		private JsArguments Factory()
		{
			return new JsArguments(_engine)
			{
				_prototype = _engine.Realm.Intrinsics.Object.PrototypeObject
			};
		}

		public JsArguments Rent(JsValue[] argumentsList)
		{
			return Rent(null, null, argumentsList, null, hasRestParameter: false);
		}

		public JsArguments Rent(Function? func, Key[]? formals, JsValue[] argumentsList, DeclarativeEnvironment? env, bool hasRestParameter)
		{
			JsArguments jsArguments = _pool.Allocate();
			jsArguments.Prepare(func, formals, argumentsList, env, hasRestParameter);
			return jsArguments;
		}

		public void Return(JsArguments instance)
		{
			if ((object)instance != null)
			{
				_pool.Free(instance);
			}
		}
	}
	internal sealed class ConcurrentObjectPool<T> where T : class
	{
		[DebuggerDisplay("{Value,nq}")]
		private struct Element
		{
			internal T Value;
		}

		internal delegate T Factory();

		private T _firstItem;

		private readonly Element[] _items;

		private readonly Factory _factory;

		internal ConcurrentObjectPool(Factory factory)
			: this(factory, System.Environment.ProcessorCount * 2)
		{
		}

		internal ConcurrentObjectPool(Factory factory, int size)
		{
			_factory = factory;
			_items = new Element[size - 1];
		}

		private T CreateInstance()
		{
			return _factory();
		}

		internal T Allocate()
		{
			T val = _firstItem;
			if (val == null || val != Interlocked.CompareExchange(ref _firstItem, null, val))
			{
				val = AllocateSlow();
			}
			return val;
		}

		private T AllocateSlow()
		{
			Element[] items = _items;
			for (int i = 0; i < items.Length; i++)
			{
				T value = items[i].Value;
				if (value != null && value == Interlocked.CompareExchange(ref items[i].Value, null, value))
				{
					return value;
				}
			}
			return CreateInstance();
		}

		internal void Free(T obj)
		{
			if (_firstItem == null)
			{
				_firstItem = obj;
			}
			else
			{
				FreeSlow(obj);
			}
		}

		private void FreeSlow(T obj)
		{
			Element[] items = _items;
			for (int i = 0; i < items.Length; i++)
			{
				if (items[i].Value == null)
				{
					items[i].Value = obj;
					break;
				}
			}
		}

		[Conditional("DEBUG")]
		internal void ForgetTrackedObject(T old, T replacement = null)
		{
		}

		[Conditional("DEBUG")]
		private void Validate(object obj)
		{
			Element[] items = _items;
			for (int i = 0; i < items.Length && items[i].Value != null; i++)
			{
			}
		}
	}
	internal sealed class JsValueArrayPool
	{
		private const int PoolSize = 15;

		private readonly ObjectPool<JsValue[]> _poolArray1;

		private readonly ObjectPool<JsValue[]> _poolArray2;

		private readonly ObjectPool<JsValue[]> _poolArray3;

		public JsValueArrayPool()
		{
			_poolArray1 = new ObjectPool<JsValue[]>(Factory1, 15);
			_poolArray2 = new ObjectPool<JsValue[]>(Factory2, 15);
			_poolArray3 = new ObjectPool<JsValue[]>(Factory3, 15);
		}

		private static JsValue[] Factory1()
		{
			return new JsValue[1];
		}

		private static JsValue[] Factory2()
		{
			return new JsValue[2];
		}

		private static JsValue[] Factory3()
		{
			return new JsValue[3];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public JsValue[] RentArray(int size)
		{
			return size switch
			{
				0 => Array.Empty<JsValue>(), 
				1 => _poolArray1.Allocate(), 
				2 => _poolArray2.Allocate(), 
				3 => _poolArray3.Allocate(), 
				_ => new JsValue[size], 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void ReturnArray(JsValue[] array)
		{
			if (array.Length == 1)
			{
				_poolArray1.Free(array);
			}
			else if (array.Length == 2)
			{
				_poolArray2.Free(array);
			}
			else if (array.Length == 3)
			{
				_poolArray3.Free(array);
			}
		}
	}
	internal sealed class ObjectPool<T> where T : class
	{
		[DebuggerDisplay("{Value,nq}")]
		private struct Element
		{
			internal T Value;
		}

		internal delegate T Factory();

		private T _firstItem;

		private readonly Element[] _items;

		private readonly Factory _factory;

		internal ObjectPool(Factory factory)
			: this(factory, System.Environment.ProcessorCount * 2)
		{
		}

		internal ObjectPool(Factory factory, int size)
		{
			_factory = factory;
			_items = new Element[size - 1];
		}

		private T CreateInstance()
		{
			return _factory();
		}

		internal T Allocate()
		{
			T firstItem = _firstItem;
			if (firstItem != null)
			{
				_firstItem = null;
				return firstItem;
			}
			return AllocateSlow();
		}

		private T AllocateSlow()
		{
			Element[] items = _items;
			for (int i = 0; i < items.Length; i++)
			{
				T value = items[i].Value;
				if (value != null)
				{
					items[i].Value = null;
					return value;
				}
			}
			return CreateInstance();
		}

		internal void Free(T obj)
		{
			if (_firstItem == null)
			{
				_firstItem = obj;
			}
			else
			{
				FreeSlow(obj);
			}
		}

		private void FreeSlow(T obj)
		{
			Element[] items = _items;
			for (int i = 0; i < items.Length; i++)
			{
				if (items[i].Value == null)
				{
					items[i].Value = obj;
					break;
				}
			}
		}

		[Conditional("DEBUG")]
		internal void ForgetTrackedObject(T old, T replacement = null)
		{
		}

		[Conditional("DEBUG")]
		private void Validate(object obj)
		{
			Element[] items = _items;
			for (int i = 0; i < items.Length && items[i].Value != null; i++)
			{
			}
		}
	}
	internal sealed class ReferencePool
	{
		private const int PoolSize = 10;

		private readonly ObjectPool<Reference> _pool;

		public ReferencePool()
		{
			_pool = new ObjectPool<Reference>(Factory, 10);
		}

		private static Reference Factory()
		{
			return new Reference(JsValue.Undefined, JsString.Empty, strict: false);
		}

		public Reference Rent(JsValue baseValue, JsValue name, bool strict, JsValue? thisValue)
		{
			return _pool.Allocate().Reassign(baseValue, name, strict, thisValue);
		}

		public void Return(Reference? reference)
		{
			if (reference != null)
			{
				_pool.Free(reference);
			}
		}
	}
}
namespace Jint.Native
{
	public abstract class Constructor : Jint.Native.Function.Function, IConstructor
	{
		protected Constructor(Engine engine, string name)
			: this(engine, engine.Realm, new JsString(name))
		{
		}

		internal Constructor(Engine engine, Realm realm, JsString name)
			: base(engine, realm, name)
		{
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			ExceptionHelper.ThrowTypeError(_realm, $"Constructor {_nameDescriptor?.Value} requires 'new'");
			return null;
		}

		public abstract ObjectInstance Construct(JsValue[] arguments, JsValue newTarget);
	}
	[Flags]
	internal enum DateFlags : byte
	{
		None = 0,
		NaN = 1,
		Infinity = 2,
		DateTimeMinValue = 4,
		DateTimeMaxValue = 8
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly record struct DatePresentation(long Value, DateFlags Flags)
	{
		public bool DateTimeRangeValid
		{
			get
			{
				if (IsFinite && Value <= JsDate.Max)
				{
					return Value >= JsDate.Min;
				}
				return false;
			}
		}

		public bool IsNaN => (Flags & DateFlags.NaN) != 0;

		public bool IsInfinity => (Flags & DateFlags.Infinity) != 0;

		public bool IsFinite => (Flags & (DateFlags.NaN | DateFlags.Infinity)) == 0;

		public static readonly DatePresentation NaN = new DatePresentation(0L, DateFlags.NaN);

		public static readonly DatePresentation MinValue = new DatePresentation(JsDate.Min, DateFlags.DateTimeMinValue);

		public static readonly DatePresentation MaxValue = new DatePresentation(JsDate.Max, DateFlags.DateTimeMaxValue);

		public DateTime ToDateTime()
		{
			return DateConstructor.Epoch.AddMilliseconds(Value);
		}

		public static implicit operator DatePresentation(long value)
		{
			return new DatePresentation(value, DateFlags.None);
		}

		public static implicit operator DatePresentation(double value)
		{
			if (double.IsInfinity(value))
			{
				return new DatePresentation(0L, DateFlags.Infinity);
			}
			if (double.IsNaN(value))
			{
				return new DatePresentation(0L, DateFlags.NaN);
			}
			return new DatePresentation((long)value, DateFlags.None);
		}

		public static DatePresentation operator +(DatePresentation a, DatePresentation b)
		{
			if (a.IsNaN || b.IsNaN)
			{
				return NaN;
			}
			return new DatePresentation(a.Value + b.Value, DateFlags.None);
		}

		public static DatePresentation operator -(DatePresentation a, DatePresentation b)
		{
			return a + -b;
		}

		public static DatePresentation operator +(DatePresentation a)
		{
			return a;
		}

		public static DatePresentation operator -(DatePresentation a)
		{
			return a with
			{
				Value = -a.Value
			};
		}

		internal DatePresentation TimeClip()
		{
			if ((Flags & (DateFlags.NaN | DateFlags.Infinity)) != DateFlags.None)
			{
				return NaN;
			}
			long value = Value;
			if ((value < -8640000000000000L || value > 8640000000000000L) ? true : false)
			{
				return NaN;
			}
			return this;
		}

		internal JsNumber ToJsValue()
		{
			bool flag = IsNaN;
			if (!flag)
			{
				long value = Value;
				bool flag2 = ((value < -8640000000000000L || value > 8640000000000000L) ? true : false);
				flag = flag2;
			}
			if (flag)
			{
				return JsNumber.DoubleNaN;
			}
			return JsNumber.Create(Value);
		}
	}
	internal static class GroupByHelper
	{
		private sealed class GroupByProtocol : IteratorProtocol
		{
			private readonly Engine _engine;

			private readonly Dictionary<JsValue, JsArray> _result;

			private readonly ICallable _callable;

			private readonly bool _mapMode;

			private ulong _k;

			private readonly JsValue[] _callArgs = new JsValue[2];

			public GroupByProtocol(Engine engine, Dictionary<JsValue, JsArray> result, IteratorInstance iterator, ICallable callable, bool mapMode)
				: base(engine, iterator, 0)
			{
				_engine = engine;
				_result = result;
				_callable = callable;
				_mapMode = mapMode;
			}

			protected override void ProcessItem(JsValue[] arguments, JsValue currentValue)
			{
				if (_k >= uint.MaxValue)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
				_callArgs[0] = currentValue;
				_callArgs[1] = _k;
				JsValue jsValue = _callable.Call(JsValue.Undefined, _callArgs);
				JsValue key;
				if (_mapMode)
				{
					JsNumber obj = jsValue as JsNumber;
					key = (((object)obj != null && obj.IsNegativeZero()) ? JsNumber.PositiveZero : jsValue);
				}
				else
				{
					key = TypeConverter.ToPropertyKey(jsValue);
				}
				if (!_result.TryGetValue(key, out JsArray value))
				{
					value = (_result[key] = new JsArray(_engine));
				}
				value.Push(currentValue);
				_k++;
			}
		}

		internal static Dictionary<JsValue, JsArray> GroupBy(Engine engine, Realm realm, JsValue items, JsValue callbackfn, bool mapMode)
		{
			ICallable callable = callbackfn.GetCallable(realm);
			Dictionary<JsValue, JsArray> result = new Dictionary<JsValue, JsArray>();
			IteratorInstance iterator = items.GetIterator(realm);
			new GroupByProtocol(engine, result, iterator, callable, mapMode).Execute();
			return result;
		}
	}
	internal interface ICallable
	{
		JsValue Call(JsValue thisObject, params JsValue[] arguments);
	}
	internal interface IConstructor
	{
		ObjectInstance Construct(JsValue[] arguments, JsValue newTarget);
	}
	public interface IJsPrimitive
	{
		Types Type { get; }

		JsValue PrimitiveValue { get; }
	}
	public sealed class JsArguments : ObjectInstance
	{
		private static readonly ThreadLocal<HashSet<Key>> _mappedNamed = new ThreadLocal<HashSet<Key>>(() => new HashSet<Key>());

		private Jint.Native.Function.Function _func;

		private Key[] _names;

		private JsValue[] _args;

		private DeclarativeEnvironment _env;

		private bool _canReturnToPool;

		private bool _hasRestParameter;

		private bool _materialized;

		internal ObjectInstance? ParameterMap { get; set; }

		internal override bool IsArrayLike => true;

		internal override bool IsIntegerIndexedArray => true;

		public uint Length => (uint)_args.Length;

		internal JsArguments(Engine engine)
			: base(engine, ObjectClass.Arguments)
		{
		}

		internal void Prepare(Jint.Native.Function.Function func, Key[] names, JsValue[] args, DeclarativeEnvironment env, bool hasRestParameter)
		{
			_func = func;
			_names = names;
			_args = args;
			_env = env;
			_hasRestParameter = hasRestParameter;
			_canReturnToPool = true;
			ClearProperties();
		}

		protected override void Initialize()
		{
			_canReturnToPool = false;
			JsValue[] args = _args;
			DefinePropertyOrThrow(CommonProperties.Length, new PropertyDescriptor(_args.Length, PropertyFlag.NonEnumerable));
			if ((object)_func == null)
			{
				ParameterMap = null;
				for (uint num = 0u; num < (uint)args.Length; num++)
				{
					JsValue v = args[num];
					CreateDataProperty(JsString.Create(num), v);
				}
				DefinePropertyOrThrow(CommonProperties.Callee, new GetSetPropertyDescriptor.ThrowerPropertyDescriptor(_engine, PropertyFlag.None));
			}
			else
			{
				ObjectInstance objectInstance = null;
				if (args.Length != 0)
				{
					HashSet<Key> value = _mappedNamed.Value;
					value.Clear();
					objectInstance = base.Engine.Realm.Intrinsics.Object.Construct(Arguments.Empty);
					for (uint num2 = 0u; num2 < (uint)args.Length; num2++)
					{
						SetOwnProperty(JsString.Create(num2), new PropertyDescriptor(args[num2], PropertyFlag.ConfigurableEnumerableWritable));
						if (num2 < _names.Length)
						{
							Key key = _names[num2];
							if (value.Add(key))
							{
								objectInstance.SetOwnProperty(JsString.Create(num2), new ClrAccessDescriptor(_env, base.Engine, key));
							}
						}
					}
				}
				ParameterMap = objectInstance;
				DefinePropertyOrThrow(CommonProperties.Callee, new PropertyDescriptor(_func, PropertyFlag.NonEnumerable));
			}
			ClrFunction value2 = new ClrFunction(base.Engine, "iterator", _engine.Realm.Intrinsics.Array.PrototypeObject.Values, 0, PropertyFlag.Configurable);
			DefinePropertyOrThrow(GlobalSymbolRegistry.Iterator, new PropertyDescriptor(value2, PropertyFlag.Writable | PropertyFlag.Configurable));
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			EnsureInitialized();
			if ((object)ParameterMap != null)
			{
				PropertyDescriptor ownProperty = base.GetOwnProperty(property);
				if (ownProperty == PropertyDescriptor.Undefined)
				{
					return ownProperty;
				}
				if (ParameterMap.TryGetValue(property, out JsValue value) && !value.IsUndefined())
				{
					ownProperty.Value = value;
				}
				return ownProperty;
			}
			return base.GetOwnProperty(property);
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			EnsureInitialized();
			if (!CanPut(property))
			{
				return false;
			}
			if (GetOwnProperty(property).IsDataDescriptor())
			{
				PropertyDescriptor desc = new PropertyDescriptor(value, PropertyFlag.None);
				return DefineOwnProperty(property, desc);
			}
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty.IsAccessorDescriptor())
			{
				if (!(ownProperty.Set is ICallable callable))
				{
					return false;
				}
				callable.Call(receiver, value);
				return true;
			}
			PropertyDescriptor desc2 = new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable);
			return DefineOwnProperty(property, desc2);
		}

		public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			if (_hasRestParameter)
			{
				return true;
			}
			EnsureInitialized();
			if ((object)ParameterMap != null)
			{
				ObjectInstance parameterMap = ParameterMap;
				PropertyDescriptor ownProperty = parameterMap.GetOwnProperty(property);
				if (!base.DefineOwnProperty(property, desc))
				{
					return false;
				}
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					if (desc.IsAccessorDescriptor())
					{
						parameterMap.Delete(property);
					}
					else
					{
						JsValue value = desc.Value;
						if ((object)value != null && !value.IsUndefined())
						{
							parameterMap.Set(property, value, throwOnError: false);
						}
						if (desc.WritableSet && !desc.Writable)
						{
							parameterMap.Delete(property);
						}
					}
				}
				return true;
			}
			return base.DefineOwnProperty(property, desc);
		}

		public override bool Delete(JsValue property)
		{
			EnsureInitialized();
			if ((object)ParameterMap != null)
			{
				ObjectInstance parameterMap = ParameterMap;
				PropertyDescriptor ownProperty = parameterMap.GetOwnProperty(property);
				bool num = base.Delete(property);
				if (num && ownProperty != PropertyDescriptor.Undefined)
				{
					parameterMap.Delete(property);
				}
				return num;
			}
			return base.Delete(property);
		}

		internal void Materialize()
		{
			if (!_materialized)
			{
				_materialized = true;
				EnsureInitialized();
				JsValue[] args = _args;
				JsValue[] array = new JsValue[args.Length];
				System.Array.Copy(args, array, args.Length);
				_args = array;
				_canReturnToPool = false;
			}
		}

		internal void FunctionWasCalled()
		{
			ParameterMap = null;
			if (_canReturnToPool)
			{
				_engine._argumentsInstancePool.Return(this);
				_canReturnToPool = false;
			}
		}
	}
	[DebuggerTypeProxy(typeof(JsArrayDebugView))]
	[DebuggerDisplay("Count = {Length}")]
	public sealed class JsArray : ArrayInstance
	{
		private sealed class JsArrayDebugView
		{
			private readonly JsArray _array;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public JsValue[] Values
			{
				get
				{
					JsValue[] array = new JsValue[_array.GetLength()];
					int num = 0;
					foreach (JsValue item in _array)
					{
						array[num++] = item;
					}
					return array;
				}
			}

			public JsArrayDebugView(JsArray array)
			{
				_array = array;
			}
		}

		public uint Length => GetLength();

		public JsArray(Engine engine, uint capacity = 0u, uint length = 0u)
			: base(engine, capacity, length)
		{
		}

		public JsArray(Engine engine, JsValue[] items)
			: base(engine, items)
		{
		}
	}
	public class JsArrayBuffer : ObjectInstance
	{
		private readonly byte[] _workBuffer = new byte[8];

		internal byte[]? _arrayBufferData;

		internal readonly int? _arrayBufferMaxByteLength;

		internal readonly JsValue _arrayBufferDetachKey = JsValue.Undefined;

		internal virtual int ArrayBufferByteLength
		{
			get
			{
				byte[]? arrayBufferData = _arrayBufferData;
				if (arrayBufferData == null)
				{
					return 0;
				}
				return arrayBufferData.Length;
			}
		}

		internal byte[]? ArrayBufferData => _arrayBufferData;

		internal bool IsDetachedBuffer => _arrayBufferData == null;

		internal bool IsFixedLengthArrayBuffer
		{
			get
			{
				int? arrayBufferMaxByteLength = _arrayBufferMaxByteLength;
				return !arrayBufferMaxByteLength.HasValue;
			}
		}

		internal virtual bool IsSharedArrayBuffer => false;

		internal JsArrayBuffer(Engine engine, byte[] data, uint? arrayBufferMaxByteLength = null)
			: base(engine)
		{
			if (arrayBufferMaxByteLength.HasValue && arrayBufferMaxByteLength.GetValueOrDefault() > int.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(engine.Realm, "arrayBufferMaxByteLength cannot be larger than int32.MaxValue");
			}
			_arrayBufferData = data;
			_arrayBufferMaxByteLength = (int?)arrayBufferMaxByteLength;
		}

		internal static byte[] CreateByteDataBlock(Realm realm, ulong byteLength)
		{
			if (byteLength > int.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(realm, "Array buffer allocation failed");
			}
			return new byte[byteLength];
		}

		internal void DetachArrayBuffer(JsValue? key = null)
		{
			if ((object)key == null)
			{
				key = JsValue.Undefined;
			}
			if (!JsValue.SameValue(_arrayBufferDetachKey, key))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			_arrayBufferData = null;
		}

		internal JsArrayBuffer CloneArrayBuffer(ArrayBufferConstructor constructor, int srcByteOffset, uint srcLength)
		{
			JsArrayBuffer jsArrayBuffer = constructor.AllocateArrayBuffer(_engine.Realm.Intrinsics.ArrayBuffer, srcLength);
			AssertNotDetached();
			byte[]? arrayBufferData = _arrayBufferData;
			byte[] arrayBufferData2 = jsArrayBuffer.ArrayBufferData;
			System.Array.Copy(arrayBufferData, srcByteOffset, arrayBufferData2, 0L, srcLength);
			return jsArrayBuffer;
		}

		internal TypedArrayValue GetValueFromBuffer(int byteIndex, TypedArrayElementType type, bool isTypedArray, ArrayBufferOrder order, bool? isLittleEndian = null)
		{
			return RawBytesToNumeric(type, byteIndex, isLittleEndian ?? BitConverter.IsLittleEndian);
		}

		internal TypedArrayValue RawBytesToNumeric(TypedArrayElementType type, int byteIndex, bool isLittleEndian)
		{
			if (type - 6 <= TypedArrayElementType.Int16)
			{
				return new TypedArrayValue(Types.Number, (int)_arrayBufferData[byteIndex], default(BigInteger));
			}
			byte elementSize = type.GetElementSize();
			byte[] array = _arrayBufferData;
			bool flag = !isLittleEndian && elementSize > 1;
			if (flag)
			{
				bool flag2 = ((type - 3 <= TypedArrayElementType.Int32 || type == TypedArrayElementType.BigUint64) ? true : false);
				flag = flag2;
			}
			if (flag)
			{
				System.Array.Copy(array, byteIndex, _workBuffer, 0, elementSize);
				byteIndex = 0;
				System.Array.Reverse(_workBuffer, 0, elementSize);
				array = _workBuffer;
			}
			TypedArrayValue? typedArrayValue;
			switch (type)
			{
			case TypedArrayElementType.Float32:
			{
				float num = BitConverter.ToSingle(array, byteIndex);
				if (float.IsNaN(num))
				{
					return double.NaN;
				}
				return num;
			}
			case TypedArrayElementType.Float64:
				return BitConverter.ToDouble(array, byteIndex);
			case TypedArrayElementType.BigUint64:
				return BitConverter.ToUInt64(array, byteIndex);
			case TypedArrayElementType.BigInt64:
				return BitConverter.ToInt64(array, byteIndex);
			case TypedArrayElementType.Int8:
				typedArrayValue = (sbyte)array[byteIndex];
				break;
			case TypedArrayElementType.Int16:
				typedArrayValue = (isLittleEndian ? ((short)(array[byteIndex] | (array[byteIndex + 1] << 8))) : ((short)(array[byteIndex + 1] | (array[byteIndex] << 8))));
				break;
			case TypedArrayElementType.Uint16:
				typedArrayValue = (isLittleEndian ? ((ushort)(array[byteIndex] | (array[byteIndex + 1] << 8))) : ((ushort)(array[byteIndex + 1] | (array[byteIndex] << 8))));
				break;
			case TypedArrayElementType.Int32:
				typedArrayValue = (isLittleEndian ? (array[byteIndex] | (array[byteIndex + 1] << 8) | (array[byteIndex + 2] << 16) | (array[byteIndex + 3] << 24)) : (array[byteIndex + 3] | (array[byteIndex + 2] << 8) | (array[byteIndex + 1] << 16) | (array[byteIndex] << 24)));
				break;
			case TypedArrayElementType.Uint32:
				typedArrayValue = (uint)(isLittleEndian ? (array[byteIndex] | (array[byteIndex + 1] << 8) | (array[byteIndex + 2] << 16) | (array[byteIndex + 3] << 24)) : (array[byteIndex + 3] | (array[byteIndex + 2] << 8) | (array[byteIndex + 1] << 16) | (array[byteIndex] << 24)));
				break;
			default:
				typedArrayValue = null;
				break;
			}
			TypedArrayValue? typedArrayValue2 = typedArrayValue;
			if (!typedArrayValue2.HasValue)
			{
				ExceptionHelper.ThrowArgumentOutOfRangeException("type", type.ToString());
			}
			return typedArrayValue2.Value;
		}

		internal void SetValueInBuffer(int byteIndex, TypedArrayElementType type, TypedArrayValue value, bool isTypedArray, ArrayBufferOrder order, bool? isLittleEndian = null)
		{
			if (type == TypedArrayElementType.Uint8)
			{
				double doubleValue = value.DoubleValue;
				long num = ((double.IsNaN(doubleValue) || doubleValue == 0.0 || double.IsInfinity(doubleValue)) ? 0 : ((long)doubleValue));
				_arrayBufferData[byteIndex] = (byte)num;
			}
			else
			{
				byte[] arrayBufferData = _arrayBufferData;
				System.Array.Copy(NumericToRawBytes(type, value, isLittleEndian ?? BitConverter.IsLittleEndian), 0, arrayBufferData, byteIndex, type.GetElementSize());
			}
		}

		private byte[] NumericToRawBytes(TypedArrayElementType type, TypedArrayValue value, bool isLittleEndian)
		{
			byte[] array;
			switch (type)
			{
			case TypedArrayElementType.Float32:
				array = BitConverter.GetBytes((float)value.DoubleValue);
				break;
			case TypedArrayElementType.Float64:
				array = BitConverter.GetBytes(value.DoubleValue);
				break;
			case TypedArrayElementType.BigInt64:
				array = BitConverter.GetBytes(TypeConverter.ToBigInt64(value.BigInteger));
				break;
			case TypedArrayElementType.BigUint64:
				array = BitConverter.GetBytes(TypeConverter.ToBigUint64(value.BigInteger));
				break;
			default:
			{
				double doubleValue = value.DoubleValue;
				long num = ((double.IsNaN(doubleValue) || doubleValue == 0.0 || double.IsInfinity(doubleValue)) ? 0 : ((long)doubleValue));
				array = _workBuffer;
				switch (type)
				{
				case TypedArrayElementType.Int8:
					array[0] = (byte)(sbyte)num;
					break;
				case TypedArrayElementType.Uint8:
					array[0] = (byte)num;
					break;
				case TypedArrayElementType.Uint8C:
					array[0] = TypeConverter.ToUint8Clamp(value.DoubleValue);
					break;
				case TypedArrayElementType.Int16:
					array = BitConverter.GetBytes((short)num);
					break;
				case TypedArrayElementType.Uint16:
					array = BitConverter.GetBytes((ushort)num);
					break;
				case TypedArrayElementType.Int32:
					array = BitConverter.GetBytes((uint)num);
					break;
				case TypedArrayElementType.Uint32:
					array = BitConverter.GetBytes((uint)num);
					break;
				default:
					ExceptionHelper.ThrowArgumentOutOfRangeException();
					return null;
				}
				break;
			}
			}
			byte elementSize = type.GetElementSize();
			if (!isLittleEndian && elementSize > 1)
			{
				System.Array.Reverse(array, 0, elementSize);
			}
			return array;
		}

		internal void Resize(uint newByteLength)
		{
			int? arrayBufferMaxByteLength = _arrayBufferMaxByteLength;
			if (!arrayBufferMaxByteLength.HasValue)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			if (newByteLength > _arrayBufferMaxByteLength)
			{
				ExceptionHelper.ThrowRangeError(_engine.Realm);
			}
			byte[]? sourceArray = _arrayBufferData ?? System.Array.Empty<byte>();
			byte[] array = CreateByteDataBlock(_engine.Realm, newByteLength);
			long length = System.Math.Min(newByteLength, ArrayBufferByteLength);
			System.Array.Copy(sourceArray, array, length);
			_arrayBufferData = array;
		}

		internal void AssertNotDetached()
		{
			if (IsDetachedBuffer)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "ArrayBuffer has been detached");
			}
		}
	}
	public sealed class JsBigInt : JsValue, IEquatable<JsBigInt>
	{
		internal readonly BigInteger _value;

		public static readonly JsBigInt Zero;

		public static readonly JsBigInt One;

		private static readonly JsBigInt[] _bigIntegerToJsValue;

		static JsBigInt()
		{
			Zero = new JsBigInt(0);
			One = new JsBigInt(1);
			JsBigInt[] array = new JsBigInt[1024];
			for (uint num = 0u; num < array.Length; num++)
			{
				array[num] = new JsBigInt(num);
			}
			_bigIntegerToJsValue = array;
		}

		public JsBigInt(BigInteger value)
			: base(Types.BigInt)
		{
			_value = value;
		}

		internal static JsBigInt Create(BigInteger bigInt)
		{
			JsBigInt[] bigIntegerToJsValue = _bigIntegerToJsValue;
			if (bigInt >= 0L && bigInt < (uint)bigIntegerToJsValue.Length)
			{
				return bigIntegerToJsValue[(int)bigInt];
			}
			return new JsBigInt(bigInt);
		}

		internal static JsBigInt Create(JsValue value)
		{
			return (value as JsBigInt) ?? Create(TypeConverter.ToBigInt(value));
		}

		public override object ToObject()
		{
			return _value;
		}

		internal override bool ToBoolean()
		{
			return _value != 0L;
		}

		public static bool operator ==(JsBigInt a, double b)
		{
			if (TypeConverter.IsIntegralNumber(b))
			{
				return a._value == (long)b;
			}
			return false;
		}

		public static bool operator !=(JsBigInt a, double b)
		{
			return !(a == b);
		}

		public override string ToString()
		{
			return TypeConverter.ToString(_value);
		}

		protected internal override bool IsLooselyEqual(JsValue value)
		{
			if (value is JsBigInt other)
			{
				return Equals(other);
			}
			if (value is JsNumber jsNumber && TypeConverter.IsIntegralNumber(jsNumber._value) && _value == new BigInteger(jsNumber._value))
			{
				return true;
			}
			if (value is JsBoolean jsBoolean)
			{
				if (!jsBoolean._value || !(_value == BigInteger.One))
				{
					if (!jsBoolean._value)
					{
						return _value == BigInteger.Zero;
					}
					return false;
				}
				return true;
			}
			if (value is JsString jsString && TypeConverter.TryStringToBigInt(jsString.ToString(), out var result) && result == _value)
			{
				return true;
			}
			if (value.IsObject())
			{
				return IsLooselyEqual(TypeConverter.ToPrimitive(value, Types.Number));
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as JsBigInt);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as JsBigInt);
		}

		public bool Equals(JsBigInt? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this != other)
			{
				return _value == other._value;
			}
			return true;
		}

		public override int GetHashCode()
		{
			return _value.GetHashCode();
		}
	}
	public sealed class JsBoolean : JsValue, IEquatable<JsBoolean>
	{
		public static readonly JsBoolean False = new JsBoolean(value: false);

		public static readonly JsBoolean True = new JsBoolean(value: true);

		internal static readonly object BoxedTrue = true;

		internal static readonly object BoxedFalse = false;

		internal readonly bool _value;

		private JsBoolean(bool value)
			: base(Types.Boolean)
		{
			_value = value;
		}

		internal static JsBoolean Create(bool value)
		{
			if (!value)
			{
				return False;
			}
			return True;
		}

		public override object ToObject()
		{
			if (!_value)
			{
				return BoxedFalse;
			}
			return BoxedTrue;
		}

		internal override bool ToBoolean()
		{
			return _value;
		}

		public override string ToString()
		{
			if (!_value)
			{
				return "false";
			}
			return "true";
		}

		protected internal override bool IsLooselyEqual(JsValue value)
		{
			if (value is JsBoolean other)
			{
				return Equals(other);
			}
			if (!value.IsNullOrUndefined())
			{
				return base.IsLooselyEqual(value);
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as JsBoolean);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as JsBoolean);
		}

		public bool Equals(JsBoolean? other)
		{
			if ((object)this == other)
			{
				return true;
			}
			if ((object)other == null)
			{
				return false;
			}
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value.GetHashCode();
		}
	}
	internal sealed class JsDataView : ObjectInstance
	{
		internal JsArrayBuffer? _viewedArrayBuffer;

		internal uint _byteLength;

		internal uint _byteOffset;

		internal JsDataView(Engine engine)
			: base(engine)
		{
		}
	}
	public sealed class JsDate : ObjectInstance
	{
		internal static readonly long Max = (long)(DateTime.MaxValue - DateConstructor.Epoch).TotalMilliseconds;

		internal static readonly long Min = (long)(0.0 - (DateConstructor.Epoch - DateTime.MinValue).TotalMilliseconds);

		internal DatePresentation _dateValue;

		public double DateValue
		{
			get
			{
				if (!_dateValue.IsFinite)
				{
					return double.NaN;
				}
				return _dateValue.Value;
			}
		}

		internal bool DateTimeRangeValid => _dateValue.DateTimeRangeValid;

		public JsDate(Engine engine, DateTimeOffset value)
			: this(engine, value.UtcDateTime)
		{
		}

		public JsDate(Engine engine, DateTime value)
			: this(engine, engine.Realm.Intrinsics.Date.FromDateTime(value))
		{
			if (value == DateTime.MinValue)
			{
				_dateValue = _dateValue with
				{
					Flags = DateFlags.DateTimeMinValue
				};
			}
			else if (value == DateTime.MinValue)
			{
				_dateValue = _dateValue with
				{
					Flags = DateFlags.DateTimeMaxValue
				};
			}
		}

		public JsDate(Engine engine, long dateValue)
			: this(engine, new DatePresentation(dateValue, DateFlags.None))
		{
		}

		internal JsDate(Engine engine, DatePresentation dateValue)
			: base(engine, ObjectClass.Date, InternalTypes.Object | InternalTypes.PlainObject)
		{
			_prototype = engine.Realm.Intrinsics.Date.PrototypeObject;
			_dateValue = dateValue.TimeClip();
		}

		public DateTime ToDateTime()
		{
			if (_dateValue.Flags == DateFlags.DateTimeMinValue)
			{
				return DateTime.MinValue;
			}
			if (_dateValue.Flags == DateFlags.DateTimeMaxValue)
			{
				return DateTime.MaxValue;
			}
			if (_dateValue.DateTimeRangeValid)
			{
				DateTime dateTime = DateConstructor.Epoch.AddMilliseconds(_dateValue.Value);
				if (_engine.Options.Interop.DateTimeKind == DateTimeKind.Local)
				{
					dateTime = TimeZoneInfo.ConvertTimeFromUtc(dateTime, _engine.Options.TimeSystem.DefaultTimeZone);
					dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Local);
				}
				return dateTime;
			}
			ExceptionHelper.ThrowRangeError(_engine.Realm);
			return DateTime.MinValue;
		}

		public override string ToString()
		{
			if (_dateValue.IsNaN)
			{
				return "NaN";
			}
			if (_dateValue.IsInfinity)
			{
				return "Infinity";
			}
			return TypeConverter.ToString(this);
		}
	}
	internal sealed class JsEmpty : JsValue
	{
		internal static readonly JsValue Instance = new JsEmpty();

		private JsEmpty()
			: base(Types.Empty)
		{
		}

		public override object? ToObject()
		{
			return null;
		}
	}
	public sealed class JsError : ErrorInstance
	{
		internal JsError(Engine engine)
			: base(engine, ObjectClass.Error)
		{
		}
	}
	internal sealed class JsMap : ObjectInstance
	{
		private readonly Realm _realm;

		internal readonly OrderedDictionary<JsValue, JsValue> _map;

		public JsMap(Engine engine, Realm realm)
			: base(engine)
		{
			_realm = realm;
			_map = new OrderedDictionary<JsValue, JsValue>(SameValueZeroComparer.Instance);
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (CommonProperties.Size.Equals(property))
			{
				return new PropertyDescriptor(_map.Count, PropertyFlag.AllForbidden);
			}
			return base.GetOwnProperty(property);
		}

		protected override bool TryGetProperty(JsValue property, [NotNullWhen(true)] out PropertyDescriptor? descriptor)
		{
			if (CommonProperties.Size.Equals(property))
			{
				descriptor = new PropertyDescriptor(_map.Count, PropertyFlag.AllForbidden);
				return true;
			}
			return base.TryGetProperty(property, out descriptor);
		}

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

		internal bool Has(JsValue key)
		{
			return _map.ContainsKey(key);
		}

		internal bool MapDelete(JsValue key)
		{
			return _map.Remove(key);
		}

		internal void MapSet(JsValue key, JsValue value)
		{
			if (key is JsNumber jsNumber && jsNumber.IsNegativeZero())
			{
				key = JsNumber.PositiveZero;
			}
			_map[key] = value;
		}

		internal void ForEach(ICallable callable, JsValue thisArg)
		{
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = this;
			for (int i = 0; i < _map.Count; i++)
			{
				array[0] = _map[i];
				array[1] = _map.GetKey(i);
				callable.Call(thisArg, array);
			}
			_engine._jsValueArrayPool.ReturnArray(array);
		}

		internal JsValue MapGet(JsValue key)
		{
			if (!_map.TryGetValue(key, out JsValue value))
			{
				return JsValue.Undefined;
			}
			return value;
		}

		internal ObjectInstance Iterator()
		{
			return _realm.Intrinsics.MapIteratorPrototype.ConstructEntryIterator(this);
		}

		internal ObjectInstance Keys()
		{
			return _realm.Intrinsics.MapIteratorPrototype.ConstructKeyIterator(this);
		}

		internal ObjectInstance Values()
		{
			return _realm.Intrinsics.MapIteratorPrototype.ConstructValueIterator(this);
		}
	}
	public sealed class JsNull : JsValue, IEquatable<JsNull>
	{
		internal JsNull()
			: base(Types.Null)
		{
		}

		public override object? ToObject()
		{
			return null;
		}

		public override string ToString()
		{
			return "null";
		}

		protected internal override bool IsLooselyEqual(JsValue value)
		{
			if ((object)JsValue.Null != value)
			{
				return (object)JsValue.Undefined == value;
			}
			return true;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as JsNull);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as JsNull);
		}

		public bool Equals(JsNull? other)
		{
			return (object)other != null;
		}

		public override int GetHashCode()
		{
			return RuntimeHelpers.GetHashCode(this);
		}
	}
	[DebuggerDisplay("{_value}", Type = "string")]
	public sealed class JsNumber : JsValue, IEquatable<JsNumber>
	{
		internal const double JavaScriptEpsilon = 2.220446049250313E-16;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal readonly double _value;

		internal const double DoubleIsIntegerTolerance = 4.94E-322;

		internal static readonly long NegativeZeroBits;

		private const int NumbersMax = 10240;

		private static readonly JsNumber[] _intToJsValue;

		internal static readonly JsNumber DoubleNaN;

		internal static readonly JsNumber DoubleNegativeOne;

		internal static readonly JsNumber DoublePositiveInfinity;

		internal static readonly JsNumber DoubleNegativeInfinity;

		internal static readonly JsNumber IntegerNegativeOne;

		internal static readonly JsNumber NegativeZero;

		internal static readonly JsNumber PositiveZero;

		internal static readonly JsNumber PositiveOne;

		internal static readonly JsNumber PositiveTwo;

		internal static readonly JsNumber PositiveThree;

		internal static readonly JsNumber PI;

		static JsNumber()
		{
			NegativeZeroBits = BitConverter.DoubleToInt64Bits(-0.0);
			DoubleNaN = new JsNumber(double.NaN);
			DoubleNegativeOne = new JsNumber(-1.0);
			DoublePositiveInfinity = new JsNumber(double.PositiveInfinity);
			DoubleNegativeInfinity = new JsNumber(double.NegativeInfinity);
			IntegerNegativeOne = new JsNumber(-1);
			NegativeZero = new JsNumber(-0.0);
			PositiveZero = new JsNumber(0);
			PositiveOne = new JsNumber(1);
			PositiveTwo = new JsNumber(2);
			PositiveThree = new JsNumber(3);
			PI = new JsNumber(System.Math.PI);
			JsNumber[] array = new JsNumber[10240];
			for (uint num = 0u; num < (uint)array.Length; num++)
			{
				array[num] = new JsNumber(num);
			}
			_intToJsValue = array;
		}

		public JsNumber(double value)
			: base(Types.Number)
		{
			_value = value;
		}

		public JsNumber(int value)
			: base(InternalTypes.Integer)
		{
			_value = value;
		}

		public JsNumber(uint value)
			: base((value <= int.MaxValue) ? InternalTypes.Integer : InternalTypes.Number)
		{
			_value = value;
		}

		public JsNumber(ulong value)
			: base((value <= int.MaxValue) ? InternalTypes.Integer : InternalTypes.Number)
		{
			_value = value;
		}

		public JsNumber(long value)
			: base((value <= int.MaxValue && value >= int.MinValue) ? InternalTypes.Integer : InternalTypes.Number)
		{
			_value = value;
		}

		public override object ToObject()
		{
			return _value;
		}

		internal override bool ToBoolean()
		{
			if (_type == InternalTypes.Integer)
			{
				return (int)_value != 0;
			}
			if (_value != 0.0)
			{
				return !double.IsNaN(_value);
			}
			return false;
		}

		internal static JsNumber Create(object value)
		{
			return System.Type.GetTypeCode(value.GetType()) switch
			{
				TypeCode.Int64 => Create(Convert.ToInt64(value, CultureInfo.InvariantCulture)), 
				TypeCode.UInt32 => Create(Convert.ToUInt64(value, CultureInfo.InvariantCulture)), 
				TypeCode.UInt64 => Create(Convert.ToUInt64(value, CultureInfo.InvariantCulture)), 
				_ => Create(Convert.ToInt32(value, CultureInfo.InvariantCulture)), 
			};
		}

		public static JsNumber Create(decimal value)
		{
			return Create((double)value);
		}

		public static JsNumber Create(double value)
		{
			if (TypeConverter.IsIntegralNumber(value) && value > -9.223372036854776E+18 && value < 9.223372036854776E+18 && !NumberInstance.IsNegativeZero(value))
			{
				long num = (long)value;
				if (num != -1)
				{
					return Create(num);
				}
				return IntegerNegativeOne;
			}
			return CreateNumberUnlikely(value);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static JsNumber CreateNumberUnlikely(double value)
		{
			if (value <= double.MaxValue && value >= double.MinValue)
			{
				return new JsNumber(value);
			}
			if (double.IsNegativeInfinity(value))
			{
				return DoubleNegativeInfinity;
			}
			if (double.IsPositiveInfinity(value))
			{
				return DoublePositiveInfinity;
			}
			if (double.IsNaN(value))
			{
				return DoubleNaN;
			}
			return new JsNumber(value);
		}

		public static JsNumber Create(byte value)
		{
			return _intToJsValue[value];
		}

		internal static JsNumber Create(sbyte value)
		{
			JsNumber[] intToJsValue = _intToJsValue;
			if ((uint)value < (uint)intToJsValue.Length)
			{
				return intToJsValue[value];
			}
			return new JsNumber(value);
		}

		public static JsNumber Create(int value)
		{
			JsNumber[] intToJsValue = _intToJsValue;
			if ((uint)value < (uint)intToJsValue.Length)
			{
				return intToJsValue[value];
			}
			if (value == -1)
			{
				return IntegerNegativeOne;
			}
			return new JsNumber(value);
		}

		internal static JsNumber Create(uint value)
		{
			JsNumber[] intToJsValue = _intToJsValue;
			if (value < (uint)intToJsValue.Length)
			{
				return intToJsValue[value];
			}
			return new JsNumber(value);
		}

		internal static JsNumber Create(ulong value)
		{
			if (value < (ulong)_intToJsValue.Length)
			{
				return _intToJsValue[value];
			}
			return new JsNumber(value);
		}

		public static JsNumber Create(long value)
		{
			if ((ulong)value < (ulong)_intToJsValue.Length)
			{
				return _intToJsValue[value];
			}
			return new JsNumber(value);
		}

		public static JsNumber Create(JsValue jsValue)
		{
			if (jsValue is JsNumber result)
			{
				return result;
			}
			return Create(TypeConverter.ToNumber(jsValue));
		}

		public override string ToString()
		{
			return TypeConverter.ToString(_value);
		}

		internal bool IsNaN()
		{
			return double.IsNaN(_value);
		}

		internal bool IsZero()
		{
			if (!IsNegativeZero())
			{
				return IsPositiveZero();
			}
			return true;
		}

		internal bool IsNegativeZero()
		{
			return NumberInstance.IsNegativeZero(_value);
		}

		internal bool IsPositiveZero()
		{
			return NumberInstance.IsPositiveZero(_value);
		}

		internal bool IsPositiveInfinity()
		{
			return double.IsPositiveInfinity(_value);
		}

		internal bool IsNegativeInfinity()
		{
			return double.IsNegativeInfinity(_value);
		}

		protected internal override bool IsLooselyEqual(JsValue value)
		{
			if (value is JsNumber other)
			{
				return Equals(other);
			}
			if (value.IsBigInt())
			{
				if (TypeConverter.IsIntegralNumber(_value))
				{
					return new BigInteger(_value) == value.AsBigInt();
				}
				return false;
			}
			return base.IsLooselyEqual(value);
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as JsNumber);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as JsNumber);
		}

		public bool Equals(JsNumber? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if (double.IsNaN(_value) || double.IsNaN(other._value))
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value.GetHashCode();
		}
	}
	public sealed class JsObject : ObjectInstance
	{
		public JsObject(Engine engine)
			: base(engine, ObjectClass.Object, InternalTypes.Object | InternalTypes.PlainObject)
		{
		}
	}
	internal sealed class JsPromise : ObjectInstance
	{
		internal List<PromiseReaction> PromiseRejectReactions = new List<PromiseReaction>();

		internal List<PromiseReaction> PromiseFulfillReactions = new List<PromiseReaction>();

		internal PromiseState State { get; private set; }

		internal JsValue Value { get; private set; }

		internal TaskCompletionSource<JsPromise> TaskCompletionSource { get; } = new TaskCompletionSource<JsPromise>();

		internal JsPromise(Engine engine)
			: base(engine)
		{
		}

		internal ResolvingFunctions CreateResolvingFunctions()
		{
			bool alreadyResolved = false;
			ClrFunction resolve = new ClrFunction(_engine, "", delegate(JsValue thisObj, JsValue[] args)
			{
				if (alreadyResolved)
				{
					return JsValue.Undefined;
				}
				alreadyResolved = true;
				return Resolve(thisObj, args);
			}, 1, PropertyFlag.Configurable);
			ClrFunction reject = new ClrFunction(_engine, "", delegate(JsValue thisObj, JsValue[] args)
			{
				if (alreadyResolved)
				{
					return JsValue.Undefined;
				}
				alreadyResolved = true;
				return Reject(thisObj, args);
			}, 1, PropertyFlag.Configurable);
			return new ResolvingFunctions(resolve, reject);
		}

		private JsValue Resolve(JsValue thisObject, JsValue[] arguments)
		{
			JsValue result = arguments.At(0);
			return Resolve(result);
		}

		internal JsValue Resolve(JsValue result)
		{
			if ((object)result == this)
			{
				return RejectPromise(_engine.Realm.Intrinsics.TypeError.Construct("Cannot resolve Promise with itself"));
			}
			if (!(result is ObjectInstance objectInstance))
			{
				return FulfillPromise(result);
			}
			JsValue jsValue;
			try
			{
				jsValue = objectInstance.Get("then");
			}
			catch (JavaScriptException ex)
			{
				return RejectPromise(ex.Error);
			}
			if (!(jsValue is ICallable thenMethod))
			{
				return FulfillPromise(result);
			}
			Realm realm = _engine.Realm;
			Action job = PromiseOperations.NewPromiseResolveThenableJob(this, objectInstance, thenMethod);
			_engine._host.HostEnqueuePromiseJob(job, realm);
			return JsValue.Undefined;
		}

		private JsValue Reject(JsValue thisObject, JsValue[] arguments)
		{
			JsValue reason = arguments.At(0);
			return RejectPromise(reason);
		}

		private JsValue RejectPromise(JsValue reason)
		{
			if (State != PromiseState.Pending)
			{
				ExceptionHelper.ThrowInvalidOperationException("Promise should be in Pending state");
			}
			Settle(PromiseState.Rejected, reason);
			List<PromiseReaction> promiseRejectReactions = PromiseRejectReactions;
			PromiseRejectReactions = new List<PromiseReaction>();
			PromiseFulfillReactions.Clear();
			TaskCompletionSource.SetCanceled();
			return PromiseOperations.TriggerPromiseReactions(_engine, promiseRejectReactions, reason);
		}

		private JsValue FulfillPromise(JsValue result)
		{
			if (State != PromiseState.Pending)
			{
				ExceptionHelper.ThrowInvalidOperationException("Promise should be in Pending state");
			}
			Settle(PromiseState.Fulfilled, result);
			List<PromiseReaction> promiseFulfillReactions = PromiseFulfillReactions;
			PromiseFulfillReactions = new List<PromiseReaction>();
			PromiseRejectReactions.Clear();
			TaskCompletionSource.SetResult(this);
			return PromiseOperations.TriggerPromiseReactions(_engine, promiseFulfillReactions, result);
		}

		private void Settle(PromiseState state, JsValue result)
		{
			State = state;
			Value = result;
		}
	}
	internal sealed class JsProxy : ObjectInstance, IConstructor, ICallable
	{
		internal ObjectInstance _target;

		internal ObjectInstance? _handler;

		private static readonly JsString TrapApply = new JsString("apply");

		private static readonly JsString TrapGet = new JsString("get");

		private static readonly JsString TrapSet = new JsString("set");

		private static readonly JsString TrapPreventExtensions = new JsString("preventExtensions");

		private static readonly JsString TrapIsExtensible = new JsString("isExtensible");

		private static readonly JsString TrapDefineProperty = new JsString("defineProperty");

		private static readonly JsString TrapDeleteProperty = new JsString("deleteProperty");

		private static readonly JsString TrapGetOwnPropertyDescriptor = new JsString("getOwnPropertyDescriptor");

		private static readonly JsString TrapHas = new JsString("has");

		private static readonly JsString TrapGetProtoTypeOf = new JsString("getPrototypeOf");

		private static readonly JsString TrapSetProtoTypeOf = new JsString("setPrototypeOf");

		private static readonly JsString TrapOwnKeys = new JsString("ownKeys");

		private static readonly JsString TrapConstruct = new JsString("construct");

		private static readonly JsString KeyFunctionRevoke = new JsString("revoke");

		private static readonly JsString KeyIsArray = new JsString("isArray");

		internal override bool IsConstructor
		{
			get
			{
				if ((object)_target != null && _target.IsConstructor)
				{
					return true;
				}
				if ((object)_handler != null && _handler.TryGetValue(TrapConstruct, out JsValue value) && value is IConstructor)
				{
					return true;
				}
				return false;
			}
		}

		public override bool Extensible
		{
			get
			{
				JsString trapIsExtensible = TrapIsExtensible;
				JsValue[] arguments = new ObjectInstance[1] { _target };
				if (!TryCallHandler(trapIsExtensible, arguments, out JsValue result))
				{
					return _target.Extensible;
				}
				bool num = TypeConverter.ToBoolean(result);
				bool extensible = _target.Extensible;
				if (num != extensible)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
				return num;
			}
		}

		internal override bool IsCallable { get; }

		public JsProxy(Engine engine, ObjectInstance target, ObjectInstance handler)
			: base(engine, target.Class)
		{
			_target = target;
			_handler = handler;
			IsCallable = target.IsCallable;
		}

		JsValue ICallable.Call(JsValue thisObject, JsValue[] arguments)
		{
			if (!(_target is ICallable))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "(intermediate value) is not a function");
			}
			JsValue[] arguments2 = new JsValue[3]
			{
				_target,
				thisObject,
				_engine.Realm.Intrinsics.Array.ConstructFast(arguments)
			};
			if (TryCallHandler(TrapApply, arguments2, out JsValue result))
			{
				return result;
			}
			ICallable obj = _target as ICallable;
			if (obj == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, _target?.ToString() + " is not a function");
			}
			return obj.Call(thisObject, arguments);
		}

		ObjectInstance IConstructor.Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (!(_target is ICallable))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "(intermediate value) is not a constructor");
			}
			ObjectInstance objectInstance = _engine.Realm.Intrinsics.Array.Construct(arguments, _engine.Realm.Intrinsics.Array);
			if (!TryCallHandler(TrapConstruct, new JsValue[3] { _target, objectInstance, newTarget }, out JsValue result))
			{
				IConstructor obj = _target as IConstructor;
				if (obj == null)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
				return obj.Construct(arguments, newTarget);
			}
			ObjectInstance obj2 = result as ObjectInstance;
			if ((object)obj2 == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return obj2;
		}

		internal override bool IsArray()
		{
			AssertNotRevoked(KeyIsArray);
			return _target.IsArray();
		}

		public override object ToObject()
		{
			return _target.ToObject();
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			AssertTargetNotRevoked(property);
			ObjectInstance target = _target;
			if (KeyFunctionRevoke.Equals(property) || !TryCallHandler(TrapGet, new JsValue[3]
			{
				target,
				TypeConverter.ToPropertyKey(property),
				receiver
			}, out JsValue result))
			{
				return target.Get(property, receiver);
			}
			PropertyDescriptor ownProperty = target.GetOwnProperty(property);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				if (ownProperty.IsDataDescriptor())
				{
					JsValue value = ownProperty.Value;
					if (!ownProperty.Configurable && !ownProperty.Writable && !JsValue.SameValue(result, value))
					{
						ExceptionHelper.ThrowTypeError(_engine.Realm, $"'get' on proxy: property '{property}' is a read-only and non-configurable data property on the proxy target but the proxy did not return its actual value (expected '{value}' but got '{result}')");
					}
				}
				if (ownProperty.IsAccessorDescriptor() && !ownProperty.Configurable && (ownProperty.Get ?? JsValue.Undefined).IsUndefined() && !result.IsUndefined())
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm, $"'get' on proxy: property '{property}' is a non-configurable accessor property on the proxy target and does not have a getter function, but the trap did not return 'undefined' (got '{result}')");
				}
			}
			return result;
		}

		public override List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			JsString trapOwnKeys = TrapOwnKeys;
			JsValue[] arguments = new ObjectInstance[1] { _target };
			if (!TryCallHandler(trapOwnKeys, arguments, out JsValue result))
			{
				return _target.GetOwnPropertyKeys(types);
			}
			List<JsValue> list = new List<JsValue>(FunctionPrototype.CreateListFromArrayLike(_engine.Realm, result, Types.String | Types.Symbol));
			if (list.Count != new HashSet<JsValue>(list).Count)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			bool extensible = _target.Extensible;
			List<JsValue> ownPropertyKeys = _target.GetOwnPropertyKeys();
			List<JsValue> list2 = new List<JsValue>();
			List<JsValue> list3 = new List<JsValue>();
			foreach (JsValue item3 in ownPropertyKeys)
			{
				PropertyDescriptor ownProperty = _target.GetOwnProperty(item3);
				if (ownProperty != PropertyDescriptor.Undefined && !ownProperty.Configurable)
				{
					list3.Add(item3);
				}
				else
				{
					list2.Add(item3);
				}
			}
			HashSet<JsValue> hashSet = new HashSet<JsValue>(list);
			for (int i = 0; i < list3.Count; i++)
			{
				JsValue item = list3[i];
				if (!hashSet.Remove(item))
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
			}
			if (extensible)
			{
				return list;
			}
			for (int j = 0; j < list2.Count; j++)
			{
				JsValue item2 = list2[j];
				if (!hashSet.Remove(item2))
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
			}
			if (hashSet.Count > 0)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return list;
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (!TryCallHandler(TrapGetOwnPropertyDescriptor, new JsValue[2]
			{
				_target,
				TypeConverter.ToPropertyKey(property)
			}, out JsValue result))
			{
				return _target.GetOwnProperty(property);
			}
			if (!result.IsObject() && !result.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			PropertyDescriptor ownProperty = _target.GetOwnProperty(property);
			if (result.IsUndefined())
			{
				if (ownProperty == PropertyDescriptor.Undefined)
				{
					return ownProperty;
				}
				if (!ownProperty.Configurable || !_target.Extensible)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
				return PropertyDescriptor.Undefined;
			}
			bool extensible = _target.Extensible;
			PropertyDescriptor propertyDescriptor = PropertyDescriptor.ToPropertyDescriptor(_engine.Realm, result);
			CompletePropertyDescriptor(propertyDescriptor);
			if (!IsCompatiblePropertyDescriptor(extensible, propertyDescriptor, ownProperty))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			if (!propertyDescriptor.Configurable)
			{
				if (ownProperty == PropertyDescriptor.Undefined || ownProperty.Configurable)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
				if (propertyDescriptor.WritableSet && !propertyDescriptor.Writable && ownProperty.Writable)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
			}
			return propertyDescriptor;
		}

		private static void CompletePropertyDescriptor(PropertyDescriptor desc)
		{
			if (desc.IsGenericDescriptor() || desc.IsDataDescriptor())
			{
				if ((object)desc.Value == null)
				{
					JsValue jsValue = (desc.Value = JsValue.Undefined);
				}
				if (!desc.WritableSet)
				{
					desc.Writable = false;
				}
			}
			else
			{
				GetSetPropertyDescriptor obj = (GetSetPropertyDescriptor)desc;
				obj.SetGet(obj.Get ?? JsValue.Undefined);
				obj.SetSet(obj.Set ?? JsValue.Undefined);
			}
			if (!desc.EnumerableSet)
			{
				desc.Enumerable = false;
			}
			if (!desc.ConfigurableSet)
			{
				desc.Configurable = false;
			}
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			if (!TryCallHandler(TrapSet, new JsValue[4]
			{
				_target,
				TypeConverter.ToPropertyKey(property),
				value,
				receiver
			}, out JsValue result))
			{
				return _target.Set(property, value, receiver);
			}
			if (!TypeConverter.ToBoolean(result))
			{
				return false;
			}
			PropertyDescriptor ownProperty = _target.GetOwnProperty(property);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				if (ownProperty.IsDataDescriptor() && !ownProperty.Configurable && !ownProperty.Writable && !JsValue.SameValue(ownProperty.Value, value))
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm, $"'set' on proxy: trap returned truish for property '{property}' which exists in the proxy target as a non-configurable and non-writable data property with a different value");
				}
				if (ownProperty.IsAccessorDescriptor() && !ownProperty.Configurable && (ownProperty.Set ?? JsValue.Undefined).IsUndefined())
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm, $"'set' on proxy: trap returned truish for property '{property}' which exists in the proxy target as a non-configurable and non-writable accessor property without a setter");
				}
			}
			return true;
		}

		public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			JsValue[] arguments = new JsValue[3]
			{
				_target,
				TypeConverter.ToPropertyKey(property),
				PropertyDescriptor.FromPropertyDescriptor(_engine, desc, strictUndefined: true)
			};
			if (!TryCallHandler(TrapDefineProperty, arguments, out JsValue result))
			{
				return _target.DefineOwnProperty(property, desc);
			}
			if (!TypeConverter.ToBoolean(result))
			{
				return false;
			}
			PropertyDescriptor ownProperty = _target.GetOwnProperty(property);
			bool extensible = _target.Extensible;
			bool flag = desc.ConfigurableSet && !desc.Configurable;
			if (ownProperty == PropertyDescriptor.Undefined)
			{
				if (!extensible || flag)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
			}
			else
			{
				if (!IsCompatiblePropertyDescriptor(extensible, desc, ownProperty))
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
				if (ownProperty.Configurable && flag)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
				if (ownProperty.IsDataDescriptor() && !ownProperty.Configurable && ownProperty.Writable && desc.WritableSet && !desc.Writable)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm);
				}
			}
			return true;
		}

		private static bool IsCompatiblePropertyDescriptor(bool extensible, PropertyDescriptor desc, PropertyDescriptor current)
		{
			return ObjectInstance.ValidateAndApplyPropertyDescriptor(null, JsString.Empty, extensible, desc, current);
		}

		public override bool HasProperty(JsValue property)
		{
			if (!TryCallHandler(TrapHas, new JsValue[2]
			{
				_target,
				TypeConverter.ToPropertyKey(property)
			}, out JsValue result))
			{
				return _target.HasProperty(property);
			}
			bool num = TypeConverter.ToBoolean(result);
			if (!num)
			{
				PropertyDescriptor ownProperty = _target.GetOwnProperty(property);
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					if (!ownProperty.Configurable)
					{
						ExceptionHelper.ThrowTypeError(_engine.Realm);
					}
					if (!_target.Extensible)
					{
						ExceptionHelper.ThrowTypeError(_engine.Realm);
					}
				}
			}
			return num;
		}

		public override bool Delete(JsValue property)
		{
			if (!TryCallHandler(TrapDeleteProperty, new JsValue[2]
			{
				_target,
				TypeConverter.ToPropertyKey(property)
			}, out JsValue result))
			{
				return _target.Delete(property);
			}
			if (!TypeConverter.ToBoolean(result))
			{
				return false;
			}
			PropertyDescriptor ownProperty = _target.GetOwnProperty(property);
			if (ownProperty == PropertyDescriptor.Undefined)
			{
				return true;
			}
			if (!ownProperty.Configurable)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, $"'deleteProperty' on proxy: trap returned truish for property '{property}' which is non-configurable in the proxy target");
			}
			if (!_target.Extensible)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return true;
		}

		public override bool PreventExtensions()
		{
			JsString trapPreventExtensions = TrapPreventExtensions;
			JsValue[] arguments = new ObjectInstance[1] { _target };
			if (!TryCallHandler(trapPreventExtensions, arguments, out JsValue result))
			{
				return _target.PreventExtensions();
			}
			bool num = TypeConverter.ToBoolean(result);
			if (num && _target.Extensible)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return num;
		}

		protected internal override ObjectInstance? GetPrototypeOf()
		{
			JsString trapGetProtoTypeOf = TrapGetProtoTypeOf;
			JsValue[] arguments = new ObjectInstance[1] { _target };
			if (!TryCallHandler(trapGetProtoTypeOf, arguments, out JsValue result))
			{
				return _target.Prototype;
			}
			if (!result.IsObject() && !result.IsNull())
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "'getPrototypeOf' on proxy: trap returned neither object nor null");
			}
			if (_target.Extensible)
			{
				return (ObjectInstance)result;
			}
			if ((object)result != _target.Prototype)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return (ObjectInstance)result;
		}

		internal override bool SetPrototypeOf(JsValue value)
		{
			if (!TryCallHandler(TrapSetProtoTypeOf, new JsValue[2] { _target, value }, out JsValue result))
			{
				return _target.SetPrototypeOf(value);
			}
			if (!TypeConverter.ToBoolean(result))
			{
				return false;
			}
			if (_target.Extensible)
			{
				return true;
			}
			if ((object)value != _target.Prototype)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return true;
		}

		private bool TryCallHandler(JsValue propertyName, JsValue[] arguments, out JsValue result)
		{
			AssertNotRevoked(propertyName);
			result = JsValue.Undefined;
			JsValue jsValue = _handler.Get(propertyName);
			if (!jsValue.IsNullOrUndefined())
			{
				ICallable callable = jsValue as ICallable;
				if (callable == null)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm, $"{_handler} returned for property '{propertyName}' of object '{_target}' is not a function");
				}
				result = callable.Call(_handler, arguments);
				return true;
			}
			return false;
		}

		private void AssertNotRevoked(JsValue key)
		{
			if ((object)_handler == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, $"Cannot perform '{key}' on a proxy that has been revoked");
			}
		}

		private void AssertTargetNotRevoked(JsValue key)
		{
			if ((object)_target == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, $"Cannot perform '{key}' on a proxy that has been revoked");
			}
		}

		public override string ToString()
		{
			if (!IsCallable)
			{
				return base.ToString();
			}
			return "function () { [native code] }";
		}
	}
	public sealed class JsRegExp : ObjectInstance
	{
		internal const string regExpForMatchingAllCharacters = "(?:)";

		internal static readonly JsString PropertyLastIndex = new JsString("lastIndex");

		private string _flags;

		private PropertyDescriptor _prototypeDescriptor;

		public Regex Value { get; set; }

		public string Source { get; set; }

		public string Flags
		{
			get
			{
				return _flags;
			}
			set
			{
				_flags = value;
				string flags = _flags;
				for (int i = 0; i < flags.Length; i++)
				{
					switch (flags[i])
					{
					case 'd':
						Indices = true;
						break;
					case 'i':
						IgnoreCase = true;
						break;
					case 'm':
						Multiline = true;
						break;
					case 'g':
						Global = true;
						break;
					case 's':
						DotAll = true;
						break;
					case 'y':
						Sticky = true;
						break;
					case 'u':
						FullUnicode = true;
						break;
					case 'v':
						UnicodeSets = true;
						break;
					}
				}
			}
		}

		public RegExpParseResult ParseResult { get; set; }

		public bool DotAll { get; private set; }

		public bool Global { get; private set; }

		public bool Indices { get; private set; }

		public bool IgnoreCase { get; private set; }

		public bool Multiline { get; private set; }

		public bool Sticky { get; private set; }

		public bool FullUnicode { get; private set; }

		public bool UnicodeSets { get; private set; }

		internal bool HasDefaultRegExpExec
		{
			get
			{
				if (base.Properties == null)
				{
					if (base.Prototype is RegExpPrototype regExpPrototype)
					{
						return regExpPrototype.HasDefaultExec;
					}
					return false;
				}
				return false;
			}
		}

		public JsRegExp(Engine engine)
			: base(engine, ObjectClass.RegExp)
		{
			Source = "(?:)";
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (PropertyLastIndex.Equals(property))
			{
				return _prototypeDescriptor ?? PropertyDescriptor.Undefined;
			}
			return base.GetOwnProperty(property);
		}

		protected internal override void SetOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			if (PropertyLastIndex.Equals(property))
			{
				_prototypeDescriptor = desc;
			}
			else
			{
				base.SetOwnProperty(property, desc);
			}
		}

		public override IEnumerable<KeyValuePair<JsValue, PropertyDescriptor>> GetOwnProperties()
		{
			if (_prototypeDescriptor != null)
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(PropertyLastIndex, _prototypeDescriptor);
			}
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in base.GetOwnProperties())
			{
				yield return ownProperty;
			}
		}

		public override List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			List<JsValue> list = new List<JsValue>();
			if (_prototypeDescriptor != null)
			{
				list.Add(PropertyLastIndex);
			}
			list.AddRange(base.GetOwnPropertyKeys(types));
			return list;
		}
	}
	internal sealed class JsSet : ObjectInstance
	{
		internal readonly OrderedSet<JsValue> _set;

		public int Size => _set.Count;

		public JsValue? this[int index]
		{
			get
			{
				if (index >= _set._list.Count)
				{
					return null;
				}
				return _set._list[index];
			}
		}

		public JsSet(Engine engine)
			: this(engine, new OrderedSet<JsValue>(SameValueZeroComparer.Instance))
		{
		}

		public JsSet(Engine engine, OrderedSet<JsValue> set)
			: base(engine)
		{
			_set = set;
			_prototype = _engine.Realm.Intrinsics.Set.PrototypeObject;
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (CommonProperties.Size.Equals(property))
			{
				return new PropertyDescriptor(_set.Count, PropertyFlag.AllForbidden);
			}
			return base.GetOwnProperty(property);
		}

		protected override bool TryGetProperty(JsValue property, [NotNullWhen(true)] out PropertyDescriptor? descriptor)
		{
			if (CommonProperties.Size.Equals(property))
			{
				descriptor = new PropertyDescriptor(_set.Count, PropertyFlag.AllForbidden);
				return true;
			}
			return base.TryGetProperty(property, out descriptor);
		}

		internal void Add(JsValue value)
		{
			_set.Add(value);
		}

		internal void Remove(JsValue value)
		{
			_set.Remove(value);
		}

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

		internal bool Has(JsValue key)
		{
			return _set.Contains(key);
		}

		internal bool SetDelete(JsValue key)
		{
			return _set.Remove(key);
		}

		internal void ForEach(ICallable callable, JsValue thisArg)
		{
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = this;
			for (int i = 0; i < _set._list.Count; i++)
			{
				array[1] = (array[0] = _set._list[i]);
				callable.Call(thisArg, array);
			}
			_engine._jsValueArrayPool.ReturnArray(array);
		}

		internal ObjectInstance Entries()
		{
			return _engine.Realm.Intrinsics.SetIteratorPrototype.ConstructEntryIterator(this);
		}

		internal ObjectInstance Values()
		{
			return _engine.Realm.Intrinsics.SetIteratorPrototype.ConstructValueIterator(this);
		}
	}
	internal sealed class JsSharedArrayBuffer : JsArrayBuffer
	{
		private readonly int _arrayBufferByteLengthData;

		internal override int ArrayBufferByteLength => _arrayBufferByteLengthData;

		internal override bool IsSharedArrayBuffer => true;

		internal JsSharedArrayBuffer(Engine engine, byte[] data, uint? arrayBufferMaxByteLength, uint arrayBufferByteLengthData)
			: base(engine, data, arrayBufferMaxByteLength)
		{
			if (arrayBufferByteLengthData > int.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(engine.Realm, "arrayBufferByteLengthData cannot be larger than int32.MaxValue");
			}
			_arrayBufferByteLengthData = (int)arrayBufferByteLengthData;
		}

		internal static byte[] CreateSharedByteDataBlock(Realm realm, ulong byteLength)
		{
			if (byteLength > int.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(realm, "Array buffer allocation failed");
			}
			return new byte[byteLength];
		}
	}
	[DebuggerDisplay("{ToString()}")]
	public class JsString : JsValue, IEquatable<JsString>, IEquatable<string>
	{
		internal sealed class ConcatenatedString : JsString
		{
			private StringBuilder? _stringBuilder;

			private bool _dirty;

			public override char this[int index] => _stringBuilder?[index] ?? _value[index];

			public override int Length => _stringBuilder?.Length ?? _value?.Length ?? 0;

			internal ConcatenatedString(string value, int capacity = 0)
				: base(value, InternalTypes.String | InternalTypes.RequiresCloning)
			{
				if (capacity > 0)
				{
					_stringBuilder = new StringBuilder(value, capacity);
				}
				else
				{
					_value = value;
				}
			}

			public override string ToString()
			{
				if (_dirty)
				{
					_value = _stringBuilder.ToString();
					_dirty = false;
				}
				return _value;
			}

			internal override JsString Append(JsValue jsValue)
			{
				string text = TypeConverter.ToString(jsValue);
				if (_stringBuilder == null)
				{
					_stringBuilder = new StringBuilder(_value, _value.Length + text.Length);
				}
				_stringBuilder.Append(text);
				_dirty = true;
				return this;
			}

			internal override JsString EnsureCapacity(int capacity)
			{
				_stringBuilder.EnsureCapacity(capacity);
				return this;
			}

			public override bool Equals(string? s)
			{
				if (s == null || Length != s.Length)
				{
					return false;
				}
				if (_stringBuilder != null)
				{
					for (int i = 0; i < _stringBuilder.Length; i++)
					{
						if (_stringBuilder[i] != s[i])
						{
							return false;
						}
					}
					return true;
				}
				return string.Equals(_value, s, StringComparison.Ordinal);
			}

			public override bool Equals(JsString? other)
			{
				if (other is ConcatenatedString concatenatedString)
				{
					StringBuilder stringBuilder = _stringBuilder;
					StringBuilder stringBuilder2 = concatenatedString._stringBuilder;
					if (stringBuilder != null && stringBuilder2 != null && stringBuilder.Length == stringBuilder2.Length)
					{
						for (int i = 0; i < stringBuilder.Length; i++)
						{
							if (stringBuilder[i] != stringBuilder2[i])
							{
								return false;
							}
						}
						return true;
					}
					return string.Equals(ToString(), concatenatedString.ToString(), StringComparison.Ordinal);
				}
				if ((object)other == null || other.Length != Length)
				{
					return false;
				}
				return string.Equals(ToString(), other.ToString(), StringComparison.Ordinal);
			}

			public override int GetHashCode()
			{
				return _stringBuilder?.GetHashCode() ?? StringComparer.Ordinal.GetHashCode(_value);
			}

			internal override JsValue DoClone()
			{
				return new JsString(ToString());
			}
		}

		private const int AsciiMax = 126;

		private static readonly JsString[] _charToJsValue;

		private static readonly JsString[] _charToStringJsValue;

		private static readonly JsString[] _intToStringJsValue;

		public static readonly JsString Empty;

		internal static readonly JsString NullString;

		internal static readonly JsString UndefinedString;

		internal static readonly JsString ObjectString;

		internal static readonly JsString FunctionString;

		internal static readonly JsString BooleanString;

		internal static readonly JsString StringString;

		internal static readonly JsString NumberString;

		internal static readonly JsString BigIntString;

		internal static readonly JsString SymbolString;

		internal static readonly JsString DefaultString;

		internal static readonly JsString NumberZeroString;

		internal static readonly JsString NumberOneString;

		internal static readonly JsString TrueString;

		internal static readonly JsString FalseString;

		internal static readonly JsString LengthString;

		internal static readonly JsValue CommaString;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal string _value;

		private static ConcurrentDictionary<string, JsString> _stringCache;

		public virtual char this[int index] => _value[index];

		public virtual int Length => _value.Length;

		static JsString()
		{
			_charToJsValue = new JsString[127];
			_charToStringJsValue = new JsString[127];
			for (int i = 0; i <= 126; i++)
			{
				_charToJsValue[i] = new JsString((char)i);
				_charToStringJsValue[i] = new JsString(((char)i).ToString());
			}
			_intToStringJsValue = new JsString[1024];
			for (int j = 0; j < _intToStringJsValue.Length; j++)
			{
				_intToStringJsValue[j] = new JsString(TypeConverter.ToString(j));
			}
			_stringCache = new ConcurrentDictionary<string, JsString>(StringComparer.Ordinal);
			Empty = new JsString("", InternalTypes.String);
			NullString = CachedCreate("null");
			UndefinedString = CachedCreate("undefined");
			ObjectString = CachedCreate("object");
			FunctionString = CachedCreate("function");
			BooleanString = CachedCreate("boolean");
			StringString = CachedCreate("string");
			NumberString = CachedCreate("number");
			BigIntString = CachedCreate("bigint");
			SymbolString = CachedCreate("symbol");
			DefaultString = CachedCreate("default");
			NumberZeroString = CachedCreate("0");
			NumberOneString = CachedCreate("1");
			TrueString = CachedCreate("true");
			FalseString = CachedCreate("false");
			LengthString = CachedCreate("length");
			CommaString = CachedCreate(",");
		}

		public JsString(string value)
			: this(value, InternalTypes.String)
		{
		}

		private JsString(string value, InternalTypes type)
			: base(type)
		{
			_value = value;
		}

		public JsString(char value)
			: base(Types.String)
		{
			_value = value.ToString();
		}

		public static bool operator ==(JsString? a, JsString? b)
		{
			if ((object)a != null)
			{
				return a.Equals(b);
			}
			if ((object)a == null)
			{
				return (object)b == null;
			}
			if ((object)b != null)
			{
				return a.Equals(b);
			}
			return false;
		}

		public static bool operator ==(JsValue? a, JsString? b)
		{
			if (a is JsString jsString && (object)b != null)
			{
				return jsString.Equals(b);
			}
			if ((object)a == null)
			{
				return (object)b == null;
			}
			if ((object)b != null)
			{
				return a.Equals(b);
			}
			return false;
		}

		public static bool operator ==(JsString? a, JsValue? b)
		{
			if ((object)a != null)
			{
				return a.Equals(b);
			}
			if ((object)a == null)
			{
				return (object)b == null;
			}
			if ((object)b != null)
			{
				return a.Equals(b);
			}
			return false;
		}

		public static bool operator !=(JsString a, JsValue b)
		{
			return !(a == b);
		}

		public static bool operator !=(JsValue a, JsString b)
		{
			return !(a == b);
		}

		public static bool operator !=(JsString a, JsString b)
		{
			return !(a == b);
		}

		internal static JsString Create(string value)
		{
			if (value.Length > 1)
			{
				return new JsString(value);
			}
			if (value.Length == 0)
			{
				return Empty;
			}
			uint num = value[0];
			JsString[] charToStringJsValue = _charToStringJsValue;
			if (num < (uint)charToStringJsValue.Length)
			{
				return charToStringJsValue[num];
			}
			return new JsString(value);
		}

		internal static JsString CachedCreate(string value)
		{
			int length = value.Length;
			if ((length < 2 || length > 10) ? true : false)
			{
				return Create(value);
			}
			return _stringCache.GetOrAdd(value, (string x) => new JsString(x));
		}

		internal static JsString Create(char value)
		{
			JsString[] charToJsValue = _charToJsValue;
			if ((uint)value < (uint)charToJsValue.Length)
			{
				return charToJsValue[(uint)value];
			}
			return new JsString(value);
		}

		internal static JsString Create(int value)
		{
			JsString[] intToStringJsValue = _intToStringJsValue;
			if (value < (uint)intToStringJsValue.Length)
			{
				return intToStringJsValue[value];
			}
			return new JsString(TypeConverter.ToString(value));
		}

		internal static JsValue Create(uint value)
		{
			JsString[] intToStringJsValue = _intToStringJsValue;
			if (value < (uint)intToStringJsValue.Length)
			{
				return intToStringJsValue[value];
			}
			return new JsString(TypeConverter.ToString(value));
		}

		internal static JsValue Create(ulong value)
		{
			JsString[] intToStringJsValue = _intToStringJsValue;
			if (value < (uint)intToStringJsValue.Length)
			{
				return intToStringJsValue[value];
			}
			return new JsString(TypeConverter.ToString(value));
		}

		internal virtual JsString Append(JsValue jsValue)
		{
			return new ConcatenatedString(ToString() + TypeConverter.ToString(jsValue));
		}

		internal virtual JsString EnsureCapacity(int capacity)
		{
			return new ConcatenatedString(_value, capacity);
		}

		public sealed override object ToObject()
		{
			return ToString();
		}

		internal sealed override bool ToBoolean()
		{
			return Length > 0;
		}

		public override string ToString()
		{
			return _value;
		}

		internal bool Contains(char c)
		{
			if (c == '\0')
			{
				return false;
			}
			return ToString().Contains(c);
		}

		internal int IndexOf(string value, int startIndex = 0)
		{
			if (Length - startIndex < value.Length)
			{
				return -1;
			}
			return ToString().IndexOf(value, startIndex, StringComparison.Ordinal);
		}

		internal bool StartsWith(string value, int start = 0)
		{
			if (value.Length + start <= Length)
			{
				return ToString().AsSpan(start).StartsWith(value.AsSpan(), StringComparison.Ordinal);
			}
			return false;
		}

		internal bool EndsWith(string value, int end = 0)
		{
			int num = end - value.Length;
			if (num >= 0)
			{
				return ToString().AsSpan(num, value.Length).EndsWith(value.AsSpan(), StringComparison.Ordinal);
			}
			return false;
		}

		internal string Substring(int startIndex, int length)
		{
			return ToString().Substring(startIndex, length);
		}

		internal string Substring(int startIndex)
		{
			return ToString().Substring(startIndex);
		}

		internal override bool TryGetIterator(Realm realm, [NotNullWhen(true)] out IteratorInstance? iterator, GeneratorKind hint = GeneratorKind.Sync, ICallable? method = null)
		{
			if (realm.Intrinsics.String.PrototypeObject.HasOriginalIterator)
			{
				iterator = new IteratorInstance.StringIterator(realm.GlobalEnv._engine, ToString());
				return true;
			}
			return base.TryGetIterator(realm, out iterator, hint, method);
		}

		public sealed override bool Equals(object? obj)
		{
			return Equals(obj as JsString);
		}

		public sealed override bool Equals(JsValue? other)
		{
			return Equals(other as JsString);
		}

		public virtual bool Equals(string? other)
		{
			if (other != null)
			{
				return string.Equals(ToString(), other, StringComparison.Ordinal);
			}
			return false;
		}

		public virtual bool Equals(JsString? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			return string.Equals(_value, other.ToString(), StringComparison.Ordinal);
		}

		protected internal override bool IsLooselyEqual(JsValue value)
		{
			if (value is JsString other)
			{
				return Equals(other);
			}
			if (value.IsBigInt())
			{
				if (value.IsBigInt() && TypeConverter.TryStringToBigInt(ToString(), out var result))
				{
					return result == value.AsBigInt();
				}
				return false;
			}
			return base.IsLooselyEqual(value);
		}

		public override int GetHashCode()
		{
			return StringComparer.Ordinal.GetHashCode(_value);
		}
	}
	public sealed class JsSymbol : JsValue, IEquatable<JsSymbol>
	{
		internal readonly JsValue _value;

		internal JsSymbol(string value)
			: this(new JsString(value))
		{
		}

		internal JsSymbol(JsValue value)
			: base(Types.Symbol)
		{
			_value = value;
		}

		public override object ToObject()
		{
			return _value;
		}

		public override string ToString()
		{
			string text = (_value.IsUndefined() ? "" : _value.AsString());
			return "Symbol(" + text + ")";
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as JsSymbol);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as JsSymbol);
		}

		public bool Equals(JsSymbol? other)
		{
			return (object)this == other;
		}

		public override int GetHashCode()
		{
			return RuntimeHelpers.GetHashCode(this);
		}
	}
	public sealed class JsTypedArray : ObjectInstance
	{
		internal const uint LengthAuto = uint.MaxValue;

		internal readonly TypedArrayContentType _contentType;

		internal readonly TypedArrayElementType _arrayElementType;

		internal JsArrayBuffer _viewedArrayBuffer;

		internal uint _byteLength;

		internal int _byteOffset;

		private readonly Intrinsics _intrinsics;

		internal uint _arrayLength;

		public JsValue this[int index]
		{
			get
			{
				return IntegerIndexedElementGet(index);
			}
			set
			{
				IntegerIndexedElementSet(index, value);
			}
		}

		public JsValue this[uint index]
		{
			get
			{
				return IntegerIndexedElementGet(index);
			}
			set
			{
				IntegerIndexedElementSet(index, value);
			}
		}

		public uint Length => GetLength();

		internal override bool IsArrayLike => true;

		internal override bool IsIntegerIndexedArray => true;

		internal JsTypedArray(Engine engine, Intrinsics intrinsics, TypedArrayElementType type, uint length)
			: base(engine)
		{
			_intrinsics = intrinsics;
			_viewedArrayBuffer = new JsArrayBuffer(engine, System.Array.Empty<byte>());
			_arrayElementType = type;
			_contentType = ((type == TypedArrayElementType.BigInt64 || type == TypedArrayElementType.BigUint64) ? TypedArrayContentType.BigInt : TypedArrayContentType.Number);
			_arrayLength = length;
		}

		internal override uint GetLength()
		{
			IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(this, ArrayBufferOrder.Unordered);
			if (!typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				return typedArrayWithBufferWitnessRecord.TypedArrayLength;
			}
			return 0u;
		}

		internal void AllocateTypedArrayBuffer(ulong len)
		{
			ulong num = _arrayElementType.GetElementSize() * len;
			JsArrayBuffer viewedArrayBuffer = _intrinsics.ArrayBuffer.AllocateArrayBuffer(_intrinsics.ArrayBuffer, num);
			_byteLength = (uint)num;
			_arrayLength = (uint)len;
			_viewedArrayBuffer = viewedArrayBuffer;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool HasProperty(long numericIndex)
		{
			return IsValidIntegerIndex(numericIndex);
		}

		public override bool HasProperty(JsValue property)
		{
			if (property.IsString())
			{
				double? num = TypeConverter.CanonicalNumericIndexString(property);
				if (num.HasValue)
				{
					return IsValidIntegerIndex(num.Value);
				}
			}
			return base.HasProperty(property);
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			double? num = TypeConverter.CanonicalNumericIndexString(property);
			if (num.HasValue)
			{
				JsValue value = IntegerIndexedElementGet(num.Value);
				if (value.IsUndefined())
				{
					return PropertyDescriptor.Undefined;
				}
				return new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable);
			}
			return base.GetOwnProperty(property);
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			double? num = TypeConverter.CanonicalNumericIndexString(property);
			if (num.HasValue)
			{
				return IntegerIndexedElementGet(num.Value);
			}
			return base.Get(property, receiver);
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			double? num = TypeConverter.CanonicalNumericIndexString(property);
			if (num.HasValue)
			{
				IntegerIndexedElementSet(num.Value, value);
				return true;
			}
			return base.Set(property, value, receiver);
		}

		public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			if (property.IsString())
			{
				double? num = TypeConverter.CanonicalNumericIndexString(property);
				if (num.HasValue)
				{
					if (!IsValidIntegerIndex(num.Value))
					{
						return false;
					}
					if (desc.ConfigurableSet && !desc.Configurable)
					{
						return false;
					}
					if (desc.EnumerableSet && !desc.Enumerable)
					{
						return false;
					}
					if (desc.IsAccessorDescriptor())
					{
						return false;
					}
					if (desc.WritableSet && !desc.Writable)
					{
						return false;
					}
					IntegerIndexedElementSet(num.Value, desc.Value);
					return true;
				}
			}
			return base.DefineOwnProperty(property, desc);
		}

		public override List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(this, ArrayBufferOrder.SeqCst);
			List<JsValue> list = new List<JsValue>();
			if (!typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				uint length = GetLength();
				for (uint num = 0u; num < length; num++)
				{
					list.Add(JsString.Create(num));
				}
			}
			if (_properties != null)
			{
				foreach (KeyValuePair<Key, PropertyDescriptor> item in (IEnumerable<KeyValuePair<Key, PropertyDescriptor>>)_properties)
				{
					list.Add(item.Key.Name);
				}
			}
			if (_symbols != null)
			{
				foreach (KeyValuePair<JsSymbol, PropertyDescriptor> symbol in _symbols)
				{
					list.Add(symbol.Key);
				}
			}
			return list;
		}

		public override bool Delete(JsValue property)
		{
			double? num = TypeConverter.CanonicalNumericIndexString(property);
			if (num.HasValue)
			{
				return !IsValidIntegerIndex(num.Value);
			}
			return base.Delete(property);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private JsValue IntegerIndexedElementGet(int index)
		{
			if (!IsValidIntegerIndex(index))
			{
				return JsValue.Undefined;
			}
			return DoIntegerIndexedElementGet(index);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private JsValue IntegerIndexedElementGet(double index)
		{
			if (!IsValidIntegerIndex(index))
			{
				return JsValue.Undefined;
			}
			return DoIntegerIndexedElementGet((int)index);
		}

		private JsValue DoIntegerIndexedElementGet(int index)
		{
			int byteOffset = _byteOffset;
			TypedArrayElementType arrayElementType = _arrayElementType;
			byte elementSize = arrayElementType.GetElementSize();
			int byteIndex = index * elementSize + byteOffset;
			TypedArrayValue valueFromBuffer = _viewedArrayBuffer.GetValueFromBuffer(byteIndex, arrayElementType, isTypedArray: true, ArrayBufferOrder.Unordered);
			if (valueFromBuffer.Type == Types.Number)
			{
				if (!_arrayElementType.FitsInt32())
				{
					return JsNumber.Create(valueFromBuffer.DoubleValue);
				}
				return JsNumber.Create((int)valueFromBuffer.DoubleValue);
			}
			return JsBigInt.Create(valueFromBuffer.BigInteger);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void IntegerIndexedElementSet(int index, JsValue value)
		{
			TypedArrayValue numValue = ((_contentType != TypedArrayContentType.BigInt) ? ((TypedArrayValue)TypeConverter.ToNumber(value)) : ((TypedArrayValue)value.ToBigInteger(_engine)));
			if (IsValidIntegerIndex(index))
			{
				DoIntegerIndexedElementSet(index, numValue);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void IntegerIndexedElementSet(double index, JsValue value)
		{
			//IL_004a: Expected O, but got Unknown
			if (_contentType != TypedArrayContentType.BigInt)
			{
				double num = TypeConverter.ToNumber(value);
				if (IsValidIntegerIndex(index))
				{
					DoIntegerIndexedElementSet((int)index, num);
				}
				return;
			}
			try
			{
				BigInteger bigInteger = TypeConverter.ToBigInt(value);
				if (IsValidIntegerIndex(index))
				{
					DoIntegerIndexedElementSet((int)index, bigInteger);
				}
			}
			catch (ParserException ex)
			{
				ParserException ex2 = ex;
				ExceptionHelper.ThrowSyntaxError(_engine.Realm, ((Exception)(object)ex2).Message);
			}
		}

		internal void DoIntegerIndexedElementSet(int index, TypedArrayValue numValue)
		{
			int byteOffset = _byteOffset;
			TypedArrayElementType arrayElementType = _arrayElementType;
			byte elementSize = arrayElementType.GetElementSize();
			int byteIndex = index * elementSize + byteOffset;
			_viewedArrayBuffer.SetValueInBuffer(byteIndex, arrayElementType, numValue, isTypedArray: true, ArrayBufferOrder.Unordered);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool IsValidIntegerIndex(double index)
		{
			if (_viewedArrayBuffer.IsDetachedBuffer)
			{
				return false;
			}
			if (!TypeConverter.IsIntegralNumber(index))
			{
				return false;
			}
			if (NumberInstance.IsNegativeZero(index))
			{
				return false;
			}
			return IsValidIntegerIndex((int)index);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool IsValidIntegerIndex(int index)
		{
			if (_viewedArrayBuffer.IsDetachedBuffer)
			{
				return false;
			}
			IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(this, ArrayBufferOrder.Unordered);
			if (typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				return false;
			}
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (index < 0 || index >= typedArrayLength)
			{
				return false;
			}
			return true;
		}

		internal T[] ToNativeArray<T>()
		{
			Type typeFromHandle = typeof(T);
			byte elementSize = _arrayElementType.GetElementSize();
			int byteOffset = _byteOffset;
			JsArrayBuffer viewedArrayBuffer = _viewedArrayBuffer;
			T[] array = new T[GetLength()];
			for (int i = 0; i < array.Length; i++)
			{
				int byteIndex = i * elementSize + byteOffset;
				TypedArrayValue typedArrayValue = viewedArrayBuffer.RawBytesToNumeric(_arrayElementType, byteIndex, BitConverter.IsLittleEndian);
				array[i] = (T)Convert.ChangeType(typedArrayValue, typeFromHandle, CultureInfo.InvariantCulture);
			}
			return array;
		}
	}
	public sealed class JsUndefined : JsValue, IEquatable<JsUndefined>
	{
		internal JsUndefined()
			: base(Types.Undefined)
		{
		}

		public override object? ToObject()
		{
			return null;
		}

		public override string ToString()
		{
			return "undefined";
		}

		protected internal override bool IsLooselyEqual(JsValue value)
		{
			if ((object)JsValue.Undefined != value)
			{
				return (object)JsValue.Null == value;
			}
			return true;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as JsUndefined);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as JsUndefined);
		}

		public bool Equals(JsUndefined? other)
		{
			return (object)other != null;
		}

		public override int GetHashCode()
		{
			return RuntimeHelpers.GetHashCode(this);
		}
	}
	public abstract class JsValue : IConvertible, IEquatable<JsValue>
	{
		public static readonly JsValue Undefined = new JsUndefined();

		public static readonly JsValue Null = new JsNull();

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal readonly InternalTypes _type;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal virtual bool IsIntegerIndexedArray => false;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal virtual bool IsConstructor => false;

		internal bool IsEmpty => (object)this == JsEmpty.Instance;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Types Type
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (_type != InternalTypes.Integer)
				{
					return (Types)(_type & ~InternalTypes.InternalFlags);
				}
				return Types.Number;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal virtual bool IsCallable => this is ICallable;

		TypeCode IConvertible.GetTypeCode()
		{
			return (_type & ~InternalTypes.InternalFlags) switch
			{
				InternalTypes.Boolean => TypeCode.Boolean, 
				InternalTypes.String => TypeCode.String, 
				InternalTypes.Number => TypeCode.Double, 
				InternalTypes.Integer => TypeCode.Int32, 
				InternalTypes.PrivateName => TypeCode.String, 
				InternalTypes.Undefined => TypeCode.Object, 
				InternalTypes.Null => TypeCode.Object, 
				InternalTypes.Object => TypeCode.Object, 
				InternalTypes.PlainObject => TypeCode.Object, 
				InternalTypes.Array => TypeCode.Object, 
				_ => TypeCode.Empty, 
			};
		}

		bool IConvertible.ToBoolean(IFormatProvider? provider)
		{
			return this.AsBoolean();
		}

		byte IConvertible.ToByte(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		char IConvertible.ToChar(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		DateTime IConvertible.ToDateTime(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		decimal IConvertible.ToDecimal(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		double IConvertible.ToDouble(IFormatProvider? provider)
		{
			return this.AsNumber();
		}

		short IConvertible.ToInt16(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		int IConvertible.ToInt32(IFormatProvider? provider)
		{
			return this.AsInteger();
		}

		long IConvertible.ToInt64(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		sbyte IConvertible.ToSByte(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		float IConvertible.ToSingle(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		string IConvertible.ToString(IFormatProvider? provider)
		{
			return this.AsString();
		}

		object IConvertible.ToType(Type conversionType, IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		ushort IConvertible.ToUInt16(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		uint IConvertible.ToUInt32(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		ulong IConvertible.ToUInt64(IFormatProvider? provider)
		{
			throw new NotImplementedException();
		}

		protected JsValue(Types type)
		{
			_type = (InternalTypes)type;
		}

		internal JsValue(InternalTypes type)
		{
			_type = type;
		}

		internal virtual bool IsArray()
		{
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal IteratorInstance GetIterator(Realm realm, GeneratorKind hint = GeneratorKind.Sync, ICallable? method = null)
		{
			if (!TryGetIterator(realm, out IteratorInstance iterator, hint, method))
			{
				ExceptionHelper.ThrowTypeError(realm, "The value is not iterable");
				return null;
			}
			return iterator;
		}

		internal IteratorInstance GetIteratorFromMethod(Realm realm, ICallable method)
		{
			if (!(method.Call(this) is ObjectInstance target))
			{
				ExceptionHelper.ThrowTypeError(realm);
				return null;
			}
			return new IteratorInstance.ObjectIterator(target);
		}

		internal virtual bool TryGetIterator(Realm realm, [NotNullWhen(true)] out IteratorInstance? iterator, GeneratorKind hint = GeneratorKind.Sync, ICallable? method = null)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(realm, this);
			if (method == null)
			{
				if (hint == GeneratorKind.Async)
				{
					method = objectInstance.GetMethod(GlobalSymbolRegistry.AsyncIterator);
					if (method == null)
					{
						ICallable method2 = objectInstance.GetMethod(GlobalSymbolRegistry.Iterator);
						objectInstance.GetIterator(realm, GeneratorKind.Sync, method2);
						ExceptionHelper.ThrowNotImplementedException("async");
					}
				}
				else
				{
					method = objectInstance.GetMethod(GlobalSymbolRegistry.Iterator);
				}
			}
			if (method == null)
			{
				iterator = null;
				return false;
			}
			ObjectInstance objectInstance2 = method.Call(objectInstance, Arguments.Empty) as ObjectInstance;
			if ((object)objectInstance2 == null)
			{
				ExceptionHelper.ThrowTypeError(realm, "Result of the Symbol.iterator method is not an object");
			}
			if (objectInstance2 is IteratorInstance iteratorInstance)
			{
				iterator = iteratorInstance;
			}
			else
			{
				iterator = new IteratorInstance.ObjectIterator(objectInstance2);
			}
			return true;
		}

		internal static JsValue ConvertAwaitableToPromise(Engine engine, object obj)
		{
			if (obj is Task task)
			{
				return ConvertTaskToPromise(engine, task);
			}
			if (obj is ValueTask valueTask)
			{
				return ConvertTaskToPromise(engine, valueTask.AsTask());
			}
			MethodInfo method = obj.GetType().GetMethod("AsTask");
			if ((object)method != null)
			{
				return ConvertTaskToPromise(engine, (Task)method.Invoke(obj, null));
			}
			return FromObject(engine, Undefined);
		}

		internal static JsValue ConvertTaskToPromise(Engine engine, Task task)
		{
			engine.RegisterPromise().Deconstruct(out JsValue Promise, out Action<JsValue> Resolve, out Action<JsValue> Reject);
			JsValue result = Promise;
			Action<JsValue> resolve = Resolve;
			Action<JsValue> reject = Reject;
			task = task.ContinueWith(delegate(Task continuationAction)
			{
				if (continuationAction.IsFaulted)
				{
					reject(FromObject(engine, continuationAction.Exception));
				}
				else if (continuationAction.IsCanceled)
				{
					reject(FromObject(engine, new ExecutionCanceledException()));
				}
				else if (Task.CompletedTask.Equals(continuationAction))
				{
					resolve(FromObject(engine, Undefined));
				}
				else
				{
					PropertyInfo property = continuationAction.GetType().GetProperty("Result");
					if ((object)property != null)
					{
						resolve(FromObject(engine, property.GetValue(continuationAction)));
					}
					else
					{
						resolve(FromObject(engine, Undefined));
					}
				}
			});
			return result;
		}

		public static JsValue FromObject(Engine engine, object? value)
		{
			return FromObjectWithType(engine, value, null);
		}

		public static JsValue FromObjectWithType(Engine engine, object? value, Type? type)
		{
			if (value == null)
			{
				return Null;
			}
			if (value is JsValue result)
			{
				return result;
			}
			if (engine._objectConverters != null)
			{
				IObjectConverter[] objectConverters = engine._objectConverters;
				for (int i = 0; i < objectConverters.Length; i++)
				{
					if (objectConverters[i].TryConvert(engine, value, out JsValue result2))
					{
						return result2;
					}
				}
			}
			if (DefaultObjectConverter.TryConvert(engine, value, type, out JsValue result3))
			{
				return result3;
			}
			return null;
		}

		public abstract object? ToObject();

		internal virtual bool ToBoolean()
		{
			return _type > InternalTypes.Null;
		}

		internal JsValue GetV(Realm realm, JsValue property)
		{
			return TypeConverter.ToObject(realm, this).Get(property, this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public JsValue Get(JsValue property)
		{
			return Get(property, this);
		}

		public virtual JsValue Get(JsValue property, JsValue receiver)
		{
			return Undefined;
		}

		public virtual bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			ExceptionHelper.ThrowNotSupportedException();
			return false;
		}

		internal bool InstanceofOperator(JsValue target)
		{
			if (!(target is ObjectInstance objectInstance))
			{
				ExceptionHelper.ThrowTypeErrorNoEngine("Right-hand side of 'instanceof' is not an object");
				return false;
			}
			ICallable method = objectInstance.GetMethod(GlobalSymbolRegistry.HasInstance);
			if (method != null)
			{
				return TypeConverter.ToBoolean(method.Call(target, this));
			}
			if (!target.IsCallable)
			{
				ExceptionHelper.ThrowTypeErrorNoEngine("Right-hand side of 'instanceof' is not callable");
			}
			return target.OrdinaryHasInstance(this);
		}

		public override string ToString()
		{
			return "None";
		}

		public static bool operator ==(JsValue? a, JsValue? b)
		{
			if ((object)a == null)
			{
				return (object)b == null;
			}
			if ((object)b != null)
			{
				return a.Equals(b);
			}
			return false;
		}

		public static bool operator !=(JsValue? a, JsValue? b)
		{
			return !(a == b);
		}

		public static implicit operator JsValue(char value)
		{
			return JsString.Create(value);
		}

		public static implicit operator JsValue(int value)
		{
			return JsNumber.Create(value);
		}

		public static implicit operator JsValue(uint value)
		{
			return JsNumber.Create(value);
		}

		public static implicit operator JsValue(double value)
		{
			return JsNumber.Create(value);
		}

		public static implicit operator JsValue(long value)
		{
			return JsNumber.Create(value);
		}

		public static implicit operator JsValue(ulong value)
		{
			return JsNumber.Create(value);
		}

		public static implicit operator JsValue(BigInteger value)
		{
			return JsBigInt.Create(value);
		}

		public static implicit operator JsValue(bool value)
		{
			if (!value)
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		[DebuggerStepThrough]
		public static implicit operator JsValue(string? value)
		{
			if (value != null)
			{
				return JsString.Create(value);
			}
			return Null;
		}

		protected internal virtual bool IsLooselyEqual(JsValue value)
		{
			if ((object)this == value)
			{
				return true;
			}
			if (this.IsNumber() && value.IsString())
			{
				return IsLooselyEqual(TypeConverter.ToNumber(value));
			}
			if (this.IsString() && value.IsNumber())
			{
				return value.IsLooselyEqual(TypeConverter.ToNumber(this));
			}
			if (this.IsBoolean())
			{
				return value.IsLooselyEqual(TypeConverter.ToNumber(this));
			}
			if (value.IsBoolean())
			{
				return IsLooselyEqual(TypeConverter.ToNumber(value));
			}
			if (value.IsObject() && (_type & InternalTypes.Primitive) != InternalTypes.Empty)
			{
				return IsLooselyEqual(TypeConverter.ToPrimitive(value));
			}
			if (this.IsObject() && (value._type & InternalTypes.Primitive) != InternalTypes.Empty)
			{
				return value.IsLooselyEqual(TypeConverter.ToPrimitive(this));
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as JsValue);
		}

		public virtual bool Equals(JsValue? other)
		{
			return (object)this == other;
		}

		public override int GetHashCode()
		{
			return _type.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal JsValue Clone()
		{
			if ((_type & InternalTypes.RequiresCloning) != InternalTypes.Empty)
			{
				return DoClone();
			}
			return this;
		}

		internal virtual JsValue DoClone()
		{
			return this;
		}

		internal virtual bool OrdinaryHasInstance(JsValue v)
		{
			if (!IsCallable)
			{
				return false;
			}
			ObjectInstance objectInstance = v as ObjectInstance;
			if ((object)objectInstance == null)
			{
				return false;
			}
			JsValue jsValue = Get(CommonProperties.Prototype);
			if (!(jsValue is ObjectInstance))
			{
				ExceptionHelper.ThrowTypeError(objectInstance.Engine.Realm, "Function has non-object prototype '" + TypeConverter.ToString(jsValue) + "' in instanceof check");
			}
			do
			{
				objectInstance = objectInstance.Prototype;
				if ((object)objectInstance == null)
				{
					return false;
				}
			}
			while (!SameValue(jsValue, objectInstance));
			return true;
		}

		internal static bool SameValue(JsValue x, JsValue y)
		{
			if ((object)x == y)
			{
				return true;
			}
			Types type = x.Type;
			Types type2 = y.Type;
			if (type != type2)
			{
				return false;
			}
			switch (type)
			{
			case Types.Number:
			{
				if (x._type == y._type && x._type == InternalTypes.Integer)
				{
					return x.AsInteger() == y.AsInteger();
				}
				double num = TypeConverter.ToNumber(x);
				double num2 = TypeConverter.ToNumber(y);
				if (double.IsNaN(num) && double.IsNaN(num2))
				{
					return true;
				}
				if (num == num2)
				{
					if (num == 0.0)
					{
						return NumberInstance.IsNegativeZero(num) == NumberInstance.IsNegativeZero(num2);
					}
					return true;
				}
				return false;
			}
			case Types.String:
				return string.Equals(TypeConverter.ToString(x), TypeConverter.ToString(y), StringComparison.Ordinal);
			case Types.Boolean:
				return TypeConverter.ToBoolean(x) == TypeConverter.ToBoolean(y);
			case Types.Undefined:
			case Types.Null:
				return true;
			case Types.Symbol:
				return x == y;
			case Types.Object:
				if (x is ObjectWrapper objectWrapper && y is ObjectWrapper objectWrapper2)
				{
					return objectWrapper.Target == objectWrapper2.Target;
				}
				return false;
			default:
				return false;
			}
		}

		internal static IConstructor AssertConstructor(Engine engine, JsValue c)
		{
			if (!c.IsConstructor)
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, c?.ToString() + " is not a constructor");
			}
			return (IConstructor)c;
		}
	}
	internal sealed class JsWeakMap : ObjectInstance
	{
		private readonly ConditionalWeakTable<JsValue, JsValue> _table;

		public JsWeakMap(Engine engine)
			: base(engine)
		{
			_table = new ConditionalWeakTable<JsValue, JsValue>();
		}

		internal bool WeakMapHas(JsValue key)
		{
			JsValue value;
			return _table.TryGetValue(key, out value);
		}

		internal bool WeakMapDelete(JsValue key)
		{
			return _table.Remove(key);
		}

		internal void WeakMapSet(JsValue key, JsValue value)
		{
			if (!key.CanBeHeldWeakly(_engine.GlobalSymbolRegistry))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "WeakMap key must be an object, got " + key);
			}
			_table.AddOrUpdate(key, value);
		}

		internal JsValue WeakMapGet(JsValue key)
		{
			if (!_table.TryGetValue(key, out JsValue value))
			{
				return JsValue.Undefined;
			}
			return value;
		}
	}
	internal sealed class JsWeakRef : ObjectInstance
	{
		private readonly WeakReference<JsValue> _weakRefTarget;

		public JsWeakRef(Engine engine, JsValue target)
			: base(engine)
		{
			_weakRefTarget = new WeakReference<JsValue>(target);
		}

		public JsValue WeakRefDeref()
		{
			if (_weakRefTarget.TryGetTarget(out JsValue target))
			{
				_engine.AddToKeptObjects(target);
				return target;
			}
			return JsValue.Undefined;
		}
	}
	internal sealed class JsWeakSet : ObjectInstance
	{
		private readonly ConditionalWeakTable<JsValue, JsValue> _table;

		public JsWeakSet(Engine engine)
			: base(engine)
		{
			_table = new ConditionalWeakTable<JsValue, JsValue>();
		}

		internal bool WeakSetHas(JsValue value)
		{
			JsValue value2;
			return _table.TryGetValue(value, out value2);
		}

		internal bool WeakSetDelete(JsValue value)
		{
			return _table.Remove(value);
		}

		internal void WeakSetAdd(JsValue value)
		{
			if (!value.CanBeHeldWeakly(_engine.GlobalSymbolRegistry))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "WeakSet value must be an object or symbol, got " + value);
			}
			_table.AddOrUpdate(value, JsValue.Undefined);
		}
	}
	internal sealed class PrivateName : JsValue, IEquatable<PrivateName>
	{
		private readonly PrivateIdentifier _identifier;

		public string Description { get; }

		public PrivateName(PrivateIdentifier identifier)
			: base(InternalTypes.PrivateName)
		{
			_identifier = identifier;
			Description = identifier.Name;
		}

		public override string ToString()
		{
			return _identifier.Name;
		}

		public override object ToObject()
		{
			throw new NotImplementedException();
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as PrivateName);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as PrivateName);
		}

		public bool Equals(PrivateName? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			return (object)this == other;
		}

		public override int GetHashCode()
		{
			return StringComparer.Ordinal.GetHashCode(_identifier.Name);
		}
	}
	internal sealed class PrivateIdentifierNameComparer : IEqualityComparer<PrivateIdentifier>
	{
		internal static readonly PrivateIdentifierNameComparer _instance = new PrivateIdentifierNameComparer();

		public bool Equals(PrivateIdentifier? x, PrivateIdentifier? y)
		{
			return string.Equals((x != null) ? x.Name : null, (y != null) ? y.Name : null, StringComparison.Ordinal);
		}

		public int GetHashCode(PrivateIdentifier obj)
		{
			return StringComparer.Ordinal.GetHashCode(obj.Name);
		}
	}
	public abstract class Prototype : ObjectInstance
	{
		internal readonly Realm _realm;

		private protected Prototype(Engine engine, Realm realm)
			: base(engine, ObjectClass.Object, InternalTypes.Object | InternalTypes.PlainObject)
		{
			_realm = realm;
		}
	}
	internal sealed class SameValueZeroComparer : IEqualityComparer<JsValue>
	{
		public static readonly SameValueZeroComparer Instance = new SameValueZeroComparer();

		bool IEqualityComparer<JsValue>.Equals(JsValue? x, JsValue? y)
		{
			return Equals(x, y);
		}

		public int GetHashCode(JsValue obj)
		{
			return obj.GetHashCode();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Equals(JsValue? x, JsValue? y)
		{
			if (!(x == y))
			{
				if (x is JsNumber jsNumber && y is JsNumber jsNumber2 && double.IsNaN(jsNumber._value))
				{
					return double.IsNaN(jsNumber2._value);
				}
				return false;
			}
			return true;
		}
	}
}
namespace Jint.Native.WeakSet
{
	internal sealed class WeakSetConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("WeakSet");

		private WeakSetPrototype PrototypeObject { get; }

		internal WeakSetConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new WeakSetPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(0, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsWeakSet jsWeakSet = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.WeakSet.PrototypeObject, (Engine engine, Realm _, object? _) => new JsWeakSet(engine));
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsNullOrUndefined())
			{
				ICallable callable = jsWeakSet.Get("add") as ICallable;
				if (jsValue is JsArray jsArray && callable == _engine.Realm.Intrinsics.WeakSet.PrototypeObject._originalAddFunction)
				{
					foreach (JsValue item in jsArray)
					{
						jsWeakSet.WeakSetAdd(item);
					}
					return jsWeakSet;
				}
				if (callable == null)
				{
					ExceptionHelper.ThrowTypeError(_realm, "add must be callable");
				}
				IteratorInstance iterator = arguments.At(0).GetIterator(_realm);
				try
				{
					JsValue[] array = new JsValue[1];
					ObjectInstance nextItem;
					while (iterator.TryIteratorStep(out nextItem))
					{
						JsValue jsValue2 = nextItem.Get(CommonProperties.Value);
						array[0] = jsValue2;
						callable.Call(jsWeakSet, array);
					}
					return jsWeakSet;
				}
				catch
				{
					iterator.Close(CompletionType.Throw);
					throw;
				}
			}
			return jsWeakSet;
		}
	}
	internal sealed class WeakSetPrototype : Prototype
	{
		private readonly WeakSetConstructor _constructor;

		internal ClrFunction _originalAddFunction;

		internal WeakSetPrototype(Engine engine, Realm realm, WeakSetConstructor constructor, ObjectPrototype prototype)
			: base(engine, realm)
		{
			_prototype = prototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			_originalAddFunction = new ClrFunction(base.Engine, "add", Add, 1, PropertyFlag.Configurable);
			PropertyDictionary properties = new PropertyDictionary(5, checkExistingKeys: false)
			{
				["length"] = new PropertyDescriptor(0, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["delete"] = new PropertyDescriptor(new ClrFunction(base.Engine, "delete", Delete, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["add"] = new PropertyDescriptor(_originalAddFunction, PropertyFlag.Writable | PropertyFlag.Configurable),
				["has"] = new PropertyDescriptor(new ClrFunction(base.Engine, "has", Has, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("WeakSet", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Add(JsValue thisObject, JsValue[] arguments)
		{
			AssertWeakSetInstance(thisObject).WeakSetAdd(arguments.At(0));
			return thisObject;
		}

		private JsValue Delete(JsValue thisObject, JsValue[] arguments)
		{
			if (!AssertWeakSetInstance(thisObject).WeakSetDelete(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsValue Has(JsValue thisObject, JsValue[] arguments)
		{
			if (!AssertWeakSetInstance(thisObject).WeakSetHas(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsWeakSet AssertWeakSetInstance(JsValue thisObject)
		{
			if (thisObject is JsWeakSet result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(_realm, "object must be a WeakSet");
			return null;
		}
	}
}
namespace Jint.Native.WeakRef
{
	internal sealed class WeakRefConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("WeakRef");

		private WeakRefPrototype PrototypeObject { get; }

		internal WeakRefConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new WeakRefPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(1, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue jsValue = arguments.At(0);
			if (!jsValue.CanBeHeldWeakly(_engine.GlobalSymbolRegistry))
			{
				ExceptionHelper.ThrowTypeError(_realm, "WeakRef: target must be an object or symbol");
			}
			JsWeakRef result = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.WeakRef.PrototypeObject, (Engine engine, Realm _, JsValue? target) => new JsWeakRef(engine, target), jsValue);
			_engine.AddToKeptObjects(jsValue);
			return result;
		}
	}
	internal sealed class WeakRefPrototype : Prototype
	{
		private readonly WeakRefConstructor _constructor;

		internal WeakRefPrototype(Engine engine, Realm realm, WeakRefConstructor constructor, ObjectPrototype prototype)
			: base(engine, realm)
		{
			_prototype = prototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(5, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["deref"] = new PropertyDescriptor(new ClrFunction(base.Engine, "deref", Deref, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("WeakRef", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Deref(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is JsWeakRef jsWeakRef)
			{
				return jsWeakRef.WeakRefDeref();
			}
			ExceptionHelper.ThrowTypeError(_realm, "object must be a WeakRef");
			return null;
		}
	}
}
namespace Jint.Native.WeakMap
{
	internal sealed class WeakMapConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("WeakMap");

		public WeakMapPrototype PrototypeObject { get; }

		internal WeakMapConstructor(Engine engine, Realm realm, FunctionPrototype prototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = prototype;
			PrototypeObject = new WeakMapPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(0, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsWeakMap jsWeakMap = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.WeakMap.PrototypeObject, (Engine engine, Realm _, object? _) => new JsWeakMap(engine));
			if (arguments.Length != 0 && !arguments[0].IsNullOrUndefined())
			{
				JsValue adder = jsWeakMap.Get("set");
				IteratorInstance iterator = arguments.At(0).GetIterator(_realm);
				IteratorProtocol.AddEntriesFromIterable(jsWeakMap, iterator, adder);
			}
			return jsWeakMap;
		}
	}
	internal sealed class WeakMapPrototype : Prototype
	{
		private readonly WeakMapConstructor _constructor;

		internal WeakMapPrototype(Engine engine, Realm realm, WeakMapConstructor constructor, ObjectPrototype prototype)
			: base(engine, realm)
		{
			_prototype = prototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(6, checkExistingKeys: false)
			{
				["length"] = new PropertyDescriptor(0, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["delete"] = new PropertyDescriptor(new ClrFunction(base.Engine, "delete", Delete, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["get"] = new PropertyDescriptor(new ClrFunction(base.Engine, "get", Get, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["has"] = new PropertyDescriptor(new ClrFunction(base.Engine, "has", Has, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["set"] = new PropertyDescriptor(new ClrFunction(base.Engine, "set", Set, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("WeakMap", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Get(JsValue thisObject, JsValue[] arguments)
		{
			return AssertWeakMapInstance(thisObject).WeakMapGet(arguments.At(0));
		}

		private JsValue Delete(JsValue thisObject, JsValue[] arguments)
		{
			JsWeakMap jsWeakMap = AssertWeakMapInstance(thisObject);
			if (arguments.Length == 0 || !jsWeakMap.WeakMapDelete(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsValue Set(JsValue thisObject, JsValue[] arguments)
		{
			AssertWeakMapInstance(thisObject).WeakMapSet(arguments.At(0), arguments.At(1));
			return thisObject;
		}

		private JsValue Has(JsValue thisObject, JsValue[] arguments)
		{
			if (!AssertWeakMapInstance(thisObject).WeakMapHas(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsWeakMap AssertWeakMapInstance(JsValue thisObject)
		{
			if (thisObject is JsWeakMap result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(_realm, "object must be a WeakMap");
			return null;
		}
	}
}
namespace Jint.Native.TypedArray
{
	internal sealed class IntrinsicTypedArrayConstructor : Constructor
	{
		public IntrinsicTypedArrayPrototype PrototypeObject { get; }

		internal IntrinsicTypedArrayConstructor(Engine engine, Realm realm, ObjectInstance functionPrototype, ObjectInstance objectPrototype, string functionName)
			: base(engine, realm, new JsString(functionName))
		{
			_prototype = functionPrototype;
			PrototypeObject = new IntrinsicTypedArrayPrototype(engine, objectPrototype, this);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false)
			{
				["from"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "from", From, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable)),
				["of"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "of", Of, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable))
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get [Symbol.species]", Species, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue From(JsValue thisObject, JsValue[] arguments)
		{
			if (!thisObject.IsConstructor)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			JsValue thisObject2 = arguments.At(2);
			bool flag = !jsValue2.IsUndefined();
			if (flag && !jsValue2.IsCallable)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			ICallable method = ObjectInstance.GetMethod(_realm, jsValue, GlobalSymbolRegistry.Iterator);
			if (method != null)
			{
				List<JsValue> list = TypedArrayConstructor.IterableToList(_realm, jsValue, method);
				int count = list.Count;
				JsTypedArray jsTypedArray = TypedArrayCreate(_realm, (IConstructor)thisObject, new JsValue[1] { count });
				for (int i = 0; i < count; i++)
				{
					JsValue jsValue3 = list[i];
					JsValue value = (flag ? ((ICallable)jsValue2).Call(thisObject2, jsValue3, i) : jsValue3);
					jsTypedArray[i] = value;
				}
				return jsTypedArray;
			}
			if (jsValue.IsNullOrUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Cannot convert undefined or null to object");
			}
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, jsValue);
			uint length = objectInstance.GetLength();
			JsValue[] argumentList = new JsValue[1] { JsNumber.Create(length) };
			JsTypedArray jsTypedArray2 = TypedArrayCreate(_realm, (IConstructor)thisObject, argumentList);
			JsValue[] array = (flag ? new JsValue[2] : null);
			for (uint num = 0u; num < length; num++)
			{
				JsNumber jsNumber = JsNumber.Create(num);
				JsValue jsValue4 = objectInstance.Get(jsNumber);
				JsValue v;
				if (flag)
				{
					array[0] = jsValue4;
					array[1] = jsNumber;
					v = ((ICallable)jsValue2).Call(thisObject2, array);
				}
				else
				{
					v = jsValue4;
				}
				jsTypedArray2.Set(jsNumber, v, throwOnError: true);
			}
			return jsTypedArray2;
		}

		private JsValue Of(JsValue thisObject, JsValue[] items)
		{
			int num = items.Length;
			if (!thisObject.IsConstructor)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsTypedArray jsTypedArray = TypedArrayCreate(_realm, (IConstructor)thisObject, new JsValue[1] { num });
			for (int i = 0; i < num; i++)
			{
				JsValue value = items[i];
				jsTypedArray[i] = value;
			}
			return jsTypedArray;
		}

		internal JsTypedArray TypedArraySpeciesCreate(JsTypedArray exemplar, JsValue[] argumentList)
		{
			IConstructor constructor = exemplar._arrayElementType.GetConstructor(_realm.Intrinsics);
			IConstructor constructor2 = ObjectInstance.SpeciesConstructor(exemplar, constructor);
			JsTypedArray jsTypedArray = TypedArrayCreate(_realm, constructor2, argumentList);
			if (jsTypedArray._contentType != exemplar._contentType)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return jsTypedArray;
		}

		internal static JsTypedArray TypedArrayCreate(Realm realm, IConstructor constructor, JsValue[] argumentList)
		{
			ObjectInstance objectInstance = ObjectInstance.Construct(constructor, argumentList);
			IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = objectInstance.ValidateTypedArray(realm);
			if (argumentList.Length == 1 && argumentList[0] is JsNumber jsNumber)
			{
				if (typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
				{
					ExceptionHelper.ThrowTypeError(realm, "TypedArray is out of bounds");
				}
				if ((double)objectInstance.GetLength() < jsNumber._value)
				{
					ExceptionHelper.ThrowTypeError(realm);
				}
			}
			return typedArrayWithBufferWitnessRecord.Object;
		}

		private static JsValue Species(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			ExceptionHelper.ThrowTypeError(_realm, "Abstract class TypedArray not directly callable");
			return JsValue.Undefined;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			ExceptionHelper.ThrowTypeError(_realm, "Abstract class TypedArray not directly constructable");
			return null;
		}
	}
	internal sealed class IntrinsicTypedArrayPrototype : Prototype
	{
		internal readonly record struct TypedArrayWithBufferWitnessRecord(JsTypedArray Object, int CachedBufferByteLength)
		{
			public bool IsTypedArrayOutOfBounds
			{
				get
				{
					JsTypedArray jsTypedArray = Object;
					int cachedBufferByteLength = CachedBufferByteLength;
					if (cachedBufferByteLength == -1)
					{
						return true;
					}
					int byteOffset = jsTypedArray._byteOffset;
					long num;
					if (jsTypedArray._arrayLength == uint.MaxValue)
					{
						num = cachedBufferByteLength;
					}
					else
					{
						byte elementSize = jsTypedArray._arrayElementType.GetElementSize();
						num = byteOffset + jsTypedArray._arrayLength * elementSize;
					}
					if (byteOffset > cachedBufferByteLength || num > cachedBufferByteLength)
					{
						return true;
					}
					return false;
				}
			}

			public uint TypedArrayLength
			{
				get
				{
					JsTypedArray jsTypedArray = Object;
					if (jsTypedArray._arrayLength != uint.MaxValue)
					{
						return jsTypedArray._arrayLength;
					}
					int byteOffset = jsTypedArray._byteOffset;
					byte elementSize = jsTypedArray._arrayElementType.GetElementSize();
					double num = System.Math.Floor(((double)CachedBufferByteLength - (double)byteOffset) / (double)(int)elementSize);
					if (!(num < 0.0))
					{
						return (uint)num;
					}
					return 0u;
				}
			}

			public uint TypedArrayByteLength
			{
				get
				{
					if (IsTypedArrayOutOfBounds)
					{
						return 0u;
					}
					uint typedArrayLength = TypedArrayLength;
					if (typedArrayLength == 0)
					{
						return 0u;
					}
					JsTypedArray jsTypedArray = Object;
					if (jsTypedArray._byteLength != uint.MaxValue)
					{
						return jsTypedArray._byteLength;
					}
					return typedArrayLength * jsTypedArray._arrayElementType.GetElementSize();
				}
			}
		}

		private sealed class TypedArrayComparer : IComparer<JsValue>
		{
			private readonly JsArrayBuffer _buffer;

			private readonly ICallable? _compare;

			private readonly JsValue[] _comparableArray = new JsValue[2];

			public static TypedArrayComparer WithFunction(JsArrayBuffer buffer, ICallable? compare)
			{
				return new TypedArrayComparer(buffer, compare);
			}

			private TypedArrayComparer(JsArrayBuffer buffer, ICallable? compare)
			{
				_buffer = buffer;
				_compare = compare;
			}

			public int Compare(JsValue? x, JsValue? y)
			{
				if ((object)x == null && (object)y == null)
				{
					return 0;
				}
				if ((object)x != null && (object)y == null)
				{
					return 1;
				}
				if ((object)x == null)
				{
					return -1;
				}
				if ((object)y == null)
				{
					return 1;
				}
				if (_compare != null)
				{
					_comparableArray[0] = x;
					_comparableArray[1] = y;
					double num = TypeConverter.ToNumber(_compare.Call(JsValue.Undefined, _comparableArray));
					if (double.IsNaN(num))
					{
						return 0;
					}
					return (int)num;
				}
				if (x.Type == Types.BigInt || y.Type == Types.BigInt)
				{
					BigInteger bigInteger = TypeConverter.ToBigInt(x);
					BigInteger other = TypeConverter.ToBigInt(y);
					return bigInteger.CompareTo(other);
				}
				double num2 = x.AsNumber();
				double num3 = y.AsNumber();
				if (double.IsNaN(num2) && double.IsNaN(num3))
				{
					return 0;
				}
				if (double.IsNaN(num2))
				{
					return 1;
				}
				if (double.IsNaN(num3))
				{
					return -1;
				}
				if (num2 < num3)
				{
					return -1;
				}
				if (num2 > num3)
				{
					return 1;
				}
				if (NumberInstance.IsNegativeZero(num2) && num3 == 0.0)
				{
					return -1;
				}
				if (num2 == 0.0 && NumberInstance.IsNegativeZero(num3))
				{
					return 1;
				}
				return 0;
			}
		}

		private readonly IntrinsicTypedArrayConstructor _constructor;

		private ClrFunction? _originalIteratorFunction;

		internal IntrinsicTypedArrayPrototype(Engine engine, ObjectInstance objectPrototype, IntrinsicTypedArrayConstructor constructor)
			: base(engine, engine.Realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(36, checkExistingKeys: false)
			{
				["at"] = new PropertyDescriptor(new ClrFunction(base.Engine, "at", At, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["buffer"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get buffer", Buffer, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["byteLength"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get byteLength", ByteLength, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["byteOffset"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get byteOffset", ByteOffset, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["copyWithin"] = new PropertyDescriptor(new ClrFunction(base.Engine, "copyWithin", CopyWithin, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["entries"] = new PropertyDescriptor(new ClrFunction(base.Engine, "entries", Entries, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["every"] = new PropertyDescriptor(new ClrFunction(base.Engine, "every", Every, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["fill"] = new PropertyDescriptor(new ClrFunction(base.Engine, "fill", Fill, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["filter"] = new PropertyDescriptor(new ClrFunction(base.Engine, "filter", Filter, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["find"] = new PropertyDescriptor(new ClrFunction(base.Engine, "find", Find, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["findIndex"] = new PropertyDescriptor(new ClrFunction(base.Engine, "findIndex", FindIndex, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["findLast"] = new PropertyDescriptor(new ClrFunction(base.Engine, "findLast", FindLast, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["findLastIndex"] = new PropertyDescriptor(new ClrFunction(base.Engine, "findLastIndex", FindLastIndex, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["forEach"] = new PropertyDescriptor(new ClrFunction(base.Engine, "forEach", ForEach, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["includes"] = new PropertyDescriptor(new ClrFunction(base.Engine, "includes", Includes, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["indexOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "indexOf", IndexOf, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["join"] = new PropertyDescriptor(new ClrFunction(base.Engine, "join", Join, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["keys"] = new PropertyDescriptor(new ClrFunction(base.Engine, "keys", Keys, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["lastIndexOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "lastIndexOf", LastIndexOf, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["length"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get length", GetLength, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["map"] = new PropertyDescriptor(new ClrFunction(base.Engine, "map", Map, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["reduce"] = new PropertyDescriptor(new ClrFunction(base.Engine, "reduce", Reduce, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["reduceRight"] = new PropertyDescriptor(new ClrFunction(base.Engine, "reduceRight", ReduceRight, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["reverse"] = new PropertyDescriptor(new ClrFunction(base.Engine, "reverse", Reverse, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["set"] = new PropertyDescriptor(new ClrFunction(base.Engine, "set", Set, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["slice"] = new PropertyDescriptor(new ClrFunction(base.Engine, "slice", Slice, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["some"] = new PropertyDescriptor(new ClrFunction(base.Engine, "some", Some, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["sort"] = new PropertyDescriptor(new ClrFunction(base.Engine, "sort", Sort, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["subarray"] = new PropertyDescriptor(new ClrFunction(base.Engine, "subarray", Subarray, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleString", ToLocaleString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toReversed"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toReversed", ToReversed, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toSorted"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toSorted", ToSorted, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleString", _realm.Intrinsics.Array.PrototypeObject.ToString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["values"] = new PropertyDescriptor(new ClrFunction(base.Engine, "values", Values, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["with"] = new PropertyDescriptor(new ClrFunction(base.Engine, "with", With, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			_originalIteratorFunction = new ClrFunction(base.Engine, "iterator", Values, 1);
			SymbolDictionary symbolDictionary = new SymbolDictionary(2);
			JsSymbol iterator = GlobalSymbolRegistry.Iterator;
			symbolDictionary[iterator] = new PropertyDescriptor(_originalIteratorFunction, PropertyFlag.Writable | PropertyFlag.Configurable);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get [Symbol.toStringTag]", ToStringTag, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Buffer(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray obj = thisObject as JsTypedArray;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return obj._viewedArrayBuffer;
		}

		private JsValue ByteLength(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray obj = thisObject as JsTypedArray;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return JsNumber.Create(MakeTypedArrayWithBufferWitnessRecord(obj, ArrayBufferOrder.SeqCst).TypedArrayByteLength);
		}

		private JsValue ByteOffset(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray jsTypedArray = thisObject as JsTypedArray;
			if ((object)jsTypedArray == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (MakeTypedArrayWithBufferWitnessRecord(jsTypedArray, ArrayBufferOrder.SeqCst).IsTypedArrayOutOfBounds)
			{
				return JsNumber.PositiveZero;
			}
			return JsNumber.Create(jsTypedArray._byteOffset);
		}

		private JsValue GetLength(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray obj = thisObject as JsTypedArray;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = MakeTypedArrayWithBufferWitnessRecord(obj, ArrayBufferOrder.SeqCst);
			if (typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				return JsNumber.PositiveZero;
			}
			return JsNumber.Create(typedArrayWithBufferWitnessRecord.TypedArrayLength);
		}

		internal static TypedArrayWithBufferWitnessRecord MakeTypedArrayWithBufferWitnessRecord(JsTypedArray obj, ArrayBufferOrder order)
		{
			JsArrayBuffer viewedArrayBuffer = obj._viewedArrayBuffer;
			int cachedBufferByteLength = (viewedArrayBuffer.IsDetachedBuffer ? (-1) : ArrayBufferByteLength(viewedArrayBuffer, order));
			return new TypedArrayWithBufferWitnessRecord(obj, cachedBufferByteLength);
		}

		internal static int ArrayBufferByteLength(JsArrayBuffer arrayBuffer, ArrayBufferOrder order)
		{
			if (arrayBuffer.IsSharedArrayBuffer)
			{
				_ = arrayBuffer.ArrayBufferByteLength;
				_ = 0;
			}
			return arrayBuffer.ArrayBufferByteLength;
		}

		private JsValue CopyWithin(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsValue argument = arguments.At(0);
			JsValue argument2 = arguments.At(1);
			JsValue jsValue = arguments.At(2);
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			long num2 = (double.IsNegativeInfinity(num) ? 0 : ((!(num < 0.0)) ? ((long)System.Math.Min(num, typedArrayLength)) : ((long)System.Math.Max((double)typedArrayLength + num, 0.0))));
			double num3 = TypeConverter.ToIntegerOrInfinity(argument2);
			long num4 = (double.IsNegativeInfinity(num3) ? 0 : ((!(num3 < 0.0)) ? ((long)System.Math.Min(num3, typedArrayLength)) : ((long)System.Math.Max((double)typedArrayLength + num3, 0.0))));
			double num5 = (jsValue.IsUndefined() ? ((double)typedArrayLength) : TypeConverter.ToIntegerOrInfinity(jsValue));
			long num6 = (double.IsNegativeInfinity(num5) ? 0 : ((!(num5 < 0.0)) ? ((long)System.Math.Min(num5, typedArrayLength)) : ((long)System.Math.Max((double)typedArrayLength + num5, 0.0))));
			long num7 = System.Math.Min(num6 - num4, typedArrayLength - num2);
			if (num7 > 0)
			{
				JsArrayBuffer viewedArrayBuffer = jsTypedArray._viewedArrayBuffer;
				viewedArrayBuffer.AssertNotDetached();
				typedArrayWithBufferWitnessRecord = MakeTypedArrayWithBufferWitnessRecord(jsTypedArray, ArrayBufferOrder.SeqCst);
				if (typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
				{
					ExceptionHelper.ThrowTypeError(_realm, "TypedArray is out of bounds");
				}
				typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
				byte elementSize = jsTypedArray._arrayElementType.GetElementSize();
				int byteOffset = jsTypedArray._byteOffset;
				long num8 = typedArrayLength * elementSize + byteOffset;
				long num9 = num2 * elementSize + byteOffset;
				long num10 = num4 * elementSize + byteOffset;
				long num11 = num7 * elementSize;
				int num12;
				if (num10 < num9 && num9 < num10 + num11)
				{
					num12 = -1;
					num10 = num10 + num11 - 1;
					num9 = num9 + num11 - 1;
				}
				else
				{
					num12 = 1;
				}
				while (num11 > 0)
				{
					if (num10 < num8 && num9 < num8)
					{
						TypedArrayValue valueFromBuffer = viewedArrayBuffer.GetValueFromBuffer((int)num10, TypedArrayElementType.Uint8, isTypedArray: true, ArrayBufferOrder.Unordered);
						viewedArrayBuffer.SetValueInBuffer((int)num9, TypedArrayElementType.Uint8, valueFromBuffer, isTypedArray: true, ArrayBufferOrder.Unordered);
						num10 += num12;
						num9 += num12;
						num11--;
					}
					else
					{
						num11 = 0L;
					}
				}
			}
			return jsTypedArray;
		}

		private JsValue Entries(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray array = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst).Object;
			return _realm.Intrinsics.ArrayIteratorPrototype.Construct(array, ArrayIteratorType.KeyAndValue);
		}

		private JsValue Every(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (typedArrayLength == 0)
			{
				return JsBoolean.True;
			}
			ICallable callable = GetCallable(arguments.At(0));
			JsValue thisObject2 = arguments.At(1);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = jsTypedArray;
			for (int i = 0; i < typedArrayLength; i++)
			{
				array[0] = jsTypedArray[i];
				array[1] = i;
				if (!TypeConverter.ToBoolean(callable.Call(thisObject2, array)))
				{
					return JsBoolean.False;
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return JsBoolean.True;
		}

		private JsValue Fill(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsValue jsValue = arguments.At(0);
			JsValue argument = arguments.At(1);
			JsValue jsValue2 = arguments.At(2);
			JsValue value = ((jsTypedArray._contentType != TypedArrayContentType.BigInt) ? ((JsValue)JsNumber.Create(jsValue)) : ((JsValue)JsBigInt.Create(jsValue.ToBigInteger(_engine))));
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			int num2 = ((!double.IsNegativeInfinity(num)) ? ((!(num < 0.0)) ? ((int)System.Math.Min(num, typedArrayLength)) : ((int)System.Math.Max((double)typedArrayLength + num, 0.0))) : 0);
			double num3 = (jsValue2.IsUndefined() ? ((double)typedArrayLength) : TypeConverter.ToIntegerOrInfinity(jsValue2));
			uint val = ((!double.IsNegativeInfinity(num3)) ? ((!(num3 < 0.0)) ? ((uint)System.Math.Min(num3, typedArrayLength)) : ((uint)System.Math.Max((double)typedArrayLength + num3, 0.0))) : 0u);
			typedArrayWithBufferWitnessRecord = MakeTypedArrayWithBufferWitnessRecord(jsTypedArray, ArrayBufferOrder.SeqCst);
			if (typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm, "TypedArray is out of bounds");
			}
			typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			val = System.Math.Min(val, typedArrayLength);
			jsTypedArray._viewedArrayBuffer.AssertNotDetached();
			for (int i = num2; i < val; i++)
			{
				jsTypedArray[i] = value;
			}
			return thisObject;
		}

		private JsValue Filter(JsValue thisObject, JsValue[] arguments)
		{
			ICallable callable = GetCallable(arguments.At(0));
			JsValue thisObject2 = arguments.At(1);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			List<JsValue> list = new List<JsValue>();
			int num = 0;
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = jsTypedArray;
			for (int i = 0; i < typedArrayLength; i++)
			{
				JsValue item = (array[0] = jsTypedArray[i]);
				array[1] = i;
				if (TypeConverter.ToBoolean(callable.Call(thisObject2, array)))
				{
					list.Add(item);
					num++;
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			JsTypedArray jsTypedArray2 = _realm.Intrinsics.TypedArray.TypedArraySpeciesCreate(jsTypedArray, new JsValue[1] { num });
			for (int j = 0; j < num; j++)
			{
				jsTypedArray2[j] = list[j];
			}
			return jsTypedArray2;
		}

		private JsValue Find(JsValue thisObject, JsValue[] arguments)
		{
			return DoFind(thisObject, arguments).Value;
		}

		private JsValue FindIndex(JsValue thisObject, JsValue[] arguments)
		{
			return DoFind(thisObject, arguments).Key;
		}

		private JsValue FindLast(JsValue thisObject, JsValue[] arguments)
		{
			return DoFind(thisObject, arguments, fromEnd: true).Value;
		}

		private JsValue FindLastIndex(JsValue thisObject, JsValue[] arguments)
		{
			return DoFind(thisObject, arguments, fromEnd: true).Key;
		}

		private KeyValuePair<JsValue, JsValue> DoFind(JsValue thisObject, JsValue[] arguments, bool fromEnd = false)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			ICallable callable = GetCallable(arguments.At(0));
			JsValue thisObject2 = arguments.At(1);
			if (typedArrayLength == 0)
			{
				return new KeyValuePair<JsValue, JsValue>(JsNumber.IntegerNegativeOne, JsValue.Undefined);
			}
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = jsTypedArray;
			if (!fromEnd)
			{
				for (int i = 0; i < typedArrayLength; i++)
				{
					JsNumber jsNumber = JsNumber.Create(i);
					JsValue value = (array[0] = jsTypedArray[i]);
					array[1] = jsNumber;
					if (TypeConverter.ToBoolean(callable.Call(thisObject2, array)))
					{
						return new KeyValuePair<JsValue, JsValue>(jsNumber, value);
					}
				}
			}
			else
			{
				for (int num = (int)(typedArrayLength - 1); num >= 0; num--)
				{
					JsNumber jsNumber2 = JsNumber.Create(num);
					JsValue value2 = (array[0] = jsTypedArray[num]);
					array[1] = jsNumber2;
					if (TypeConverter.ToBoolean(callable.Call(thisObject2, array)))
					{
						return new KeyValuePair<JsValue, JsValue>(jsNumber2, value2);
					}
				}
			}
			return new KeyValuePair<JsValue, JsValue>(JsNumber.IntegerNegativeOne, JsValue.Undefined);
		}

		private JsValue ForEach(JsValue thisObject, JsValue[] arguments)
		{
			ICallable callable = GetCallable(arguments.At(0));
			JsValue thisObject2 = arguments.At(1);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = jsTypedArray;
			for (int i = 0; i < typedArrayLength; i++)
			{
				JsValue jsValue = jsTypedArray[i];
				array[0] = jsValue;
				array[1] = i;
				callable.Call(thisObject2, array);
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return JsValue.Undefined;
		}

		private JsValue Includes(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (typedArrayLength == 0)
			{
				return false;
			}
			JsValue y = arguments.At(0);
			double num = TypeConverter.ToIntegerOrInfinity(arguments.At(1, 0));
			if (double.IsPositiveInfinity(num))
			{
				return JsBoolean.False;
			}
			if (double.IsNegativeInfinity(num))
			{
				num = 0.0;
			}
			long num2;
			if (num >= 0.0)
			{
				num2 = (long)num;
			}
			else
			{
				num2 = (long)((double)typedArrayLength + num);
				if (num2 < 0)
				{
					num2 = 0L;
				}
			}
			for (; num2 < typedArrayLength; num2++)
			{
				if (SameValueZeroComparer.Equals(jsTypedArray[(int)num2], y))
				{
					return JsBoolean.True;
				}
			}
			return JsBoolean.False;
		}

		private JsValue IndexOf(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			JsValue argument = arguments.At(1);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (typedArrayLength == 0)
			{
				return JsNumber.IntegerNegativeOne;
			}
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.IntegerNegativeOne;
			}
			if (double.IsNegativeInfinity(num))
			{
				num = 0.0;
			}
			long num2;
			if (num >= 0.0)
			{
				num2 = (long)num;
			}
			else
			{
				num2 = (long)((double)typedArrayLength + num);
				if (num2 < 0)
				{
					num2 = 0L;
				}
			}
			for (; num2 < typedArrayLength; num2++)
			{
				if (jsTypedArray.HasProperty(num2) && jsTypedArray[(int)num2] == jsValue)
				{
					return num2;
				}
			}
			return JsNumber.IntegerNegativeOne;
		}

		private JsValue Join(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			string s = TypeConverter.ToString(jsValue.IsUndefined() ? JsString.CommaString : jsValue);
			if (typedArrayLength == 0)
			{
				return JsString.Empty;
			}
			string text = StringFromJsValue(jsTypedArray[0]);
			if (typedArrayLength == 1)
			{
				return text;
			}
			using (System.Text.ValueStringBuilder valueStringBuilder = default(System.Text.ValueStringBuilder))
			{
				valueStringBuilder.Append(text);
				for (int i = 1; i < typedArrayLength; i++)
				{
					valueStringBuilder.Append(s);
					valueStringBuilder.Append(StringFromJsValue(jsTypedArray[i]));
				}
				return valueStringBuilder.ToString();
			}
			static string StringFromJsValue(JsValue value)
			{
				if (!value.IsUndefined())
				{
					return TypeConverter.ToString(value);
				}
				return "";
			}
		}

		private JsValue Keys(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray array = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst).Object;
			return _realm.Intrinsics.ArrayIteratorPrototype.Construct(array, ArrayIteratorType.Key);
		}

		private JsValue LastIndexOf(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (typedArrayLength == 0)
			{
				return JsNumber.IntegerNegativeOne;
			}
			double num = TypeConverter.ToIntegerOrInfinity(arguments.At(1, typedArrayLength - 1));
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.IntegerNegativeOne;
			}
			for (long num2 = ((!(num >= 0.0)) ? ((long)((double)typedArrayLength + num)) : ((long)System.Math.Min(num, typedArrayLength - 1))); num2 >= 0; num2--)
			{
				if (jsTypedArray.HasProperty(num2) && jsTypedArray[(int)num2] == jsValue)
				{
					return num2;
				}
			}
			return JsNumber.IntegerNegativeOne;
		}

		private ObjectInstance Map(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsValue thisObject2 = arguments.At(1);
			ICallable callable = GetCallable(arguments.At(0));
			JsTypedArray jsTypedArray2 = _realm.Intrinsics.TypedArray.TypedArraySpeciesCreate(jsTypedArray, new JsValue[1] { typedArrayLength });
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = jsTypedArray;
			for (int i = 0; i < typedArrayLength; i++)
			{
				array[0] = jsTypedArray[i];
				array[1] = i;
				JsValue value = callable.Call(thisObject2, array);
				jsTypedArray2[i] = value;
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return jsTypedArray2;
		}

		private JsValue Reduce(JsValue thisObject, JsValue[] arguments)
		{
			ICallable callable = GetCallable(arguments.At(0));
			JsValue jsValue = arguments.At(1);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (typedArrayLength == 0 && arguments.Length < 2)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			int i = 0;
			JsValue undefined = JsValue.Undefined;
			if (!jsValue.IsUndefined())
			{
				undefined = jsValue;
			}
			else
			{
				undefined = jsTypedArray[i];
				i++;
			}
			JsValue[] array = _engine._jsValueArrayPool.RentArray(4);
			array[3] = jsTypedArray;
			for (; i < typedArrayLength; i++)
			{
				JsValue jsValue2 = jsTypedArray[i];
				array[0] = undefined;
				array[1] = jsValue2;
				array[2] = i;
				undefined = callable.Call(JsValue.Undefined, array);
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return undefined;
		}

		private JsValue ReduceRight(JsValue thisObject, JsValue[] arguments)
		{
			ICallable callable = GetCallable(arguments.At(0));
			JsValue jsValue = arguments.At(1);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (typedArrayLength == 0 && arguments.Length < 2)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			long num = (long)typedArrayLength - 1L;
			JsValue jsValue2;
			if (arguments.Length > 1)
			{
				jsValue2 = jsValue;
			}
			else
			{
				jsValue2 = jsTypedArray[num];
				num--;
			}
			JsValue[] array = _engine._jsValueArrayPool.RentArray(4);
			array[3] = jsTypedArray;
			while (num >= 0)
			{
				array[0] = jsValue2;
				array[1] = jsTypedArray[(int)num];
				array[2] = num;
				jsValue2 = callable.Call(JsValue.Undefined, array);
				num--;
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return jsValue2;
		}

		private ObjectInstance Reverse(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			int num = (int)System.Math.Floor((double)typedArrayLength / 2.0);
			for (int i = 0; i != num; i++)
			{
				long num2 = typedArrayLength - i - 1;
				JsValue value = jsTypedArray[i];
				JsValue value2 = jsTypedArray[num2];
				jsTypedArray[i] = value2;
				jsTypedArray[num2] = value;
			}
			return jsTypedArray;
		}

		private JsValue Set(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray jsTypedArray = thisObject as JsTypedArray;
			if ((object)jsTypedArray == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue jsValue = arguments.At(0);
			double num = TypeConverter.ToIntegerOrInfinity(arguments.At(1));
			if (num < 0.0)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid offset");
			}
			if (jsValue is JsTypedArray source)
			{
				SetTypedArrayFromTypedArray(jsTypedArray, num, source);
			}
			else
			{
				SetTypedArrayFromArrayLike(jsTypedArray, (int)num, jsValue);
			}
			return JsValue.Undefined;
		}

		private void SetTypedArrayFromTypedArray(JsTypedArray target, double targetOffset, JsTypedArray source)
		{
			JsArrayBuffer viewedArrayBuffer = target._viewedArrayBuffer;
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = MakeTypedArrayWithBufferWitnessRecord(target, ArrayBufferOrder.SeqCst);
			if (typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsArrayBuffer jsArrayBuffer = source._viewedArrayBuffer;
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord2 = MakeTypedArrayWithBufferWitnessRecord(source, ArrayBufferOrder.SeqCst);
			if (typedArrayWithBufferWitnessRecord2.IsTypedArrayOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			TypedArrayElementType arrayElementType = target._arrayElementType;
			byte elementSize = arrayElementType.GetElementSize();
			int byteOffset = target._byteOffset;
			TypedArrayElementType arrayElementType2 = source._arrayElementType;
			byte elementSize2 = arrayElementType2.GetElementSize();
			uint typedArrayLength2 = typedArrayWithBufferWitnessRecord2.TypedArrayLength;
			int byteOffset2 = source._byteOffset;
			if (double.IsNegativeInfinity(targetOffset))
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid target offset");
			}
			if ((double)typedArrayLength2 + targetOffset > (double)typedArrayLength)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid target offset");
			}
			if (target._contentType != source._contentType)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Content type mismatch");
			}
			int num;
			if (JsValue.SameValue(jsArrayBuffer, viewedArrayBuffer))
			{
				uint typedArrayByteLength = typedArrayWithBufferWitnessRecord2.TypedArrayByteLength;
				jsArrayBuffer = jsArrayBuffer.CloneArrayBuffer(_realm.Intrinsics.ArrayBuffer, byteOffset2, typedArrayByteLength);
				num = 0;
			}
			else
			{
				num = byteOffset2;
			}
			int i = (int)(targetOffset * (double)(int)elementSize + (double)byteOffset);
			long num2 = i + elementSize * typedArrayLength2;
			if (arrayElementType2 == arrayElementType)
			{
				for (; i < num2; i++)
				{
					TypedArrayValue valueFromBuffer = jsArrayBuffer.GetValueFromBuffer(num, TypedArrayElementType.Uint8, isTypedArray: true, ArrayBufferOrder.Unordered);
					viewedArrayBuffer.SetValueInBuffer(i, TypedArrayElementType.Uint8, valueFromBuffer, isTypedArray: true, ArrayBufferOrder.Unordered);
					num++;
				}
			}
			else
			{
				for (; i < num2; i += elementSize)
				{
					TypedArrayValue valueFromBuffer2 = jsArrayBuffer.GetValueFromBuffer(num, arrayElementType2, isTypedArray: true, ArrayBufferOrder.Unordered);
					viewedArrayBuffer.SetValueInBuffer(i, arrayElementType, valueFromBuffer2, isTypedArray: true, ArrayBufferOrder.Unordered);
					num += elementSize2;
				}
			}
		}

		private void SetTypedArrayFromArrayLike(JsTypedArray target, int targetOffset, JsValue source)
		{
			target._viewedArrayBuffer.AssertNotDetached();
			uint arrayLength = target._arrayLength;
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, source, forWrite: false);
			uint length = arrayOperations.GetLength();
			if (double.IsNegativeInfinity(targetOffset))
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid target offset");
			}
			if (length + targetOffset > arrayLength)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid target offset");
			}
			for (int i = 0; i < length; i++)
			{
				JsValue value = arrayOperations.Get((ulong)i);
				target.IntegerIndexedElementSet(targetOffset + i, value);
			}
		}

		private JsValue At(JsValue thisObject, JsValue[] arguments)
		{
			JsValue o = arguments.At(0);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			double num = TypeConverter.ToInteger(o);
			int num2 = ((!(num < 0.0)) ? ((int)num) : ((int)((double)typedArrayLength + num)));
			if (num2 < 0 || num2 >= typedArrayLength)
			{
				return JsValue.Undefined;
			}
			return jsTypedArray.Get(num2);
		}

		private JsValue Slice(JsValue thisObject, JsValue[] arguments)
		{
			JsValue argument = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			int num2 = ((!double.IsNegativeInfinity(num)) ? ((!(num < 0.0)) ? ((int)System.Math.Min(num, typedArrayLength)) : ((int)System.Math.Max((double)typedArrayLength + num, 0.0))) : 0);
			double num3 = (jsValue.IsUndefined() ? ((double)typedArrayLength) : TypeConverter.ToIntegerOrInfinity(jsValue));
			long num4 = (double.IsNegativeInfinity(num3) ? 0 : ((!(num3 < 0.0)) ? ((long)System.Math.Min(num3, typedArrayLength)) : ((long)System.Math.Max((double)typedArrayLength + num3, 0.0))));
			long num5 = System.Math.Max(num4 - num2, 0L);
			JsTypedArray jsTypedArray2 = _realm.Intrinsics.TypedArray.TypedArraySpeciesCreate(jsTypedArray, new JsValue[1] { num5 });
			if (num5 > 0)
			{
				jsTypedArray._viewedArrayBuffer.AssertNotDetached();
				TypedArrayElementType arrayElementType = jsTypedArray._arrayElementType;
				TypedArrayElementType arrayElementType2 = jsTypedArray2._arrayElementType;
				if (arrayElementType != arrayElementType2)
				{
					int num6 = 0;
					while (num2 < num4)
					{
						JsValue value = jsTypedArray[num2];
						jsTypedArray2[num6] = value;
						num2++;
						num6++;
					}
				}
				else
				{
					JsArrayBuffer viewedArrayBuffer = jsTypedArray._viewedArrayBuffer;
					JsArrayBuffer viewedArrayBuffer2 = jsTypedArray2._viewedArrayBuffer;
					byte elementSize = arrayElementType.GetElementSize();
					int byteOffset = jsTypedArray._byteOffset;
					int i = jsTypedArray2._byteOffset;
					int num7 = num2 * elementSize + byteOffset;
					for (long num8 = i + num5 * elementSize; i < num8; i++)
					{
						TypedArrayValue valueFromBuffer = viewedArrayBuffer.GetValueFromBuffer(num7, TypedArrayElementType.Uint8, isTypedArray: true, ArrayBufferOrder.Unordered);
						viewedArrayBuffer2.SetValueInBuffer(i, TypedArrayElementType.Uint8, valueFromBuffer, isTypedArray: true, ArrayBufferOrder.Unordered);
						num7++;
					}
				}
			}
			return jsTypedArray2;
		}

		private JsValue Some(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			ICallable callable = GetCallable(arguments.At(0));
			JsValue thisObject2 = arguments.At(1);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = jsTypedArray;
			for (int i = 0; i < typedArrayLength; i++)
			{
				array[0] = jsTypedArray[i];
				array[1] = i;
				if (TypeConverter.ToBoolean(callable.Call(thisObject2, array)))
				{
					return JsBoolean.True;
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return JsBoolean.False;
		}

		private JsValue Sort(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsArrayBuffer viewedArrayBuffer = jsTypedArray._viewedArrayBuffer;
			ICallable compareFunction = GetCompareFunction(arguments.At(0));
			if (typedArrayLength <= 1)
			{
				return jsTypedArray;
			}
			JsValue[] array = SortArray(viewedArrayBuffer, compareFunction, jsTypedArray);
			for (int i = 0; i < (uint)array.Length; i++)
			{
				jsTypedArray[i] = array[i];
			}
			return jsTypedArray;
		}

		private JsValue Subarray(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray jsTypedArray = thisObject as JsTypedArray;
			if ((object)jsTypedArray == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue argument = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			JsArrayBuffer viewedArrayBuffer = jsTypedArray._viewedArrayBuffer;
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = MakeTypedArrayWithBufferWitnessRecord(jsTypedArray, ArrayBufferOrder.SeqCst);
			uint num = 0u;
			if (!typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				num = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			}
			double num2 = TypeConverter.ToIntegerOrInfinity(argument);
			double num3 = (double.IsNegativeInfinity(num2) ? 0.0 : ((!(num2 < 0.0)) ? System.Math.Min(num2, num) : System.Math.Max((double)num + num2, 0.0)));
			byte elementSize = jsTypedArray._arrayElementType.GetElementSize();
			double num4 = (double)jsTypedArray._byteOffset + num3 * (double)(int)elementSize;
			JsValue[] argumentList;
			if (jsTypedArray._arrayLength == uint.MaxValue && jsValue.IsUndefined())
			{
				argumentList = new JsValue[2] { viewedArrayBuffer, num4 };
			}
			else
			{
				double num5 = ((!jsValue.IsUndefined()) ? TypeConverter.ToIntegerOrInfinity(jsValue) : ((double)num));
				double num6 = (double.IsNegativeInfinity(num5) ? 0.0 : ((!(num5 < 0.0)) ? System.Math.Min(num5, num) : System.Math.Max((double)num + num5, 0.0)));
				double num7 = System.Math.Max(num6 - num3, 0.0);
				argumentList = new JsValue[3] { viewedArrayBuffer, num4, num7 };
			}
			return _realm.Intrinsics.TypedArray.TypedArraySpeciesCreate(jsTypedArray, argumentList);
		}

		private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			if (typedArrayLength == 0)
			{
				return JsString.Empty;
			}
			JsValue jsValue;
			if (!jsTypedArray.TryGetValue(0, out JsValue value) || value.IsNull() || value.IsUndefined())
			{
				jsValue = JsString.Empty;
			}
			else
			{
				ObjectInstance objectInstance = TypeConverter.ToObject(_realm, value);
				ICallable obj = objectInstance.Get("toLocaleString") as ICallable;
				if (obj == null)
				{
					ExceptionHelper.ThrowTypeError(_realm);
				}
				jsValue = obj.Call(objectInstance, Arguments.Empty);
			}
			for (int i = 1; i < typedArrayLength; i++)
			{
				string text = jsValue?.ToString() + ",";
				ObjectInstance objectInstance2 = TypeConverter.ToObject(_realm, jsTypedArray[i]);
				ICallable obj2 = objectInstance2.Get("toLocaleString") as ICallable;
				if (obj2 == null)
				{
					ExceptionHelper.ThrowTypeError(_realm);
				}
				jsValue = text + obj2.Call(objectInstance2, Arguments.Empty);
			}
			return jsValue;
		}

		private JsValue Values(JsValue thisObject, JsValue[] arguments)
		{
			JsTypedArray array = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst).Object;
			return _realm.Intrinsics.ArrayIteratorPrototype.Construct(array, ArrayIteratorType.Value);
		}

		private static JsValue ToStringTag(JsValue thisObject, JsValue[] arguments)
		{
			if (!(thisObject is JsTypedArray jsTypedArray))
			{
				return JsValue.Undefined;
			}
			return jsTypedArray._arrayElementType.GetTypedArrayName();
		}

		private JsValue ToReversed(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsValue[] argumentList = new JsNumber[1] { JsNumber.Create(typedArrayLength) };
			JsTypedArray jsTypedArray2 = TypedArrayCreateSameType(jsTypedArray, argumentList);
			uint num = 0u;
			while (num < typedArrayLength)
			{
				uint num2 = typedArrayLength - num - 1;
				jsTypedArray2[num++] = jsTypedArray.Get(num2);
			}
			return jsTypedArray2;
		}

		private JsValue ToSorted(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			ICallable compareFunction = GetCompareFunction(arguments.At(0));
			JsArrayBuffer viewedArrayBuffer = jsTypedArray._viewedArrayBuffer;
			JsValue[] argumentList = new JsNumber[1] { JsNumber.Create(typedArrayLength) };
			JsTypedArray jsTypedArray2 = TypedArrayCreateSameType(jsTypedArray, argumentList);
			JsValue[] array = SortArray(viewedArrayBuffer, compareFunction, jsTypedArray);
			for (int i = 0; (uint)i < (uint)array.Length; i++)
			{
				jsTypedArray2[i] = array[i];
			}
			return jsTypedArray2;
		}

		private ObjectInstance With(JsValue thisObject, JsValue[] arguments)
		{
			TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = thisObject.ValidateTypedArray(_realm, ArrayBufferOrder.SeqCst);
			JsTypedArray jsTypedArray = typedArrayWithBufferWitnessRecord.Object;
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			JsValue jsValue = arguments.At(1);
			double num = TypeConverter.ToIntegerOrInfinity(arguments.At(0));
			long num2 = ((!(num >= 0.0)) ? ((long)((double)typedArrayLength + num)) : ((long)num));
			jsValue = ((jsTypedArray._contentType == TypedArrayContentType.BigInt) ? ((JsValue)TypeConverter.ToJsBigInt(jsValue)) : ((JsValue)TypeConverter.ToJsNumber(jsValue)));
			if (!jsTypedArray.IsValidIntegerIndex(num2))
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid start index");
			}
			JsValue[] argumentList = new JsNumber[1] { JsNumber.Create(typedArrayLength) };
			JsTypedArray jsTypedArray2 = TypedArrayCreateSameType(jsTypedArray, argumentList);
			for (int i = 0; i < typedArrayLength; i++)
			{
				jsTypedArray2[i] = ((i == (int)num2) ? jsValue : jsTypedArray.Get(i));
			}
			return jsTypedArray2;
		}

		private JsTypedArray TypedArrayCreateSameType(JsTypedArray exemplar, JsValue[] argumentList)
		{
			IConstructor constructor = exemplar._arrayElementType.GetConstructor(_realm.Intrinsics);
			return IntrinsicTypedArrayConstructor.TypedArrayCreate(_realm, constructor, argumentList);
		}

		private ICallable? GetCompareFunction(JsValue compareArg)
		{
			ICallable result = null;
			if (!compareArg.IsUndefined())
			{
				if (!(compareArg is ICallable callable))
				{
					ExceptionHelper.ThrowTypeError(_realm, "The comparison function must be either a function or undefined");
					return null;
				}
				result = callable;
			}
			return result;
		}

		private static JsValue[] SortArray(JsArrayBuffer buffer, ICallable? compareFn, JsTypedArray obj)
		{
			TypedArrayComparer comparer = TypedArrayComparer.WithFunction(buffer, compareFn);
			ArrayOperations source = ArrayOperations.For(obj, forWrite: false);
			try
			{
				return source.OrderBy((JsValue x) => x, comparer).ToArray();
			}
			catch (InvalidOperationException ex)
			{
				throw ex.InnerException ?? ex;
			}
		}
	}
	internal static class TypeArrayHelper
	{
		internal static IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord ValidateTypedArray(this JsValue o, Realm realm, ArrayBufferOrder order = ArrayBufferOrder.Unordered)
		{
			if (!(o is JsTypedArray obj))
			{
				ExceptionHelper.ThrowTypeError(realm);
				return default(IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord);
			}
			IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord result = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(obj, order);
			if (result.IsTypedArrayOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(realm, "TypedArray is out of bounds");
			}
			return result;
		}
	}
	public abstract class TypedArrayConstructor : Constructor
	{
		private readonly TypedArrayElementType _arrayElementType;

		private TypedArrayPrototype PrototypeObject { get; }

		internal TypedArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype, TypedArrayElementType type)
			: base(engine, realm, new JsString(type.GetTypedArrayName()))
		{
			_arrayElementType = type;
			_prototype = functionPrototype;
			PrototypeObject = new TypedArrayPrototype(engine, objectPrototype, this, type);
			_length = new PropertyDescriptor(JsNumber.PositiveThree, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { ["BYTES_PER_ELEMENT"] = new PropertyDescriptor(new PropertyDescriptor(JsNumber.Create(_arrayElementType.GetElementSize()), PropertyFlag.AllForbidden)) };
			SetProperties(properties);
		}

		public JsTypedArray Construct(JsArrayBuffer buffer, int? byteOffset = null, int? length = null)
		{
			JsTypedArray jsTypedArray = AllocateTypedArray(this);
			InitializeTypedArrayFromArrayBuffer(jsTypedArray, buffer, byteOffset, length);
			return jsTypedArray;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (arguments.Length == 0)
			{
				return AllocateTypedArray(newTarget);
			}
			JsValue jsValue = arguments[0];
			if (jsValue.IsObject())
			{
				JsTypedArray jsTypedArray = AllocateTypedArray(newTarget);
				if (jsValue is JsTypedArray srcArray)
				{
					InitializeTypedArrayFromTypedArray(jsTypedArray, srcArray);
				}
				else if (jsValue is JsArrayBuffer buffer)
				{
					int? byteOffset = ((!arguments.At(1).IsUndefined()) ? new int?((int)TypeConverter.ToIndex(_realm, arguments[1])) : ((int?)null));
					int? length = ((!arguments.At(2).IsUndefined()) ? new int?((int)TypeConverter.ToIndex(_realm, arguments[2])) : ((int?)null));
					InitializeTypedArrayFromArrayBuffer(jsTypedArray, buffer, byteOffset, length);
				}
				else
				{
					ICallable method = ObjectInstance.GetMethod(_realm, jsValue, GlobalSymbolRegistry.Iterator);
					if (method != null)
					{
						List<JsValue> values = IterableToList(_realm, jsValue, method);
						InitializeTypedArrayFromList(jsTypedArray, values);
					}
					else
					{
						InitializeTypedArrayFromArrayLike(jsTypedArray, (ObjectInstance)jsValue);
					}
				}
				return jsTypedArray;
			}
			uint length2 = TypeConverter.ToIndex(_realm, jsValue);
			return AllocateTypedArray(newTarget, length2);
		}

		internal static List<JsValue> IterableToList(Realm realm, JsValue items, ICallable? method = null)
		{
			IteratorInstance iterator = items.GetIterator(realm);
			List<JsValue> list = new List<JsValue>();
			ObjectInstance nextItem;
			while (iterator.TryIteratorStep(out nextItem))
			{
				list.Add(nextItem.Get(CommonProperties.Value));
			}
			return list;
		}

		private void InitializeTypedArrayFromTypedArray(JsTypedArray o, JsTypedArray srcArray)
		{
			JsArrayBuffer viewedArrayBuffer = srcArray._viewedArrayBuffer;
			viewedArrayBuffer.AssertNotDetached();
			TypedArrayElementType arrayElementType = o._arrayElementType;
			TypedArrayElementType arrayElementType2 = srcArray._arrayElementType;
			byte elementSize = arrayElementType2.GetElementSize();
			int byteOffset = srcArray._byteOffset;
			IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(srcArray, ArrayBufferOrder.SeqCst);
			if (typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			uint typedArrayLength = typedArrayWithBufferWitnessRecord.TypedArrayLength;
			byte elementSize2 = arrayElementType.GetElementSize();
			uint num = elementSize2 * typedArrayLength;
			ArrayBufferConstructor arrayBuffer = _realm.Intrinsics.ArrayBuffer;
			JsArrayBuffer jsArrayBuffer;
			if (arrayElementType == arrayElementType2)
			{
				jsArrayBuffer = viewedArrayBuffer.CloneArrayBuffer(arrayBuffer, byteOffset, num);
			}
			else
			{
				jsArrayBuffer = arrayBuffer.AllocateArrayBuffer(arrayBuffer, num);
				viewedArrayBuffer.AssertNotDetached();
				if (srcArray._contentType != o._contentType)
				{
					ExceptionHelper.ThrowTypeError(_realm, "Content types differ");
				}
				int num2 = byteOffset;
				int num3 = 0;
				for (uint num4 = typedArrayLength; num4 != 0; num4--)
				{
					TypedArrayValue valueFromBuffer = viewedArrayBuffer.GetValueFromBuffer(num2, arrayElementType2, isTypedArray: true, ArrayBufferOrder.Unordered);
					jsArrayBuffer.SetValueInBuffer(num3, arrayElementType, valueFromBuffer, isTypedArray: true, ArrayBufferOrder.Unordered);
					num2 += elementSize;
					num3 += elementSize2;
				}
			}
			o._viewedArrayBuffer = jsArrayBuffer;
			o._arrayLength = typedArrayLength;
			o._byteLength = num;
			o._byteOffset = 0;
		}

		private void InitializeTypedArrayFromArrayBuffer(JsTypedArray o, JsArrayBuffer buffer, int? byteOffset, int? length)
		{
			byte elementSize = o._arrayElementType.GetElementSize();
			int valueOrDefault = byteOffset.GetValueOrDefault();
			if (valueOrDefault % elementSize != 0)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid offset");
			}
			int valueOrDefault2 = length.GetValueOrDefault();
			bool isFixedLengthArrayBuffer = buffer.IsFixedLengthArrayBuffer;
			buffer.AssertNotDetached();
			int num = IntrinsicTypedArrayPrototype.ArrayBufferByteLength(buffer, ArrayBufferOrder.SeqCst);
			if (!length.HasValue && !isFixedLengthArrayBuffer)
			{
				if (valueOrDefault > num)
				{
					ExceptionHelper.ThrowRangeError(_realm, "Invalid offset");
				}
				o._arrayLength = uint.MaxValue;
				o._byteLength = uint.MaxValue;
			}
			else
			{
				int num2;
				if (!length.HasValue)
				{
					if (num % elementSize != 0)
					{
						ExceptionHelper.ThrowRangeError(_realm, "Invalid buffer byte length");
					}
					num2 = num - valueOrDefault;
					if (num2 < 0)
					{
						ExceptionHelper.ThrowRangeError(_realm, "Invalid buffer byte length");
					}
				}
				else
				{
					num2 = valueOrDefault2 * elementSize;
					if (valueOrDefault + num2 > num)
					{
						ExceptionHelper.ThrowRangeError(_realm, "Invalid buffer byte length");
					}
				}
				o._arrayLength = (uint)(num2 / elementSize);
				o._byteLength = (uint)num2;
			}
			o._viewedArrayBuffer = buffer;
			o._byteOffset = valueOrDefault;
		}

		private static void InitializeTypedArrayFromList(JsTypedArray o, List<JsValue> values)
		{
			int count = values.Count;
			o.AllocateTypedArrayBuffer((uint)count);
			for (int i = 0; i < count; i++)
			{
				o[i] = values[i];
			}
		}

		private static void InitializeTypedArrayFromArrayLike(JsTypedArray o, ObjectInstance arrayLike)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(arrayLike, forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			o.AllocateTypedArrayBuffer(longLength);
			for (uint num = 0u; num < longLength; num++)
			{
				o[(int)num] = arrayOperations.Get(num);
			}
		}

		private JsTypedArray AllocateTypedArray(JsValue newTarget, uint length = 0u)
		{
			ObjectInstance prototypeFromConstructor = GetPrototypeFromConstructor(newTarget, _arrayElementType switch
			{
				TypedArrayElementType.Float32 => (Intrinsics intrinsics) => intrinsics.Float32Array.PrototypeObject, 
				TypedArrayElementType.Float64 => (Intrinsics intrinsics) => intrinsics.Float64Array.PrototypeObject, 
				TypedArrayElementType.Int8 => (Intrinsics intrinsics) => intrinsics.Int8Array.PrototypeObject, 
				TypedArrayElementType.Int16 => (Intrinsics intrinsics) => intrinsics.Int16Array.PrototypeObject, 
				TypedArrayElementType.Int32 => (Intrinsics intrinsics) => intrinsics.Int32Array.PrototypeObject, 
				TypedArrayElementType.BigInt64 => (Intrinsics intrinsics) => intrinsics.BigInt64Array.PrototypeObject, 
				TypedArrayElementType.Uint8 => (Intrinsics intrinsics) => intrinsics.Uint8Array.PrototypeObject, 
				TypedArrayElementType.Uint8C => (Intrinsics intrinsics) => intrinsics.Uint8ClampedArray.PrototypeObject, 
				TypedArrayElementType.Uint16 => (Intrinsics intrinsics) => intrinsics.Uint16Array.PrototypeObject, 
				TypedArrayElementType.Uint32 => (Intrinsics intrinsics) => intrinsics.Uint32Array.PrototypeObject, 
				TypedArrayElementType.BigUint64 => (Intrinsics intrinsics) => intrinsics.BigUint64Array.PrototypeObject, 
				_ => null, 
			});
			Realm functionRealm = GetFunctionRealm(newTarget);
			JsTypedArray jsTypedArray = new JsTypedArray(_engine, functionRealm.Intrinsics, _arrayElementType, length)
			{
				_prototype = prototypeFromConstructor
			};
			if (length != 0)
			{
				jsTypedArray.AllocateTypedArrayBuffer(length);
			}
			return jsTypedArray;
		}

		internal static void FillTypedArrayInstance<T>(JsTypedArray target, T[] values)
		{
			for (int i = 0; i < values.Length; i++)
			{
				target.DoIntegerIndexedElementSet(i, Convert.ToDouble(values[i], CultureInfo.InvariantCulture));
			}
		}

		internal static void FillTypedArrayInstance(JsTypedArray target, ulong[] values)
		{
			for (int i = 0; i < values.Length; i++)
			{
				target.DoIntegerIndexedElementSet(i, values[i]);
			}
		}

		internal static void FillTypedArrayInstance(JsTypedArray target, long[] values)
		{
			for (int i = 0; i < values.Length; i++)
			{
				target.DoIntegerIndexedElementSet(i, values[i]);
			}
		}
	}
	public sealed class Int8ArrayConstructor : TypedArrayConstructor
	{
		internal Int8ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Int8)
		{
		}

		public JsTypedArray Construct(sbyte[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Uint8ArrayConstructor : TypedArrayConstructor
	{
		internal Uint8ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Uint8)
		{
		}

		public JsTypedArray Construct(byte[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Uint8ClampedArrayConstructor : TypedArrayConstructor
	{
		internal Uint8ClampedArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Uint8C)
		{
		}

		public JsTypedArray Construct(byte[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Int16ArrayConstructor : TypedArrayConstructor
	{
		internal Int16ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Int16)
		{
		}

		public JsTypedArray Construct(short[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Uint16ArrayConstructor : TypedArrayConstructor
	{
		internal Uint16ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Uint16)
		{
		}

		public JsTypedArray Construct(ushort[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Int32ArrayConstructor : TypedArrayConstructor
	{
		internal Int32ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Int32)
		{
		}

		public JsTypedArray Construct(int[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Uint32ArrayConstructor : TypedArrayConstructor
	{
		internal Uint32ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Uint32)
		{
		}

		public JsTypedArray Construct(uint[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Float32ArrayConstructor : TypedArrayConstructor
	{
		internal Float32ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Float32)
		{
		}

		public JsTypedArray Construct(float[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class Float64ArrayConstructor : TypedArrayConstructor
	{
		internal Float64ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.Float64)
		{
		}

		public JsTypedArray Construct(double[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class BigInt64ArrayConstructor : TypedArrayConstructor
	{
		internal BigInt64ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.BigInt64)
		{
		}

		public JsTypedArray Construct(long[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	public sealed class BigUint64ArrayConstructor : TypedArrayConstructor
	{
		internal BigUint64ArrayConstructor(Engine engine, Realm realm, IntrinsicTypedArrayConstructor functionPrototype, IntrinsicTypedArrayPrototype objectPrototype)
			: base(engine, realm, functionPrototype, objectPrototype, TypedArrayElementType.BigUint64)
		{
		}

		public JsTypedArray Construct(ulong[] values)
		{
			JsTypedArray obj = (JsTypedArray)Construct(new JsValue[1] { values.Length }, this);
			TypedArrayConstructor.FillTypedArrayInstance(obj, values);
			return obj;
		}
	}
	internal enum TypedArrayContentType : byte
	{
		Number,
		BigInt
	}
	internal enum TypedArrayElementType : byte
	{
		Int8,
		Int16,
		Int32,
		BigInt64,
		Float32,
		Float64,
		Uint8,
		Uint8C,
		Uint16,
		Uint32,
		BigUint64
	}
	internal static class TypedArrayExtensions
	{
		internal static byte GetElementSize(this TypedArrayElementType type)
		{
			return type switch
			{
				TypedArrayElementType.Int8 => 1, 
				TypedArrayElementType.Uint8 => 1, 
				TypedArrayElementType.Uint8C => 1, 
				TypedArrayElementType.Int16 => 2, 
				TypedArrayElementType.Uint16 => 2, 
				TypedArrayElementType.Int32 => 4, 
				TypedArrayElementType.Uint32 => 4, 
				TypedArrayElementType.BigInt64 => 8, 
				TypedArrayElementType.BigUint64 => 8, 
				TypedArrayElementType.Float32 => 4, 
				TypedArrayElementType.Float64 => 8, 
				_ => 0, 
			};
		}

		internal static string GetTypedArrayName(this TypedArrayElementType type)
		{
			return type switch
			{
				TypedArrayElementType.Int8 => "Int8Array", 
				TypedArrayElementType.Uint8 => "Uint8Array", 
				TypedArrayElementType.Uint8C => "Uint8ClampedArray", 
				TypedArrayElementType.Int16 => "Int16Array", 
				TypedArrayElementType.Uint16 => "Uint16Array", 
				TypedArrayElementType.Int32 => "Int32Array", 
				TypedArrayElementType.Uint32 => "Uint32Array", 
				TypedArrayElementType.BigInt64 => "BigInt64Array", 
				TypedArrayElementType.BigUint64 => "BigUint64Array", 
				TypedArrayElementType.Float32 => "Float32Array", 
				TypedArrayElementType.Float64 => "Float64Array", 
				_ => "", 
			};
		}

		internal static IConstructor GetConstructor(this TypedArrayElementType type, Intrinsics intrinsics)
		{
			return type switch
			{
				TypedArrayElementType.Int8 => intrinsics.Int8Array, 
				TypedArrayElementType.Uint8 => intrinsics.Uint8Array, 
				TypedArrayElementType.Uint8C => intrinsics.Uint8ClampedArray, 
				TypedArrayElementType.Int16 => intrinsics.Int16Array, 
				TypedArrayElementType.Uint16 => intrinsics.Uint16Array, 
				TypedArrayElementType.Int32 => intrinsics.Int32Array, 
				TypedArrayElementType.Uint32 => intrinsics.Uint32Array, 
				TypedArrayElementType.BigInt64 => intrinsics.BigInt64Array, 
				TypedArrayElementType.BigUint64 => intrinsics.BigUint64Array, 
				TypedArrayElementType.Float32 => intrinsics.Float32Array, 
				TypedArrayElementType.Float64 => intrinsics.Float64Array, 
				_ => null, 
			};
		}

		internal static bool IsUnsignedElementType(this TypedArrayElementType type)
		{
			return (int)type > 5;
		}

		internal static bool FitsInt32(this TypedArrayElementType type)
		{
			return (int)type <= 2;
		}

		internal static bool IsBigIntElementType(this TypedArrayElementType type)
		{
			if (type == TypedArrayElementType.BigInt64 || type == TypedArrayElementType.BigUint64)
			{
				return true;
			}
			return false;
		}
	}
	internal sealed class TypedArrayPrototype : Prototype
	{
		private readonly TypedArrayConstructor _constructor;

		private readonly TypedArrayElementType _arrayElementType;

		internal TypedArrayPrototype(Engine engine, IntrinsicTypedArrayPrototype objectPrototype, TypedArrayConstructor constructor, TypedArrayElementType type)
			: base(engine, engine.Realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
			_arrayElementType = type;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false)
			{
				["BYTES_PER_ELEMENT"] = new PropertyDescriptor(JsNumber.Create(_arrayElementType.GetElementSize()), PropertyFlag.AllForbidden),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable)
			};
			SetProperties(properties);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly record struct TypedArrayValue(Types Type, double DoubleValue, BigInteger BigInteger) : IConvertible
	{
		public static implicit operator TypedArrayValue(double value)
		{
			return new TypedArrayValue(Types.Number, value, default(BigInteger));
		}

		public static implicit operator TypedArrayValue(byte value)
		{
			return new TypedArrayValue(Types.Number, (int)value, default(BigInteger));
		}

		public static implicit operator TypedArrayValue(int value)
		{
			return new TypedArrayValue(Types.Number, value, default(BigInteger));
		}

		public static implicit operator TypedArrayValue(ushort value)
		{
			return new TypedArrayValue(Types.Number, (int)value, default(BigInteger));
		}

		public static implicit operator TypedArrayValue(short value)
		{
			return new TypedArrayValue(Types.Number, value, default(BigInteger));
		}

		public static implicit operator TypedArrayValue(uint value)
		{
			return new TypedArrayValue(Types.Number, value, default(BigInteger));
		}

		public static implicit operator TypedArrayValue(BigInteger value)
		{
			return new TypedArrayValue(Types.BigInt, 0.0, value);
		}

		public static implicit operator TypedArrayValue(ulong value)
		{
			return new TypedArrayValue(Types.BigInt, 0.0, value);
		}

		public static implicit operator TypedArrayValue(long value)
		{
			return new TypedArrayValue(Types.BigInt, 0.0, value);
		}

		public JsValue ToJsValue()
		{
			if (Type != Types.Number)
			{
				return JsBigInt.Create(BigInteger);
			}
			return JsNumber.Create(DoubleValue);
		}

		public TypeCode GetTypeCode()
		{
			ExceptionHelper.ThrowNotImplementedException();
			return TypeCode.Empty;
		}

		public bool ToBoolean(IFormatProvider? provider)
		{
			ExceptionHelper.ThrowNotImplementedException();
			return false;
		}

		public char ToChar(IFormatProvider? provider)
		{
			ExceptionHelper.ThrowNotImplementedException();
			return '\0';
		}

		public sbyte ToSByte(IFormatProvider? provider)
		{
			return (sbyte)DoubleValue;
		}

		public byte ToByte(IFormatProvider? provider)
		{
			return (byte)DoubleValue;
		}

		public short ToInt16(IFormatProvider? provider)
		{
			return (short)DoubleValue;
		}

		public ushort ToUInt16(IFormatProvider? provider)
		{
			return (ushort)DoubleValue;
		}

		public int ToInt32(IFormatProvider? provider)
		{
			return (int)DoubleValue;
		}

		public uint ToUInt32(IFormatProvider? provider)
		{
			return (uint)DoubleValue;
		}

		public long ToInt64(IFormatProvider? provider)
		{
			return (long)BigInteger;
		}

		public ulong ToUInt64(IFormatProvider? provider)
		{
			return (ulong)BigInteger;
		}

		public float ToSingle(IFormatProvider? provider)
		{
			return (float)DoubleValue;
		}

		public double ToDouble(IFormatProvider? provider)
		{
			return DoubleValue;
		}

		public decimal ToDecimal(IFormatProvider? provider)
		{
			return (decimal)DoubleValue;
		}

		public DateTime ToDateTime(IFormatProvider? provider)
		{
			ExceptionHelper.ThrowNotImplementedException();
			return default(DateTime);
		}

		public string ToString(IFormatProvider? provider)
		{
			ExceptionHelper.ThrowNotImplementedException();
			return null;
		}

		public object ToType(Type conversionType, IFormatProvider? provider)
		{
			if (conversionType == typeof(BigInteger) && Type == Types.BigInt)
			{
				return BigInteger;
			}
			ExceptionHelper.ThrowNotImplementedException();
			return null;
		}
	}
}
namespace Jint.Native.Symbol
{
	public sealed class GlobalSymbolRegistry
	{
		public static readonly JsSymbol AsyncIterator = new JsSymbol("Symbol.asyncIterator");

		public static readonly JsSymbol HasInstance = new JsSymbol("Symbol.hasInstance");

		public static readonly JsSymbol IsConcatSpreadable = new JsSymbol("Symbol.isConcatSpreadable");

		public static readonly JsSymbol Iterator = new JsSymbol("Symbol.iterator");

		public static readonly JsSymbol Match = new JsSymbol("Symbol.match");

		public static readonly JsSymbol MatchAll = new JsSymbol("Symbol.matchAll");

		public static readonly JsSymbol Replace = new JsSymbol("Symbol.replace");

		public static readonly JsSymbol Search = new JsSymbol("Symbol.search");

		public static readonly JsSymbol Species = new JsSymbol("Symbol.species");

		public static readonly JsSymbol Split = new JsSymbol("Symbol.split");

		public static readonly JsSymbol ToPrimitive = new JsSymbol("Symbol.toPrimitive");

		public static readonly JsSymbol ToStringTag = new JsSymbol("Symbol.toStringTag");

		public static readonly JsSymbol Unscopables = new JsSymbol("Symbol.unscopables");

		private Dictionary<JsValue, JsSymbol>? _customSymbolLookup;

		internal bool TryGetSymbol(JsValue key, [NotNullWhen(true)] out JsSymbol? symbol)
		{
			symbol = null;
			if (_customSymbolLookup != null)
			{
				return _customSymbolLookup.TryGetValue(key, out symbol);
			}
			return false;
		}

		internal void Add(JsSymbol symbol)
		{
			if (_customSymbolLookup == null)
			{
				_customSymbolLookup = new Dictionary<JsValue, JsSymbol>();
			}
			_customSymbolLookup[symbol._value] = symbol;
		}

		internal static JsSymbol CreateSymbol(JsValue description)
		{
			return new JsSymbol(description);
		}

		internal bool ContainsCustom(JsValue value)
		{
			if (value is JsSymbol jsSymbol)
			{
				return _customSymbolLookup?.ContainsKey(jsSymbol._value) ?? false;
			}
			return false;
		}
	}
	internal sealed class SymbolConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Symbol");

		public SymbolPrototype PrototypeObject { get; }

		internal SymbolConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new SymbolPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(15, checkExistingKeys: false)
			{
				["for"] = new PropertyDescriptor(new ClrFunction(base.Engine, "for", For, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["keyFor"] = new PropertyDescriptor(new ClrFunction(base.Engine, "keyFor", KeyFor, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["hasInstance"] = new PropertyDescriptor(GlobalSymbolRegistry.HasInstance, PropertyFlag.AllForbidden),
				["isConcatSpreadable"] = new PropertyDescriptor(GlobalSymbolRegistry.IsConcatSpreadable, PropertyFlag.AllForbidden),
				["iterator"] = new PropertyDescriptor(GlobalSymbolRegistry.Iterator, PropertyFlag.AllForbidden),
				["match"] = new PropertyDescriptor(GlobalSymbolRegistry.Match, PropertyFlag.AllForbidden),
				["matchAll"] = new PropertyDescriptor(GlobalSymbolRegistry.MatchAll, PropertyFlag.AllForbidden),
				["replace"] = new PropertyDescriptor(GlobalSymbolRegistry.Replace, PropertyFlag.AllForbidden),
				["search"] = new PropertyDescriptor(GlobalSymbolRegistry.Search, PropertyFlag.AllForbidden),
				["species"] = new PropertyDescriptor(GlobalSymbolRegistry.Species, PropertyFlag.AllForbidden),
				["split"] = new PropertyDescriptor(GlobalSymbolRegistry.Split, PropertyFlag.AllForbidden),
				["toPrimitive"] = new PropertyDescriptor(GlobalSymbolRegistry.ToPrimitive, PropertyFlag.AllForbidden),
				["toStringTag"] = new PropertyDescriptor(GlobalSymbolRegistry.ToStringTag, PropertyFlag.AllForbidden),
				["unscopables"] = new PropertyDescriptor(GlobalSymbolRegistry.Unscopables, PropertyFlag.AllForbidden),
				["asyncIterator"] = new PropertyDescriptor(GlobalSymbolRegistry.AsyncIterator, PropertyFlag.AllForbidden)
			};
			SetProperties(properties);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			return GlobalSymbolRegistry.CreateSymbol(jsValue.IsUndefined() ? JsValue.Undefined : TypeConverter.ToJsString(jsValue));
		}

		private JsValue For(JsValue thisObject, JsValue[] arguments)
		{
			JsString jsString = TypeConverter.ToJsString(arguments.At(0));
			if (!_engine.GlobalSymbolRegistry.TryGetSymbol(jsString, out JsSymbol symbol))
			{
				symbol = GlobalSymbolRegistry.CreateSymbol(jsString);
				_engine.GlobalSymbolRegistry.Add(symbol);
			}
			return symbol;
		}

		private JsValue KeyFor(JsValue thisObject, JsValue[] arguments)
		{
			JsSymbol jsSymbol = arguments.At(0) as JsSymbol;
			if ((object)jsSymbol == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (_engine.GlobalSymbolRegistry.TryGetSymbol(jsSymbol._value, out JsSymbol symbol))
			{
				return symbol._value;
			}
			return JsValue.Undefined;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			ExceptionHelper.ThrowTypeError(_realm, "Symbol is not a constructor");
			return null;
		}

		public SymbolInstance Construct(JsSymbol symbol)
		{
			return new SymbolInstance(base.Engine, PrototypeObject, symbol);
		}
	}
	internal sealed class SymbolInstance : ObjectInstance, IJsPrimitive
	{
		Types IJsPrimitive.Type => Types.Symbol;

		JsValue IJsPrimitive.PrimitiveValue => SymbolData;

		public JsSymbol SymbolData { get; }

		internal SymbolInstance(Engine engine, SymbolPrototype prototype, JsSymbol symbol)
			: base(engine)
		{
			_prototype = prototype;
			SymbolData = symbol;
		}
	}
	internal sealed class SymbolPrototype : Prototype
	{
		private readonly SymbolConstructor _constructor;

		internal SymbolPrototype(Engine engine, Realm realm, SymbolConstructor symbolConstructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = symbolConstructor;
		}

		protected override void Initialize()
		{
			SetProperties(new PropertyDictionary(5, checkExistingKeys: false)
			{
				["length"] = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.Writable | PropertyFlag.Configurable),
				["description"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "description", Description, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToSymbolString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["valueOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			});
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toPrimitive = GlobalSymbolRegistry.ToPrimitive;
			symbolDictionary[toPrimitive] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.toPrimitive]", ToPrimitive, 1, PropertyFlag.Configurable), PropertyFlag.Configurable);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor(new JsString("Symbol"), PropertyFlag.Configurable);
			SetSymbols(symbolDictionary);
		}

		private JsValue Description(JsValue thisObject, JsValue[] arguments)
		{
			return ThisSymbolValue(thisObject)._value;
		}

		private JsValue ToSymbolString(JsValue thisObject, JsValue[] arguments)
		{
			return new JsString(ThisSymbolValue(thisObject).ToString());
		}

		private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
		{
			return ThisSymbolValue(thisObject);
		}

		private JsValue ToPrimitive(JsValue thisObject, JsValue[] arguments)
		{
			return ThisSymbolValue(thisObject);
		}

		private JsSymbol ThisSymbolValue(JsValue thisObject)
		{
			if (thisObject is JsSymbol result)
			{
				return result;
			}
			if (thisObject is SymbolInstance symbolInstance)
			{
				return symbolInstance.SymbolData;
			}
			ExceptionHelper.ThrowTypeError(_realm);
			return null;
		}
	}
}
namespace Jint.Native.String
{
	internal sealed class StringConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("String");

		public StringPrototype PrototypeObject { get; }

		public StringConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new StringPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(3, checkExistingKeys: false)
			{
				["fromCharCode"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "fromCharCode", FromCharCode, 1), PropertyFlag.NonEnumerable)),
				["fromCodePoint"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "fromCodePoint", FromCodePoint, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable)),
				["raw"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "raw", Raw, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable))
			};
			SetProperties(properties);
		}

		private static JsValue FromCharCode(JsValue? thisObj, JsValue[] arguments)
		{
			int num = arguments.Length;
			if (num == 0)
			{
				return JsString.Empty;
			}
			if (arguments.Length == 1)
			{
				return JsString.Create((char)TypeConverter.ToUint16(arguments[0]));
			}
			Span<char> span = ((num >= 512) ? ((Span<char>)new char[num]) : stackalloc char[num]);
			Span<char> span2 = span;
			for (int i = 0; i < span2.Length; i++)
			{
				ushort num2 = TypeConverter.ToUint16(arguments[i]);
				span2[i] = (char)num2;
			}
			return JsString.Create(new string(span2));
		}

		private JsValue FromCodePoint(JsValue thisObject, JsValue[] arguments)
		{
			Span<char> initialBuffer = stackalloc char[128];
			using System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			int num = 0;
			JsNumber jsNumber;
			while (true)
			{
				if (num < arguments.Length)
				{
					jsNumber = TypeConverter.ToJsNumber(arguments[num]);
					int num2;
					if (jsNumber.IsInteger())
					{
						num2 = (int)jsNumber._value;
						if ((num2 < 0 || num2 > 1114111) ? true : false)
						{
							break;
						}
					}
					else
					{
						double value = jsNumber._value;
						if (value < 0.0 || value > 1114111.0 || double.IsInfinity(value) || double.IsNaN(value) || (double)TypeConverter.ToInt32(value) != value)
						{
							break;
						}
						num2 = (int)value;
					}
					if (num2 <= 65535)
					{
						valueStringBuilder.Append((char)num2);
					}
					else
					{
						num2 -= 65536;
						valueStringBuilder.Append((char)((num2 >> 10) + 55296));
						valueStringBuilder.Append((char)(num2 % 1024 + 56320));
					}
					num++;
					continue;
				}
				return JsString.Create(valueStringBuilder.ToString());
			}
			_engine.SignalError(ExceptionHelper.CreateRangeError(_realm, "Invalid code point " + jsNumber));
			return JsEmpty.Instance;
		}

		private JsValue Raw(JsValue thisObject, JsValue[] arguments)
		{
			JsValue value = TypeConverter.ToObject(_realm, arguments.At(0)).Get(JintTaggedTemplateExpression.PropertyRaw);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, value, forWrite: false);
			uint length = arrayOperations.GetLength();
			if (length == 0)
			{
				return JsString.Empty;
			}
			using System.Text.ValueStringBuilder valueStringBuilder = default(System.Text.ValueStringBuilder);
			for (int i = 0; i < length; i++)
			{
				if (i > 0 && i < arguments.Length && !arguments[i].IsUndefined())
				{
					valueStringBuilder.Append(TypeConverter.ToString(arguments[i]));
				}
				valueStringBuilder.Append(TypeConverter.ToString(arrayOperations.Get((ulong)i)));
			}
			return valueStringBuilder.ToString();
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			if (arguments.Length == 0)
			{
				return JsString.Empty;
			}
			JsValue jsValue = arguments[0];
			return JsString.Create((jsValue is JsSymbol jsSymbol) ? jsSymbol.ToString() : TypeConverter.ToString(jsValue));
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsString value;
			if (arguments.Length == 0)
			{
				value = JsString.Empty;
			}
			else
			{
				JsValue jsValue = arguments.At(0);
				if (newTarget.IsUndefined() && jsValue.IsSymbol())
				{
					return StringCreate(JsString.Create(((JsSymbol)jsValue).ToString()), PrototypeObject);
				}
				value = TypeConverter.ToJsString(arguments[0]);
			}
			if (newTarget.IsUndefined())
			{
				return StringCreate(value, PrototypeObject);
			}
			return StringCreate(value, GetPrototypeFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.String.PrototypeObject));
		}

		public StringInstance Construct(JsString value)
		{
			return StringCreate(value, PrototypeObject);
		}

		private StringInstance StringCreate(JsString value, ObjectInstance prototype)
		{
			return new StringInstance(base.Engine, value)
			{
				_prototype = prototype
			};
		}
	}
	internal sealed class StringExecutionContext
	{
		private static readonly ThreadLocal<StringExecutionContext> _executionContext = new ThreadLocal<StringExecutionContext>(() => new StringExecutionContext());

		private List<string>? _splitSegmentList;

		private string[]? _splitArray1;

		public List<string> SplitSegmentList => _splitSegmentList ?? (_splitSegmentList = new List<string>());

		public string[] SplitArray1 => _splitArray1 ?? (_splitArray1 = new string[1]);

		public static StringExecutionContext Current => _executionContext.Value;

		private StringExecutionContext()
		{
		}
	}
	internal class StringInlHelper
	{
		private static List<int> GetLithuaninanReplaceableCharIdx(string input)
		{
			List<int> list = new List<int>();
			for (int i = 0; i < input.Length; i++)
			{
				if (input[i].Equals('\u0307'))
				{
					list.Add(i);
				}
			}
			list.RemoveAll((int idx) => (idx > 0 && input[idx - 1] == 'I') || input[idx - 1] == 'J');
			return list;
		}

		public static string LithuanianStringProcessor(string input)
		{
			List<int> lithuaninanReplaceableCharIdx = GetLithuaninanReplaceableCharIdx(input);
			if (lithuaninanReplaceableCharIdx.Count > 0)
			{
				StringBuilder stringBuilder = new StringBuilder(input);
				for (int num = lithuaninanReplaceableCharIdx.Count - 1; num >= 0; num--)
				{
					int num2 = lithuaninanReplaceableCharIdx[num];
					if (num2 >= 0 && num2 < stringBuilder.Length)
					{
						stringBuilder.Remove(num2, 1);
					}
				}
				return stringBuilder.ToString();
			}
			return input;
		}
	}
	internal class StringInstance : ObjectInstance, IJsPrimitive
	{
		internal PropertyDescriptor? _length;

		Types IJsPrimitive.Type => Types.String;

		JsValue IJsPrimitive.PrimitiveValue => StringData;

		public JsString StringData { get; }

		public StringInstance(Engine engine, JsString value)
			: base(engine, ObjectClass.String)
		{
			StringData = value;
			_length = PropertyDescriptor.AllForbiddenDescriptor.ForNumber(value.Length);
		}

		private static bool IsInt32(double d, out int intValue)
		{
			if (d >= -2147483648.0 && d <= 2147483647.0)
			{
				intValue = (int)d;
				return (double)intValue == d;
			}
			intValue = 0;
			return false;
		}

		public sealed override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (CommonProperties.Infinity.Equals(property))
			{
				return PropertyDescriptor.Undefined;
			}
			if (CommonProperties.Length.Equals(property))
			{
				return _length ?? PropertyDescriptor.Undefined;
			}
			PropertyDescriptor ownProperty = base.GetOwnProperty(property);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				return ownProperty;
			}
			if ((property._type & (InternalTypes.String | InternalTypes.Number | InternalTypes.Integer)) == 0)
			{
				return PropertyDescriptor.Undefined;
			}
			string text = StringData.ToString();
			if (!IsInt32(TypeConverter.ToNumber(property), out var intValue) || intValue < 0 || intValue >= text.Length)
			{
				return PropertyDescriptor.Undefined;
			}
			return new PropertyDescriptor(text[intValue], PropertyFlag.OnlyEnumerable);
		}

		public sealed override IEnumerable<KeyValuePair<JsValue, PropertyDescriptor>> GetOwnProperties()
		{
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in base.GetOwnProperties())
			{
				yield return ownProperty;
			}
			if (_length != null)
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(CommonProperties.Length, _length);
			}
		}

		internal sealed override IEnumerable<JsValue> GetInitialOwnStringPropertyKeys()
		{
			yield return JsString.LengthString;
		}

		public sealed override List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			List<JsValue> list = new List<JsValue>(StringData.Length + 1);
			if ((types & Types.String) != Types.Empty)
			{
				for (uint num = 0u; num < StringData.Length; num++)
				{
					list.Add(JsString.Create(num));
				}
				list.AddRange(base.GetOwnPropertyKeys(Types.String));
			}
			if ((types & Types.Symbol) != Types.Empty)
			{
				list.AddRange(base.GetOwnPropertyKeys(Types.Symbol));
			}
			return list;
		}

		protected internal sealed override void SetOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			if (CommonProperties.Length.Equals(property))
			{
				_length = desc;
			}
			else
			{
				base.SetOwnProperty(property, desc);
			}
		}

		public sealed override void RemoveOwnProperty(JsValue property)
		{
			if (CommonProperties.Length.Equals(property))
			{
				_length = null;
			}
			base.RemoveOwnProperty(property);
		}
	}
	internal sealed class StringIteratorPrototype : IteratorPrototype
	{
		internal StringIteratorPrototype(Engine engine, Realm realm, IteratorPrototype iteratorPrototype)
			: base(engine, realm, iteratorPrototype)
		{
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { [KnownKeys.Next] = new PropertyDescriptor(new ClrFunction(base.Engine, "next", base.Next, 0, PropertyFlag.Configurable), true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("String Iterator", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		public ObjectInstance Construct(string str)
		{
			return new IteratorInstance.StringIterator(base.Engine, str)
			{
				_prototype = this
			};
		}
	}
	internal sealed class StringPrototype : StringInstance
	{
		[StructLayout(LayoutKind.Auto)]
		private readonly record struct CodePointResult(int CodePoint, int CodeUnitCount, bool IsUnpairedSurrogate);

		private readonly Realm _realm;

		private readonly StringConstructor _constructor;

		internal ClrFunction? _originalIteratorFunction;

		private const char BOM_CHAR = '\ufeff';

		internal override bool HasOriginalIterator => (object)Get(GlobalSymbolRegistry.Iterator) == _originalIteratorFunction;

		internal StringPrototype(Engine engine, Realm realm, StringConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, JsString.Empty)
		{
			_prototype = objectPrototype;
			_length = PropertyDescriptor.AllForbiddenDescriptor.NumberZero;
			_realm = realm;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDescriptor value = new PropertyDescriptor(new ClrFunction(base.Engine, "trimStart", TrimStart, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			PropertyDescriptor value2 = new PropertyDescriptor(new ClrFunction(base.Engine, "trimEnd", TrimEnd, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			PropertyDictionary properties = new PropertyDictionary(37, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToStringString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["valueOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["charAt"] = new PropertyDescriptor(new ClrFunction(base.Engine, "charAt", CharAt, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["charCodeAt"] = new PropertyDescriptor(new ClrFunction(base.Engine, "charCodeAt", CharCodeAt, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["codePointAt"] = new PropertyDescriptor(new ClrFunction(base.Engine, "codePointAt", CodePointAt, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["concat"] = new PropertyDescriptor(new ClrFunction(base.Engine, "concat", Concat, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["indexOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "indexOf", IndexOf, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["endsWith"] = new PropertyDescriptor(new ClrFunction(base.Engine, "endsWith", EndsWith, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["startsWith"] = new PropertyDescriptor(new ClrFunction(base.Engine, "startsWith", StartsWith, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["lastIndexOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "lastIndexOf", LastIndexOf, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["localeCompare"] = new PropertyDescriptor(new ClrFunction(base.Engine, "localeCompare", LocaleCompare, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["match"] = new PropertyDescriptor(new ClrFunction(base.Engine, "match", Match, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["matchAll"] = new PropertyDescriptor(new ClrFunction(base.Engine, "matchAll", MatchAll, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["replace"] = new PropertyDescriptor(new ClrFunction(base.Engine, "replace", Replace, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["replaceAll"] = new PropertyDescriptor(new ClrFunction(base.Engine, "replaceAll", ReplaceAll, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["search"] = new PropertyDescriptor(new ClrFunction(base.Engine, "search", Search, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["slice"] = new PropertyDescriptor(new ClrFunction(base.Engine, "slice", Slice, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["split"] = new PropertyDescriptor(new ClrFunction(base.Engine, "split", Split, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["substr"] = new PropertyDescriptor(new ClrFunction(base.Engine, "substr", Substr, 2), PropertyFlag.Writable | PropertyFlag.Configurable),
				["substring"] = new PropertyDescriptor(new ClrFunction(base.Engine, "substring", Substring, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLowerCase"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLowerCase", ToLowerCase, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleLowerCase"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleLowerCase", ToLocaleLowerCase, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toUpperCase"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toUpperCase", ToUpperCase, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleUpperCase"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleUpperCase", ToLocaleUpperCase, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["trim"] = new PropertyDescriptor(new ClrFunction(base.Engine, "trim", Trim, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["trimStart"] = value,
				["trimEnd"] = value2,
				["trimLeft"] = value,
				["trimRight"] = value2,
				["padStart"] = new PropertyDescriptor(new ClrFunction(base.Engine, "padStart", PadStart, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["padEnd"] = new PropertyDescriptor(new ClrFunction(base.Engine, "padEnd", PadEnd, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["includes"] = new PropertyDescriptor(new ClrFunction(base.Engine, "includes", Includes, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["normalize"] = new PropertyDescriptor(new ClrFunction(base.Engine, "normalize", Normalize, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["repeat"] = new PropertyDescriptor(new ClrFunction(base.Engine, "repeat", Repeat, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["at"] = new PropertyDescriptor(new ClrFunction(base.Engine, "at", At, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["isWellFormed"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isWellFormed", IsWellFormed, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toWellFormed"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toWellFormed", ToWellFormed, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			_originalIteratorFunction = new ClrFunction(base.Engine, "[Symbol.iterator]", Iterator, 0, PropertyFlag.Configurable);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol iterator = GlobalSymbolRegistry.Iterator;
			symbolDictionary[iterator] = new PropertyDescriptor(_originalIteratorFunction, PropertyFlag.Writable | PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private ObjectInstance Iterator(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			string str = TypeConverter.ToString(thisObject);
			return _realm.Intrinsics.StringIteratorPrototype.Construct(str);
		}

		private JsValue ToStringString(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject.IsString())
			{
				return thisObject;
			}
			StringInstance obj = TypeConverter.ToObject(_realm, thisObject) as StringInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return obj.StringData;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsWhiteSpaceEx(char c)
		{
			if (!char.IsWhiteSpace(c))
			{
				return c == '\ufeff';
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static string TrimEndEx(string s)
		{
			if (s.Length == 0)
			{
				return string.Empty;
			}
			if (!IsWhiteSpaceEx(s[s.Length - 1]))
			{
				return s;
			}
			return TrimEnd(s);
		}

		private static string TrimEnd(string s)
		{
			int num = s.Length - 1;
			while (num >= 0 && IsWhiteSpaceEx(s[num]))
			{
				num--;
			}
			if (num < 0)
			{
				return string.Empty;
			}
			return s.Substring(0, num + 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string TrimStartEx(string s)
		{
			if (s.Length == 0)
			{
				return string.Empty;
			}
			if (!IsWhiteSpaceEx(s[0]))
			{
				return s;
			}
			return TrimStart(s);
		}

		private static string TrimStart(string s)
		{
			int i;
			for (i = 0; i < s.Length && IsWhiteSpaceEx(s[i]); i++)
			{
			}
			if (i < s.Length)
			{
				return s.Substring(i);
			}
			return string.Empty;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static string TrimEx(string s)
		{
			return TrimEndEx(TrimStartEx(s));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private JsValue Trim(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			if (jsString.Length == 0 || (!IsWhiteSpaceEx(jsString[0]) && !IsWhiteSpaceEx(jsString[jsString.Length - 1])))
			{
				return jsString;
			}
			return TrimEx(jsString.ToString());
		}

		private JsValue TrimStart(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			if (jsString.Length == 0 || !IsWhiteSpaceEx(jsString[0]))
			{
				return jsString;
			}
			return TrimStartEx(jsString.ToString());
		}

		private JsValue TrimEnd(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			if (jsString.Length == 0 || !IsWhiteSpaceEx(jsString[jsString.Length - 1]))
			{
				return jsString;
			}
			return TrimEndEx(jsString.ToString());
		}

		private JsValue ToLocaleUpperCase(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			string text = TypeConverter.ToString(thisObject);
			CultureInfo cultureInfo = CultureInfo.InvariantCulture;
			if (arguments.Length != 0 && arguments[0].IsString())
			{
				try
				{
					cultureInfo = CultureInfo.GetCultureInfo(arguments[0].ToString());
				}
				catch (CultureNotFoundException)
				{
					ExceptionHelper.ThrowRangeError(_realm, "Incorrect culture information provided");
				}
			}
			if (string.Equals("lt", cultureInfo.Name, StringComparison.OrdinalIgnoreCase))
			{
				text = StringInlHelper.LithuanianStringProcessor(text);
			}
			return new JsString(text.ToUpper(cultureInfo));
		}

		private JsValue ToUpperCase(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			return new JsString(TypeConverter.ToString(thisObject).ToUpperInvariant());
		}

		private JsValue ToLocaleLowerCase(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			return new JsString(TypeConverter.ToString(thisObject).ToLower(CultureInfo.InvariantCulture));
		}

		private JsValue ToLowerCase(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			return TypeConverter.ToString(thisObject).ToLowerInvariant();
		}

		private static int ToIntegerSupportInfinity(JsValue numberVal)
		{
			if (numberVal._type != InternalTypes.Integer)
			{
				return ToIntegerSupportInfinityUnlikely(numberVal);
			}
			return numberVal.AsInteger();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static int ToIntegerSupportInfinityUnlikely(JsValue numberVal)
		{
			double num = TypeConverter.ToInteger(numberVal);
			if (double.IsPositiveInfinity(num))
			{
				return int.MaxValue;
			}
			if (double.IsNegativeInfinity(num))
			{
				return int.MinValue;
			}
			return (int)num;
		}

		private JsValue Substring(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			string text = TypeConverter.ToString(thisObject);
			double num = TypeConverter.ToNumber(arguments.At(0));
			double num2 = TypeConverter.ToNumber(arguments.At(1));
			if (double.IsNaN(num) || num < 0.0)
			{
				num = 0.0;
			}
			if (double.IsNaN(num2) || num2 < 0.0)
			{
				num2 = 0.0;
			}
			int length = text.Length;
			int val = ToIntegerSupportInfinity(num);
			int val2 = (arguments.At(1).IsUndefined() ? length : ToIntegerSupportInfinity(num2));
			int val3 = System.Math.Min(length, System.Math.Max(val, 0));
			int val4 = System.Math.Min(length, System.Math.Max(val2, 0));
			int num3 = System.Math.Min(val3, val4);
			int num4 = System.Math.Max(val3, val4) - num3;
			return num4 switch
			{
				0 => JsString.Empty, 
				1 => JsString.Create(text[num3]), 
				_ => new JsString(text.Substring(num3, num4)), 
			};
		}

		private static JsValue Substr(JsValue thisObject, JsValue[] arguments)
		{
			string text = TypeConverter.ToString(thisObject);
			double num = TypeConverter.ToInteger(arguments.At(0));
			double val = (arguments.At(1).IsUndefined() ? double.PositiveInfinity : TypeConverter.ToInteger(arguments.At(1)));
			num = ((num >= 0.0) ? num : System.Math.Max((double)text.Length + num, 0.0));
			val = System.Math.Min(System.Math.Max(val, 0.0), (double)text.Length - num);
			if (val <= 0.0)
			{
				return JsString.Empty;
			}
			int num2 = TypeConverter.ToInt32(num);
			int num3 = TypeConverter.ToInt32(val);
			if (num3 == 1)
			{
				return TypeConverter.ToString(text[num2]);
			}
			return text.Substring(num2, num3);
		}

		private JsValue Split(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			if (jsValue is JsRegExp jsRegExp && string.Equals(jsRegExp.Source, "(?:)", StringComparison.Ordinal))
			{
				jsValue = JsString.Empty;
			}
			if (jsValue is ObjectInstance v)
			{
				ICallable method = ObjectInstance.GetMethod(_realm, v, GlobalSymbolRegistry.Split);
				if (method != null)
				{
					return method.Call(jsValue, thisObject, jsValue2);
				}
			}
			string text = TypeConverter.ToString(thisObject);
			uint num = (jsValue2.IsUndefined() ? uint.MaxValue : TypeConverter.ToUint32(jsValue2));
			if (jsValue.IsNull())
			{
				jsValue = "null";
			}
			else if (!jsValue.IsUndefined() && !jsValue.IsRegExp())
			{
				jsValue = TypeConverter.ToJsString(jsValue);
			}
			if (num == 0)
			{
				return _realm.Intrinsics.Array.ArrayCreate(0uL);
			}
			if (jsValue.IsUndefined())
			{
				JsArray jsArray = _realm.Intrinsics.Array.ArrayCreate(1uL);
				jsArray.SetIndexValue(0u, text, updateLength: false);
				return jsArray;
			}
			return SplitWithStringSeparator(_realm, jsValue, text, num);
		}

		internal static JsValue SplitWithStringSeparator(Realm realm, JsValue separator, string s, uint lim)
		{
			List<string> splitSegmentList = StringExecutionContext.Current.SplitSegmentList;
			splitSegmentList.Clear();
			string text = TypeConverter.ToString(separator);
			if (text == string.Empty)
			{
				if (s.Length > splitSegmentList.Capacity)
				{
					splitSegmentList.Capacity = s.Length;
				}
				for (int i = 0; i < s.Length; i++)
				{
					splitSegmentList.Add(TypeConverter.ToString(s[i]));
				}
			}
			else
			{
				string[] splitArray = StringExecutionContext.Current.SplitArray1;
				splitArray[0] = text;
				splitSegmentList.AddRange(s.Split(splitArray, StringSplitOptions.None));
			}
			uint num = (uint)System.Math.Min(splitSegmentList.Count, lim);
			JsArray jsArray = realm.Intrinsics.Array.ArrayCreate(num);
			for (int j = 0; j < num; j++)
			{
				jsArray.SetIndexValue((uint)j, splitSegmentList[j], updateLength: false);
			}
			jsArray.SetLength(num);
			return jsArray;
		}

		private JsValue At(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			JsValue o = arguments.At(0);
			string text = thisObject.ToString();
			long num = text.Length;
			double num2 = TypeConverter.ToInteger(o);
			int num3 = ((!(num2 < 0.0)) ? ((int)num2) : ((int)((double)num + num2)));
			if (num3 < 0 || num3 >= num)
			{
				return JsValue.Undefined;
			}
			return text[num3];
		}

		private JsValue Slice(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNegativeInfinity(num))
			{
				num = 0.0;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsString.Empty;
			}
			JsString jsString = TypeConverter.ToJsString(thisObject);
			double num2 = TypeConverter.ToNumber(arguments.At(1));
			if (double.IsPositiveInfinity(num2))
			{
				num2 = jsString.Length;
			}
			int length = jsString.Length;
			int num3 = (int)num;
			int num4 = (arguments.At(1).IsUndefined() ? length : ((int)TypeConverter.ToInteger(num2)));
			int num5 = ((num3 < 0) ? System.Math.Max(length + num3, 0) : System.Math.Min(num3, length));
			int num6 = System.Math.Max(((num4 < 0) ? System.Math.Max(length + num4, 0) : System.Math.Min(num4, length)) - num5, 0);
			return num6 switch
			{
				0 => JsString.Empty, 
				1 => JsString.Create(jsString[num5]), 
				_ => jsString.Substring(num5, num6), 
			};
		}

		private JsValue Search(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue is ObjectInstance v)
			{
				ICallable method = ObjectInstance.GetMethod(_realm, v, GlobalSymbolRegistry.Search);
				if (method != null)
				{
					return method.Call(jsValue, thisObject);
				}
			}
			JsRegExp v2 = (JsRegExp)_realm.Intrinsics.RegExp.Construct(new JsValue[1] { jsValue });
			JsString jsString = TypeConverter.ToJsString(thisObject);
			return _engine.Invoke(v2, GlobalSymbolRegistry.Search, new JsValue[1] { jsString });
		}

		private JsValue Replace(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			if (!jsValue.IsNullOrUndefined())
			{
				ICallable method = ObjectInstance.GetMethod(_realm, jsValue, GlobalSymbolRegistry.Replace);
				if (method != null)
				{
					return method.Call(jsValue, thisObject, jsValue2);
				}
			}
			JsString jsString = TypeConverter.ToJsString(thisObject);
			string text = TypeConverter.ToString(jsValue);
			bool flag = jsValue2 is ICallable;
			if (!flag)
			{
				jsValue2 = TypeConverter.ToJsString(jsValue2);
			}
			int num = jsString.IndexOf(text);
			if (num < 0)
			{
				return jsString;
			}
			string text2;
			if (flag)
			{
				text2 = TypeConverter.ToString(((ICallable)jsValue2).Call(JsValue.Undefined, text, num, jsString));
			}
			else
			{
				string[] captures = System.Array.Empty<string>();
				text2 = RegExpPrototype.GetSubstitution(text, jsString.ToString(), num, captures, JsValue.Undefined, TypeConverter.ToString(jsValue2));
			}
			int startIndex = num + text.Length;
			return jsString.Substring(0, num) + text2 + jsString.Substring(startIndex);
		}

		private JsValue ReplaceAll(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			if (!jsValue.IsNullOrUndefined())
			{
				if (jsValue.IsRegExp())
				{
					JsValue jsValue3 = jsValue.Get(RegExpPrototype.PropertyFlags);
					TypeConverter.CheckObjectCoercible(_engine, jsValue3);
					if (!TypeConverter.ToString(jsValue3).Contains('g'))
					{
						ExceptionHelper.ThrowTypeError(_realm, "String.prototype.replaceAll called with a non-global RegExp argument");
					}
				}
				ICallable method = ObjectInstance.GetMethod(_realm, jsValue, GlobalSymbolRegistry.Replace);
				if (method != null)
				{
					return method.Call(jsValue, thisObject, jsValue2);
				}
			}
			string text = TypeConverter.ToString(thisObject);
			string text2 = TypeConverter.ToString(jsValue);
			bool flag = jsValue2 is ICallable;
			if (!flag)
			{
				jsValue2 = TypeConverter.ToJsString(jsValue2);
				string text3 = jsValue2.ToString();
				if (!text3.Contains('$') && text2.Length > 0)
				{
					return text.Replace(text2, text3);
				}
			}
			int length = text2.Length;
			int num = System.Math.Max(1, length);
			int num2 = 0;
			System.Text.ValueStringBuilder valueStringBuilder = default(System.Text.ValueStringBuilder);
			try
			{
				for (int num3 = StringIndexOf(text, text2, 0); num3 != -1; num3 = StringIndexOf(text, text2, num3 + num))
				{
					string s = text.Substring(num2, num3 - num2);
					string s2;
					if (flag)
					{
						s2 = TypeConverter.ToString(((ICallable)jsValue2).Call(JsValue.Undefined, text2, num3, text));
					}
					else
					{
						string[] captures = System.Array.Empty<string>();
						s2 = RegExpPrototype.GetSubstitution(text2, text, num3, captures, JsValue.Undefined, TypeConverter.ToString(jsValue2));
					}
					valueStringBuilder.Append(s);
					valueStringBuilder.Append(s2);
					num2 = num3 + length;
				}
				if (num2 < text.Length)
				{
					string text4 = text;
					int num4 = num2;
					valueStringBuilder.Append(text4.Substring(num4, text4.Length - num4));
				}
				return valueStringBuilder.ToString();
			}
			finally
			{
				valueStringBuilder.Dispose();
			}
			static int StringIndexOf(string text5, string search, int fromIndex)
			{
				if (search.Length == 0 && fromIndex <= text5.Length)
				{
					return fromIndex;
				}
				if (fromIndex >= text5.Length)
				{
					return -1;
				}
				return text5.IndexOf(search, fromIndex, StringComparison.Ordinal);
			}
		}

		private JsValue Match(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue is ObjectInstance v)
			{
				ICallable method = ObjectInstance.GetMethod(_realm, v, GlobalSymbolRegistry.Match);
				if (method != null)
				{
					return method.Call(jsValue, thisObject);
				}
			}
			JsRegExp v2 = (JsRegExp)_realm.Intrinsics.RegExp.Construct(new JsValue[1] { jsValue });
			JsString jsString = TypeConverter.ToJsString(thisObject);
			return _engine.Invoke(v2, GlobalSymbolRegistry.Match, new JsValue[1] { jsString });
		}

		private JsValue MatchAll(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsNullOrUndefined())
			{
				if (jsValue.IsRegExp())
				{
					JsValue jsValue2 = jsValue.Get(RegExpPrototype.PropertyFlags);
					TypeConverter.CheckObjectCoercible(_engine, jsValue2);
					if (!TypeConverter.ToString(jsValue2).Contains('g'))
					{
						ExceptionHelper.ThrowTypeError(_realm);
					}
				}
				ICallable method = ObjectInstance.GetMethod(_realm, (ObjectInstance)jsValue, GlobalSymbolRegistry.MatchAll);
				if (method != null)
				{
					return method.Call(jsValue, thisObject);
				}
			}
			JsString jsString = TypeConverter.ToJsString(thisObject);
			JsRegExp v = (JsRegExp)_realm.Intrinsics.RegExp.Construct(new JsValue[2] { jsValue, "g" });
			return _engine.Invoke(v, GlobalSymbolRegistry.MatchAll, new JsValue[1] { jsString });
		}

		private JsValue LocaleCompare(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			string text = TypeConverter.ToString(thisObject);
			return string.CompareOrdinal(strB: TypeConverter.ToString(arguments.At(0)).Normalize(NormalizationForm.FormKD), strA: text.Normalize(NormalizationForm.FormKD));
		}

		private JsValue LastIndexOf(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			string text = TypeConverter.ToString(arguments.At(0));
			double num = double.NaN;
			if (arguments.Length > 1 && !arguments[1].IsUndefined())
			{
				num = TypeConverter.ToNumber(arguments[1]);
			}
			double val = (double.IsNaN(num) ? double.PositiveInfinity : TypeConverter.ToInteger(num));
			int length = jsString.Length;
			int num2 = (int)System.Math.Min(System.Math.Max(val, 0.0), length);
			int length2 = text.Length;
			if (length2 > length)
			{
				return JsNumber.IntegerNegativeOne;
			}
			string text2 = jsString.ToString();
			int num3 = num2;
			bool flag;
			do
			{
				flag = true;
				int num4 = 0;
				while (flag && num4 < length2)
				{
					if (num3 + length2 > length || text2[num3 + num4] != text[num4])
					{
						flag = false;
					}
					else
					{
						num4++;
					}
				}
				if (!flag)
				{
					num3--;
				}
			}
			while (!flag && num3 >= 0);
			return num3;
		}

		private JsValue IndexOf(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			string value = TypeConverter.ToString(arguments.At(0));
			double num = 0.0;
			if (arguments.Length > 1 && !arguments[1].IsUndefined())
			{
				num = TypeConverter.ToInteger(arguments[1]);
			}
			if (num > (double)jsString.Length)
			{
				num = jsString.Length;
			}
			if (num < 0.0)
			{
				num = 0.0;
			}
			return jsString.IndexOf(value, (int)num);
		}

		private JsValue Concat(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = ((thisObject is JsString jsString2) ? jsString2.EnsureCapacity(0) : new JsString.ConcatenatedString(TypeConverter.ToString(thisObject)));
			foreach (JsValue jsValue in arguments)
			{
				jsString = jsString.Append(jsValue);
			}
			return jsString;
		}

		private JsValue CharCodeAt(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsValue o = ((arguments.Length != 0) ? arguments[0] : ((JsValue)0));
			JsString jsString = TypeConverter.ToJsString(thisObject);
			int num = (int)TypeConverter.ToInteger(o);
			if (num < 0 || num >= jsString.Length)
			{
				return JsNumber.DoubleNaN;
			}
			return (long)jsString[num];
		}

		private JsValue CodePointAt(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsValue o = ((arguments.Length != 0) ? arguments[0] : ((JsValue)0));
			string text = TypeConverter.ToString(thisObject);
			int num = (int)TypeConverter.ToInteger(o);
			if (num < 0 || num >= text.Length)
			{
				return JsValue.Undefined;
			}
			return CodePointAt(text, num).CodePoint;
		}

		private static CodePointResult CodePointAt(string s, int position)
		{
			int length = s.Length;
			char c = s.CharCodeAt(position);
			char codePoint = s.CharCodeAt(position);
			bool flag = char.IsHighSurrogate(c);
			bool flag2 = char.IsLowSurrogate(c);
			if (!flag && !flag2)
			{
				return new CodePointResult(codePoint, 1, IsUnpairedSurrogate: false);
			}
			if (flag2 || position + 1 == length)
			{
				return new CodePointResult(codePoint, 1, IsUnpairedSurrogate: true);
			}
			char c2 = s.CharCodeAt(position + 1);
			if (!char.IsLowSurrogate(c2))
			{
				return new CodePointResult(codePoint, 1, IsUnpairedSurrogate: true);
			}
			return new CodePointResult(char.ConvertToUtf32(c, c2), 2, IsUnpairedSurrogate: false);
		}

		private JsValue CharAt(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			double num = TypeConverter.ToInteger(arguments.At(0));
			int length = jsString.Length;
			if (num >= (double)length || num < 0.0)
			{
				return JsString.Empty;
			}
			return JsString.Create(jsString[(int)num]);
		}

		private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is StringInstance stringInstance)
			{
				return stringInstance.StringData;
			}
			if (thisObject is JsString)
			{
				return thisObject;
			}
			ExceptionHelper.ThrowTypeError(_realm);
			return JsValue.Undefined;
		}

		private JsValue PadStart(JsValue thisObject, JsValue[] arguments)
		{
			return StringPad(thisObject, arguments, padStart: true);
		}

		private JsValue PadEnd(JsValue thisObject, JsValue[] arguments)
		{
			return StringPad(thisObject, arguments, padStart: false);
		}

		private JsValue StringPad(JsValue thisObject, JsValue[] arguments, bool padStart)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			int num = TypeConverter.ToInt32(arguments.At(0));
			JsValue jsValue = arguments.At(1);
			string text = (jsValue.IsUndefined() ? " " : TypeConverter.ToString(jsValue));
			if (jsString.Length > num || text.Length == 0)
			{
				return jsString;
			}
			num -= jsString.Length;
			if (num > text.Length)
			{
				text = string.Join("", Enumerable.Repeat(text, num / text.Length + 1));
			}
			return padStart ? $"{text.Substring(0, num)}{jsString}" : $"{jsString}{text.Substring(0, num)}";
		}

		private JsValue StartsWith(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			JsValue jsValue = arguments.At(0);
			if ((object)jsValue == JsValue.Null)
			{
				jsValue = "null";
			}
			else if (jsValue.IsRegExp())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			string value = TypeConverter.ToString(jsValue);
			int val = TypeConverter.ToInt32(arguments.At(1));
			int start = System.Math.Min(val2: jsString.Length, val1: System.Math.Max(val, 0));
			return jsString.StartsWith(value, start);
		}

		private JsValue EndsWith(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			JsValue jsValue = arguments.At(0);
			if ((object)jsValue == JsValue.Null)
			{
				jsValue = "null";
			}
			else if (jsValue.IsRegExp())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			string value = TypeConverter.ToString(jsValue);
			int length = jsString.Length;
			int end = System.Math.Min(System.Math.Max(TypeConverter.ToInt32(arguments.At(1, length)), 0), length);
			return jsString.EndsWith(value, end);
		}

		private JsValue Includes(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			JsString jsString = TypeConverter.ToJsString(thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue.IsRegExp())
			{
				ExceptionHelper.ThrowTypeError(_realm, "First argument to String.prototype.includes must not be a regular expression");
			}
			string text = TypeConverter.ToString(jsValue);
			double num = 0.0;
			if (arguments.Length > 1 && !arguments[1].IsUndefined())
			{
				num = TypeConverter.ToInteger(arguments[1]);
			}
			if (text.Length == 0)
			{
				return JsBoolean.True;
			}
			if (num < 0.0)
			{
				num = 0.0;
			}
			return jsString.IndexOf(text, (int)num) > -1;
		}

		private JsValue Normalize(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			string text = TypeConverter.ToString(thisObject);
			JsValue jsValue = arguments.At(0);
			string text2 = "NFC";
			if (!jsValue.IsUndefined())
			{
				text2 = TypeConverter.ToString(jsValue);
			}
			NormalizationForm normalizationForm = NormalizationForm.FormC;
			switch (text2)
			{
			case "NFC":
				normalizationForm = NormalizationForm.FormC;
				break;
			case "NFD":
				normalizationForm = NormalizationForm.FormD;
				break;
			case "NFKC":
				normalizationForm = NormalizationForm.FormKC;
				break;
			case "NFKD":
				normalizationForm = NormalizationForm.FormKD;
				break;
			default:
				ExceptionHelper.ThrowRangeError(_realm, "The normalization form should be one of NFC, NFD, NFKC, NFKD.");
				break;
			}
			return text.Normalize(normalizationForm);
		}

		private JsValue Repeat(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(base.Engine, thisObject);
			string text = TypeConverter.ToString(thisObject);
			double num = TypeConverter.ToIntegerOrInfinity(arguments.At(0));
			if (num < 0.0 || double.IsPositiveInfinity(num))
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid count value");
			}
			if (num == 0.0 || text.Length == 0)
			{
				return JsString.Empty;
			}
			if (text.Length == 1)
			{
				return new string(text[0], (int)num);
			}
			System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder((int)(num * (double)text.Length));
			for (int i = 0; (double)i < num; i++)
			{
				valueStringBuilder.Append(text);
			}
			return valueStringBuilder.ToString();
		}

		private JsValue IsWellFormed(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			return IsStringWellFormedUnicode(TypeConverter.ToString(thisObject));
		}

		private JsValue ToWellFormed(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.CheckObjectCoercible(_engine, thisObject);
			string text = TypeConverter.ToString(thisObject);
			int length = text.Length;
			int i = 0;
			System.Text.ValueStringBuilder valueStringBuilder = default(System.Text.ValueStringBuilder);
			CodePointResult codePointResult;
			for (; i < length; i += codePointResult.CodeUnitCount)
			{
				codePointResult = CodePointAt(text, i);
				if (codePointResult.IsUnpairedSurrogate)
				{
					valueStringBuilder.Append('\ufffd');
				}
				else
				{
					valueStringBuilder.Append(text.AsSpan(i, codePointResult.CodeUnitCount));
				}
			}
			return valueStringBuilder.ToString();
		}

		private static bool IsStringWellFormedUnicode(string s)
		{
			for (int i = 0; i < s.Length; i++)
			{
				if ((s.CharCodeAt(i) & 0xF800) == 55296)
				{
					if (s.CharCodeAt(i) >= '\udc00')
					{
						return false;
					}
					if (i + 1 >= s.Length || (s.CharCodeAt(i + 1) & 0xFC00) != 56320)
					{
						return false;
					}
					i++;
				}
			}
			return true;
		}
	}
}
namespace Jint.Native.SharedArrayBuffer
{
	internal sealed class SharedArrayBufferConstructor : Constructor
	{
		private readonly record struct ConstructState(byte[]? Block, uint ByteLength, uint? MaxByteLength, uint ArrayBufferByteLengthData);

		private static readonly JsString _functionName = new JsString("SharedArrayBuffer");

		private SharedArrayBufferPrototype PrototypeObject { get; }

		internal SharedArrayBufferConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new SharedArrayBufferPrototype(engine, this, objectPrototype);
			_length = new PropertyDescriptor(1, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { ["isView"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "isView", IsView, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get [Symbol.species]", Species, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private static JsValue IsView(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			bool flag = ((jsValue is JsDataView || jsValue is JsTypedArray) ? true : false);
			return flag;
		}

		private static JsValue Species(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			ExceptionHelper.ThrowTypeError(_realm, "Constructor SharedArrayBuffer requires 'new'");
			return JsValue.Undefined;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue value = arguments.At(0);
			JsValue options = arguments.At(1);
			uint byteLength = TypeConverter.ToIndex(_realm, value);
			uint? arrayBufferMaxByteLengthOption = options.GetArrayBufferMaxByteLengthOption();
			return AllocateSharedArrayBuffer(newTarget, byteLength, arrayBufferMaxByteLengthOption);
		}

		private JsSharedArrayBuffer AllocateSharedArrayBuffer(JsValue constructor, uint byteLength, uint? maxByteLength = null)
		{
			if (maxByteLength.HasValue && byteLength > maxByteLength)
			{
				ExceptionHelper.ThrowRangeError(_realm);
			}
			uint byteLength2 = maxByteLength ?? byteLength;
			return OrdinaryCreateFromConstructor(constructor, (Intrinsics intrinsics) => intrinsics.SharedArrayBuffer.PrototypeObject, (Engine engine, Realm _, ConstructState state) => new JsSharedArrayBuffer(engine, System.Array.Empty<byte>(), state.MaxByteLength, state.ArrayBufferByteLengthData)
			{
				_arrayBufferData = (state.Block ?? ((state.ByteLength != 0) ? JsSharedArrayBuffer.CreateSharedByteDataBlock(engine.Realm, state.ByteLength) : System.Array.Empty<byte>()))
			}, new ConstructState(null, byteLength2, maxByteLength, byteLength));
		}
	}
	internal sealed class SharedArrayBufferPrototype : Prototype
	{
		private readonly SharedArrayBufferConstructor _constructor;

		internal SharedArrayBufferPrototype(Engine engine, SharedArrayBufferConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, engine.Realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(3, checkExistingKeys: false)
			{
				["byteLength"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get byteLength", ByteLength, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				[KnownKeys.Constructor] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["growable"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get growable", Growable, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["grow"] = new PropertyDescriptor(new ClrFunction(_engine, "grow", Grow, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["maxByteLength"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get maxByteLength", MaxByteLength, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["slice"] = new PropertyDescriptor(new ClrFunction(base.Engine, "slice", Slice, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("SharedArrayBuffer", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsNumber ByteLength(JsValue thisObj, JsValue[] arguments)
		{
			JsSharedArrayBuffer jsSharedArrayBuffer = thisObj as JsSharedArrayBuffer;
			if ((object)jsSharedArrayBuffer == null || !jsSharedArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method prototype.byteLength called on incompatible receiver " + thisObj);
			}
			return JsNumber.Create(jsSharedArrayBuffer.ArrayBufferByteLength);
		}

		private JsSharedArrayBuffer Slice(JsValue thisObj, JsValue[] arguments)
		{
			JsSharedArrayBuffer jsSharedArrayBuffer = thisObj as JsSharedArrayBuffer;
			if ((object)jsSharedArrayBuffer == null || !jsSharedArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method prototype.slice called on incompatible receiver " + thisObj);
			}
			jsSharedArrayBuffer.AssertNotDetached();
			JsValue argument = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			int arrayBufferByteLength = jsSharedArrayBuffer.ArrayBufferByteLength;
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			int num2 = ((num != double.NegativeInfinity) ? ((!(num < 0.0)) ? ((int)System.Math.Min(num, arrayBufferByteLength)) : ((int)System.Math.Max((double)arrayBufferByteLength + num, 0.0))) : 0);
			int num3 = num2;
			double num4 = ((!jsValue.IsUndefined()) ? TypeConverter.ToIntegerOrInfinity(jsValue) : ((double)arrayBufferByteLength));
			num2 = ((num4 != double.NegativeInfinity) ? ((!(num4 < 0.0)) ? ((int)System.Math.Min(num4, arrayBufferByteLength)) : ((int)System.Math.Max((double)arrayBufferByteLength + num4, 0.0))) : 0);
			int num5 = System.Math.Max(num2 - num3, 0);
			JsSharedArrayBuffer jsSharedArrayBuffer2 = ObjectInstance.Construct(ObjectInstance.SpeciesConstructor(jsSharedArrayBuffer, _realm.Intrinsics.SharedArrayBuffer), new JsValue[1] { JsNumber.Create(num5) }) as JsSharedArrayBuffer;
			if ((object)jsSharedArrayBuffer2 == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (!jsSharedArrayBuffer2.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (jsSharedArrayBuffer2.IsDetachedBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if ((object)jsSharedArrayBuffer2 == jsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (jsSharedArrayBuffer2.ArrayBufferByteLength < num5)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (jsSharedArrayBuffer2.IsDetachedBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			byte[]? arrayBufferData = jsSharedArrayBuffer.ArrayBufferData;
			byte[] arrayBufferData2 = jsSharedArrayBuffer2.ArrayBufferData;
			System.Array.Copy(arrayBufferData, num3, arrayBufferData2, 0, num5);
			return jsSharedArrayBuffer2;
		}

		private JsValue Growable(JsValue thisObject, JsValue[] arguments)
		{
			JsSharedArrayBuffer jsSharedArrayBuffer = thisObject as JsSharedArrayBuffer;
			if ((object)jsSharedArrayBuffer == null || !jsSharedArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method SharedArrayBuffer.prototype.growable called on incompatible receiver " + thisObject);
			}
			return !jsSharedArrayBuffer.IsFixedLengthArrayBuffer;
		}

		private JsValue Grow(JsValue thisObject, JsValue[] arguments)
		{
			JsSharedArrayBuffer jsSharedArrayBuffer = thisObject as JsSharedArrayBuffer;
			if ((object)jsSharedArrayBuffer == null || !jsSharedArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method SharedArrayBuffer.prototype.grow called on incompatible receiver " + thisObject);
			}
			JsValue value = arguments.At(0);
			uint newByteLength = TypeConverter.ToIndex(_realm, value);
			jsSharedArrayBuffer.AssertNotDetached();
			jsSharedArrayBuffer.Resize(newByteLength);
			return JsValue.Undefined;
		}

		private JsValue MaxByteLength(JsValue thisObject, JsValue[] arguments)
		{
			JsSharedArrayBuffer jsSharedArrayBuffer = thisObject as JsSharedArrayBuffer;
			if ((object)jsSharedArrayBuffer == null || !jsSharedArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method SharedArrayBuffer.prototype.maxByteLength called on incompatible receiver " + thisObject);
			}
			if (jsSharedArrayBuffer.IsDetachedBuffer)
			{
				return JsNumber.PositiveZero;
			}
			return (long)(jsSharedArrayBuffer.IsFixedLengthArrayBuffer ? jsSharedArrayBuffer.ArrayBufferByteLength : jsSharedArrayBuffer._arrayBufferMaxByteLength.GetValueOrDefault());
		}
	}
}
namespace Jint.Native.ShadowRealm
{
	public sealed class ShadowRealm : ObjectInstance
	{
		private sealed class StepsFunction : Jint.Native.Function.Function
		{
			private readonly string _exportNameString;

			public StepsFunction(Engine engine, Realm realm, string exportNameString)
				: base(engine, realm, JsString.Empty)
			{
				_exportNameString = exportNameString;
				SetFunctionLength(JsNumber.PositiveOne);
			}

			protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
			{
				ModuleNamespace obj = (ModuleNamespace)arguments.At(0);
				string exportNameString = _exportNameString;
				if (!obj.HasOwnProperty(exportNameString))
				{
					ExceptionHelper.ThrowTypeError(_realm, "export name " + exportNameString + " missing");
				}
				JsValue value = obj.Get(exportNameString);
				Realm realm = _realm;
				return GetWrappedValue(_engine.Realm, realm, value);
			}
		}

		private sealed class WrappedFunction : Jint.Native.Function.Function
		{
			private readonly ObjectInstance _wrappedTargetFunction;

			public WrappedFunction(Engine engine, Realm callerRealm, ObjectInstance wrappedTargetFunction)
				: base(engine, callerRealm, null)
			{
				_wrappedTargetFunction = wrappedTargetFunction;
				_prototype = callerRealm.Intrinsics.Function.PrototypeObject;
			}

			protected internal override JsValue Call(JsValue thisArgument, JsValue[] arguments)
			{
				ObjectInstance wrappedTargetFunction = _wrappedTargetFunction;
				Realm functionRealm = GetFunctionRealm(wrappedTargetFunction);
				Realm functionRealm2 = GetFunctionRealm(this);
				JsValue[] array = new JsValue[arguments.Length];
				for (int i = 0; i < arguments.Length; i++)
				{
					array[i] = GetWrappedValue(functionRealm2, functionRealm, arguments[i]);
				}
				JsValue wrappedValue = GetWrappedValue(functionRealm2, functionRealm, thisArgument);
				JsValue value;
				try
				{
					value = wrappedTargetFunction.Call(wrappedValue, array);
				}
				catch (JavaScriptException ex)
				{
					ThrowCrossRealmError(_realm, ex.Message);
					return null;
				}
				return GetWrappedValue(functionRealm2, functionRealm2, value);
			}
		}

		private sealed class ShadowScriptValidator : AstVisitor
		{
			private readonly Realm _realm;

			public ShadowScriptValidator(Realm realm)
			{
				_realm = realm;
			}

			protected override object? VisitSuper(Super super)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Shadow realm code cannot contain super");
				return null;
			}
		}

		internal readonly Realm _shadowRealm;

		private readonly Jint.Runtime.Environments.ExecutionContext _executionContext;

		internal ShadowRealm(Engine engine, in Jint.Runtime.Environments.ExecutionContext executionContext, Realm shadowRealm)
			: base(engine)
		{
			_executionContext = executionContext;
			_shadowRealm = shadowRealm;
		}

		public JsValue Evaluate(string sourceText, ScriptParsingOptions? parsingOptions = null)
		{
			Realm realm = _engine.Realm;
			ParserOptions parserOptions = parsingOptions?.GetParserOptions() ?? _engine.GetActiveParserOptions();
			JavaScriptParser parserFor = _engine.GetParserFor(parserOptions);
			return PerformShadowRealmEval(sourceText, parserOptions, parserFor, realm);
		}

		public JsValue Evaluate(in Prepared<Script> preparedScript)
		{
			if (!preparedScript.IsValid)
			{
				ExceptionHelper.ThrowInvalidPreparedScriptArgumentException("preparedScript");
			}
			Realm realm = _engine.Realm;
			return PerformShadowRealmEval(in preparedScript, realm);
		}

		public JsValue ImportValue(string specifier, string exportName)
		{
			Realm realm = _engine.Realm;
			JsValue result = ShadowRealmImportValue(specifier, exportName, realm);
			_engine.RunAvailableContinuations();
			return result;
		}

		[RequiresUnreferencedCode("User supplied delegate")]
		public ShadowRealm SetValue(string name, Delegate value)
		{
			_shadowRealm.GlobalObject.FastSetProperty(name, new PropertyDescriptor(new DelegateWrapper(_engine, value), PropertyFlag.NonEnumerable));
			return this;
		}

		public ShadowRealm SetValue(string name, string value)
		{
			return SetValue(name, JsString.Create(value));
		}

		public ShadowRealm SetValue(string name, double value)
		{
			return SetValue(name, JsNumber.Create(value));
		}

		public ShadowRealm SetValue(string name, int value)
		{
			return SetValue(name, JsNumber.Create(value));
		}

		public ShadowRealm SetValue(string name, bool value)
		{
			return SetValue(name, value ? JsBoolean.True : JsBoolean.False);
		}

		public ShadowRealm SetValue(string name, JsValue value)
		{
			_shadowRealm.GlobalObject.Set(name, value);
			return this;
		}

		public ShadowRealm SetValue(string name, object obj)
		{
			JsValue value = ((obj is Type type) ? TypeReference.CreateTypeReference(_engine, type) : JsValue.FromObject(_engine, obj));
			return SetValue(name, value);
		}

		internal JsValue PerformShadowRealmEval(string sourceText, ParserOptions parserOptions, JavaScriptParser parser, Realm callerRealm)
		{
			//IL_0031: Expected O, but got Unknown
			Realm shadowRealm = _shadowRealm;
			_engine._host.EnsureCanCompileStrings(callerRealm, shadowRealm);
			Script program;
			try
			{
				program = parser.ParseScript(sourceText, (string)null, _engine._isStrict);
			}
			catch (ParserException ex)
			{
				ParserException ex2 = ex;
				if (string.Equals(ex2.Description, "Invalid left-hand side in assignment", StringComparison.Ordinal))
				{
					ExceptionHelper.ThrowReferenceError(callerRealm, "Invalid left-hand side in assignment");
				}
				else
				{
					ExceptionHelper.ThrowSyntaxError(callerRealm, ((Exception)(object)ex2).Message);
				}
				return null;
			}
			return PerformShadowRealmEvalInternal(new Prepared<Script>(program, parserOptions), callerRealm);
		}

		internal JsValue PerformShadowRealmEval(in Prepared<Script> preparedScript, Realm callerRealm)
		{
			Realm shadowRealm = _shadowRealm;
			_engine._host.EnsureCanCompileStrings(callerRealm, shadowRealm);
			return PerformShadowRealmEvalInternal(in preparedScript, callerRealm);
		}

		internal JsValue PerformShadowRealmEvalInternal(in Prepared<Script> preparedScript, Realm callerRealm)
		{
			Realm shadowRealm = _shadowRealm;
			Script program = preparedScript.Program;
			if (((NodeList<Statement>)((Program)program).Body).Count == 0)
			{
				return JsValue.Undefined;
			}
			((AstVisitor)new ShadowScriptValidator(callerRealm)).Visit((Node)(object)program);
			bool strict = ((Program)program).Strict;
			_ = ref _engine.ExecutionContext;
			DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(_engine, shadowRealm.GlobalEnv);
			Jint.Runtime.Environments.Environment environment = shadowRealm.GlobalEnv;
			if (strict)
			{
				environment = declarativeEnvironment;
			}
			Jint.Runtime.Environments.ExecutionContext context = new Jint.Runtime.Environments.ExecutionContext(null, declarativeEnvironment, environment, null, shadowRealm, null, null, preparedScript.ParserOptions);
			_engine.EnterExecutionContext(in context);
			Completion completion;
			try
			{
				_engine.EvalDeclarationInstantiation(program, environment, declarativeEnvironment, null, strict);
				using (new StrictModeScope(strict, force: true))
				{
					EvaluationContext activeEvaluationContext = _engine._activeEvaluationContext;
					_engine._activeEvaluationContext = new EvaluationContext(_engine);
					try
					{
						completion = new JintScript(program).Execute(_engine._activeEvaluationContext);
					}
					finally
					{
						_engine._activeEvaluationContext = activeEvaluationContext;
					}
				}
				if (completion.Type == CompletionType.Throw)
				{
					ThrowCrossRealmError(callerRealm, completion.GetValueOrDefault().ToString());
				}
			}
			finally
			{
				_engine.LeaveExecutionContext();
			}
			return GetWrappedValue(callerRealm, callerRealm, completion.Value);
		}

		private static JsValue GetWrappedValue(Realm throwerRealm, Realm callerRealm, JsValue value)
		{
			if (value is ObjectInstance objectInstance)
			{
				if (!objectInstance.IsCallable)
				{
					ThrowCrossRealmError(throwerRealm, "Result is not callable");
				}
				return WrappedFunctionCreate(throwerRealm, callerRealm, objectInstance);
			}
			return value;
		}

		private static WrappedFunction WrappedFunctionCreate(Realm throwerRealm, Realm callerRealm, ObjectInstance target)
		{
			WrappedFunction wrappedFunction = new WrappedFunction(callerRealm.GlobalEnv._engine, callerRealm, target);
			try
			{
				CopyNameAndLength(wrappedFunction, target);
			}
			catch (JavaScriptException ex)
			{
				ThrowCrossRealmError(throwerRealm, ex.Message);
			}
			return wrappedFunction;
		}

		private static void CopyNameAndLength(WrappedFunction f, ObjectInstance target, string? prefix = null, int argCount = 0)
		{
			JsNumber functionLength = JsNumber.PositiveZero;
			if (target.HasOwnProperty("length"))
			{
				JsValue jsValue = target.Get("length");
				if (jsValue is JsNumber jsNumber)
				{
					functionLength = (jsNumber.IsPositiveInfinity() ? jsNumber : ((!jsNumber.IsNegativeInfinity()) ? JsNumber.Create(System.Math.Max(TypeConverter.ToIntegerOrInfinity(jsValue) - (double)argCount, 0.0)) : JsNumber.PositiveZero));
				}
			}
			f.SetFunctionLength(functionLength);
			JsValue jsValue2 = target.Get(CommonProperties.Name);
			if (!jsValue2.IsString())
			{
				jsValue2 = JsString.Empty;
			}
			f.SetFunctionName(jsValue2, prefix);
		}

		internal JsValue ShadowRealmImportValue(string specifierString, string exportNameString, Realm callerRealm)
		{
			PromiseCapability promiseCapability = PromiseConstructor.NewPromiseCapability(_engine, _engine.Realm.Intrinsics.Promise);
			_engine.EnterExecutionContext(in _executionContext);
			_engine._host.LoadImportedModule(null, new ModuleRequest(specifierString, System.Array.Empty<ModuleImportAttribute>()), promiseCapability);
			_engine.LeaveExecutionContext();
			StepsFunction onFulfilled = new StepsFunction(_engine, callerRealm, exportNameString);
			PromiseCapability resultCapability = PromiseConstructor.NewPromiseCapability(_engine, _engine.Realm.Intrinsics.Promise);
			return PromiseOperations.PerformPromiseThen(_engine, (JsPromise)promiseCapability.PromiseInstance, onFulfilled, callerRealm.Intrinsics.ThrowTypeError, resultCapability);
		}

		private static ShadowRealm ValidateShadowRealmObject(Realm callerRealm, JsValue thisObj)
		{
			ShadowRealm obj = thisObj as ShadowRealm;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(callerRealm, "object must be a ShadowRealm");
			}
			return obj;
		}

		private static void ThrowCrossRealmError(Realm callerRealm, string message)
		{
			ExceptionHelper.ThrowTypeError(callerRealm, "Cross-Realm Error: " + message);
		}
	}
	public sealed class ShadowRealmConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("ShadowRealm");

		private ShadowRealmPrototype PrototypeObject { get; }

		internal ShadowRealmConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new ShadowRealmPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(0, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public ShadowRealm Construct()
		{
			return Construct(PrototypeObject);
		}

		private ShadowRealm Construct(JsValue newTarget)
		{
			Realm state = _engine._host.CreateRealm();
			ShadowRealm shadowRealm = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.ShadowRealm.PrototypeObject, (Engine engine, Realm _, Realm? realmRec) => new ShadowRealm(engine, new Jint.Runtime.Environments.ExecutionContext(null, realmRec.GlobalEnv, realmRec.GlobalEnv, null, realmRec), realmRec), state);
			_engine._host.InitializeShadowRealm(shadowRealm._shadowRealm);
			return shadowRealm;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return Construct(newTarget);
		}
	}
	internal sealed class ShadowRealmPrototype : Prototype
	{
		private readonly ShadowRealmConstructor _constructor;

		internal ShadowRealmPrototype(Engine engine, Realm realm, ShadowRealmConstructor constructor, ObjectPrototype prototype)
			: base(engine, realm)
		{
			_prototype = prototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(5, checkExistingKeys: false)
			{
				["length"] = new PropertyDescriptor(0, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["evaluate"] = new PropertyDescriptor(new ClrFunction(base.Engine, "evaluate", Evaluate, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["importValue"] = new PropertyDescriptor(new ClrFunction(base.Engine, "importValue", ImportValue, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("ShadowRealm", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Evaluate(JsValue thisObject, JsValue[] arguments)
		{
			ShadowRealm shadowRealm = ValidateShadowRealmObject(thisObject);
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsString())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Invalid source text " + jsValue);
			}
			ParserOptions activeParserOptions = _engine.GetActiveParserOptions();
			ParserOptions obj;
			if (!activeParserOptions.AllowReturnOutsideFunction)
			{
				obj = activeParserOptions;
			}
			else
			{
				obj = activeParserOptions.<Clone>$();
				obj.AllowReturnOutsideFunction = false;
			}
			ParserOptions parserOptions = obj;
			return shadowRealm.PerformShadowRealmEval(parser: _engine.GetParserFor(parserOptions), sourceText: jsValue.AsString(), parserOptions: activeParserOptions, callerRealm: _realm);
		}

		private JsValue ImportValue(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			ShadowRealm shadowRealm = ValidateShadowRealmObject(thisObject);
			JsString jsString = TypeConverter.ToJsString(jsValue);
			if (!jsValue.IsString())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Invalid specifier");
			}
			if (!jsValue2.IsString())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Invalid exportName");
			}
			Realm realm = _realm;
			return shadowRealm.ShadowRealmImportValue(jsString.ToString(), jsValue2.ToString(), realm);
		}

		private ShadowRealm ValidateShadowRealmObject(JsValue thisObject)
		{
			if (thisObject is ShadowRealm result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(_realm, "object must be a ShadowRealm");
			return null;
		}
	}
}
namespace Jint.Native.Set
{
	internal sealed class SetConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Set");

		internal SetPrototype PrototypeObject { get; }

		internal SetConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new SetPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(0, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get [Symbol.species]", Species, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private static JsValue Species(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			JsSet jsSet = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Set.PrototypeObject, (Engine engine, Realm _, object? _) => new JsSet(engine));
			if (arguments.Length != 0 && !arguments[0].IsNullOrUndefined())
			{
				ICallable callable = jsSet.Get("add") as ICallable;
				if (callable == null)
				{
					ExceptionHelper.ThrowTypeError(_engine.Realm, "add must be callable");
				}
				IteratorInstance iterator = arguments.At(0).GetIterator(_realm);
				try
				{
					JsValue[] array = new JsValue[1];
					ObjectInstance nextItem;
					while (iterator.TryIteratorStep(out nextItem))
					{
						JsValue jsValue = nextItem.Get(CommonProperties.Value);
						array[0] = jsValue;
						callable.Call(jsSet, array);
					}
					return jsSet;
				}
				catch
				{
					iterator.Close(CompletionType.Throw);
					throw;
				}
			}
			return jsSet;
		}
	}
	internal sealed class SetIteratorPrototype : IteratorPrototype
	{
		private sealed class SetEntryIterator : IteratorInstance
		{
			private readonly JsSet _set;

			private int _position;

			public SetEntryIterator(Engine engine, JsSet set)
				: base(engine)
			{
				_prototype = engine.Realm.Intrinsics.SetIteratorPrototype;
				_set = set;
				_position = 0;
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (_position < _set._set._list.Count)
				{
					JsValue jsValue = _set._set[_position];
					_position++;
					nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine, jsValue, jsValue);
					return true;
				}
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		private sealed class SetValueIterator : IteratorInstance
		{
			private readonly List<JsValue> _values;

			private int _position;

			private bool _closed;

			public SetValueIterator(Engine engine, List<JsValue> values)
				: base(engine)
			{
				_prototype = engine.Realm.Intrinsics.SetIteratorPrototype;
				_values = values;
				_position = 0;
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (!_closed && _position < _values.Count)
				{
					JsValue value = _values[_position];
					_position++;
					nextItem = IteratorResult.CreateValueIteratorPosition(_engine, value);
					return true;
				}
				_closed = true;
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		internal SetIteratorPrototype(Engine engine, Realm realm, IteratorPrototype iteratorPrototype)
			: base(engine, realm, iteratorPrototype)
		{
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { [KnownKeys.Next] = new PropertyDescriptor(new ClrFunction(base.Engine, "next", base.Next, 0, PropertyFlag.Configurable), true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Set Iterator", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		internal IteratorInstance ConstructEntryIterator(JsSet set)
		{
			return new SetEntryIterator(base.Engine, set);
		}

		internal IteratorInstance ConstructValueIterator(JsSet set)
		{
			return new SetValueIterator(base.Engine, set._set._list);
		}
	}
	internal sealed class SetPrototype : Prototype
	{
		private readonly record struct SetRecord(JsValue Set, double Size, ICallable Has, ICallable Keys);

		private readonly SetConstructor _constructor;

		internal SetPrototype(Engine engine, Realm realm, SetConstructor setConstructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = setConstructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(12, checkExistingKeys: false)
			{
				["length"] = new PropertyDescriptor(0, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["add"] = new PropertyDescriptor(new ClrFunction(base.Engine, "add", Add, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["clear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "clear", Clear, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["delete"] = new PropertyDescriptor(new ClrFunction(base.Engine, "delete", Delete, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["difference"] = new PropertyDescriptor(new ClrFunction(base.Engine, "difference", Difference, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["entries"] = new PropertyDescriptor(new ClrFunction(base.Engine, "entries", Entries, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["forEach"] = new PropertyDescriptor(new ClrFunction(base.Engine, "forEach", ForEach, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["has"] = new PropertyDescriptor(new ClrFunction(base.Engine, "has", Has, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["intersection"] = new PropertyDescriptor(new ClrFunction(base.Engine, "intersection", Intersection, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["isDisjointFrom"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isDisjointFrom", IsDisjointFrom, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["isSubsetOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isSubsetOf", IsSubsetOf, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["isSupersetOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isSupersetOf", IsSupersetOf, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["keys"] = new PropertyDescriptor(new ClrFunction(base.Engine, "keys", Values, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["values"] = new PropertyDescriptor(new ClrFunction(base.Engine, "values", Values, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["size"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get size", Size, 0, PropertyFlag.Configurable), null, PropertyFlag.Configurable),
				["symmetricDifference"] = new PropertyDescriptor(new ClrFunction(base.Engine, "symmetricDifference", SymmetricDifference, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["union"] = new PropertyDescriptor(new ClrFunction(base.Engine, "union", Union, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(2);
			JsSymbol iterator = GlobalSymbolRegistry.Iterator;
			symbolDictionary[iterator] = new PropertyDescriptor(new ClrFunction(base.Engine, "iterator", Values, 1, PropertyFlag.Configurable), true, false, true);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Set", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsNumber Size(JsValue thisObject, JsValue[] arguments)
		{
			AssertSetInstance(thisObject);
			return JsNumber.Create(0);
		}

		private JsValue Add(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue is JsNumber jsNumber && jsNumber.IsNegativeZero())
			{
				jsValue = JsNumber.PositiveZero;
			}
			jsSet.Add(jsValue);
			return thisObject;
		}

		private JsValue Clear(JsValue thisObject, JsValue[] arguments)
		{
			AssertSetInstance(thisObject).Clear();
			return JsValue.Undefined;
		}

		private JsBoolean Delete(JsValue thisObject, JsValue[] arguments)
		{
			if (!AssertSetInstance(thisObject).SetDelete(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsSet Difference(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			SetRecord setRecord = GetSetRecord(jsValue);
			JsSet jsSet2 = new JsSet(_engine, new OrderedSet<JsValue>(jsSet._set._set));
			if ((double)jsSet.Size <= setRecord.Size)
			{
				if (jsValue is JsSet jsSet3)
				{
					HashSet<JsValue> hashSet = new HashSet<JsValue>(jsSet._set._set, SameValueZeroComparer.Instance);
					hashSet.ExceptWith(jsSet3._set._set);
					return new JsSet(_engine, new OrderedSet<JsValue>(hashSet));
				}
				int i = 0;
				JsValue[] array = new JsValue[1];
				for (; i < jsSet.Size; i++)
				{
					JsValue jsValue2 = jsSet2[i];
					if ((object)jsValue2 != null)
					{
						array[0] = jsValue2;
						if (TypeConverter.ToBoolean(setRecord.Has.Call(setRecord.Set, array)))
						{
							jsSet2.Remove(jsValue2);
							i--;
						}
					}
				}
				return jsSet2;
			}
			IteratorInstance iteratorFromMethod = setRecord.Set.GetIteratorFromMethod(_realm, setRecord.Keys);
			ObjectInstance nextItem;
			while (iteratorFromMethod.TryIteratorStep(out nextItem))
			{
				JsValue jsValue3 = nextItem.Get(CommonProperties.Value);
				if (jsValue3 == JsNumber.NegativeZero)
				{
					jsValue3 = JsNumber.PositiveZero;
				}
				jsSet2.Remove(jsValue3);
			}
			return jsSet2;
		}

		private JsBoolean IsDisjointFrom(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			SetRecord setRecord = GetSetRecord(jsValue);
			JsSet jsSet2 = new JsSet(_engine, new OrderedSet<JsValue>(jsSet._set._set));
			if ((double)jsSet.Size <= setRecord.Size)
			{
				if (jsValue is JsSet jsSet3)
				{
					if (!jsSet._set._set.Overlaps(jsSet3._set._set))
					{
						return JsBoolean.True;
					}
					return JsBoolean.False;
				}
				int num = 0;
				JsValue[] array = new JsValue[1];
				while (num < jsSet.Size)
				{
					JsValue jsValue2 = jsSet2[num];
					num++;
					if ((object)jsValue2 != null)
					{
						array[0] = jsValue2;
						if (TypeConverter.ToBoolean(setRecord.Has.Call(setRecord.Set, array)))
						{
							return JsBoolean.False;
						}
					}
				}
				return JsBoolean.True;
			}
			IteratorInstance iteratorFromMethod = setRecord.Set.GetIteratorFromMethod(_realm, setRecord.Keys);
			ObjectInstance nextItem;
			while (iteratorFromMethod.TryIteratorStep(out nextItem))
			{
				JsValue key = nextItem.Get(CommonProperties.Value);
				if (jsSet.Has(key))
				{
					iteratorFromMethod.Close(CompletionType.Normal);
					return JsBoolean.False;
				}
			}
			return JsBoolean.True;
		}

		private JsSet Intersection(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			SetRecord setRecord = GetSetRecord(jsValue);
			JsSet jsSet2 = new JsSet(_engine);
			int size = jsSet.Size;
			if ((double)size <= setRecord.Size)
			{
				if (jsValue is JsSet jsSet3)
				{
					HashSet<JsValue> hashSet = new HashSet<JsValue>(jsSet._set._set, SameValueZeroComparer.Instance);
					hashSet.IntersectWith(jsSet3._set._set);
					return new JsSet(_engine, new OrderedSet<JsValue>(hashSet));
				}
				int num = 0;
				JsValue[] array = new JsValue[1];
				while (num < size)
				{
					JsValue jsValue2 = jsSet[num];
					num++;
					if ((object)jsValue2 != null)
					{
						array[0] = jsValue2;
						if (TypeConverter.ToBoolean(setRecord.Has.Call(setRecord.Set, array)) && !jsSet2.Has(jsValue2))
						{
							jsSet2.Add(jsValue2);
						}
						size = jsSet.Size;
					}
				}
				return jsSet2;
			}
			IteratorInstance iteratorFromMethod = setRecord.Set.GetIteratorFromMethod(_realm, setRecord.Keys);
			ObjectInstance nextItem;
			while (iteratorFromMethod.TryIteratorStep(out nextItem))
			{
				JsValue jsValue3 = nextItem.Get(CommonProperties.Value);
				if (jsValue3 == JsNumber.NegativeZero)
				{
					jsValue3 = JsNumber.PositiveZero;
				}
				bool num2 = jsSet2.Has(jsValue3);
				bool flag = jsSet.Has(jsValue3);
				if (!num2 && flag)
				{
					jsSet2.Add(jsValue3);
				}
			}
			return jsSet2;
		}

		private JsSet SymmetricDifference(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue is JsSet jsSet2)
			{
				HashSet<JsValue> hashSet = new HashSet<JsValue>(jsSet._set._set, SameValueZeroComparer.Instance);
				hashSet.SymmetricExceptWith(jsSet2._set._set);
				return new JsSet(_engine, new OrderedSet<JsValue>(hashSet));
			}
			SetRecord setRecord = GetSetRecord(jsValue);
			IteratorInstance iteratorFromMethod = setRecord.Set.GetIteratorFromMethod(_realm, setRecord.Keys);
			JsSet jsSet3 = new JsSet(_engine, new OrderedSet<JsValue>(jsSet._set._set));
			ObjectInstance nextItem;
			while (iteratorFromMethod.TryIteratorStep(out nextItem))
			{
				JsValue jsValue2 = nextItem.Get(CommonProperties.Value);
				if (jsValue2 == JsNumber.NegativeZero)
				{
					jsValue2 = JsNumber.PositiveZero;
				}
				bool flag = jsSet3.Has(jsValue2);
				if (jsSet.Has(jsValue2))
				{
					if (flag)
					{
						jsSet3.Remove(jsValue2);
					}
				}
				else if (!flag)
				{
					jsSet3.Add(jsValue2);
				}
			}
			return jsSet3;
		}

		private JsBoolean IsSubsetOf(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue is JsSet jsSet2)
			{
				if (!jsSet._set._set.IsSubsetOf(jsSet2._set._set))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
			SetRecord setRecord = GetSetRecord(jsValue);
			JsSet jsSet3 = new JsSet(_engine, new OrderedSet<JsValue>(jsSet._set._set));
			int size = jsSet.Size;
			if ((double)size > setRecord.Size)
			{
				return JsBoolean.False;
			}
			if ((double)size <= setRecord.Size)
			{
				int i = 0;
				JsValue[] array = new JsValue[1];
				for (; i < size; i++)
				{
					JsValue jsValue2 = jsSet3[i];
					if ((object)jsValue2 != null)
					{
						array[0] = jsValue2;
						if (!TypeConverter.ToBoolean(setRecord.Has.Call(setRecord.Set, array)))
						{
							return JsBoolean.False;
						}
					}
					size = jsSet.Size;
				}
			}
			return JsBoolean.True;
		}

		private JsBoolean IsSupersetOf(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue is JsSet jsSet2)
			{
				if (!new HashSet<JsValue>(jsSet._set._set, SameValueZeroComparer.Instance).IsSupersetOf(jsSet2._set._set))
				{
					return JsBoolean.False;
				}
				return JsBoolean.True;
			}
			int size = jsSet.Size;
			SetRecord setRecord = GetSetRecord(jsValue);
			if ((double)size < setRecord.Size)
			{
				return JsBoolean.False;
			}
			IteratorInstance iteratorFromMethod = setRecord.Set.GetIteratorFromMethod(_realm, setRecord.Keys);
			ObjectInstance nextItem;
			while (iteratorFromMethod.TryIteratorStep(out nextItem))
			{
				JsValue key = nextItem.Get(CommonProperties.Value);
				if (!jsSet.Has(key))
				{
					iteratorFromMethod.Close(CompletionType.Normal);
					return JsBoolean.False;
				}
			}
			return JsBoolean.True;
		}

		private JsBoolean Has(JsValue thisObject, JsValue[] arguments)
		{
			if (!AssertSetInstance(thisObject).Has(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private ObjectInstance Entries(JsValue thisObject, JsValue[] arguments)
		{
			return AssertSetInstance(thisObject).Entries();
		}

		private JsValue ForEach(JsValue thisObject, JsValue[] arguments)
		{
			JsValue source = arguments.At(0);
			JsValue thisArg = arguments.At(1);
			JsSet jsSet = AssertSetInstance(thisObject);
			ICallable callable = GetCallable(source);
			jsSet.ForEach(callable, thisArg);
			return JsValue.Undefined;
		}

		private JsSet Union(JsValue thisObject, JsValue[] arguments)
		{
			JsSet jsSet = AssertSetInstance(thisObject);
			JsValue obj = arguments.At(0);
			SetRecord setRecord = GetSetRecord(obj);
			IteratorInstance iteratorFromMethod = setRecord.Set.GetIteratorFromMethod(_realm, setRecord.Keys);
			OrderedSet<JsValue> orderedSet = jsSet._set.Clone();
			ObjectInstance nextItem;
			while (iteratorFromMethod.TryIteratorStep(out nextItem))
			{
				JsValue jsValue = nextItem.Get(CommonProperties.Value);
				if (jsValue == JsNumber.NegativeZero)
				{
					jsValue = JsNumber.PositiveZero;
				}
				orderedSet.Add(jsValue);
			}
			return new JsSet(_engine, orderedSet);
		}

		private SetRecord GetSetRecord(JsValue obj)
		{
			if (!(obj is ObjectInstance))
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			double num = TypeConverter.ToNumber(obj.Get(CommonProperties.Size));
			if (double.IsNaN(num))
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			double num2 = TypeConverter.ToIntegerOrInfinity(num);
			if (num2 < 0.0)
			{
				ExceptionHelper.ThrowRangeError(_realm);
			}
			JsValue jsValue = obj.Get(CommonProperties.Has);
			if (!jsValue.IsCallable)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue jsValue2 = obj.Get(CommonProperties.Keys);
			if (!jsValue2.IsCallable)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return new SetRecord(obj, num2, (ICallable)jsValue, (ICallable)jsValue2);
		}

		private ObjectInstance Values(JsValue thisObject, JsValue[] arguments)
		{
			return AssertSetInstance(thisObject).Values();
		}

		private JsSet AssertSetInstance(JsValue thisObject)
		{
			if (thisObject is JsSet result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(_realm, "object must be a Set");
			return null;
		}
	}
}
namespace Jint.Native.RegExp
{
	public sealed class RegExpConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("RegExp");

		internal RegExpPrototype PrototypeObject { get; }

		internal RegExpConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new RegExpPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(2, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get [Symbol.species]", (JsValue thisObj, JsValue[] _) => thisObj, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, thisObject);
		}

		public ObjectInstance Construct(JsValue[] arguments)
		{
			return Construct(arguments, this);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			bool flag = jsValue.IsRegExp();
			if (newTarget.IsUndefined())
			{
				newTarget = this;
				if (flag && jsValue2.IsUndefined())
				{
					JsValue jsValue3 = jsValue.Get(CommonProperties.Constructor);
					if ((object)newTarget == jsValue3)
					{
						return (ObjectInstance)jsValue;
					}
				}
			}
			JsValue pattern;
			JsValue flags;
			if (jsValue is JsRegExp jsRegExp)
			{
				pattern = jsRegExp.Source;
				flags = (jsValue2.IsUndefined() ? ((JsValue)jsRegExp.Flags) : jsValue2);
			}
			else if (flag)
			{
				pattern = jsValue.Get(RegExpPrototype.PropertySource);
				flags = (jsValue2.IsUndefined() ? jsValue.Get(RegExpPrototype.PropertyFlags) : jsValue2);
			}
			else
			{
				pattern = jsValue;
				flags = jsValue2;
			}
			JsRegExp r = RegExpAlloc(newTarget);
			return RegExpInitialize(r, pattern, flags);
		}

		private JsRegExp RegExpInitialize(JsRegExp r, JsValue pattern, JsValue flags)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			string text = (pattern.IsUndefined() ? "" : TypeConverter.ToString(pattern));
			if (string.IsNullOrEmpty(text))
			{
				text = "(?:)";
			}
			string text2 = (flags.IsUndefined() ? "" : TypeConverter.ToString(flags));
			ParserOptions activeParserOptions = _engine.GetActiveParserOptions();
			try
			{
				RegExpParseResult parseResult = Scanner.AdaptRegExp(text, text2, false, (TimeSpan?)activeParserOptions.RegexTimeout, false);
				if (!((RegExpParseResult)(ref parseResult)).Success)
				{
					ExceptionHelper.ThrowSyntaxError(_realm, "Unsupported regular expression. " + ((RegExpParseResult)(ref parseResult)).ConversionError.Description);
				}
				r.Value = ((RegExpParseResult)(ref parseResult)).Regex;
				r.ParseResult = parseResult;
			}
			catch (Exception ex)
			{
				ExceptionHelper.ThrowSyntaxError(_realm, ex.Message);
			}
			r.Flags = text2;
			r.Source = text;
			RegExpInitialize(r);
			return r;
		}

		private JsRegExp RegExpAlloc(JsValue newTarget)
		{
			return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.RegExp.PrototypeObject, (Engine engine, Realm _, object? _) => new JsRegExp(engine));
		}

		public JsRegExp Construct(Regex regExp, string source, string flags, RegExpParseResult regExpParseResult = default(RegExpParseResult))
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			JsRegExp jsRegExp = RegExpAlloc(this);
			jsRegExp.Value = regExp;
			jsRegExp.Source = source;
			jsRegExp.Flags = flags;
			jsRegExp.ParseResult = regExpParseResult;
			RegExpInitialize(jsRegExp);
			return jsRegExp;
		}

		private static void RegExpInitialize(JsRegExp r)
		{
			r.SetOwnProperty(JsRegExp.PropertyLastIndex, new PropertyDescriptor(0, PropertyFlag.OnlyWritable));
		}
	}
	internal static class RegExpExtensions
	{
	}
	internal sealed class RegExpPrototype : Prototype
	{
		private static readonly JsString PropertyExec = new JsString("exec");

		private static readonly JsString PropertyIndex = new JsString("index");

		private static readonly JsString PropertyInput = new JsString("input");

		private static readonly JsString PropertySticky = new JsString("sticky");

		private static readonly JsString PropertyGlobal = new JsString("global");

		internal static readonly JsString PropertySource = new JsString("source");

		private static readonly JsString DefaultSource = new JsString("(?:)");

		internal static readonly JsString PropertyFlags = new JsString("flags");

		private static readonly JsString PropertyGroups = new JsString("groups");

		private static readonly JsString PropertyIgnoreCase = new JsString("ignoreCase");

		private static readonly JsString PropertyMultiline = new JsString("multiline");

		private static readonly JsString PropertyDotAll = new JsString("dotAll");

		private static readonly JsString PropertyUnicode = new JsString("unicode");

		private static readonly JsString PropertyUnicodeSets = new JsString("unicodeSets");

		private readonly RegExpConstructor _constructor;

		private readonly Func<JsValue, JsValue[], JsValue> _defaultExec;

		internal bool HasDefaultExec
		{
			get
			{
				if (Get(PropertyExec) is ClrFunction clrFunction)
				{
					return clrFunction._func == _defaultExec;
				}
				return false;
			}
		}

		internal RegExpPrototype(Engine engine, Realm realm, RegExpConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_defaultExec = Exec;
			_constructor = constructor;
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(14, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.Writable | PropertyFlag.Configurable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToRegExpString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["exec"] = new PropertyDescriptor(new ClrFunction(base.Engine, "exec", _defaultExec, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["test"] = new PropertyDescriptor(new ClrFunction(base.Engine, "test", Test, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["dotAll"] = CreateGetAccessorDescriptor("get dotAll", (JsRegExp r) => r.DotAll),
				["flags"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get flags", Flags, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["global"] = CreateGetAccessorDescriptor("get global", (JsRegExp r) => r.Global),
				["hasIndices"] = CreateGetAccessorDescriptor("get hasIndices", (JsRegExp r) => r.Indices),
				["ignoreCase"] = CreateGetAccessorDescriptor("get ignoreCase", (JsRegExp r) => r.IgnoreCase),
				["multiline"] = CreateGetAccessorDescriptor("get multiline", (JsRegExp r) => r.Multiline),
				["source"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get source", Source, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["sticky"] = CreateGetAccessorDescriptor("get sticky", (JsRegExp r) => r.Sticky),
				["unicode"] = CreateGetAccessorDescriptor("get unicode", (JsRegExp r) => r.FullUnicode),
				["unicodeSets"] = CreateGetAccessorDescriptor("get unicodeSets", (JsRegExp r) => r.UnicodeSets)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(5);
			JsSymbol match = GlobalSymbolRegistry.Match;
			symbolDictionary[match] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.match]", Match, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			JsSymbol matchAll = GlobalSymbolRegistry.MatchAll;
			symbolDictionary[matchAll] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.matchAll]", MatchAll, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			JsSymbol replace = GlobalSymbolRegistry.Replace;
			symbolDictionary[replace] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.replace]", Replace, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			JsSymbol search = GlobalSymbolRegistry.Search;
			symbolDictionary[search] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.search]", Search, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			JsSymbol split = GlobalSymbolRegistry.Split;
			symbolDictionary[split] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.split]", Split, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
			GetSetPropertyDescriptor CreateGetAccessorDescriptor(string name, Func<JsRegExp, JsValue> valueExtractor, JsValue? protoValue = null)
			{
				return new GetSetPropertyDescriptor(new ClrFunction(base.Engine, name, delegate(JsValue thisObj, JsValue[] arguments)
				{
					if ((object)thisObj == this)
					{
						return protoValue ?? JsValue.Undefined;
					}
					JsRegExp jsRegExp = thisObj as JsRegExp;
					if ((object)jsRegExp == null)
					{
						ExceptionHelper.ThrowTypeError(_realm);
					}
					return valueExtractor(jsRegExp);
				}, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			}
		}

		private JsValue Source(JsValue thisObject, JsValue[] arguments)
		{
			if ((object)thisObject == this)
			{
				return DefaultSource;
			}
			JsRegExp jsRegExp = thisObject as JsRegExp;
			if ((object)jsRegExp == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (string.IsNullOrEmpty(jsRegExp.Source))
			{
				return "(?:)";
			}
			return jsRegExp.Source.Replace("\\/", "/").Replace("/", "\\/").Replace("\n", "\\n");
		}

		private JsValue Replace(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.replace");
			string s = TypeConverter.ToString(arguments.At(0));
			int length = s.Length;
			JsValue replaceValue = arguments.At(1);
			bool flag = replaceValue is ICallable;
			bool flag2 = false;
			if (!flag)
			{
				string text = TypeConverter.ToString(replaceValue);
				replaceValue = text;
				flag2 = text.Contains('$');
			}
			string text2 = TypeConverter.ToString(objectInstance.Get(PropertyFlags));
			bool flag3 = text2.Contains('g');
			bool flag4 = false;
			if (flag3)
			{
				flag4 = text2.Contains('u');
				objectInstance.Set(JsRegExp.PropertyLastIndex, 0, throwOnError: true);
			}
			JsRegExp rei;
			if (!flag4 && !flag2 && !TypeConverter.ToBoolean(objectInstance.Get(PropertySticky)))
			{
				rei = objectInstance as JsRegExp;
				if ((object)rei != null && rei.HasDefaultRegExpExec)
				{
					int count = ((!flag3) ? 1 : int.MaxValue);
					string text3 = ((!flag) ? rei.Value.Replace(s, TypeConverter.ToString(replaceValue), count) : rei.Value.Replace(s, Evaluator, count));
					objectInstance.Set(JsRegExp.PropertyLastIndex, JsNumber.PositiveZero);
					return text3;
				}
			}
			List<ObjectInstance> list = new List<ObjectInstance>();
			while (true)
			{
				JsValue jsValue = RegExpExec(objectInstance, s);
				if (jsValue.IsNull())
				{
					break;
				}
				list.Add((ObjectInstance)jsValue);
				if (!flag3)
				{
					break;
				}
				if (TypeConverter.ToString(jsValue.Get(0)) == "")
				{
					ulong index = TypeConverter.ToLength(objectInstance.Get(JsRegExp.PropertyLastIndex));
					ulong num = AdvanceStringIndex(s, index, flag4);
					objectInstance.Set(JsRegExp.PropertyLastIndex, num);
				}
			}
			string text4 = "";
			int num2 = 0;
			List<string> list2 = new List<string>();
			for (int i = 0; i < list.Count; i++)
			{
				ObjectInstance objectInstance2 = list[i];
				int length2 = (int)objectInstance2.GetLength();
				length2 = System.Math.Max(length2 - 1, 0);
				string text5 = TypeConverter.ToString(objectInstance2.Get(0));
				int length3 = text5.Length;
				int val = (int)TypeConverter.ToInteger(objectInstance2.Get(PropertyIndex));
				val = System.Math.Max(System.Math.Min(val, length), 0);
				uint num3 = 1u;
				list2.Clear();
				for (; num3 <= length2; num3++)
				{
					JsValue jsValue2 = objectInstance2.Get(num3);
					string item = ((!jsValue2.IsUndefined()) ? TypeConverter.ToString(jsValue2) : "");
					list2.Add(item);
				}
				JsValue jsValue3 = objectInstance2.Get(PropertyGroups);
				string text6;
				if (flag)
				{
					List<JsValue> list3 = new List<JsValue>();
					list3.Add(text5);
					foreach (string item2 in list2)
					{
						list3.Add(item2);
					}
					list3.Add(val);
					list3.Add(s);
					if (!jsValue3.IsUndefined())
					{
						list3.Add(jsValue3);
					}
					text6 = CallFunctionalReplace(replaceValue, list3);
				}
				else
				{
					if (!jsValue3.IsUndefined())
					{
						jsValue3 = TypeConverter.ToObject(_realm, jsValue3);
					}
					text6 = GetSubstitution(text5, s, val, list2.ToArray(), jsValue3, TypeConverter.ToString(replaceValue));
				}
				if (val >= num2)
				{
					text4 = text4 + s.Substring(num2, val - num2) + text6;
					num2 = val + length3;
				}
			}
			if (num2 >= length)
			{
				return text4;
			}
			return text4 + s.Substring(num2);
			string Evaluator(Match match)
			{
				int actualRegexGroupCount = GetActualRegexGroupCount(rei, match);
				List<JsValue> list4 = new List<JsValue>(actualRegexGroupCount + 2) { match.Value };
				ObjectInstance objectInstance3 = null;
				for (int j = 1; j < actualRegexGroupCount; j++)
				{
					Group obj = match.Groups[j];
					list4.Add(obj.Success ? ((JsValue)obj.Value) : JsValue.Undefined);
					string regexGroupName = GetRegexGroupName(rei, j);
					if (!string.IsNullOrWhiteSpace(regexGroupName))
					{
						if ((object)objectInstance3 == null)
						{
							objectInstance3 = ObjectInstance.OrdinaryObjectCreate(_engine, null);
						}
						objectInstance3.CreateDataPropertyOrThrow(regexGroupName, obj.Success ? ((JsValue)obj.Value) : JsValue.Undefined);
					}
				}
				list4.Add(match.Index);
				list4.Add(s);
				if ((object)objectInstance3 != null)
				{
					list4.Add(objectInstance3);
				}
				return CallFunctionalReplace(replaceValue, list4);
			}
		}

		private static string CallFunctionalReplace(JsValue replacer, List<JsValue> replacerArgs)
		{
			return TypeConverter.ToString(((ICallable)replacer).Call(JsValue.Undefined, replacerArgs.ToArray()));
		}

		internal static string GetSubstitution(string matched, string str, int position, string[] captures, JsValue namedCaptures, string replacement)
		{
			if (!replacement.Contains('$'))
			{
				return replacement;
			}
			Span<char> initialBuffer = stackalloc char[128];
			using System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			for (int i = 0; i < replacement.Length; i++)
			{
				char c = replacement[i];
				if (c == '$' && i < replacement.Length - 1)
				{
					c = replacement[++i];
					switch (c)
					{
					case '$':
						valueStringBuilder.Append('$');
						continue;
					case '&':
						valueStringBuilder.Append(matched);
						continue;
					case '`':
						valueStringBuilder.Append(str.AsSpan(0, position));
						continue;
					case '\'':
						valueStringBuilder.Append(str.AsSpan(position + matched.Length));
						continue;
					case '<':
					{
						int num = replacement.IndexOf('>', i + 1);
						if (num == -1 || namedCaptures.IsUndefined())
						{
							valueStringBuilder.Append('$');
							valueStringBuilder.Append(c);
							continue;
						}
						int num2 = i + 1;
						string text = replacement.Substring(num2, num - num2);
						JsValue jsValue = namedCaptures.Get(text);
						if (!jsValue.IsUndefined())
						{
							valueStringBuilder.Append(TypeConverter.ToString(jsValue));
						}
						i = num;
						continue;
					}
					}
					if (char.IsDigit(c))
					{
						int num3 = c - 48;
						int num4 = 0;
						if (i < replacement.Length - 1 && char.IsDigit(replacement[i + 1]))
						{
							num4 = num3 * 10 + (replacement[i + 1] - 48);
						}
						if (num4 > 0 && num4 <= captures.Length)
						{
							valueStringBuilder.Append(TypeConverter.ToString(captures[num4 - 1]));
							i++;
						}
						else if (num3 > 0 && num3 <= captures.Length)
						{
							valueStringBuilder.Append(TypeConverter.ToString(captures[num3 - 1]));
						}
						else
						{
							valueStringBuilder.Append('$');
							i--;
						}
					}
					else
					{
						valueStringBuilder.Append('$');
						valueStringBuilder.Append(c);
					}
				}
				else
				{
					valueStringBuilder.Append(c);
				}
			}
			return valueStringBuilder.ToString();
		}

		private JsValue Split(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.split");
			string text = TypeConverter.ToString(arguments.At(0));
			JsValue jsValue = arguments.At(1);
			IConstructor f = ObjectInstance.SpeciesConstructor(objectInstance, _realm.Intrinsics.RegExp);
			JsString jsString = TypeConverter.ToJsString(objectInstance.Get(PropertyFlags));
			bool flag = jsString.Contains('u');
			JsString jsString2 = (jsString.Contains('y') ? jsString : new JsString(jsString.ToString() + "y"));
			ObjectInstance objectInstance2 = ObjectInstance.Construct(f, new JsValue[2] { objectInstance, jsString2 });
			uint lengthA = 0u;
			long num = (jsValue.IsUndefined() ? 9007199254740991L : TypeConverter.ToUint32(jsValue));
			if (num == 0L)
			{
				return _realm.Intrinsics.Array.ArrayCreate(0uL);
			}
			if (text.Length == 0)
			{
				JsArray jsArray = _realm.Intrinsics.Array.ArrayCreate(0uL);
				if (!RegExpExec(objectInstance2, text).IsNull())
				{
					return jsArray;
				}
				jsArray.SetIndexValue(0u, text, updateLength: true);
				return jsArray;
			}
			if (!flag && objectInstance is JsRegExp { HasDefaultRegExpExec: not false } jsRegExp)
			{
				if (string.Equals(jsRegExp.Source, "(?:)", StringComparison.Ordinal))
				{
					return StringPrototype.SplitWithStringSeparator(_realm, "", text, (uint)text.Length);
				}
				JsArray jsArray2 = _realm.Intrinsics.Array.Construct(Arguments.Empty);
				int num2 = 0;
				uint num3 = 0u;
				Match match = jsRegExp.Value.Match(text, 0);
				while (match.Success)
				{
					if (match.Length != 0 || (match.Index != 0 && match.Index != text.Length && match.Index != num2))
					{
						jsArray2.SetIndexValue(num3++, text.Substring(num2, match.Index - num2), updateLength: true);
						if (num3 >= num)
						{
							return jsArray2;
						}
						num2 = match.Index + match.Length;
						int actualRegexGroupCount = GetActualRegexGroupCount(jsRegExp, match);
						for (int i = 1; i < actualRegexGroupCount; i++)
						{
							Group obj = match.Groups[i];
							JsValue value = JsValue.Undefined;
							if (obj.Captures.Count > 0)
							{
								value = match.Groups[i].Value;
							}
							jsArray2.SetIndexValue(num3++, value, updateLength: true);
							if (num3 >= num)
							{
								return jsArray2;
							}
						}
					}
					match = match.NextMatch();
				}
				jsArray2.SetIndexValue(num3, text.Substring(num2), updateLength: true);
				return jsArray2;
			}
			return SplitSlow(text, objectInstance2, flag, lengthA, num);
		}

		private JsArray SplitSlow(string s, ObjectInstance splitter, bool unicodeMatching, uint lengthA, long lim)
		{
			JsArray jsArray = _realm.Intrinsics.Array.ArrayCreate(0uL);
			ulong num = 0uL;
			ulong num2 = 0uL;
			while (num2 < (ulong)s.Length)
			{
				splitter.Set(JsRegExp.PropertyLastIndex, num2, throwOnError: true);
				JsValue jsValue = RegExpExec(splitter, s);
				if (jsValue.IsNull())
				{
					num2 = AdvanceStringIndex(s, num2, unicodeMatching);
					continue;
				}
				ulong val = TypeConverter.ToLength(splitter.Get(JsRegExp.PropertyLastIndex));
				val = System.Math.Min(val, (ulong)s.Length);
				if (val == num)
				{
					num2 = AdvanceStringIndex(s, num2, unicodeMatching);
					continue;
				}
				string text = s.Substring((int)num, (int)(num2 - num));
				jsArray.SetIndexValue(lengthA, text, updateLength: true);
				lengthA++;
				if (lengthA == lim)
				{
					return jsArray;
				}
				num = val;
				int num3 = (int)TypeConverter.ToLength(jsValue.Get(CommonProperties.Length));
				num3 = System.Math.Max(num3 - 1, 0);
				int num4 = 1;
				while (num4 <= num3)
				{
					JsValue value = jsValue.Get(num4);
					jsArray.SetIndexValue(lengthA, value, updateLength: true);
					num4++;
					lengthA++;
					if (lengthA == lim)
					{
						return jsArray;
					}
				}
				num2 = num;
			}
			jsArray.SetIndexValue(lengthA, s.Substring((int)num, s.Length - (int)num), updateLength: true);
			return jsArray;
		}

		private JsValue Flags(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance o = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.flags");
			string text = AddFlagIfPresent(s: AddFlagIfPresent(s: AddFlagIfPresent(s: AddFlagIfPresent(s: AddFlagIfPresent(s: AddFlagIfPresent(s: AddFlagIfPresent(s: AddFlagIfPresent(o, "hasIndices", 'd', ""), o: o, p: PropertyGlobal, flag: 'g'), o: o, p: PropertyIgnoreCase, flag: 'i'), o: o, p: PropertyMultiline, flag: 'm'), o: o, p: PropertyDotAll, flag: 's'), o: o, p: PropertyUnicode, flag: 'u'), o: o, p: PropertyUnicodeSets, flag: 'v'), o: o, p: PropertySticky, flag: 'y');
			return text;
			static string AddFlagIfPresent(JsValue jsValue, JsValue p, char flag, string s)
			{
				if (!TypeConverter.ToBoolean(jsValue.Get(p)))
				{
					return s;
				}
				return s + flag;
			}
		}

		private JsValue ToRegExpString(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.toString");
			string text = TypeConverter.ToString(objectInstance.Get(PropertySource));
			string text2 = TypeConverter.ToString(objectInstance.Get(PropertyFlags));
			return "/" + text + "/" + text2;
		}

		private JsValue Test(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.test");
			string text = TypeConverter.ToString(arguments.At(0));
			if (objectInstance is JsRegExp { FullUnicode: false } jsRegExp)
			{
				if (!jsRegExp.Sticky && !jsRegExp.Global)
				{
					jsRegExp.Set(JsRegExp.PropertyLastIndex, 0, throwOnError: true);
					return jsRegExp.Value.IsMatch(text);
				}
				int num = (int)TypeConverter.ToLength(jsRegExp.Get(JsRegExp.PropertyLastIndex));
				if (num >= text.Length && text.Length > 0)
				{
					return JsBoolean.False;
				}
				Match match = jsRegExp.Value.Match(text, num);
				if (!match.Success || (jsRegExp.Sticky && match.Index != num))
				{
					jsRegExp.Set(JsRegExp.PropertyLastIndex, 0, throwOnError: true);
					return JsBoolean.False;
				}
				jsRegExp.Set(JsRegExp.PropertyLastIndex, match.Index + match.Length, throwOnError: true);
				return JsBoolean.True;
			}
			return !RegExpExec(objectInstance, text).IsNull();
		}

		private JsValue Search(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.search");
			string s = TypeConverter.ToString(arguments.At(0));
			JsValue jsValue = objectInstance.Get(JsRegExp.PropertyLastIndex);
			if (!JsValue.SameValue(jsValue, 0))
			{
				objectInstance.Set(JsRegExp.PropertyLastIndex, 0, throwOnError: true);
			}
			JsValue jsValue2 = RegExpExec(objectInstance, s);
			if (!JsValue.SameValue(objectInstance.Get(JsRegExp.PropertyLastIndex), jsValue))
			{
				objectInstance.Set(JsRegExp.PropertyLastIndex, jsValue, throwOnError: true);
			}
			if (jsValue2.IsNull())
			{
				return -1;
			}
			return jsValue2.Get(PropertyIndex);
		}

		private JsValue Match(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.match");
			string text = TypeConverter.ToString(arguments.At(0));
			string text2 = TypeConverter.ToString(objectInstance.Get(PropertyFlags));
			if (!text2.Contains('g'))
			{
				return RegExpExec(objectInstance, text);
			}
			bool flag = text2.Contains('u');
			objectInstance.Set(JsRegExp.PropertyLastIndex, JsNumber.PositiveZero, throwOnError: true);
			if (!flag && objectInstance is JsRegExp { HasDefaultRegExpExec: not false } jsRegExp)
			{
				JsArray jsArray = _realm.Intrinsics.Array.ArrayCreate(0uL);
				if (jsRegExp.Sticky)
				{
					Match match = jsRegExp.Value.Match(text);
					if (!match.Success || match.Index != 0)
					{
						return JsValue.Null;
					}
					jsArray.SetIndexValue(0u, match.Value, updateLength: false);
					uint num = 0u;
					while (true)
					{
						match = match.NextMatch();
						if (!match.Success || match.Index != ++num)
						{
							break;
						}
						jsArray.SetIndexValue(num, match.Value, updateLength: false);
					}
					jsArray.SetLength(num);
					return jsArray;
				}
				MatchCollection matchCollection = jsRegExp.Value.Matches(text);
				if (matchCollection.Count == 0)
				{
					return JsValue.Null;
				}
				jsArray.EnsureCapacity((uint)matchCollection.Count);
				jsArray.SetLength((uint)matchCollection.Count);
				for (int i = 0; i < matchCollection.Count; i++)
				{
					jsArray.SetIndexValue((uint)i, matchCollection[i].Value, updateLength: false);
				}
				return jsArray;
			}
			return MatchSlow(objectInstance, text, flag);
		}

		private JsValue MatchSlow(ObjectInstance rx, string s, bool fullUnicode)
		{
			JsArray jsArray = _realm.Intrinsics.Array.ArrayCreate(0uL);
			uint num = 0u;
			while (true)
			{
				JsValue jsValue = RegExpExec(rx, s);
				if (jsValue.IsNull())
				{
					break;
				}
				string text = TypeConverter.ToString(jsValue.Get(JsString.NumberZeroString));
				jsArray.SetIndexValue(num, text, updateLength: false);
				if (text == "")
				{
					ulong index = TypeConverter.ToLength(rx.Get(JsRegExp.PropertyLastIndex));
					ulong num2 = AdvanceStringIndex(s, index, fullUnicode);
					rx.Set(JsRegExp.PropertyLastIndex, num2, throwOnError: true);
				}
				num++;
			}
			jsArray.SetLength(num);
			if (num != 0)
			{
				return jsArray;
			}
			return JsValue.Null;
		}

		private JsValue MatchAll(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.matchAll");
			string iteratedString = TypeConverter.ToString(arguments.At(0));
			IConstructor f = ObjectInstance.SpeciesConstructor(objectInstance, _realm.Intrinsics.RegExp);
			JsString jsString = TypeConverter.ToJsString(objectInstance.Get(PropertyFlags));
			ObjectInstance objectInstance2 = ObjectInstance.Construct(f, new JsValue[2] { objectInstance, jsString });
			ulong num = TypeConverter.ToLength(objectInstance.Get(JsRegExp.PropertyLastIndex));
			objectInstance2.Set(JsRegExp.PropertyLastIndex, num, throwOnError: true);
			bool global = jsString.Contains('g');
			bool unicode = jsString.Contains('u');
			return _realm.Intrinsics.RegExpStringIteratorPrototype.Construct(objectInstance2, iteratedString, global, unicode);
		}

		private static ulong AdvanceStringIndex(string s, ulong index, bool unicode)
		{
			if (!unicode || index + 1 >= (ulong)s.Length)
			{
				return index + 1;
			}
			char c = s[(int)index];
			if (c < '\ud800' || c > '\udbff')
			{
				return index + 1;
			}
			char c2 = s[(int)(index + 1)];
			if (c2 < '\udc00' || c2 > '\udfff')
			{
				return index + 1;
			}
			return index + 2;
		}

		internal static JsValue RegExpExec(ObjectInstance r, string s)
		{
			JsRegExp jsRegExp = r as JsRegExp;
			if (((object)jsRegExp == null || !jsRegExp.HasDefaultRegExpExec) && r.Get(PropertyExec) is ICallable callable)
			{
				JsValue jsValue = callable.Call(r, s);
				if (!jsValue.IsNull() && !jsValue.IsObject())
				{
					ExceptionHelper.ThrowTypeError(r.Engine.Realm);
				}
				return jsValue;
			}
			if ((object)jsRegExp == null)
			{
				ExceptionHelper.ThrowTypeError(r.Engine.Realm);
			}
			return RegExpBuiltinExec(jsRegExp, s);
		}

		private static JsValue RegExpBuiltinExec(JsRegExp R, string s)
		{
			ulong num = (ulong)s.Length;
			ulong num2 = TypeConverter.ToLength(R.Get(JsRegExp.PropertyLastIndex));
			bool global = R.Global;
			bool sticky = R.Sticky;
			if (!global && !sticky)
			{
				num2 = 0uL;
			}
			if (string.Equals(R.Source, "(?:)", StringComparison.Ordinal))
			{
				if (num2 > (ulong)s.Length)
				{
					return JsValue.Null;
				}
				JsArray jsArray = R.Engine.Realm.Intrinsics.Array.ArrayCreate(1uL);
				jsArray.FastSetDataProperty(PropertyIndex._value, num2);
				jsArray.FastSetDataProperty(PropertyInput._value, s);
				jsArray.SetIndexValue(0u, JsString.Empty, updateLength: false);
				return jsArray;
			}
			Regex value = R.Value;
			bool fullUnicode = R.FullUnicode;
			bool indices = R.Indices;
			if (!global && !sticky && !fullUnicode && !indices)
			{
				Match match = value.Match(s, (int)num2);
				if (!match.Success)
				{
					return JsValue.Null;
				}
				return CreateReturnValueArray(R, match, s, fullUnicode: false, hasIndices: false);
			}
			if (num2 > num)
			{
				R.Set(JsRegExp.PropertyLastIndex, JsNumber.PositiveZero, throwOnError: true);
				return JsValue.Null;
			}
			int num3 = (int)num2;
			Match match2;
			while (true)
			{
				match2 = R.Value.Match(s, num3);
				if (!(match2.Success && fullUnicode) || match2.Length != 0 || 0 >= match2.Index || match2.Index >= s.Length || !char.IsHighSurrogate(s[match2.Index - 1]) || !char.IsLowSurrogate(s[match2.Index]))
				{
					break;
				}
				num3++;
			}
			if (!match2.Success || (sticky && match2.Index != (int)num2))
			{
				R.Set(JsRegExp.PropertyLastIndex, JsNumber.PositiveZero, throwOnError: true);
				return JsValue.Null;
			}
			int num4 = match2.Index + match2.Length;
			if (global || sticky)
			{
				R.Set(JsRegExp.PropertyLastIndex, num4, throwOnError: true);
			}
			return CreateReturnValueArray(R, match2, s, fullUnicode, indices);
		}

		private static JsArray CreateReturnValueArray(JsRegExp rei, Match match, string s, bool fullUnicode, bool hasIndices)
		{
			Engine engine = rei.Engine;
			int actualRegexGroupCount = GetActualRegexGroupCount(rei, match);
			JsArray jsArray = engine.Realm.Intrinsics.Array.ArrayCreate((ulong)actualRegexGroupCount);
			jsArray.CreateDataProperty(PropertyIndex, match.Index);
			jsArray.CreateDataProperty(PropertyInput, s);
			ObjectInstance objectInstance = null;
			List<string> list = null;
			List<JsNumber[]> list2 = (hasIndices ? new List<JsNumber[]>(actualRegexGroupCount) : null);
			for (uint num = 0u; num < actualRegexGroupCount; num++)
			{
				Group obj = match.Groups[(int)num];
				JsValue jsValue = JsValue.Undefined;
				if (obj != null && obj.Success)
				{
					jsValue = obj.Value;
				}
				if (hasIndices)
				{
					if (obj != null && obj.Success)
					{
						list2.Add(new JsNumber[2]
						{
							JsNumber.Create(obj.Index),
							JsNumber.Create(obj.Index + obj.Length)
						});
					}
					else
					{
						list2.Add(null);
					}
				}
				string regexGroupName = GetRegexGroupName(rei, (int)num);
				if (!string.IsNullOrWhiteSpace(regexGroupName))
				{
					if ((object)objectInstance == null)
					{
						objectInstance = ObjectInstance.OrdinaryObjectCreate(engine, null);
					}
					objectInstance.CreateDataPropertyOrThrow(regexGroupName, jsValue);
					if (list == null)
					{
						list = new List<string>();
					}
					list.Add(regexGroupName);
				}
				jsArray.SetIndexValue(num, jsValue, updateLength: false);
			}
			jsArray.CreateDataProperty(PropertyGroups, objectInstance ?? JsValue.Undefined);
			if (hasIndices)
			{
				JsArray v = MakeMatchIndicesIndexPairArray(engine, s, list2, list, list != null && list.Count > 0);
				jsArray.CreateDataPropertyOrThrow("indices", v);
			}
			return jsArray;
		}

		private static JsArray MakeMatchIndicesIndexPairArray(Engine engine, string s, List<JsNumber[]?> indices, List<string>? groupNames, bool hasGroups)
		{
			int count = indices.Count;
			JsArray jsArray = engine.Realm.Intrinsics.Array.Construct((uint)count);
			ObjectInstance objectInstance = null;
			if (hasGroups)
			{
				objectInstance = ObjectInstance.OrdinaryObjectCreate(engine, null);
			}
			jsArray.CreateDataPropertyOrThrow("groups", objectInstance ?? JsValue.Undefined);
			for (int i = 0; i < count; i++)
			{
				JsNumber[] array = indices[i];
				JsValue jsValue = ((array != null) ? GetMatchIndexPair(engine, s, array) : JsValue.Undefined);
				jsArray.Push(jsValue);
				if (i > 0 && !string.IsNullOrWhiteSpace(groupNames?[i - 1]))
				{
					objectInstance.CreateDataPropertyOrThrow(groupNames[i - 1], jsValue);
				}
			}
			return jsArray;
		}

		private static JsValue GetMatchIndexPair(Engine engine, string s, JsNumber[] match)
		{
			return engine.Realm.Intrinsics.Array.CreateArrayFromList(match);
		}

		private static int GetActualRegexGroupCount(JsRegExp rei, Match match)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			RegExpParseResult parseResult = rei.ParseResult;
			if (!((RegExpParseResult)(ref parseResult)).Success)
			{
				return match.Groups.Count;
			}
			parseResult = rei.ParseResult;
			return ((RegExpParseResult)(ref parseResult)).ActualRegexGroupCount;
		}

		private static string? GetRegexGroupName(JsRegExp rei, int index)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (index == 0)
			{
				return null;
			}
			Regex value = rei.Value;
			RegExpParseResult parseResult = rei.ParseResult;
			if (((RegExpParseResult)(ref parseResult)).Success)
			{
				parseResult = rei.ParseResult;
				return ((RegExpParseResult)(ref parseResult)).GetRegexGroupName(index);
			}
			string text = value.GroupNameFromNumber(index);
			if (text.Length == 1 && text[0] == 48 + index)
			{
				return null;
			}
			return text;
		}

		private JsValue Exec(JsValue thisObject, JsValue[] arguments)
		{
			JsRegExp obj = thisObject as JsRegExp;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			string s = TypeConverter.ToString(arguments.At(0));
			return RegExpBuiltinExec(obj, s);
		}
	}
	internal sealed class RegExpStringIteratorPrototype : IteratorPrototype
	{
		internal RegExpStringIteratorPrototype(Engine engine, Realm realm, IteratorPrototype iteratorPrototype)
			: base(engine, realm, iteratorPrototype)
		{
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { [KnownKeys.Next] = new PropertyDescriptor(new ClrFunction(base.Engine, "next", base.Next, 0, PropertyFlag.Configurable), true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("RegExp String Iterator", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		internal IteratorInstance Construct(ObjectInstance iteratingRegExp, string iteratedString, bool global, bool unicode)
		{
			return new IteratorInstance.RegExpStringIterator(base.Engine, iteratingRegExp, iteratedString, global, unicode)
			{
				_prototype = this
			};
		}
	}
}
namespace Jint.Native.Reflect
{
	internal sealed class ReflectInstance : ObjectInstance
	{
		private readonly Realm _realm;

		internal ReflectInstance(Engine engine, Realm realm, ObjectPrototype objectPrototype)
			: base(engine)
		{
			_realm = realm;
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(14, checkExistingKeys: false)
			{
				["apply"] = new PropertyDescriptor(new ClrFunction(base.Engine, "apply", Apply, 3, PropertyFlag.Configurable), true, false, true),
				["construct"] = new PropertyDescriptor(new ClrFunction(base.Engine, "construct", Construct, 2, PropertyFlag.Configurable), true, false, true),
				["defineProperty"] = new PropertyDescriptor(new ClrFunction(base.Engine, "defineProperty", DefineProperty, 3, PropertyFlag.Configurable), true, false, true),
				["deleteProperty"] = new PropertyDescriptor(new ClrFunction(base.Engine, "deleteProperty", DeleteProperty, 2, PropertyFlag.Configurable), true, false, true),
				["get"] = new PropertyDescriptor(new ClrFunction(base.Engine, "get", Get, 2, PropertyFlag.Configurable), true, false, true),
				["getOwnPropertyDescriptor"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getOwnPropertyDescriptor", GetOwnPropertyDescriptor, 2, PropertyFlag.Configurable), true, false, true),
				["getPrototypeOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getPrototypeOf", GetPrototypeOf, 1, PropertyFlag.Configurable), true, false, true),
				["has"] = new PropertyDescriptor(new ClrFunction(base.Engine, "has", Has, 2, PropertyFlag.Configurable), true, false, true),
				["isExtensible"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isExtensible", IsExtensible, 1, PropertyFlag.Configurable), true, false, true),
				["ownKeys"] = new PropertyDescriptor(new ClrFunction(base.Engine, "ownKeys", OwnKeys, 1, PropertyFlag.Configurable), true, false, true),
				["preventExtensions"] = new PropertyDescriptor(new ClrFunction(base.Engine, "preventExtensions", PreventExtensions, 1, PropertyFlag.Configurable), true, false, true),
				["set"] = new PropertyDescriptor(new ClrFunction(base.Engine, "set", Set, 3, PropertyFlag.Configurable), true, false, true),
				["setPrototypeOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setPrototypeOf", SetPrototypeOf, 2, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Reflect", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Apply(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			JsValue thisObject2 = arguments.At(1);
			JsValue argArray = arguments.At(2);
			if (!jsValue.IsCallable)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue[] arguments2 = FunctionPrototype.CreateListFromArrayLike(_realm, argArray);
			return ((ICallable)jsValue).Call(thisObject2, arguments2);
		}

		private JsValue Construct(JsValue thisObject, JsValue[] arguments)
		{
			IConstructor constructor = JsValue.AssertConstructor(_engine, arguments.At(0));
			JsValue jsValue = arguments.At(2, arguments[0]);
			JsValue.AssertConstructor(_engine, jsValue);
			JsValue[] arguments2 = FunctionPrototype.CreateListFromArrayLike(_realm, arguments.At(1));
			return constructor.Construct(arguments2, jsValue);
		}

		private JsValue DefineProperty(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = arguments.At(0) as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.defineProperty called on non-object");
			}
			JsValue o = arguments.At(1);
			JsValue o2 = arguments.At(2);
			JsValue property = TypeConverter.ToPropertyKey(o);
			PropertyDescriptor desc = PropertyDescriptor.ToPropertyDescriptor(_realm, o2);
			return obj.DefineOwnProperty(property, desc);
		}

		private JsValue DeleteProperty(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = arguments.At(0) as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.deleteProperty called on non-object");
			}
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(1));
			if (!obj.Delete(property))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsValue Has(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = arguments.At(0) as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.has called on non-object");
			}
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(1));
			if (!obj.HasProperty(property))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsValue Set(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(1));
			JsValue value = arguments.At(2);
			JsValue receiver = arguments.At(3, jsValue);
			ObjectInstance obj = jsValue as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.set called on non-object");
			}
			return obj.Set(property, value, receiver);
		}

		private JsValue Get(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			ObjectInstance obj = jsValue as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.get called on non-object");
			}
			JsValue receiver = arguments.At(2, jsValue);
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(1));
			return obj.Get(property, receiver);
		}

		private JsValue GetOwnPropertyDescriptor(JsValue thisObject, JsValue[] arguments)
		{
			if (!arguments.At(0).IsObject())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.getOwnPropertyDescriptor called on non-object");
			}
			return _realm.Intrinsics.Object.GetOwnPropertyDescriptor(JsValue.Undefined, arguments);
		}

		private JsValue OwnKeys(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = arguments.At(0) as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.get called on non-object");
			}
			List<JsValue> ownPropertyKeys = obj.GetOwnPropertyKeys();
			return _realm.Intrinsics.Array.CreateArrayFromList(ownPropertyKeys);
		}

		private JsValue IsExtensible(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = arguments.At(0) as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.isExtensible called on non-object");
			}
			return obj.Extensible;
		}

		private JsValue PreventExtensions(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = arguments.At(0) as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.preventExtensions called on non-object");
			}
			return obj.PreventExtensions();
		}

		private JsValue GetPrototypeOf(JsValue thisObject, JsValue[] arguments)
		{
			if (!arguments.At(0).IsObject())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.getPrototypeOf called on non-object");
			}
			return _realm.Intrinsics.Object.GetPrototypeOf(JsValue.Undefined, arguments);
		}

		private JsValue SetPrototypeOf(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = arguments.At(0) as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Reflect.setPrototypeOf called on non-object");
			}
			JsValue jsValue = arguments.At(1);
			if (!jsValue.IsObject() && !jsValue.IsNull())
			{
				ExceptionHelper.ThrowTypeError(_realm, $"Object prototype may only be an Object or null: {jsValue}");
			}
			return obj.SetPrototypeOf(jsValue);
		}
	}
}
namespace Jint.Native.Proxy
{
	internal sealed class ProxyConstructor : Constructor
	{
		private static readonly JsString _name = new JsString("Proxy");

		private static readonly JsString PropertyProxy = new JsString("proxy");

		private static readonly JsString PropertyRevoke = new JsString("revoke");

		internal ProxyConstructor(Engine engine, Realm realm)
			: base(engine, realm, _name)
		{
			_length = new PropertyDescriptor(2, PropertyFlag.Configurable);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { ["revocable"] = new PropertyDescriptor(new ClrFunction(_engine, "revocable", Revocable, 2, PropertyFlag.Configurable), true, true, true) };
			SetProperties(properties);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return Construct(arguments.At(0), arguments.At(1));
		}

		protected internal override ObjectInstance? GetPrototypeOf()
		{
			return _realm.Intrinsics.Function.Prototype;
		}

		public JsProxy Construct(JsValue target, JsValue handler)
		{
			return ProxyCreate(target, handler);
		}

		private JsValue Revocable(JsValue thisObject, JsValue[] arguments)
		{
			JsProxy p = ProxyCreate(arguments.At(0), arguments.At(1));
			ObjectInstance objectInstance = _realm.Intrinsics.Object.Construct(System.Array.Empty<JsValue>());
			objectInstance.DefineOwnProperty(PropertyRevoke, new PropertyDescriptor(new ClrFunction(_engine, "", Revoke, 0, PropertyFlag.Configurable), PropertyFlag.ConfigurableEnumerableWritable));
			objectInstance.DefineOwnProperty(PropertyProxy, new PropertyDescriptor(p, PropertyFlag.ConfigurableEnumerableWritable));
			return objectInstance;
			JsValue Revoke(JsValue jsValue, JsValue[] array)
			{
				p._handler = null;
				p._target = null;
				return JsValue.Undefined;
			}
		}

		private JsProxy ProxyCreate(JsValue target, JsValue handler)
		{
			if (!(target is ObjectInstance target2))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Cannot create proxy with a non-object as target");
				return null;
			}
			if (!(handler is ObjectInstance handler2))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Cannot create proxy with a non-object as handler");
				return null;
			}
			return new JsProxy(base.Engine, target2, handler2);
		}
	}
}
namespace Jint.Native.Promise
{
	internal sealed record PromiseCapability(JsValue PromiseInstance, ICallable Resolve, ICallable Reject, JsValue RejectObj, JsValue ResolveObj);
	internal sealed class PromiseConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Promise");

		internal PromisePrototype PrototypeObject { get; }

		internal PromiseConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new PromisePrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(1, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(6, checkExistingKeys: false)
			{
				["all"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "all", All, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)),
				["allSettled"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "allSettled", AllSettled, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)),
				["any"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "any", Any, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)),
				["race"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "race", Race, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)),
				["reject"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "reject", Reject, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)),
				["resolve"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "resolve", Resolve, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)),
				["withResolvers"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "withResolvers", WithResolvers, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable))
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get [Symbol.species]", (JsValue thisObj, JsValue[] _) => thisObj, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Constructor Promise requires 'new'");
			}
			if (!(arguments.At(0) is ICallable callable))
			{
				ExceptionHelper.ThrowTypeError(_realm, $"Promise executor {arguments.At(0)} is not a function");
				return null;
			}
			JsPromise jsPromise = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Promise.PrototypeObject, (Engine engine, Realm _, object? _) => new JsPromise(engine));
			var (function3, function4) = jsPromise.CreateResolvingFunctions();
			try
			{
				callable.Call(JsValue.Undefined, function3, function4);
			}
			catch (JavaScriptException ex)
			{
				function4.Call(JsValue.Undefined, new JsValue[1] { ex.Error });
			}
			return jsPromise;
		}

		internal JsValue Resolve(JsValue thisObject, JsValue[] arguments)
		{
			if (!thisObject.IsObject())
			{
				ExceptionHelper.ThrowTypeError(_realm, "PromiseResolve called on non-object");
			}
			if (!(thisObject is IConstructor))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Promise.resolve invoked on a non-constructor value");
			}
			JsValue x = arguments.At(0);
			return PromiseResolve(thisObject, x);
		}

		private JsObject WithResolvers(JsValue thisObject, JsValue[] arguments)
		{
			PromiseCapability promiseCapability = NewPromiseCapability(_engine, thisObject);
			JsObject jsObject = ObjectInstance.OrdinaryObjectCreate(_engine, _engine.Realm.Intrinsics.Object.PrototypeObject);
			jsObject.CreateDataPropertyOrThrow("promise", promiseCapability.PromiseInstance);
			jsObject.CreateDataPropertyOrThrow("resolve", promiseCapability.ResolveObj);
			jsObject.CreateDataPropertyOrThrow("reject", promiseCapability.RejectObj);
			return jsObject;
		}

		private JsValue PromiseResolve(JsValue thisObject, JsValue x)
		{
			if (x.IsPromise() && JsValue.SameValue(x.Get(CommonProperties.Constructor), thisObject))
			{
				return x;
			}
			var (result, callable3, _, _, _) = NewPromiseCapability(_engine, thisObject);
			callable3.Call(JsValue.Undefined, x);
			return result;
		}

		private JsValue Reject(JsValue thisObject, JsValue[] arguments)
		{
			if (!thisObject.IsObject())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Promise.reject called on non-object");
			}
			if (!(thisObject is IConstructor))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Promise.reject invoked on a non-constructor value");
			}
			JsValue jsValue = arguments.At(0);
			var (result, _, callable3, _, _) = NewPromiseCapability(_engine, thisObject);
			callable3.Call(JsValue.Undefined, jsValue);
			return result;
		}

		private bool TryGetPromiseCapabilityAndIterator(JsValue thisObject, JsValue[] arguments, string callerName, out PromiseCapability capability, out ICallable promiseResolve, out IteratorInstance iterator)
		{
			if (!thisObject.IsObject())
			{
				ExceptionHelper.ThrowTypeError(_realm, callerName + " called on non-object");
			}
			capability = NewPromiseCapability(_engine, thisObject);
			ICallable reject = capability.Reject;
			try
			{
				promiseResolve = GetPromiseResolve(thisObject);
			}
			catch (JavaScriptException ex)
			{
				reject.Call(JsValue.Undefined, ex.Error);
				promiseResolve = null;
				iterator = null;
				return false;
			}
			try
			{
				if (arguments.Length == 0)
				{
					ExceptionHelper.ThrowTypeError(_realm, "no arguments were passed to " + callerName);
				}
				JsValue jsValue = arguments.At(0);
				iterator = jsValue.GetIterator(_realm);
			}
			catch (JavaScriptException ex2)
			{
				reject.Call(JsValue.Undefined, ex2.Error);
				iterator = null;
				return false;
			}
			return true;
		}

		private JsValue All(JsValue thisObject, JsValue[] arguments)
		{
			if (!TryGetPromiseCapabilityAndIterator(thisObject, arguments, "Promise.all", out PromiseCapability capability, out ICallable promiseResolve, out IteratorInstance iterator))
			{
				return capability.PromiseInstance;
			}
			capability.Deconstruct(out JsValue PromiseInstance, out ICallable Resolve, out ICallable Reject, out JsValue _, out JsValue ResolveObj);
			JsValue result = PromiseInstance;
			ICallable resolve = Resolve;
			ICallable callable = Reject;
			JsValue jsValue = ResolveObj;
			List<JsValue> results = new List<JsValue>();
			bool doneIterating = false;
			try
			{
				int num = 0;
				while (true)
				{
					JsValue jsValue2;
					try
					{
						if (!iterator.TryIteratorStep(out ObjectInstance nextItem))
						{
							doneIterating = true;
							ResolveIfFinished();
							return result;
						}
						jsValue2 = nextItem.Get(CommonProperties.Value);
					}
					catch (JavaScriptException ex)
					{
						callable.Call(JsValue.Undefined, ex.Error);
						return result;
					}
					results.Add(null);
					JsValue jsValue3 = promiseResolve.Call(thisObject, jsValue2);
					if (jsValue3.Get("then") is ICallable callable2)
					{
						int capturedIndex = num;
						bool alreadyCalled = false;
						ClrFunction clrFunction = new ClrFunction(_engine, "", delegate(JsValue _, JsValue[] args)
						{
							if (!alreadyCalled)
							{
								alreadyCalled = true;
								results[capturedIndex] = args.At(0);
								ResolveIfFinished();
							}
							return JsValue.Undefined;
						}, 1, PropertyFlag.Configurable);
						callable2.Call(jsValue3, clrFunction, jsValue);
					}
					else
					{
						ExceptionHelper.ThrowTypeError(_realm, "Passed non Promise-like value");
					}
					num++;
				}
			}
			catch (JavaScriptException ex2)
			{
				iterator.Close(CompletionType.Throw);
				callable.Call(JsValue.Undefined, ex2.Error);
				return result;
			}
			void ResolveIfFinished()
			{
				if (results.TrueForAll((JsValue x) => (object)x != null) && doneIterating)
				{
					JsArray jsArray = _realm.Intrinsics.Array.ConstructFast(results);
					resolve.Call(JsValue.Undefined, jsArray);
				}
			}
		}

		private JsValue AllSettled(JsValue thisObject, JsValue[] arguments)
		{
			if (!TryGetPromiseCapabilityAndIterator(thisObject, arguments, "Promise.allSettled", out PromiseCapability capability, out ICallable promiseResolve, out IteratorInstance iterator))
			{
				return capability.PromiseInstance;
			}
			capability.Deconstruct(out JsValue PromiseInstance, out ICallable Resolve, out ICallable Reject, out JsValue _, out JsValue _);
			JsValue result = PromiseInstance;
			ICallable resolve = Resolve;
			ICallable callable = Reject;
			List<JsValue> results = new List<JsValue>();
			bool doneIterating = false;
			try
			{
				int num = 0;
				while (true)
				{
					JsValue jsValue;
					try
					{
						if (!iterator.TryIteratorStep(out ObjectInstance nextItem))
						{
							doneIterating = true;
							ResolveIfFinished();
							return result;
						}
						jsValue = nextItem.Get(CommonProperties.Value);
					}
					catch (JavaScriptException ex)
					{
						callable.Call(JsValue.Undefined, ex.Error);
						return result;
					}
					results.Add(null);
					JsValue jsValue2 = promiseResolve.Call(thisObject, jsValue);
					if (jsValue2.Get("then") is ICallable callable2)
					{
						int capturedIndex = num;
						bool alreadyCalled = false;
						ClrFunction clrFunction = new ClrFunction(_engine, "", delegate(JsValue _, JsValue[] args)
						{
							if (!alreadyCalled)
							{
								alreadyCalled = true;
								ObjectInstance objectInstance = base.Engine.Realm.Intrinsics.Object.Construct(2);
								objectInstance.FastSetDataProperty("status", "fulfilled");
								objectInstance.FastSetDataProperty("value", args.At(0));
								results[capturedIndex] = objectInstance;
								ResolveIfFinished();
							}
							return JsValue.Undefined;
						}, 1, PropertyFlag.Configurable);
						ClrFunction clrFunction2 = new ClrFunction(_engine, "", delegate(JsValue _, JsValue[] args)
						{
							if (!alreadyCalled)
							{
								alreadyCalled = true;
								ObjectInstance objectInstance = base.Engine.Realm.Intrinsics.Object.Construct(2);
								objectInstance.FastSetDataProperty("status", "rejected");
								objectInstance.FastSetDataProperty("reason", args.At(0));
								results[capturedIndex] = objectInstance;
								ResolveIfFinished();
							}
							return JsValue.Undefined;
						}, 1, PropertyFlag.Configurable);
						callable2.Call(jsValue2, clrFunction, clrFunction2);
					}
					else
					{
						ExceptionHelper.ThrowTypeError(_realm, "Passed non Promise-like value");
					}
					num++;
				}
			}
			catch (JavaScriptException ex2)
			{
				iterator.Close(CompletionType.Throw);
				callable.Call(JsValue.Undefined, ex2.Error);
				return result;
			}
			void ResolveIfFinished()
			{
				if (results.TrueForAll((JsValue x) => (object)x != null) && doneIterating)
				{
					JsArray jsArray = _realm.Intrinsics.Array.ConstructFast(results);
					resolve.Call(JsValue.Undefined, jsArray);
				}
			}
		}

		private JsValue Any(JsValue thisObject, JsValue[] arguments)
		{
			if (!TryGetPromiseCapabilityAndIterator(thisObject, arguments, "Promise.any", out PromiseCapability capability, out ICallable promiseResolve, out IteratorInstance iterator))
			{
				return capability.PromiseInstance;
			}
			capability.Deconstruct(out JsValue PromiseInstance, out ICallable _, out ICallable Reject, out JsValue RejectObj, out JsValue _);
			JsValue result = PromiseInstance;
			ICallable reject = Reject;
			JsValue jsValue = RejectObj;
			List<JsValue> errors = new List<JsValue>();
			bool doneIterating = false;
			try
			{
				int num = 0;
				while (true)
				{
					ObjectInstance nextItem = null;
					JsValue jsValue2;
					try
					{
						if (!iterator.TryIteratorStep(out nextItem))
						{
							doneIterating = true;
							RejectIfAllRejected();
							return result;
						}
						jsValue2 = nextItem.Get(CommonProperties.Value);
					}
					catch (JavaScriptException ex)
					{
						if ((object)nextItem != null && nextItem.Get("done")?.AsBoolean() == false)
						{
							throw;
						}
						errors.Add(ex.Error);
						continue;
					}
					errors.Add(null);
					JsValue jsValue3 = promiseResolve.Call(thisObject, jsValue2);
					if (jsValue3.Get("then") is ICallable callable)
					{
						int capturedIndex = num;
						bool alreadyCalled = false;
						ClrFunction clrFunction = new ClrFunction(_engine, "", delegate(JsValue _, JsValue[] args)
						{
							if (!alreadyCalled)
							{
								alreadyCalled = true;
								errors[capturedIndex] = args.At(0);
								RejectIfAllRejected();
							}
							return JsValue.Undefined;
						}, 1, PropertyFlag.Configurable);
						callable.Call(jsValue3, jsValue, clrFunction);
					}
					else
					{
						ExceptionHelper.ThrowTypeError(_realm, "Passed non Promise-like value");
					}
					num++;
				}
			}
			catch (JavaScriptException ex2)
			{
				iterator.Close(CompletionType.Throw);
				reject.Call(JsValue.Undefined, ex2.Error);
				return result;
			}
			void RejectIfAllRejected()
			{
				if (errors.TrueForAll((JsValue x) => (object)x != null) && doneIterating)
				{
					JsArray jsArray = _realm.Intrinsics.Array.ConstructFast(errors);
					reject.Call(JsValue.Undefined, ObjectInstance.Construct(_realm.Intrinsics.AggregateError, new JsValue[1] { jsArray }));
				}
			}
		}

		private JsValue Race(JsValue thisObject, JsValue[] arguments)
		{
			if (!TryGetPromiseCapabilityAndIterator(thisObject, arguments, "Promise.race", out PromiseCapability capability, out ICallable promiseResolve, out IteratorInstance iterator))
			{
				return capability.PromiseInstance;
			}
			var (result, callable3, callable4, _, jsValue4) = capability;
			try
			{
				while (true)
				{
					JsValue jsValue5;
					try
					{
						if (!iterator.TryIteratorStep(out ObjectInstance nextItem))
						{
							return result;
						}
						jsValue5 = nextItem.Get(CommonProperties.Value);
					}
					catch (JavaScriptException ex)
					{
						callable4.Call(JsValue.Undefined, ex.Error);
						return result;
					}
					JsValue v = promiseResolve.Call(thisObject, jsValue5);
					_engine.Invoke(v, "then", new JsValue[2]
					{
						(JsValue)callable3,
						jsValue4
					});
				}
			}
			catch (JavaScriptException ex2)
			{
				iterator.Close(CompletionType.Throw);
				callable4.Call(JsValue.Undefined, ex2.Error);
				return result;
			}
		}

		private ICallable GetPromiseResolve(JsValue promiseConstructor)
		{
			JsValue.AssertConstructor(_engine, promiseConstructor);
			if (promiseConstructor.Get("resolve") is ICallable result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(_realm, "resolve is not a function");
			return null;
		}

		internal static PromiseCapability NewPromiseCapability(Engine engine, JsValue c)
		{
			IConstructor constructor = JsValue.AssertConstructor(engine, c);
			JsValue resolveArg = null;
			JsValue rejectArg = null;
			ClrFunction clrFunction = new ClrFunction(engine, "", Executor, 2, PropertyFlag.Configurable);
			ObjectInstance promiseInstance = constructor.Construct(new JsValue[1] { clrFunction }, c);
			ICallable resolve = null;
			ICallable reject = null;
			if (resolveArg is ICallable callable)
			{
				resolve = callable;
			}
			else
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, "resolve is not a function");
			}
			if (rejectArg is ICallable callable2)
			{
				reject = callable2;
			}
			else
			{
				ExceptionHelper.ThrowTypeError(engine.Realm, "reject is not a function");
			}
			return new PromiseCapability(promiseInstance, resolve, reject, resolveArg, rejectArg);
			JsValue Executor(JsValue thisObject, JsValue[] arguments)
			{
				if (((object)resolveArg != null && resolveArg != JsValue.Undefined) || ((object)rejectArg != null && rejectArg != JsValue.Undefined))
				{
					ExceptionHelper.ThrowTypeError(engine.Realm, "executor was already called with not undefined args");
				}
				resolveArg = arguments.At(0);
				rejectArg = arguments.At(1);
				return JsValue.Undefined;
			}
		}
	}
	internal static class PromiseOperations
	{
		private static Action NewPromiseReactionJob(PromiseReaction reaction, JsValue value)
		{
			return delegate
			{
				PromiseCapability capability = reaction.Capability;
				if (reaction.Handler is ICallable callable)
				{
					try
					{
						JsValue jsValue = callable.Call(JsValue.Undefined, value);
						capability.Resolve.Call(JsValue.Undefined, jsValue);
						return;
					}
					catch (JavaScriptException ex)
					{
						capability.Reject.Call(JsValue.Undefined, ex.Error);
						return;
					}
				}
				switch (reaction.Type)
				{
				case ReactionType.Fulfill:
					capability.Resolve.Call(JsValue.Undefined, value);
					break;
				case ReactionType.Reject:
					capability.Reject.Call(JsValue.Undefined, value);
					break;
				default:
					throw new ArgumentOutOfRangeException("reaction", "Unknown reaction type");
				}
			};
		}

		internal static Action NewPromiseResolveThenableJob(JsPromise promise, ObjectInstance thenable, ICallable thenMethod)
		{
			return delegate
			{
				var (function3, function4) = promise.CreateResolvingFunctions();
				try
				{
					thenMethod.Call(thenable, function3, function4);
				}
				catch (JavaScriptException ex)
				{
					function4.Call(JsValue.Undefined, new JsValue[1] { ex.Error });
				}
			};
		}

		internal static JsValue TriggerPromiseReactions(Engine engine, List<PromiseReaction> reactions, JsValue result)
		{
			foreach (PromiseReaction reaction in reactions)
			{
				engine.AddToEventLoop(NewPromiseReactionJob(reaction, result));
			}
			return JsValue.Undefined;
		}

		internal static JsValue PerformPromiseThen(Engine engine, JsPromise promise, JsValue onFulfilled, JsValue onRejected, PromiseCapability resultCapability)
		{
			PromiseReaction promiseReaction = new PromiseReaction(ReactionType.Fulfill, resultCapability, onFulfilled);
			PromiseReaction promiseReaction2 = new PromiseReaction(ReactionType.Reject, resultCapability, onRejected);
			switch (promise.State)
			{
			case PromiseState.Pending:
				promise.PromiseFulfillReactions.Add(promiseReaction);
				promise.PromiseRejectReactions.Add(promiseReaction2);
				break;
			case PromiseState.Fulfilled:
				engine.AddToEventLoop(NewPromiseReactionJob(promiseReaction, promise.Value));
				break;
			case PromiseState.Rejected:
				engine.AddToEventLoop(NewPromiseReactionJob(promiseReaction2, promise.Value));
				break;
			default:
				ExceptionHelper.ThrowArgumentOutOfRangeException();
				break;
			}
			if ((object)resultCapability == null)
			{
				return JsValue.Undefined;
			}
			return resultCapability.PromiseInstance;
		}
	}
	internal sealed class PromisePrototype : Prototype
	{
		private readonly PromiseConstructor _constructor;

		internal PromisePrototype(Engine engine, Realm realm, PromiseConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(5, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["then"] = new PropertyDescriptor(new ClrFunction(base.Engine, "then", Then, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["catch"] = new PropertyDescriptor(new ClrFunction(base.Engine, "catch", Catch, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["finally"] = new PropertyDescriptor(new ClrFunction(base.Engine, "finally", Finally, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor(new JsString("Promise"), PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Then(JsValue thisValue, JsValue[] arguments)
		{
			JsPromise jsPromise = thisValue as JsPromise;
			if ((object)jsPromise == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method Promise.prototype.then called on incompatible receiver");
			}
			IConstructor constructor = ObjectInstance.SpeciesConstructor(jsPromise, _realm.Intrinsics.Promise);
			PromiseCapability resultCapability = PromiseConstructor.NewPromiseCapability(_engine, (JsValue)constructor);
			return PromiseOperations.PerformPromiseThen(_engine, jsPromise, arguments.At(0), arguments.At(1), resultCapability);
		}

		private JsValue Catch(JsValue thisValue, JsValue[] arguments)
		{
			return _engine.Invoke(thisValue, "then", new JsValue[2]
			{
				JsValue.Undefined,
				arguments.At(0)
			});
		}

		private JsValue Finally(JsValue thisValue, JsValue[] arguments)
		{
			ObjectInstance objectInstance = thisValue as ObjectInstance;
			if ((object)objectInstance == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "this passed to Promise.prototype.finally is not an object");
			}
			IConstructor ctor = ObjectInstance.SpeciesConstructor(objectInstance, _realm.Intrinsics.Promise);
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2;
			JsValue jsValue3;
			if (!(jsValue is ICallable onFinally))
			{
				jsValue2 = jsValue;
				jsValue3 = jsValue;
			}
			else
			{
				jsValue2 = ThenFinallyFunctions(onFinally, ctor);
				jsValue3 = CatchFinallyFunctions(onFinally, ctor);
			}
			return _engine.Invoke(objectInstance, "then", new JsValue[2] { jsValue2, jsValue3 });
		}

		private ClrFunction ThenFinallyFunctions(ICallable onFinally, IConstructor ctor)
		{
			return new ClrFunction(_engine, "", delegate(JsValue _, JsValue[] args)
			{
				JsValue value = args.At(0);
				JsValue jsValue = onFinally.Call(JsValue.Undefined, Arguments.Empty);
				JsValue v = _realm.Intrinsics.Promise.Resolve((JsValue)ctor, new JsValue[1] { jsValue });
				ClrFunction clrFunction = new ClrFunction(_engine, "", (JsValue jsValue2, JsValue[] array) => value);
				return _engine.Invoke(v, "then", new JsValue[1] { clrFunction });
			}, 1, PropertyFlag.Configurable);
		}

		private ClrFunction CatchFinallyFunctions(ICallable onFinally, IConstructor ctor)
		{
			return new ClrFunction(_engine, "", delegate(JsValue _, JsValue[] args)
			{
				JsValue reason = args.At(0);
				JsValue jsValue = onFinally.Call(JsValue.Undefined, Arguments.Empty);
				JsValue v = _realm.Intrinsics.Promise.Resolve((JsValue)ctor, new JsValue[1] { jsValue });
				ClrFunction clrFunction = new ClrFunction(_engine, "", delegate
				{
					throw new JavaScriptException(reason);
				});
				return _engine.Invoke(v, "then", new JsValue[1] { clrFunction });
			}, 1, PropertyFlag.Configurable);
		}
	}
	internal enum PromiseState
	{
		Pending,
		Fulfilled,
		Rejected
	}
	internal enum ReactionType
	{
		Fulfill,
		Reject
	}
	internal sealed record PromiseReaction(ReactionType Type, PromiseCapability Capability, JsValue Handler);
	internal sealed record ResolvingFunctions(Jint.Native.Function.Function Resolve, Jint.Native.Function.Function Reject);
	public sealed record ManualPromise(JsValue Promise, Action<JsValue> Resolve, Action<JsValue> Reject);
}
namespace Jint.Native.Object
{
	[Flags]
	internal enum ObjectChangeFlags
	{
		None = 0,
		Property = 1,
		Symbol = 2,
		ArrayIndex = 4,
		NonDefaultDataDescriptorUsage = 8
	}
	internal enum ObjectClass : byte
	{
		Arguments,
		Boolean,
		Date,
		Error,
		Function,
		Number,
		Object,
		RegExp,
		String
	}
	public sealed class ObjectConstructor : Constructor
	{
		private sealed class CreateDataPropertyOnObject : ICallable
		{
			internal static readonly CreateDataPropertyOnObject Instance = new CreateDataPropertyOnObject();

			private CreateDataPropertyOnObject()
			{
			}

			public JsValue Call(JsValue thisObject, params JsValue[] arguments)
			{
				ObjectInstance obj = (ObjectInstance)thisObject;
				JsValue o = arguments.At(0);
				JsValue v = arguments.At(1);
				JsValue p = TypeConverter.ToPropertyKey(o);
				obj.CreateDataPropertyOrThrow(p, v);
				return JsValue.Undefined;
			}
		}

		private static readonly JsString _name = new JsString("Object");

		public ObjectPrototype PrototypeObject { get; }

		internal ObjectConstructor(Engine engine, Realm realm)
			: base(engine, realm, _name)
		{
			PrototypeObject = new ObjectPrototype(engine, realm, this);
			_length = PropertyDescriptor.AllForbiddenDescriptor.NumberOne;
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			_prototype = _realm.Intrinsics.Function.PrototypeObject;
			PropertyDictionary properties = new PropertyDictionary(16, checkExistingKeys: false)
			{
				["assign"] = new PropertyDescriptor(new ClrFunction(base.Engine, "assign", Assign, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["entries"] = new PropertyDescriptor(new ClrFunction(base.Engine, "entries", Entries, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["fromEntries"] = new PropertyDescriptor(new ClrFunction(base.Engine, "fromEntries", FromEntries, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getPrototypeOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getPrototypeOf", GetPrototypeOf, 1), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getOwnPropertyDescriptor"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getOwnPropertyDescriptor", GetOwnPropertyDescriptor, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getOwnPropertyDescriptors"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getOwnPropertyDescriptors", GetOwnPropertyDescriptors, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getOwnPropertyNames"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getOwnPropertyNames", GetOwnPropertyNames, 1), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getOwnPropertySymbols"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getOwnPropertySymbols", GetOwnPropertySymbols, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["groupBy"] = new PropertyDescriptor(new ClrFunction(base.Engine, "groupBy", GroupBy, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["create"] = new PropertyDescriptor(new ClrFunction(base.Engine, "create", Create, 2), PropertyFlag.Writable | PropertyFlag.Configurable),
				["defineProperty"] = new PropertyDescriptor(new ClrFunction(base.Engine, "defineProperty", DefineProperty, 3), PropertyFlag.Writable | PropertyFlag.Configurable),
				["defineProperties"] = new PropertyDescriptor(new ClrFunction(base.Engine, "defineProperties", DefineProperties, 2), PropertyFlag.Writable | PropertyFlag.Configurable),
				["is"] = new PropertyDescriptor(new ClrFunction(base.Engine, "is", Is, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["seal"] = new PropertyDescriptor(new ClrFunction(base.Engine, "seal", Seal, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["freeze"] = new PropertyDescriptor(new ClrFunction(base.Engine, "freeze", Freeze, 1), PropertyFlag.Writable | PropertyFlag.Configurable),
				["preventExtensions"] = new PropertyDescriptor(new ClrFunction(base.Engine, "preventExtensions", PreventExtensions, 1), PropertyFlag.Writable | PropertyFlag.Configurable),
				["isSealed"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isSealed", IsSealed, 1), PropertyFlag.Writable | PropertyFlag.Configurable),
				["isFrozen"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isFrozen", IsFrozen, 1), PropertyFlag.Writable | PropertyFlag.Configurable),
				["isExtensible"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isExtensible", IsExtensible, 1), PropertyFlag.Writable | PropertyFlag.Configurable),
				["keys"] = new PropertyDescriptor(new ClrFunction(base.Engine, "keys", Keys, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["values"] = new PropertyDescriptor(new ClrFunction(base.Engine, "values", Values, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setPrototypeOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setPrototypeOf", SetPrototypeOf, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["hasOwn"] = new PropertyDescriptor(new ClrFunction(base.Engine, "hasOwn", HasOwn, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
		}

		private JsValue Assign(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, arguments.At(0));
			if (arguments.Length < 2)
			{
				return objectInstance;
			}
			for (int i = 1; i < arguments.Length; i++)
			{
				JsValue value = arguments[i];
				if (value.IsNullOrUndefined())
				{
					continue;
				}
				ObjectInstance objectInstance2 = TypeConverter.ToObject(_realm, value);
				foreach (JsValue ownPropertyKey in objectInstance2.GetOwnPropertyKeys())
				{
					PropertyDescriptor ownProperty = objectInstance2.GetOwnProperty(ownPropertyKey);
					if (ownProperty != PropertyDescriptor.Undefined && ownProperty.Enumerable)
					{
						JsValue v = objectInstance2.Get(ownPropertyKey);
						objectInstance.Set(ownPropertyKey, v, throwOnError: true);
					}
				}
			}
			return objectInstance;
		}

		private JsValue Entries(JsValue thisObject, JsValue[] arguments)
		{
			return TypeConverter.ToObject(_realm, arguments.At(0)).EnumerableOwnProperties(EnumerableOwnPropertyNamesKind.KeyValue);
		}

		private JsValue FromEntries(JsValue thisObject, JsValue[] arguments)
		{
			JsValue o = arguments.At(0);
			TypeConverter.CheckObjectCoercible(_engine, o);
			ObjectInstance objectInstance = _realm.Intrinsics.Object.Construct(0);
			CreateDataPropertyOnObject instance = CreateDataPropertyOnObject.Instance;
			IteratorInstance iterator = arguments.At(0).GetIterator(_realm);
			IteratorProtocol.AddEntriesFromIterable(objectInstance, iterator, instance);
			return objectInstance;
		}

		private static JsValue Is(JsValue thisObject, JsValue[] arguments)
		{
			return JsValue.SameValue(arguments.At(0), arguments.At(1));
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			if (arguments.Length == 0)
			{
				return Construct(arguments);
			}
			if (arguments[0].IsNullOrUndefined())
			{
				return Construct(arguments);
			}
			return TypeConverter.ToObject(_realm, arguments[0]);
		}

		public ObjectInstance Construct(JsValue[] arguments)
		{
			return Construct(arguments, this);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if ((object)this != newTarget && !newTarget.IsUndefined())
			{
				return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Object.PrototypeObject, (Engine engine, Realm _, object? _) => new JsObject(engine));
			}
			if (arguments.Length != 0)
			{
				JsValue jsValue = arguments[0];
				if (jsValue is ObjectInstance result)
				{
					return result;
				}
				Types type = jsValue.Type;
				if ((type == Types.Boolean || type == Types.String || type == Types.Number) ? true : false)
				{
					return TypeConverter.ToObject(_realm, jsValue);
				}
			}
			return new JsObject(_engine);
		}

		internal ObjectInstance Construct(int propertyCount)
		{
			JsObject jsObject = new JsObject(_engine);
			jsObject.SetProperties((propertyCount > 0) ? new PropertyDictionary(propertyCount, checkExistingKeys: true) : null);
			return jsObject;
		}

		public JsValue GetPrototypeOf(JsValue thisObject, JsValue[] arguments)
		{
			return TypeConverter.ToObject(_realm, arguments.At(0)).Prototype ?? JsValue.Null;
		}

		private JsValue SetPrototypeOf(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			TypeConverter.CheckObjectCoercible(_engine, jsValue);
			JsValue jsValue2 = arguments.At(1);
			if (!jsValue2.IsObject() && !jsValue2.IsNull())
			{
				ExceptionHelper.ThrowTypeError(_realm, $"Object prototype may only be an Object or null: {jsValue2}");
			}
			if (!(jsValue is ObjectInstance objectInstance))
			{
				return jsValue;
			}
			if (!objectInstance.SetPrototypeOf(jsValue2))
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return objectInstance;
		}

		private JsValue HasOwn(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, arguments.At(0));
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(1));
			if (!objectInstance.HasOwnProperty(property))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		internal JsValue GetOwnPropertyDescriptor(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, arguments.At(0));
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(1));
			PropertyDescriptor ownProperty = objectInstance.GetOwnProperty(property);
			return PropertyDescriptor.FromPropertyDescriptor(base.Engine, ownProperty);
		}

		private JsValue GetOwnPropertyDescriptors(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, arguments.At(0));
			List<JsValue> ownPropertyKeys = objectInstance.GetOwnPropertyKeys();
			ObjectInstance objectInstance2 = _realm.Intrinsics.Object.Construct(0);
			foreach (JsValue item in ownPropertyKeys)
			{
				PropertyDescriptor ownProperty = objectInstance.GetOwnProperty(item);
				JsValue jsValue = PropertyDescriptor.FromPropertyDescriptor(base.Engine, ownProperty);
				if ((object)jsValue != JsValue.Undefined)
				{
					objectInstance2.CreateDataProperty(item, jsValue);
				}
			}
			return objectInstance2;
		}

		private JsValue GetOwnPropertyNames(JsValue thisObject, JsValue[] arguments)
		{
			List<JsValue> ownPropertyKeys = TypeConverter.ToObject(_realm, arguments.At(0)).GetOwnPropertyKeys(Types.String);
			return _realm.Intrinsics.Array.ConstructFast(ownPropertyKeys);
		}

		private JsValue GetOwnPropertySymbols(JsValue thisObject, JsValue[] arguments)
		{
			List<JsValue> ownPropertyKeys = TypeConverter.ToObject(_realm, arguments.At(0)).GetOwnPropertyKeys(Types.Symbol);
			return _realm.Intrinsics.Array.ConstructFast(ownPropertyKeys);
		}

		private JsValue Create(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsObject() && !jsValue.IsNull())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Object prototype may only be an Object or null: " + jsValue);
			}
			ObjectInstance objectInstance = base.Engine.Realm.Intrinsics.Object.Construct(Arguments.Empty);
			objectInstance._prototype = (jsValue.IsNull() ? null : jsValue.AsObject());
			JsValue jsValue2 = arguments.At(1);
			if (!jsValue2.IsUndefined())
			{
				ObjectDefineProperties(objectInstance, jsValue2);
			}
			return objectInstance;
		}

		private JsValue DefineProperty(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is ObjectInstance objectInstance))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Object.defineProperty called on non-object");
				return null;
			}
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(1));
			JsValue o = arguments.At(2);
			PropertyDescriptor desc = PropertyDescriptor.ToPropertyDescriptor(_realm, o);
			objectInstance.DefinePropertyOrThrow(property, desc);
			return arguments.At(0);
		}

		private JsValue DefineProperties(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = arguments.At(0) as ObjectInstance;
			if ((object)objectInstance == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Object.defineProperty called on non-object");
			}
			JsValue properties = arguments.At(1);
			return ObjectDefineProperties(objectInstance, properties);
		}

		private JsValue ObjectDefineProperties(ObjectInstance o, JsValue properties)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, properties);
			List<JsValue> ownPropertyKeys = objectInstance.GetOwnPropertyKeys();
			List<KeyValuePair<JsValue, PropertyDescriptor>> list = new List<KeyValuePair<JsValue, PropertyDescriptor>>();
			for (int i = 0; i < ownPropertyKeys.Count; i++)
			{
				JsValue jsValue = ownPropertyKeys[i];
				PropertyDescriptor ownProperty = objectInstance.GetOwnProperty(jsValue);
				if (ownProperty != PropertyDescriptor.Undefined && ownProperty.Enumerable)
				{
					JsValue o2 = objectInstance.Get(jsValue);
					PropertyDescriptor value = PropertyDescriptor.ToPropertyDescriptor(_realm, o2);
					list.Add(new KeyValuePair<JsValue, PropertyDescriptor>(jsValue, value));
				}
			}
			foreach (KeyValuePair<JsValue, PropertyDescriptor> item in list)
			{
				o.DefinePropertyOrThrow(item.Key, item.Value);
			}
			return o;
		}

		private JsValue Seal(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is ObjectInstance objectInstance))
			{
				return arguments.At(0);
			}
			if (!objectInstance.SetIntegrityLevel(IntegrityLevel.Sealed))
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return objectInstance;
		}

		private JsValue Freeze(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is ObjectInstance objectInstance))
			{
				return arguments.At(0);
			}
			if (!objectInstance.SetIntegrityLevel(IntegrityLevel.Frozen))
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return objectInstance;
		}

		private JsValue PreventExtensions(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is ObjectInstance objectInstance))
			{
				return arguments.At(0);
			}
			if (!objectInstance.PreventExtensions())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return objectInstance;
		}

		private static JsValue IsSealed(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is ObjectInstance o))
			{
				return JsBoolean.True;
			}
			return TestIntegrityLevel(o, IntegrityLevel.Sealed);
		}

		private static JsValue IsFrozen(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is ObjectInstance o))
			{
				return JsBoolean.True;
			}
			return TestIntegrityLevel(o, IntegrityLevel.Frozen);
		}

		private static JsValue TestIntegrityLevel(ObjectInstance o, IntegrityLevel level)
		{
			if (o.Extensible)
			{
				return JsBoolean.False;
			}
			foreach (JsValue ownPropertyKey in o.GetOwnPropertyKeys())
			{
				PropertyDescriptor ownProperty = o.GetOwnProperty(ownPropertyKey);
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					if (ownProperty.Configurable)
					{
						return JsBoolean.False;
					}
					if (level == IntegrityLevel.Frozen && ownProperty.IsDataDescriptor() && ownProperty.Writable)
					{
						return JsBoolean.False;
					}
				}
			}
			return JsBoolean.True;
		}

		private static JsValue IsExtensible(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is ObjectInstance objectInstance))
			{
				return JsBoolean.False;
			}
			return objectInstance.Extensible;
		}

		private JsValue Keys(JsValue thisObject, JsValue[] arguments)
		{
			return TypeConverter.ToObject(_realm, arguments.At(0)).EnumerableOwnProperties(EnumerableOwnPropertyNamesKind.Key);
		}

		private JsValue Values(JsValue thisObject, JsValue[] arguments)
		{
			return TypeConverter.ToObject(_realm, arguments.At(0)).EnumerableOwnProperties(EnumerableOwnPropertyNamesKind.Value);
		}

		private JsValue GroupBy(JsValue thisObject, JsValue[] arguments)
		{
			JsValue items = arguments.At(0);
			JsValue callbackfn = arguments.At(1);
			Dictionary<JsValue, JsArray> dictionary = GroupByHelper.GroupBy(_engine, _realm, items, callbackfn, mapMode: false);
			JsObject jsObject = ObjectInstance.OrdinaryObjectCreate(_engine, null);
			foreach (KeyValuePair<JsValue, JsArray> item in dictionary)
			{
				jsObject.FastSetProperty(item.Key, new PropertyDescriptor(item.Value, PropertyFlag.ConfigurableEnumerableWritable));
			}
			return jsObject;
		}
	}
	[DebuggerTypeProxy(typeof(ObjectInstanceDebugView))]
	public class ObjectInstance : JsValue, IEquatable<ObjectInstance>
	{
		internal enum EnumerableOwnPropertyNamesKind
		{
			Key,
			Value,
			KeyValue
		}

		internal enum IntegrityLevel
		{
			Sealed,
			Frozen
		}

		private sealed class ObjectInstanceDebugView
		{
			private readonly ObjectInstance _obj;

			public ObjectInstance? Prototype => _obj.Prototype;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public KeyValuePair<JsValue, JsValue>[] Entries
			{
				get
				{
					KeyValuePair<JsValue, JsValue>[] array = new KeyValuePair<JsValue, JsValue>[(_obj._properties?.Count ?? 0) + (_obj._symbols?.Count ?? 0)];
					int num = 0;
					if (_obj._properties != null)
					{
						foreach (KeyValuePair<Key, PropertyDescriptor> item in (IEnumerable<KeyValuePair<Key, PropertyDescriptor>>)_obj._properties)
						{
							array[num++] = new KeyValuePair<JsValue, JsValue>(item.Key.Name, UnwrapJsValue(item.Value, _obj));
						}
					}
					if (_obj._symbols != null)
					{
						foreach (KeyValuePair<JsSymbol, PropertyDescriptor> symbol in _obj._symbols)
						{
							array[num++] = new KeyValuePair<JsValue, JsValue>(symbol.Key, UnwrapJsValue(symbol.Value, _obj));
						}
					}
					return array;
				}
			}

			public ObjectInstanceDebugView(ObjectInstance obj)
			{
				_obj = obj;
			}

			private string DebugToString()
			{
				return new JsonSerializer(_obj._engine).Serialize(_obj, JsValue.Undefined, "  ").ToString();
			}
		}

		private bool _initialized;

		private readonly ObjectClass _class;

		internal PropertyDictionary? _properties;

		internal SymbolDictionary? _symbols;

		internal ObjectInstance? _prototype;

		protected readonly Engine _engine;

		private static readonly PropertyDescriptor _marker = new PropertyDescriptor(JsValue.Undefined, PropertyFlag.ConfigurableEnumerableWritable);

		private Dictionary<PrivateName, PrivateElement>? _privateElements;

		public Engine Engine
		{
			[DebuggerStepThrough]
			get
			{
				return _engine;
			}
		}

		public ObjectInstance? Prototype
		{
			[DebuggerStepThrough]
			get
			{
				return GetPrototypeOf();
			}
			set
			{
				SetPrototypeOf(value);
			}
		}

		public virtual bool Extensible { get; private set; }

		internal PropertyDictionary? Properties
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerStepThrough]
			get
			{
				return _properties;
			}
		}

		internal ObjectClass Class
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[DebuggerStepThrough]
			get
			{
				return _class;
			}
		}

		public JsValue this[JsValue property]
		{
			get
			{
				return Get(property);
			}
			set
			{
				Set(property, value);
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal bool IsConcatSpreadable
		{
			get
			{
				JsValue jsValue = Get(GlobalSymbolRegistry.IsConcatSpreadable);
				if (!jsValue.IsUndefined())
				{
					return TypeConverter.ToBoolean(jsValue);
				}
				return IsArray();
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal virtual bool IsArrayLike
		{
			get
			{
				if (TryGetValue(CommonProperties.Length, out JsValue value) && value.IsNumber())
				{
					return ((JsNumber)value)._value >= 0.0;
				}
				return false;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal virtual bool HasOriginalIterator => false;

		internal override bool IsIntegerIndexedArray => false;

		protected ObjectInstance(Engine engine)
			: this(engine, ObjectClass.Object, InternalTypes.Object)
		{
		}

		internal ObjectInstance(Engine engine, ObjectClass objectClass = ObjectClass.Object, InternalTypes type = InternalTypes.Object)
			: base(type)
		{
			_engine = engine;
			_class = objectClass;
			_prototype = engine.Realm.Intrinsics?.Object?.PrototypeObject;
			Extensible = true;
		}

		internal static ObjectInstance Construct(IConstructor f, JsValue[]? argumentsList = null, IConstructor? newTarget = null)
		{
			if (newTarget == null)
			{
				newTarget = f;
			}
			if (argumentsList == null)
			{
				argumentsList = System.Array.Empty<JsValue>();
			}
			return f.Construct(argumentsList, (JsValue)newTarget);
		}

		internal static IConstructor SpeciesConstructor(ObjectInstance o, IConstructor defaultConstructor)
		{
			JsValue jsValue = o.Get(CommonProperties.Constructor);
			if (jsValue.IsUndefined())
			{
				return defaultConstructor;
			}
			ObjectInstance obj = jsValue as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(o._engine.Realm);
			}
			JsValue jsValue2 = obj.Get(GlobalSymbolRegistry.Species);
			if (jsValue2.IsNullOrUndefined())
			{
				return defaultConstructor;
			}
			if (jsValue2.IsConstructor)
			{
				return (IConstructor)jsValue2;
			}
			ExceptionHelper.ThrowTypeError(o._engine.Realm);
			return null;
		}

		internal void SetProperties(StringDictionarySlim<PropertyDescriptor> properties)
		{
			SetProperties(new PropertyDictionary(properties));
		}

		internal void SetProperties(PropertyDictionary? properties)
		{
			if (properties != null)
			{
				properties.CheckExistingKeys = true;
			}
			_properties = properties;
		}

		internal void SetSymbols(SymbolDictionary? symbols)
		{
			_symbols = symbols;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetProperty(JsValue property, PropertyDescriptor value)
		{
			if (property is JsString jsString)
			{
				SetProperty(jsString.ToString(), value);
			}
			else
			{
				SetPropertyUnlikely(property, value);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetProperty(string property, PropertyDescriptor value)
		{
			Key property2 = property;
			SetProperty(property2, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetProperty(Key property, PropertyDescriptor value)
		{
			if (_properties == null)
			{
				_properties = new PropertyDictionary();
			}
			_properties[property] = value;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void SetPropertyUnlikely(JsValue property, PropertyDescriptor value)
		{
			JsValue jsValue = TypeConverter.ToPropertyKey(property);
			if (!property.IsSymbol())
			{
				if (_properties == null)
				{
					_properties = new PropertyDictionary();
				}
				_properties[TypeConverter.ToString(jsValue)] = value;
			}
			else
			{
				if (_symbols == null)
				{
					_symbols = new SymbolDictionary();
				}
				_symbols[(JsSymbol)jsValue] = value;
			}
		}

		internal void ClearProperties()
		{
			_properties?.Clear();
			_symbols?.Clear();
		}

		public virtual IEnumerable<KeyValuePair<JsValue, PropertyDescriptor>> GetOwnProperties()
		{
			EnsureInitialized();
			if (_properties != null)
			{
				foreach (KeyValuePair<Key, PropertyDescriptor> item in (IEnumerable<KeyValuePair<Key, PropertyDescriptor>>)_properties)
				{
					yield return new KeyValuePair<JsValue, PropertyDescriptor>(new JsString(item.Key), item.Value);
				}
			}
			if (_symbols == null)
			{
				yield break;
			}
			foreach (KeyValuePair<JsSymbol, PropertyDescriptor> symbol in _symbols)
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(symbol.Key, symbol.Value);
			}
		}

		public virtual List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			EnsureInitialized();
			int num;
			if ((types & Types.Symbol) != Types.Empty)
			{
				SymbolDictionary? symbols = _symbols;
				num = ((symbols != null && symbols.Count > 0) ? 1 : 0);
			}
			else
			{
				num = 0;
			}
			bool flag = (byte)num != 0;
			int num2;
			if ((types & Types.String) != Types.Empty)
			{
				PropertyDictionary? properties = _properties;
				num2 = ((properties != null && properties.Count > 0) ? 1 : 0);
			}
			else
			{
				num2 = 0;
			}
			bool flag2 = (byte)num2 != 0;
			List<JsValue> list = new List<JsValue>();
			if ((types & Types.String) != Types.Empty)
			{
				IEnumerable<JsValue> initialOwnStringPropertyKeys = GetInitialOwnStringPropertyKeys();
				if (initialOwnStringPropertyKeys != Enumerable.Empty<JsValue>())
				{
					list.AddRange(initialOwnStringPropertyKeys);
				}
			}
			if (!flag)
			{
				if (!flag2)
				{
					return list;
				}
				int count = list.Count;
				list.Capacity += _properties.Count;
				{
					foreach (KeyValuePair<Key, PropertyDescriptor> item in (IEnumerable<KeyValuePair<Key, PropertyDescriptor>>)_properties)
					{
						if (char.IsDigit((item.Key.Name.Length > 0) ? item.Key.Name[0] : 'a') && count + _properties.Count > 1)
						{
							list.RemoveRange(count, list.Count - count);
							return GetOwnPropertyKeysSorted(list, flag2, flag);
						}
						list.Add(new JsString(item.Key.Name));
					}
					return list;
				}
			}
			if ((types & Types.String) == 0 && (types & Types.Symbol) != Types.Empty)
			{
				if (_symbols != null)
				{
					foreach (KeyValuePair<JsSymbol, PropertyDescriptor> symbol in _symbols)
					{
						list.Add(symbol.Key);
					}
				}
				return list;
			}
			return GetOwnPropertyKeysSorted(list, flag2, flag);
		}

		private List<JsValue> GetOwnPropertyKeysSorted(List<JsValue> initialOwnPropertyKeys, bool returningStringKeys, bool returningSymbols)
		{
			List<JsValue> list = new List<JsValue>(_properties?.Count ?? _symbols?.Count ?? initialOwnPropertyKeys.Count);
			if (returningStringKeys && _properties != null)
			{
				foreach (KeyValuePair<Key, PropertyDescriptor> item in (IEnumerable<KeyValuePair<Key, PropertyDescriptor>>)_properties)
				{
					string name = item.Key.Name;
					uint num = ArrayInstance.ParseArrayIndex(name);
					if ((ulong)num < 4294967295uL)
					{
						list.Add(JsString.Create(num));
					}
					else
					{
						initialOwnPropertyKeys.Add(new JsString(name));
					}
				}
			}
			list.Sort((JsValue v1, JsValue v2) => TypeConverter.ToNumber(v1).CompareTo(TypeConverter.ToNumber(v2)));
			list.AddRange(initialOwnPropertyKeys);
			if (returningSymbols)
			{
				foreach (KeyValuePair<JsSymbol, PropertyDescriptor> symbol in _symbols)
				{
					list.Add(symbol.Key);
				}
			}
			return list;
		}

		internal virtual IEnumerable<JsValue> GetInitialOwnStringPropertyKeys()
		{
			return Enumerable.Empty<JsValue>();
		}

		[Obsolete("Will be removed")]
		protected virtual void AddProperty(JsValue property, PropertyDescriptor descriptor)
		{
			SetProperty(property, descriptor);
		}

		protected virtual bool TryGetProperty(JsValue property, [NotNullWhen(true)] out PropertyDescriptor? descriptor)
		{
			descriptor = null;
			JsValue jsValue = TypeConverter.ToPropertyKey(property);
			if (!jsValue.IsSymbol())
			{
				return _properties?.TryGetValue(TypeConverter.ToString(jsValue), out descriptor) ?? false;
			}
			return _symbols?.TryGetValue((JsSymbol)jsValue, out descriptor) ?? false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool HasOwnProperty(JsValue property)
		{
			return GetOwnProperty(property) != PropertyDescriptor.Undefined;
		}

		public virtual void RemoveOwnProperty(JsValue property)
		{
			EnsureInitialized();
			JsValue jsValue = TypeConverter.ToPropertyKey(property);
			if (!jsValue.IsSymbol())
			{
				_properties?.Remove(TypeConverter.ToString(jsValue));
			}
			else
			{
				_symbols?.Remove((JsSymbol)jsValue);
			}
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			if ((_type & InternalTypes.PlainObject) != InternalTypes.Empty && (object)this == receiver && property is JsString jsString)
			{
				EnsureInitialized();
				PropertyDictionary? properties = _properties;
				if (properties != null && properties.TryGetValue(jsString.ToString(), out PropertyDescriptor value))
				{
					return UnwrapJsValue(value, receiver);
				}
			}
			else
			{
				PropertyDescriptor ownProperty = GetOwnProperty(property);
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					return UnwrapJsValue(ownProperty, receiver);
				}
			}
			return Prototype?.Get(property, receiver) ?? JsValue.Undefined;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal JsValue UnwrapJsValue(PropertyDescriptor desc)
		{
			return UnwrapJsValue(desc, this);
		}

		internal static JsValue UnwrapJsValue(PropertyDescriptor desc, JsValue thisObject)
		{
			JsValue jsValue = (((desc._flags & PropertyFlag.CustomJsValue) != PropertyFlag.None) ? desc.CustomValue : desc._value);
			if ((desc._flags & (PropertyFlag.Writable | PropertyFlag.WritableSet)) != PropertyFlag.None || (object)jsValue != null)
			{
				return jsValue ?? JsValue.Undefined;
			}
			return UnwrapFromGetter(desc, thisObject);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static JsValue UnwrapFromGetter(PropertyDescriptor desc, JsValue thisObject)
		{
			JsValue jsValue = desc.Get ?? JsValue.Undefined;
			if (jsValue.IsUndefined())
			{
				return JsValue.Undefined;
			}
			Jint.Native.Function.Function function = (Jint.Native.Function.Function)jsValue;
			return function._engine.Call(function, thisObject);
		}

		public virtual PropertyDescriptor GetOwnProperty(JsValue property)
		{
			EnsureInitialized();
			PropertyDescriptor value = null;
			JsValue jsValue = TypeConverter.ToPropertyKey(property);
			if (!jsValue.IsSymbol())
			{
				_properties?.TryGetValue(TypeConverter.ToString(jsValue), out value);
			}
			else
			{
				_symbols?.TryGetValue((JsSymbol)jsValue, out value);
			}
			return value ?? PropertyDescriptor.Undefined;
		}

		protected internal virtual void SetOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			EnsureInitialized();
			SetProperty(property, desc);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Obsolete("Use Get or GetOwnProperty")]
		public PropertyDescriptor GetProperty(JsValue property)
		{
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				return ownProperty;
			}
			return Prototype?.GetProperty(property) ?? PropertyDescriptor.Undefined;
		}

		public bool TryGetValue(JsValue property, out JsValue value)
		{
			value = JsValue.Undefined;
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				JsValue value2 = ownProperty.Value;
				if (ownProperty.WritableSet && (object)value2 != null)
				{
					value = value2;
					return true;
				}
				JsValue jsValue = ownProperty.Get ?? JsValue.Undefined;
				if (jsValue.IsUndefined())
				{
					value = JsValue.Undefined;
					return false;
				}
				ICallable callable = (ICallable)jsValue;
				value = callable.Call(this, Arguments.Empty);
				return true;
			}
			return Prototype?.TryGetValue(property, out value) ?? false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Set(JsValue p, JsValue v, bool throwOnError)
		{
			if (!Set(p, v) && throwOnError)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Set(JsValue property, JsValue value)
		{
			if ((_type & InternalTypes.PlainObject) != InternalTypes.Empty && property is JsString jsString)
			{
				PropertyDictionary? properties = _properties;
				if (properties != null && properties.TryGetValue(jsString.ToString(), out PropertyDescriptor value2) && (value2._flags & PropertyFlag.Writable) != PropertyFlag.None)
				{
					value2._value = value;
					return true;
				}
			}
			return Set(property, value, this);
		}

		public override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			if ((_type & InternalTypes.PlainObject) != InternalTypes.Empty && (object)this == receiver && property is JsString jsString)
			{
				Key key = jsString.ToString();
				PropertyDictionary? properties = _properties;
				if (properties != null && properties.TryGetValue(key, out PropertyDescriptor value2) && (value2._flags & PropertyFlag.Writable) != PropertyFlag.None)
				{
					value2._value = value;
					return true;
				}
			}
			return SetUnlikely(property, value, receiver);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private bool SetUnlikely(JsValue property, JsValue value, JsValue receiver)
		{
			PropertyDescriptor propertyDescriptor = GetOwnProperty(property);
			if (propertyDescriptor == PropertyDescriptor.Undefined)
			{
				ObjectInstance prototypeOf = GetPrototypeOf();
				if ((object)prototypeOf != null)
				{
					return prototypeOf.Set(property, value, receiver);
				}
				propertyDescriptor = _marker;
			}
			if (propertyDescriptor.IsDataDescriptor())
			{
				if (!propertyDescriptor.Writable)
				{
					return false;
				}
				if (!(receiver is ObjectInstance objectInstance))
				{
					return false;
				}
				PropertyDescriptor ownProperty = objectInstance.GetOwnProperty(property);
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					if (ownProperty.IsAccessorDescriptor())
					{
						return false;
					}
					if (!ownProperty.Writable)
					{
						return false;
					}
					PropertyDescriptor desc = new PropertyDescriptor(value, PropertyFlag.None);
					return objectInstance.DefineOwnProperty(property, desc);
				}
				return objectInstance.CreateDataProperty(property, value);
			}
			if (!(propertyDescriptor.Set is Jint.Native.Function.Function function))
			{
				return false;
			}
			_engine.Call(function, receiver, new JsValue[1] { value }, null);
			return true;
		}

		internal bool CanPut(JsValue property)
		{
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty != PropertyDescriptor.Undefined)
			{
				if (ownProperty.IsAccessorDescriptor())
				{
					JsValue set = ownProperty.Set;
					if ((object)set == null || set.IsUndefined())
					{
						return false;
					}
					return true;
				}
				return ownProperty.Writable;
			}
			if ((object)Prototype == null)
			{
				return Extensible;
			}
			PropertyDescriptor ownProperty2 = Prototype.GetOwnProperty(property);
			if (ownProperty2 == PropertyDescriptor.Undefined)
			{
				return Extensible;
			}
			if (ownProperty2.IsAccessorDescriptor())
			{
				JsValue set2 = ownProperty2.Set;
				if ((object)set2 == null || set2.IsUndefined())
				{
					return false;
				}
				return true;
			}
			if (!Extensible)
			{
				return false;
			}
			return ownProperty2.Writable;
		}

		public virtual bool HasProperty(JsValue property)
		{
			JsValue property2 = TypeConverter.ToPropertyKey(property);
			if (GetOwnProperty(property2) != PropertyDescriptor.Undefined)
			{
				return true;
			}
			return GetPrototypeOf()?.HasProperty(property2) ?? false;
		}

		internal bool DeletePropertyOrThrow(JsValue property)
		{
			if (!Delete(property))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return true;
		}

		public virtual bool Delete(JsValue property)
		{
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty == PropertyDescriptor.Undefined)
			{
				return true;
			}
			if (ownProperty.Configurable)
			{
				RemoveOwnProperty(property);
				return true;
			}
			return false;
		}

		internal bool DefinePropertyOrThrow(JsValue property, PropertyDescriptor desc)
		{
			if (!DefineOwnProperty(property, desc))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Cannot redefine property: " + property);
			}
			return true;
		}

		public virtual bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty == desc)
			{
				return true;
			}
			return ValidateAndApplyPropertyDescriptor(this, property, Extensible, desc, ownProperty);
		}

		protected static bool ValidateAndApplyPropertyDescriptor(ObjectInstance? o, JsValue property, bool extensible, PropertyDescriptor desc, PropertyDescriptor current)
		{
			JsValue value = desc.Value;
			if (current == PropertyDescriptor.Undefined)
			{
				if (!extensible)
				{
					return false;
				}
				if ((object)o != null)
				{
					if (desc.IsGenericDescriptor() || desc.IsDataDescriptor())
					{
						PropertyDescriptor desc2 = (((desc._flags & PropertyFlag.ConfigurableEnumerableWritable) == PropertyFlag.ConfigurableEnumerableWritable) ? new PropertyDescriptor(value ?? JsValue.Undefined, PropertyFlag.ConfigurableEnumerableWritable) : (((desc._flags & PropertyFlag.ConfigurableEnumerableWritable) != PropertyFlag.None) ? new PropertyDescriptor(desc)
						{
							Value = (value ?? JsValue.Undefined)
						} : new PropertyDescriptor(value ?? JsValue.Undefined, PropertyFlag.AllForbidden)));
						o.SetOwnProperty(property, desc2);
					}
					else
					{
						GetSetPropertyDescriptor desc3 = new GetSetPropertyDescriptor(desc.Get, desc.Set, PropertyFlag.None)
						{
							Enumerable = desc.Enumerable,
							Configurable = desc.Configurable
						};
						o.SetOwnProperty(property, desc3);
					}
				}
				return true;
			}
			JsValue get = current.Get;
			JsValue set = current.Set;
			JsValue value2 = current.Value;
			if ((current._flags & PropertyFlag.AllForbidden) == 0 && (object)get == null && (object)set == null && (object)value2 == null)
			{
				return true;
			}
			JsValue get2 = desc.Get;
			JsValue set2 = desc.Set;
			if (current.Configurable == desc.Configurable && current.ConfigurableSet == desc.ConfigurableSet && current.Writable == desc.Writable && current.WritableSet == desc.WritableSet && current.Enumerable == desc.Enumerable && current.EnumerableSet == desc.EnumerableSet && (((object)get == null && (object)get2 == null) || ((object)get != null && (object)get2 != null && JsValue.SameValue(get, get2))) && (((object)set == null && (object)set2 == null) || ((object)set != null && (object)set2 != null && JsValue.SameValue(set, set2))) && (((object)value2 == null && (object)value == null) || ((object)value2 != null && (object)value != null && value2 == value)))
			{
				return true;
			}
			if (!current.Configurable)
			{
				if (desc.Configurable)
				{
					return false;
				}
				if (desc.EnumerableSet && desc.Enumerable != current.Enumerable)
				{
					return false;
				}
			}
			if (!desc.IsGenericDescriptor())
			{
				if (current.IsDataDescriptor() != desc.IsDataDescriptor())
				{
					if (!current.Configurable)
					{
						return false;
					}
					if ((object)o != null)
					{
						PropertyFlag flags = current.Flags & ~(PropertyFlag.Writable | PropertyFlag.WritableSet | PropertyFlag.CustomJsValue);
						if (current.IsDataDescriptor())
						{
							o.SetOwnProperty(property, current = new GetSetPropertyDescriptor(JsValue.Undefined, JsValue.Undefined, flags));
						}
						else
						{
							o.SetOwnProperty(property, current = new PropertyDescriptor(JsValue.Undefined, flags));
						}
					}
				}
				else if (current.IsDataDescriptor() && desc.IsDataDescriptor())
				{
					if (!current.Configurable)
					{
						if (!current.Writable && desc.Writable)
						{
							return false;
						}
						if (!current.Writable && (object)value != null && !JsValue.SameValue(value, value2))
						{
							return false;
						}
					}
				}
				else if (current.IsAccessorDescriptor() && desc.IsAccessorDescriptor() && !current.Configurable && (((object)set2 != null && !JsValue.SameValue(set2, set ?? JsValue.Undefined)) || ((object)get2 != null && !JsValue.SameValue(get2, get ?? JsValue.Undefined))))
				{
					return false;
				}
			}
			if ((object)o != null)
			{
				if ((object)value != null)
				{
					current.Value = value;
				}
				if (desc.WritableSet)
				{
					current.Writable = desc.Writable;
				}
				if (desc.EnumerableSet)
				{
					current.Enumerable = desc.Enumerable;
				}
				if (desc.ConfigurableSet)
				{
					current.Configurable = desc.Configurable;
				}
				PropertyDescriptor propertyDescriptor = null;
				if ((object)get2 != null)
				{
					propertyDescriptor = new GetSetPropertyDescriptor(propertyDescriptor ?? current);
					((GetSetPropertyDescriptor)propertyDescriptor).SetGet(get2);
				}
				if ((object)set2 != null)
				{
					propertyDescriptor = new GetSetPropertyDescriptor(propertyDescriptor ?? current);
					((GetSetPropertyDescriptor)propertyDescriptor).SetSet(set2);
				}
				if (propertyDescriptor != null)
				{
					o.SetOwnProperty(property, propertyDescriptor);
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected internal void EnsureInitialized()
		{
			if (!_initialized)
			{
				_initialized = true;
				Initialize();
			}
		}

		protected virtual void Initialize()
		{
		}

		public override object ToObject()
		{
			return ToObject(new ObjectTraverseStack(_engine));
		}

		private object ToObject(ObjectTraverseStack stack)
		{
			if (this is IObjectWrapper objectWrapper)
			{
				return objectWrapper.Target;
			}
			stack.Enter(this);
			object result = null;
			switch (Class)
			{
			case ObjectClass.String:
				if (this is StringInstance stringInstance)
				{
					result = stringInstance.StringData.ToString();
				}
				break;
			case ObjectClass.Date:
				if (this is JsDate jsDate)
				{
					result = jsDate.ToDateTime();
				}
				break;
			case ObjectClass.Boolean:
				if (this is BooleanInstance booleanInstance)
				{
					result = (booleanInstance.BooleanData._value ? JsBoolean.BoxedTrue : JsBoolean.BoxedFalse);
				}
				break;
			case ObjectClass.Function:
				if (this is ICallable callable)
				{
					result = new Func<JsValue, JsValue[], JsValue>(callable.Call);
				}
				break;
			case ObjectClass.Number:
				if (this is NumberInstance numberInstance)
				{
					result = numberInstance.NumberData._value;
				}
				break;
			case ObjectClass.RegExp:
				if (this is JsRegExp jsRegExp)
				{
					result = jsRegExp.Value;
				}
				break;
			case ObjectClass.Arguments:
			case ObjectClass.Object:
			{
				if (this is JsArray jsArray)
				{
					object[] array = new object[jsArray.GetLength()];
					for (uint num = 0u; num < array.Length; num++)
					{
						JsValue jsValue = jsArray[num];
						object obj = null;
						if (!jsValue.IsUndefined())
						{
							obj = ((jsValue is ObjectInstance objectInstance) ? objectInstance.ToObject(stack) : jsValue.ToObject());
						}
						array[num] = obj;
					}
					result = array;
					break;
				}
				if (this is JsTypedArray jsTypedArray)
				{
					result = jsTypedArray._arrayElementType switch
					{
						TypedArrayElementType.Int8 => jsTypedArray.ToNativeArray<sbyte>(), 
						TypedArrayElementType.Int16 => jsTypedArray.ToNativeArray<short>(), 
						TypedArrayElementType.Int32 => jsTypedArray.ToNativeArray<int>(), 
						TypedArrayElementType.BigInt64 => jsTypedArray.ToNativeArray<long>(), 
						TypedArrayElementType.Float32 => jsTypedArray.ToNativeArray<float>(), 
						TypedArrayElementType.Float64 => jsTypedArray.ToNativeArray<double>(), 
						TypedArrayElementType.Uint8 => jsTypedArray.ToNativeArray<byte>(), 
						TypedArrayElementType.Uint8C => jsTypedArray.ToNativeArray<byte>(), 
						TypedArrayElementType.Uint16 => jsTypedArray.ToNativeArray<ushort>(), 
						TypedArrayElementType.Uint32 => jsTypedArray.ToNativeArray<uint>(), 
						TypedArrayElementType.BigUint64 => jsTypedArray.ToNativeArray<ulong>(), 
						_ => throw new NotSupportedException("cannot handle element type"), 
					};
					break;
				}
				if (this is JsArrayBuffer jsArrayBuffer)
				{
					jsArrayBuffer.AssertNotDetached();
					result = jsArrayBuffer.ArrayBufferData;
					break;
				}
				if (this is JsDataView jsDataView)
				{
					jsDataView._viewedArrayBuffer.AssertNotDetached();
					byte[] array2 = new byte[jsDataView._byteLength];
					System.Array.Copy(jsDataView._viewedArrayBuffer._arrayBufferData, jsDataView._byteOffset, array2, 0L, jsDataView._byteLength);
					result = array2;
					break;
				}
				if (this is BigIntInstance bigIntInstance)
				{
					result = bigIntInstance.BigIntData._value;
					break;
				}
				Func<ObjectInstance, IDictionary<string, object>> createClrObject = _engine.Options.Interop.CreateClrObject;
				if (createClrObject != null)
				{
					IDictionary<string, object> dictionary = createClrObject(this);
					foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in GetOwnProperties())
					{
						if (ownProperty.Value.Enumerable)
						{
							string key = ownProperty.Key.ToString();
							JsValue jsValue2 = Get(ownProperty.Key);
							object value = ((jsValue2 is ObjectInstance objectInstance2) ? objectInstance2.ToObject(stack) : jsValue2.ToObject());
							dictionary.Add(key, value);
						}
					}
					result = dictionary;
					break;
				}
				goto default;
			}
			default:
				result = this;
				break;
			}
			stack.Exit();
			return result;
		}

		internal virtual bool FindWithCallback(JsValue[] arguments, out ulong index, out JsValue value, bool visitUnassigned, bool fromEnd = false)
		{
			ulong num = GetLength();
			if (num == 0L)
			{
				index = 0uL;
				value = JsValue.Undefined;
				return false;
			}
			JsValue source = arguments.At(0);
			JsValue thisObject = arguments.At(1);
			ICallable callable = GetCallable(source);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = this;
			if (!fromEnd)
			{
				for (ulong num2 = 0uL; num2 < num; num2++)
				{
					if (TryGetValue(num2, out var jsValue) || visitUnassigned)
					{
						array[0] = jsValue;
						array[1] = num2;
						if (TypeConverter.ToBoolean(callable.Call(thisObject, array)))
						{
							index = num2;
							value = jsValue;
							return true;
						}
					}
				}
			}
			else
			{
				for (long num3 = (long)(num - 1); num3 >= 0; num3--)
				{
					if (TryGetValue((ulong)num3, out var jsValue2) || visitUnassigned)
					{
						if ((object)jsValue2 == null)
						{
							jsValue2 = JsValue.Undefined;
						}
						array[0] = jsValue2;
						array[1] = num3;
						if (TypeConverter.ToBoolean(callable.Call(thisObject, array)))
						{
							index = (ulong)num3;
							value = jsValue2;
							return true;
						}
					}
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			index = 0uL;
			value = JsValue.Undefined;
			return false;
			ulong GetLength()
			{
				double val = TypeConverter.ToNumber(Get(CommonProperties.Length));
				return (ulong)System.Math.Max(0.0, System.Math.Min(val, 9007199254740991.0));
			}
			bool TryGetValue(ulong idx, out JsValue reference)
			{
				JsValue property = JsString.Create(idx);
				bool flag = HasProperty(property);
				reference = (flag ? Get(property) : JsValue.Undefined);
				return flag;
			}
		}

		internal ICallable GetCallable(JsValue source)
		{
			return source.GetCallable(_engine.Realm);
		}

		internal virtual uint GetLength()
		{
			return (uint)TypeConverter.ToLength(Get(CommonProperties.Length));
		}

		public virtual bool PreventExtensions()
		{
			Extensible = false;
			return true;
		}

		protected internal virtual ObjectInstance? GetPrototypeOf()
		{
			return _prototype;
		}

		internal virtual bool SetPrototypeOf(JsValue value)
		{
			if (!value.IsObject() && !value.IsNull())
			{
				ExceptionHelper.ThrowArgumentException();
			}
			JsValue jsValue = _prototype ?? JsValue.Null;
			if ((object)value == jsValue)
			{
				return true;
			}
			if (!Extensible)
			{
				return false;
			}
			if (value.IsNull())
			{
				_prototype = null;
				return true;
			}
			ObjectInstance objectInstance = value as ObjectInstance;
			bool flag = false;
			while (!flag)
			{
				if ((object)objectInstance == null)
				{
					flag = true;
					continue;
				}
				if ((object)objectInstance == this)
				{
					return false;
				}
				objectInstance = objectInstance._prototype;
			}
			_prototype = value as ObjectInstance;
			return true;
		}

		internal void SetFunctionName(JsValue name, string? prefix = null)
		{
			if (name is JsSymbol jsSymbol)
			{
				name = (jsSymbol._value.IsUndefined() ? JsString.Empty : new JsString("[" + jsSymbol._value?.ToString() + "]"));
			}
			if (!string.IsNullOrWhiteSpace(prefix))
			{
				name = prefix + " " + name;
			}
			DefinePropertyOrThrow(CommonProperties.Name, new PropertyDescriptor(name, PropertyFlag.Configurable));
		}

		internal virtual bool CreateMethodProperty(JsValue p, JsValue v)
		{
			PropertyDescriptor desc = new PropertyDescriptor(v, PropertyFlag.NonEnumerable);
			return DefineOwnProperty(p, desc);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CreateDataProperty(JsValue p, JsValue v)
		{
			return DefineOwnProperty(p, new PropertyDescriptor(v, PropertyFlag.ConfigurableEnumerableWritable));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool CreateDataPropertyOrThrow(JsValue p, JsValue v)
		{
			if (!CreateDataProperty(p, v))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return true;
		}

		internal void CreateNonEnumerableDataPropertyOrThrow(JsValue p, JsValue v)
		{
			PropertyDescriptor desc = new PropertyDescriptor(v, true, false, true);
			DefinePropertyOrThrow(p, desc);
		}

		internal static JsObject OrdinaryObjectCreate(Engine engine, ObjectInstance? proto)
		{
			return new JsObject(engine)
			{
				_prototype = proto
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ICallable? GetMethod(JsValue property)
		{
			return GetMethod(_engine.Realm, this, property);
		}

		internal static ICallable? GetMethod(Realm realm, JsValue v, JsValue p)
		{
			JsValue jsValue = v.Get(p);
			if (jsValue.IsNullOrUndefined())
			{
				return null;
			}
			ICallable obj = jsValue as ICallable;
			if (obj == null)
			{
				ExceptionHelper.ThrowTypeError(realm, "Value returned for property '" + p?.ToString() + "' of object is not a function");
			}
			return obj;
		}

		internal void CopyDataProperties(ObjectInstance target, HashSet<JsValue>? excludedItems)
		{
			List<JsValue> ownPropertyKeys = GetOwnPropertyKeys();
			for (int i = 0; i < ownPropertyKeys.Count; i++)
			{
				JsValue jsValue = ownPropertyKeys[i];
				if (excludedItems == null || !excludedItems.Contains(jsValue))
				{
					PropertyDescriptor ownProperty = GetOwnProperty(jsValue);
					if (ownProperty.Enumerable)
					{
						target.CreateDataProperty(jsValue, UnwrapJsValue(ownProperty, this));
					}
				}
			}
		}

		internal JsArray EnumerableOwnProperties(EnumerableOwnPropertyNamesKind kind)
		{
			List<JsValue> ownPropertyKeys = GetOwnPropertyKeys(Types.String);
			JsArray jsArray = Engine.Realm.Intrinsics.Array.ArrayCreate((uint)ownPropertyKeys.Count);
			uint num = 0u;
			for (int i = 0; i < ownPropertyKeys.Count; i++)
			{
				JsValue jsValue = ownPropertyKeys[i];
				if (!jsValue.IsString())
				{
					continue;
				}
				PropertyDescriptor ownProperty = GetOwnProperty(jsValue);
				if (ownProperty == PropertyDescriptor.Undefined || !ownProperty.Enumerable)
				{
					continue;
				}
				if (kind == EnumerableOwnPropertyNamesKind.Key)
				{
					jsArray.SetIndexValue(num, jsValue, updateLength: false);
				}
				else
				{
					JsValue value = Get(jsValue);
					if (kind == EnumerableOwnPropertyNamesKind.Value)
					{
						jsArray.SetIndexValue(num, value, updateLength: false);
					}
					else
					{
						JsArray jsArray2 = _engine.Realm.Intrinsics.Array.ArrayCreate(2uL);
						jsArray2.SetIndexValue(0u, jsValue, updateLength: false);
						jsArray2.SetIndexValue(1u, value, updateLength: false);
						jsArray.SetIndexValue(num, jsArray2, updateLength: false);
					}
				}
				num++;
			}
			jsArray.SetLength(num);
			return jsArray;
		}

		internal ObjectInstance AssertThisIsObjectInstance(JsValue value, string methodName)
		{
			ObjectInstance obj = value as ObjectInstance;
			if ((object)obj == null)
			{
				ThrowIncompatibleReceiver(value, methodName);
			}
			return obj;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void ThrowIncompatibleReceiver(JsValue value, string methodName)
		{
			ExceptionHelper.ThrowTypeError(_engine.Realm, $"Method {methodName} called on incompatible receiver {value}");
		}

		public override bool Equals(object? obj)
		{
			return Equals(obj as ObjectInstance);
		}

		public override bool Equals(JsValue? other)
		{
			return Equals(other as ObjectInstance);
		}

		public bool Equals(ObjectInstance? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return RuntimeHelpers.GetHashCode(this);
		}

		internal IEnumerable<JsValue> GetKeys()
		{
			HashSet<JsValue> visited = new HashSet<JsValue>();
			foreach (JsValue ownPropertyKey in GetOwnPropertyKeys(Types.String))
			{
				PropertyDescriptor ownProperty = GetOwnProperty(ownPropertyKey);
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					visited.Add(ownPropertyKey);
					if (ownProperty.Enumerable)
					{
						yield return ownPropertyKey;
					}
				}
			}
			if ((object)Prototype == null)
			{
				yield break;
			}
			foreach (JsValue key in Prototype.GetKeys())
			{
				if (!visited.Contains(key))
				{
					yield return key;
				}
			}
		}

		public override string ToString()
		{
			return TypeConverter.ToString(this);
		}

		internal virtual ulong GetSmallestIndex(ulong length)
		{
			if (Properties == null)
			{
				return 0uL;
			}
			ulong num = length;
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in GetOwnProperties())
			{
				if (ulong.TryParse(ownProperty.Key.ToString(), out var result))
				{
					num = System.Math.Min(result, num);
				}
			}
			if (Prototype?.Properties != null)
			{
				foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty2 in Prototype.GetOwnProperties())
				{
					if (ulong.TryParse(ownProperty2.Key.ToString(), out var result2))
					{
						num = System.Math.Min(result2, num);
					}
				}
			}
			return num;
		}

		internal JsValue Invoke(JsValue v, JsValue p, JsValue[] arguments)
		{
			if (!(v.GetV(_engine.Realm, p) is ICallable callable))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Can only invoke functions");
				return null;
			}
			return callable.Call(v, arguments);
		}

		internal bool SetIntegrityLevel(IntegrityLevel level)
		{
			if (!PreventExtensions())
			{
				return false;
			}
			List<JsValue> ownPropertyKeys = GetOwnPropertyKeys();
			if (level == IntegrityLevel.Sealed)
			{
				for (int i = 0; i < ownPropertyKeys.Count; i++)
				{
					JsValue property = ownPropertyKeys[i];
					DefinePropertyOrThrow(property, new PropertyDescriptor
					{
						Configurable = false
					});
				}
			}
			else
			{
				for (int j = 0; j < ownPropertyKeys.Count; j++)
				{
					JsValue property2 = ownPropertyKeys[j];
					PropertyDescriptor ownProperty = GetOwnProperty(property2);
					if (ownProperty != PropertyDescriptor.Undefined)
					{
						PropertyDescriptor desc = ((!ownProperty.IsAccessorDescriptor()) ? new PropertyDescriptor
						{
							Configurable = false,
							Writable = false
						} : new PropertyDescriptor
						{
							Configurable = false
						});
						DefinePropertyOrThrow(property2, desc);
					}
				}
			}
			return true;
		}

		internal static void DefineField(ObjectInstance receiver, ClassFieldDefinition fieldRecord)
		{
			JsValue name = fieldRecord.Name;
			ScriptFunction initializer = fieldRecord.Initializer;
			JsValue jsValue = JsValue.Undefined;
			if ((object)initializer != null)
			{
				jsValue = receiver._engine.Call(initializer, receiver);
				if (jsValue is Jint.Native.Function.Function function)
				{
					function.SetFunctionName(name);
				}
			}
			if (name is PrivateName property)
			{
				receiver.PrivateFieldAdd(property, jsValue);
			}
			else
			{
				receiver.CreateDataPropertyOrThrow(name, jsValue);
			}
		}

		public void FastSetProperty(string name, PropertyDescriptor value)
		{
			SetProperty(name, value);
		}

		public void FastSetProperty(JsValue property, PropertyDescriptor value)
		{
			SetProperty(property, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void FastSetDataProperty(string name, JsValue value)
		{
			SetProperty(name, new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable));
		}

		internal void InitializeInstanceElements(ScriptFunction constructor)
		{
			List<PrivateElement> privateMethods = constructor._privateMethods;
			if (privateMethods != null)
			{
				for (int i = 0; i < privateMethods.Count; i++)
				{
					PrivateMethodOrAccessorAdd(privateMethods[i]);
				}
			}
			List<ClassFieldDefinition> fields = constructor._fields;
			if (fields != null)
			{
				for (int j = 0; j < fields.Count; j++)
				{
					DefineField(this, fields[j]);
				}
			}
		}

		internal void PrivateMethodOrAccessorAdd(PrivateElement method)
		{
			if (PrivateElementFind(method.Key) != null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Already present");
			}
			if (_privateElements == null)
			{
				_privateElements = new Dictionary<PrivateName, PrivateElement>();
			}
			_privateElements.Add(method.Key, method);
		}

		private void PrivateFieldAdd(PrivateName property, JsValue value)
		{
			if (PrivateElementFind(property) != null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Already present");
			}
			if (_privateElements == null)
			{
				_privateElements = new Dictionary<PrivateName, PrivateElement>();
			}
			_privateElements.Add(property, new PrivateElement
			{
				Key = property,
				Kind = PrivateElementKind.Field,
				Value = value
			});
		}

		internal JsValue PrivateGet(PrivateName property)
		{
			PrivateElement privateElement = PrivateElementFind(property);
			if (privateElement == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, $"Cannot read private member #{property} from an object whose class did not declare it");
			}
			PrivateElementKind kind = privateElement.Kind;
			if ((uint)kind <= 1u)
			{
				return privateElement.Value ?? JsValue.Undefined;
			}
			JsValue? get = privateElement.Get;
			if ((object)get == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, $"'#{property}' was defined without a getter");
			}
			Jint.Native.Function.Function function = (Jint.Native.Function.Function)get;
			return function._engine.Call(function, this);
		}

		internal void PrivateSet(PrivateName property, JsValue value)
		{
			PrivateElement privateElement = PrivateElementFind(property);
			if (privateElement == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Not found");
			}
			if (privateElement.Kind == PrivateElementKind.Field)
			{
				privateElement.Value = value;
				return;
			}
			if (privateElement.Kind == PrivateElementKind.Method)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Cannot set method");
				return;
			}
			JsValue set = privateElement.Set;
			if ((object)set == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, $"'#{property}' was defined without a setter");
			}
			_engine.Call(set, this, new JsValue[1] { value });
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal PrivateElement? PrivateElementFind(PrivateName property)
		{
			Dictionary<PrivateName, PrivateElement>? privateElements = _privateElements;
			if (privateElements == null || !privateElements.TryGetValue(property, out PrivateElement value))
			{
				return null;
			}
			return value;
		}
	}
	internal sealed class ClassFieldDefinition
	{
		public required JsValue Name { get; set; }

		public ScriptFunction? Initializer { get; set; }
	}
	internal sealed class ClassStaticBlockDefinition
	{
		public required Jint.Native.Function.Function BodyFunction { get; set; }
	}
	internal sealed class PrivateElement
	{
		public required PrivateName Key { get; set; }

		public PrivateElementKind Kind { get; set; }

		public JsValue? Value { get; set; }

		public JsValue? Get { get; set; }

		public JsValue? Set { get; set; }
	}
	internal enum PrivateElementKind
	{
		Field,
		Method,
		Accessor
	}
	public sealed class ObjectPrototype : Prototype
	{
		private readonly ObjectConstructor _constructor;

		internal ObjectChangeFlags _objectChangeFlags;

		internal ObjectPrototype(Engine engine, Realm realm, ObjectConstructor constructor)
			: base(engine, realm)
		{
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(12, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.Writable | PropertyFlag.Configurable),
				["__defineGetter__"] = new PropertyDescriptor(new ClrFunction(base.Engine, "__defineGetter__", DefineGetter, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["__defineSetter__"] = new PropertyDescriptor(new ClrFunction(base.Engine, "__defineSetter__", DefineSetter, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["__lookupGetter__"] = new PropertyDescriptor(new ClrFunction(base.Engine, "__lookupGetter__", LookupGetter, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["__lookupSetter__"] = new PropertyDescriptor(new ClrFunction(base.Engine, "__lookupSetter__", LookupSetter, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["__proto__"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get __proto__", (JsValue thisObject, JsValue[] _) => TypeConverter.ToObject(_realm, thisObject).GetPrototypeOf() ?? JsValue.Null, 0, PropertyFlag.Configurable), new ClrFunction(base.Engine, "set __proto__", delegate(JsValue thisObject, JsValue[] arguments)
				{
					TypeConverter.CheckObjectCoercible(_engine, thisObject);
					JsValue jsValue = arguments.At(0);
					if ((!jsValue.IsObject() && !jsValue.IsNull()) || !(thisObject is ObjectInstance objectInstance))
					{
						return JsValue.Undefined;
					}
					if (!objectInstance.SetPrototypeOf(jsValue))
					{
						ExceptionHelper.ThrowTypeError(_realm, "Invalid prototype");
					}
					return JsValue.Undefined;
				}, 0, PropertyFlag.Configurable), false, true),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToObjectString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleString", ToLocaleString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["valueOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["hasOwnProperty"] = new PropertyDescriptor(new ClrFunction(base.Engine, "hasOwnProperty", HasOwnProperty, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["isPrototypeOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isPrototypeOf", IsPrototypeOf, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["propertyIsEnumerable"] = new PropertyDescriptor(new ClrFunction(base.Engine, "propertyIsEnumerable", PropertyIsEnumerable, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
		}

		public override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			TrackChanges(property);
			return base.DefineOwnProperty(property, desc);
		}

		protected internal override void SetOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			TrackChanges(property);
			base.SetOwnProperty(property, desc);
		}

		private void TrackChanges(JsValue property)
		{
			EnsureInitialized();
			if (ArrayInstance.IsArrayIndex(property, out var _))
			{
				_objectChangeFlags |= ObjectChangeFlags.ArrayIndex;
			}
			else
			{
				_objectChangeFlags |= (ObjectChangeFlags)((!property.IsSymbol()) ? 1 : 2);
			}
		}

		private JsValue DefineGetter(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			JsValue o = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			if (!jsValue.IsCallable)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Target is not callable");
			}
			GetSetPropertyDescriptor desc = new GetSetPropertyDescriptor(jsValue, null, true, true);
			JsValue property = TypeConverter.ToPropertyKey(o);
			objectInstance.DefinePropertyOrThrow(property, desc);
			return JsValue.Undefined;
		}

		private JsValue DefineSetter(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			JsValue o = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			if (!jsValue.IsCallable)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Target is not callable");
			}
			GetSetPropertyDescriptor desc = new GetSetPropertyDescriptor(null, jsValue, true, true);
			JsValue property = TypeConverter.ToPropertyKey(o);
			objectInstance.DefinePropertyOrThrow(property, desc);
			return JsValue.Undefined;
		}

		private JsValue LookupGetter(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(0));
			do
			{
				PropertyDescriptor ownProperty = objectInstance.GetOwnProperty(property);
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					if (ownProperty.IsAccessorDescriptor())
					{
						return ownProperty.Get ?? JsValue.Undefined;
					}
					return JsValue.Undefined;
				}
				objectInstance = objectInstance.GetPrototypeOf();
			}
			while ((object)objectInstance != null);
			return JsValue.Undefined;
		}

		private JsValue LookupSetter(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			JsValue property = TypeConverter.ToPropertyKey(arguments.At(0));
			do
			{
				PropertyDescriptor ownProperty = objectInstance.GetOwnProperty(property);
				if (ownProperty != PropertyDescriptor.Undefined)
				{
					if (ownProperty.IsAccessorDescriptor())
					{
						return ownProperty.Set ?? JsValue.Undefined;
					}
					return JsValue.Undefined;
				}
				objectInstance = objectInstance.GetPrototypeOf();
			}
			while ((object)objectInstance != null);
			return JsValue.Undefined;
		}

		private JsValue PropertyIsEnumerable(JsValue thisObject, JsValue[] arguments)
		{
			JsValue property = TypeConverter.ToPropertyKey(arguments[0]);
			PropertyDescriptor ownProperty = TypeConverter.ToObject(_realm, thisObject).GetOwnProperty(property);
			if (ownProperty == PropertyDescriptor.Undefined)
			{
				return JsBoolean.False;
			}
			return ownProperty.Enumerable;
		}

		private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
		{
			return TypeConverter.ToObject(_realm, thisObject);
		}

		private JsValue IsPrototypeOf(JsValue thisObject, JsValue[] arguments)
		{
			JsValue value = arguments[0];
			if (!value.IsObject())
			{
				return JsBoolean.False;
			}
			ObjectInstance objectInstance = value.AsObject();
			ObjectInstance objectInstance2 = TypeConverter.ToObject(_realm, thisObject);
			do
			{
				objectInstance = objectInstance.Prototype;
				if ((object)objectInstance == null)
				{
					return JsBoolean.False;
				}
			}
			while ((object)objectInstance2 != objectInstance);
			return JsBoolean.True;
		}

		private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
		{
			return Invoke(thisObject, "toString", System.Array.Empty<JsValue>());
		}

		internal JsValue ToObjectString(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject.IsUndefined())
			{
				return "[object Undefined]";
			}
			if (thisObject.IsNull())
			{
				return "[object Null]";
			}
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			bool flag = objectInstance.IsArray();
			JsValue jsValue = objectInstance.Get(GlobalSymbolRegistry.ToStringTag);
			if (!jsValue.IsString())
			{
				jsValue = (flag ? ((JsValue)"Array") : ((!objectInstance.IsCallable) ? ((JsValue)((objectInstance is JsProxy) ? ObjectClass.Object : objectInstance.Class).ToString()) : ((JsValue)"Function")));
			}
			return "[object " + jsValue?.ToString() + "]";
		}

		private JsValue HasOwnProperty(JsValue thisObject, JsValue[] arguments)
		{
			JsValue property = TypeConverter.ToPropertyKey(arguments[0]);
			return TypeConverter.ToObject(_realm, thisObject).GetOwnProperty(property) != PropertyDescriptor.Undefined;
		}
	}
}
namespace Jint.Native.Number
{
	internal sealed class NumberConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Number");

		private const long MinSafeInteger = -9007199254740991L;

		internal const long MaxSafeInteger = 9007199254740991L;

		public NumberPrototype PrototypeObject { get; }

		public NumberConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new NumberPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(15, checkExistingKeys: false)
			{
				["MAX_VALUE"] = new PropertyDescriptor(new PropertyDescriptor(double.MaxValue, PropertyFlag.AllForbidden)),
				["MIN_VALUE"] = new PropertyDescriptor(new PropertyDescriptor(double.Epsilon, PropertyFlag.AllForbidden)),
				["NaN"] = new PropertyDescriptor(new PropertyDescriptor(double.NaN, PropertyFlag.AllForbidden)),
				["NEGATIVE_INFINITY"] = new PropertyDescriptor(new PropertyDescriptor(double.NegativeInfinity, PropertyFlag.AllForbidden)),
				["POSITIVE_INFINITY"] = new PropertyDescriptor(new PropertyDescriptor(double.PositiveInfinity, PropertyFlag.AllForbidden)),
				["EPSILON"] = new PropertyDescriptor(new PropertyDescriptor(2.220446049250313E-16, PropertyFlag.AllForbidden)),
				["MIN_SAFE_INTEGER"] = new PropertyDescriptor(new PropertyDescriptor(-9007199254740991L, PropertyFlag.AllForbidden)),
				["MAX_SAFE_INTEGER"] = new PropertyDescriptor(new PropertyDescriptor(9007199254740991L, PropertyFlag.AllForbidden)),
				["isFinite"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isFinite", IsFinite, 1, PropertyFlag.Configurable), true, false, true),
				["isInteger"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isInteger", IsInteger, 1, PropertyFlag.Configurable), true, false, true),
				["isNaN"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isNaN", IsNaN, 1, PropertyFlag.Configurable), true, false, true),
				["isSafeInteger"] = new PropertyDescriptor(new ClrFunction(base.Engine, "isSafeInteger", IsSafeInteger, 1, PropertyFlag.Configurable), true, false, true),
				["parseFloat"] = new PropertyDescriptor(new ClrFunction(base.Engine, "parseFloat", GlobalObject.ParseFloat, 0, PropertyFlag.Configurable), true, false, true),
				["parseInt"] = new PropertyDescriptor(new ClrFunction(base.Engine, "parseInt", GlobalObject.ParseInt, 0, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
		}

		private static JsValue IsFinite(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is JsNumber jsNumber))
			{
				return false;
			}
			if (!double.IsInfinity(jsNumber._value) && !double.IsNaN(jsNumber._value))
			{
				return JsBoolean.True;
			}
			return JsBoolean.False;
		}

		private static JsValue IsInteger(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is JsNumber jsNumber))
			{
				return false;
			}
			if (double.IsInfinity(jsNumber._value) || double.IsNaN(jsNumber._value))
			{
				return JsBoolean.False;
			}
			return TypeConverter.ToInteger(jsNumber) == jsNumber._value;
		}

		private static JsValue IsNaN(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is JsNumber jsNumber))
			{
				return false;
			}
			return double.IsNaN(jsNumber._value);
		}

		private static JsValue IsSafeInteger(JsValue thisObject, JsValue[] arguments)
		{
			if (!(arguments.At(0) is JsNumber jsNumber))
			{
				return false;
			}
			if (double.IsInfinity(jsNumber._value) || double.IsNaN(jsNumber._value))
			{
				return JsBoolean.False;
			}
			double num = TypeConverter.ToInteger(jsNumber);
			if (num != jsNumber._value)
			{
				return false;
			}
			return System.Math.Abs(num) <= 9007199254740991.0;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return ProcessFirstParameter(arguments);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsNumber jsNumber = ProcessFirstParameter(arguments);
			if (newTarget.IsUndefined())
			{
				return Construct(jsNumber);
			}
			return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Number.PrototypeObject, (Engine engine, Realm realm, JsNumber? state) => new NumberInstance(engine, state), jsNumber);
		}

		private static JsNumber ProcessFirstParameter(JsValue[] arguments)
		{
			JsNumber result = JsNumber.PositiveZero;
			if (arguments.Length != 0)
			{
				JsValue jsValue = TypeConverter.ToNumeric(arguments[0]);
				result = ((!jsValue.IsBigInt()) ? ((JsNumber)jsValue) : JsNumber.Create((long)((JsBigInt)jsValue)._value));
			}
			return result;
		}

		public NumberInstance Construct(JsNumber value)
		{
			return new NumberInstance(base.Engine, value)
			{
				_prototype = PrototypeObject
			};
		}
	}
	internal class NumberInstance : ObjectInstance, IJsPrimitive
	{
		private static readonly long NegativeZeroBits = BitConverter.DoubleToInt64Bits(-0.0);

		Types IJsPrimitive.Type => Types.Number;

		JsValue IJsPrimitive.PrimitiveValue => NumberData;

		public JsNumber NumberData { get; }

		private protected NumberInstance(Engine engine, InternalTypes type)
			: base(engine, ObjectClass.Number, type)
		{
			NumberData = JsNumber.PositiveZero;
		}

		public NumberInstance(Engine engine, JsNumber value)
			: base(engine, ObjectClass.Number)
		{
			NumberData = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNegativeZero(double x)
		{
			if (x == 0.0)
			{
				return BitConverter.DoubleToInt64Bits(x) == NegativeZeroBits;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPositiveZero(double x)
		{
			if (x == 0.0)
			{
				return BitConverter.DoubleToInt64Bits(x) != NegativeZeroBits;
			}
			return false;
		}
	}
	internal class NumberIntlHelper
	{
		private const int JS_MAX_DECIMAL_DIGIT_COUNT = 3;

		public static int GetDecimalDigitCount(double number)
		{
			for (int i = 0; i < 3; i++)
			{
				double num = number * System.Math.Pow(10.0, i);
				if (num == (double)(int)num)
				{
					return i;
				}
			}
			return 3;
		}
	}
	internal sealed class NumberPrototype : NumberInstance
	{
		private const int SmallDtoaLength = 25;

		private const int LargeDtoaLength = 101;

		private readonly Realm _realm;

		private readonly NumberConstructor _constructor;

		private const double Ten21 = 1E+21;

		internal NumberPrototype(Engine engine, Realm realm, NumberConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, InternalTypes.Object | InternalTypes.PlainObject)
		{
			_prototype = objectPrototype;
			_realm = realm;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(8, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, true, false, true),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToNumberString, 1, PropertyFlag.Configurable), true, false, true),
				["toLocaleString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleString", ToLocaleString, 0, PropertyFlag.Configurable), true, false, true),
				["valueOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), true, false, true),
				["toFixed"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toFixed", ToFixed, 1, PropertyFlag.Configurable), true, false, true),
				["toExponential"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toExponential", ToExponential, 1, PropertyFlag.Configurable), true, false, true),
				["toPrecision"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toPrecision", ToPrecision, 1, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
		}

		private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
		{
			if (!thisObject.IsNumber() && (object)thisObject.TryCast<NumberInstance>() == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			double num = TypeConverter.ToNumber(thisObject);
			if (double.IsNaN(num))
			{
				return "NaN";
			}
			if (num == 0.0)
			{
				return JsString.NumberZeroString;
			}
			if (num < 0.0)
			{
				return "-" + ToLocaleString(0.0 - num, arguments);
			}
			if (double.IsPositiveInfinity(num) || num >= double.MaxValue)
			{
				return "Infinity";
			}
			if (double.IsNegativeInfinity(num) || num <= double.MinValue)
			{
				return "-Infinity";
			}
			NumberFormatInfo numberFormatInfo = (NumberFormatInfo)base.Engine.Options.Culture.NumberFormat.Clone();
			try
			{
				if (arguments.Length != 0 && arguments[0].IsString())
				{
					numberFormatInfo = (NumberFormatInfo)CultureInfo.GetCultureInfo(arguments[0].ToString()).NumberFormat.Clone();
				}
				int decimalDigitCount = NumberIntlHelper.GetDecimalDigitCount(num);
				numberFormatInfo.NumberDecimalDigits = decimalDigitCount;
			}
			catch (CultureNotFoundException)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Incorrect locale information provided");
			}
			return num.ToString("n", numberFormatInfo);
		}

		private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is NumberInstance numberInstance)
			{
				return numberInstance.NumberData;
			}
			if (thisObject is JsNumber)
			{
				return thisObject;
			}
			ExceptionHelper.ThrowTypeError(_realm);
			return null;
		}

		private JsValue ToFixed(JsValue thisObject, JsValue[] arguments)
		{
			int num = (int)TypeConverter.ToInteger(arguments.At(0, 0));
			if (num < 0 || num > 100)
			{
				ExceptionHelper.ThrowRangeError(_realm, "fractionDigits argument must be between 0 and 100");
			}
			if (num == 100)
			{
				ExceptionHelper.ThrowRangeError(_realm, "100 fraction digits is not supported due to .NET format specifier limitation");
			}
			double num2 = TypeConverter.ToNumber(thisObject);
			if (double.IsNaN(num2))
			{
				return "NaN";
			}
			if (num2 >= 1E+21)
			{
				return ToNumberString(num2);
			}
			if (System.Math.Abs(num2 - (double)(long)num2) < 4.94E-322)
			{
				return ((long)num2).ToString("f" + num, CultureInfo.InvariantCulture);
			}
			return num2.ToString("f" + num, CultureInfo.InvariantCulture);
		}

		private JsValue ToExponential(JsValue thisObject, JsValue[] arguments)
		{
			if (!thisObject.IsNumber() && (object)thisObject.TryCast<NumberInstance>() == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			double num = TypeConverter.ToNumber(thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue.IsUndefined())
			{
				jsValue = JsNumber.PositiveZero;
			}
			int num2 = (int)TypeConverter.ToInteger(jsValue);
			if (double.IsNaN(num))
			{
				return "NaN";
			}
			if (double.IsInfinity(num))
			{
				return thisObject.ToString();
			}
			if (num2 < 0 || num2 > 100)
			{
				ExceptionHelper.ThrowRangeError(_realm, "fractionDigits argument must be between 0 and 100");
			}
			if (arguments.At(0).IsUndefined())
			{
				num2 = -1;
			}
			bool negative = false;
			if (num < 0.0)
			{
				num = 0.0 - num;
				negative = true;
			}
			Span<char> initialBuffer = stackalloc char[(num2 == -1) ? 25 : 101];
			DtoaBuilder buffer = new DtoaBuilder(initialBuffer);
			bool negative2;
			int point;
			if (num2 == -1)
			{
				DtoaNumberFormatter.DoubleToAscii(ref buffer, num, DtoaMode.Shortest, 0, out negative2, out point);
				num2 = buffer.Length - 1;
			}
			else
			{
				DtoaNumberFormatter.DoubleToAscii(ref buffer, num, DtoaMode.Precision, num2 + 1, out negative2, out point);
			}
			int exponent = point - 1;
			return CreateExponentialRepresentation(ref buffer, exponent, negative, num2 + 1);
		}

		private JsValue ToPrecision(JsValue thisObject, JsValue[] arguments)
		{
			if (!thisObject.IsNumber() && (object)thisObject.TryCast<NumberInstance>() == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			double num = TypeConverter.ToNumber(thisObject);
			JsValue jsValue = arguments.At(0);
			if (jsValue.IsUndefined())
			{
				return TypeConverter.ToString(num);
			}
			int num2 = (int)TypeConverter.ToInteger(jsValue);
			if (double.IsNaN(num))
			{
				return "NaN";
			}
			if (double.IsInfinity(num))
			{
				return thisObject.ToString();
			}
			if (num2 < 1 || num2 > 100)
			{
				ExceptionHelper.ThrowRangeError(_realm, "precision must be between 1 and 100");
			}
			Span<char> initialBuffer = stackalloc char[101];
			DtoaBuilder buffer = new DtoaBuilder(initialBuffer);
			DtoaNumberFormatter.DoubleToAscii(ref buffer, num, DtoaMode.Precision, num2, out var negative, out var point);
			int num3 = point - 1;
			if (num3 < -6 || num3 >= num2)
			{
				return CreateExponentialRepresentation(ref buffer, num3, negative, num2);
			}
			initialBuffer = stackalloc char[128];
			System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			if (negative)
			{
				valueStringBuilder.Append('-');
			}
			if (point <= 0)
			{
				valueStringBuilder.Append("0.");
				valueStringBuilder.Append('0', -point);
				valueStringBuilder.Append(buffer._chars.Slice(0, buffer.Length));
				valueStringBuilder.Append('0', num2 - buffer.Length);
			}
			else
			{
				int length = System.Math.Min(buffer.Length, point);
				valueStringBuilder.Append(buffer._chars.Slice(0, length));
				valueStringBuilder.Append('0', System.Math.Max(0, point - buffer.Length));
				if (point < num2)
				{
					valueStringBuilder.Append('.');
					int num4 = ((!negative) ? 1 : 2);
					if (buffer.Length > point)
					{
						int length2 = System.Math.Min(buffer.Length - point, num2 - (valueStringBuilder.Length - num4));
						valueStringBuilder.Append(buffer._chars.Slice(point, length2));
					}
					valueStringBuilder.Append('0', System.Math.Max(0, num4 + (num2 - valueStringBuilder.Length)));
				}
			}
			return valueStringBuilder.ToString();
		}

		private static string CreateExponentialRepresentation(ref DtoaBuilder buffer, int exponent, bool negative, int significantDigits)
		{
			bool flag = false;
			if (exponent < 0)
			{
				flag = true;
				exponent = -exponent;
			}
			Span<char> initialBuffer = stackalloc char[128];
			System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			if (negative)
			{
				valueStringBuilder.Append('-');
			}
			valueStringBuilder.Append(buffer[0]);
			if (significantDigits != 1)
			{
				valueStringBuilder.Append('.');
				valueStringBuilder.Append(buffer.Slice(1, buffer.Length - 1));
				int length = buffer.Length;
				valueStringBuilder.Append('0', significantDigits - length);
			}
			valueStringBuilder.Append('e');
			valueStringBuilder.Append(flag ? '-' : '+');
			valueStringBuilder.Append(exponent.ToString(CultureInfo.InvariantCulture));
			return valueStringBuilder.ToString();
		}

		private JsValue ToNumberString(JsValue thisObject, JsValue[] arguments)
		{
			if (!thisObject.IsNumber() && (object)thisObject.TryCast<NumberInstance>() == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			int num = (arguments.At(0).IsUndefined() ? 10 : ((int)TypeConverter.ToInteger(arguments.At(0))));
			if (num < 2 || num > 36)
			{
				ExceptionHelper.ThrowRangeError(_realm, "radix must be between 2 and 36");
			}
			double num2 = TypeConverter.ToNumber(thisObject);
			if (double.IsNaN(num2))
			{
				return "NaN";
			}
			if (num2 == 0.0)
			{
				return JsString.NumberZeroString;
			}
			if (double.IsPositiveInfinity(num2) || num2 >= double.MaxValue)
			{
				return "Infinity";
			}
			if (num2 < 0.0)
			{
				return "-" + ToNumberString(0.0 - num2, arguments);
			}
			if (num == 10)
			{
				return ToNumberString(num2);
			}
			long num3 = (long)num2;
			double num4 = num2 - (double)num3;
			string text = ToBase(num3, num);
			if (num4 != 0.0)
			{
				text = text + "." + ToFractionBase(num4, num);
			}
			return text;
		}

		internal static string ToBase(long n, int radix)
		{
			if (n == 0L)
			{
				return "0";
			}
			Span<char> initialBuffer = stackalloc char[64];
			System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			while (n > 0)
			{
				int index = (int)(n % radix);
				n /= radix;
				valueStringBuilder.Append("0123456789abcdefghijklmnopqrstuvwxyz"[index]);
			}
			valueStringBuilder.Reverse();
			return valueStringBuilder.ToString();
		}

		internal static string ToFractionBase(double n, int radix)
		{
			if (n == 0.0)
			{
				return "0";
			}
			Span<char> initialBuffer = stackalloc char[64];
			System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			while (n > 0.0 && valueStringBuilder.Length < 50)
			{
				double num = n * (double)radix;
				int num2 = (int)num;
				n = num - (double)num2;
				valueStringBuilder.Append("0123456789abcdefghijklmnopqrstuvwxyz"[num2]);
			}
			return valueStringBuilder.ToString();
		}

		internal static string ToNumberString(double m)
		{
			if (double.IsNaN(m))
			{
				return "NaN";
			}
			if (m == 0.0)
			{
				return "0";
			}
			if (double.IsInfinity(m))
			{
				if (!double.IsNegativeInfinity(m))
				{
					return "Infinity";
				}
				return "-Infinity";
			}
			Span<char> initialBuffer = stackalloc char[25];
			DtoaBuilder buffer = new DtoaBuilder(initialBuffer);
			DtoaNumberFormatter.DoubleToAscii(ref buffer, m, DtoaMode.Shortest, 0, out var negative, out var point);
			initialBuffer = stackalloc char[64];
			System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			if (negative)
			{
				valueStringBuilder.Append('-');
			}
			if (buffer.Length <= point && point <= 21)
			{
				valueStringBuilder.Append(buffer._chars.Slice(0, buffer.Length));
				valueStringBuilder.Append('0', point - buffer.Length);
			}
			else if (0 < point && point <= 21)
			{
				valueStringBuilder.Append(buffer._chars.Slice(0, point));
				valueStringBuilder.Append('.');
				valueStringBuilder.Append(buffer._chars.Slice(point, buffer.Length - point));
			}
			else if (point <= 0 && point > -6)
			{
				valueStringBuilder.Append("0.");
				valueStringBuilder.Append('0', -point);
				valueStringBuilder.Append(buffer._chars.Slice(0, buffer.Length));
			}
			else
			{
				valueStringBuilder.Append(buffer._chars[0]);
				if (buffer.Length != 1)
				{
					valueStringBuilder.Append('.');
					valueStringBuilder.Append(buffer._chars.Slice(1, buffer.Length - 1));
				}
				valueStringBuilder.Append('e');
				valueStringBuilder.Append((point >= 0) ? '+' : '-');
				int num = point - 1;
				if (num < 0)
				{
					num = -num;
				}
				valueStringBuilder.Append(num.ToString(CultureInfo.InvariantCulture));
			}
			return valueStringBuilder.ToString();
		}
	}
}
namespace Jint.Native.Number.Dtoa
{
	internal sealed class Bignum
	{
		private const int kMaxSignificantBits = 3584;

		private const int kChunkSize = 32;

		private const int kDoubleChunkSize = 64;

		private const int kBigitSize = 28;

		private const uint kBigitMask = 268435455u;

		private const int kBigitCapacity = 128;

		private readonly uint[] bigits_ = new uint[128];

		private int exponent_;

		private int used_digits_;

		private int BigitLength()
		{
			return used_digits_ + exponent_;
		}

		public uint DivideModuloIntBignum(Bignum other)
		{
			if (BigitLength() < other.BigitLength())
			{
				return 0u;
			}
			Align(other);
			uint num = 0u;
			while (BigitLength() > other.BigitLength())
			{
				num += bigits_[used_digits_ - 1];
				SubtractTimes(other, bigits_[used_digits_ - 1]);
			}
			uint num2 = bigits_[used_digits_ - 1];
			uint num3 = other.bigits_[other.used_digits_ - 1];
			if (other.used_digits_ == 1)
			{
				uint num4 = num2 / num3;
				bigits_[used_digits_ - 1] = num2 - num3 * num4;
				num += num4;
				Clamp();
				return num;
			}
			uint num5 = num2 / (num3 + 1);
			num += num5;
			SubtractTimes(other, num5);
			if (num3 * (num5 + 1) > num2)
			{
				return num;
			}
			while (LessEqual(other, this))
			{
				SubtractBignum(other);
				num++;
			}
			return num;
		}

		private void Align(Bignum other)
		{
			if (exponent_ > other.exponent_)
			{
				int num = exponent_ - other.exponent_;
				ValidateCapacity(used_digits_ + num);
				for (int num2 = used_digits_ - 1; num2 >= 0; num2--)
				{
					bigits_[num2 + num] = bigits_[num2];
				}
				for (int i = 0; i < num; i++)
				{
					bigits_[i] = 0u;
				}
				used_digits_ += num;
				exponent_ -= num;
			}
		}

		private static void ValidateCapacity(int size)
		{
			if (size > 128)
			{
				ExceptionHelper.ThrowInvalidOperationException();
			}
		}

		private void Clamp()
		{
			while (used_digits_ > 0 && bigits_[used_digits_ - 1] == 0)
			{
				used_digits_--;
			}
			if (used_digits_ == 0)
			{
				exponent_ = 0;
			}
		}

		private bool IsClamped()
		{
			if (used_digits_ != 0)
			{
				return bigits_[used_digits_ - 1] != 0;
			}
			return true;
		}

		private void Zero()
		{
			for (int i = 0; i < used_digits_; i++)
			{
				bigits_[i] = 0u;
			}
			used_digits_ = 0;
			exponent_ = 0;
		}

		internal void AssignUInt16(uint value)
		{
			Zero();
			if (value != 0)
			{
				ValidateCapacity(1);
				bigits_[0] = value;
				used_digits_ = 1;
			}
		}

		internal void AssignUInt64(ulong value)
		{
			Zero();
			if (value != 0L)
			{
				int num = 3;
				ValidateCapacity(num);
				for (int i = 0; i < num; i++)
				{
					bigits_[i] = (uint)(value & 0xFFFFFFF);
					value >>= 28;
				}
				used_digits_ = num;
				Clamp();
			}
		}

		internal void AssignBignum(Bignum other)
		{
			exponent_ = other.exponent_;
			for (int i = 0; i < other.used_digits_; i++)
			{
				bigits_[i] = other.bigits_[i];
			}
			for (int j = other.used_digits_; j < used_digits_; j++)
			{
				bigits_[j] = 0u;
			}
			used_digits_ = other.used_digits_;
		}

		private void SubtractTimes(Bignum other, uint factor)
		{
			if (factor < 3)
			{
				for (int i = 0; i < factor; i++)
				{
					SubtractBignum(other);
				}
				return;
			}
			uint num = 0u;
			int num2 = other.exponent_ - exponent_;
			for (int j = 0; j < other.used_digits_; j++)
			{
				ulong num3 = factor * other.bigits_[j];
				ulong num4 = num + num3;
				uint num5 = bigits_[j + num2] - (uint)(int)(num4 & 0xFFFFFFF);
				bigits_[j + num2] = num5 & 0xFFFFFFF;
				num = (uint)((num5 >> 31) + (num4 >> 28));
			}
			for (int k = other.used_digits_ + num2; k < used_digits_; k++)
			{
				if (num == 0)
				{
					return;
				}
				uint num6 = bigits_[k] - num;
				bigits_[k] = num6 & 0xFFFFFFF;
				num = num6 >> 31;
			}
			Clamp();
		}

		private void SubtractBignum(Bignum other)
		{
			Align(other);
			int num = other.exponent_ - exponent_;
			uint num2 = 0u;
			int i;
			for (i = 0; i < other.used_digits_; i++)
			{
				uint num3 = bigits_[i + num] - other.bigits_[i] - num2;
				bigits_[i + num] = num3 & 0xFFFFFFF;
				num2 = num3 >> 31;
			}
			while (num2 != 0)
			{
				uint num4 = bigits_[i + num] - num2;
				bigits_[i + num] = num4 & 0xFFFFFFF;
				num2 = num4 >> 31;
				i++;
			}
			Clamp();
		}

		internal static bool Equal(Bignum a, Bignum b)
		{
			return Compare(a, b) == 0;
		}

		internal static bool LessEqual(Bignum a, Bignum b)
		{
			return Compare(a, b) <= 0;
		}

		internal static bool Less(Bignum a, Bignum b)
		{
			return Compare(a, b) < 0;
		}

		private static bool PlusEqual(Bignum a, Bignum b, Bignum c)
		{
			return PlusCompare(a, b, c) == 0;
		}

		private static bool PlusLessEqual(Bignum a, Bignum b, Bignum c)
		{
			return PlusCompare(a, b, c) <= 0;
		}

		private static bool PlusLess(Bignum a, Bignum b, Bignum c)
		{
			return PlusCompare(a, b, c) < 0;
		}

		private uint BigitAt(int index)
		{
			if (index >= BigitLength())
			{
				return 0u;
			}
			if (index < exponent_)
			{
				return 0u;
			}
			return bigits_[index - exponent_];
		}

		private static int Compare(Bignum a, Bignum b)
		{
			int num = a.BigitLength();
			int num2 = b.BigitLength();
			if (num < num2)
			{
				return -1;
			}
			if (num > num2)
			{
				return 1;
			}
			for (int num3 = num - 1; num3 >= System.Math.Min(a.exponent_, b.exponent_); num3--)
			{
				uint num4 = a.BigitAt(num3);
				uint num5 = b.BigitAt(num3);
				if (num4 < num5)
				{
					return -1;
				}
				if (num4 > num5)
				{
					return 1;
				}
			}
			return 0;
		}

		internal static int PlusCompare(Bignum a, Bignum b, Bignum c)
		{
			if (a.BigitLength() < b.BigitLength())
			{
				return PlusCompare(b, a, c);
			}
			if (a.BigitLength() + 1 < c.BigitLength())
			{
				return -1;
			}
			if (a.BigitLength() > c.BigitLength())
			{
				return 1;
			}
			if (a.exponent_ >= b.BigitLength() && a.BigitLength() < c.BigitLength())
			{
				return -1;
			}
			uint num = 0u;
			int num2 = System.Math.Min(System.Math.Min(a.exponent_, b.exponent_), c.exponent_);
			for (int num3 = c.BigitLength() - 1; num3 >= num2; num3--)
			{
				uint num4 = a.BigitAt(num3);
				uint num5 = b.BigitAt(num3);
				uint num6 = c.BigitAt(num3);
				uint num7 = num4 + num5;
				if (num7 > num6 + num)
				{
					return 1;
				}
				num = num6 + num - num7;
				if (num > 1)
				{
					return -1;
				}
				num <<= 28;
			}
			if (num == 0)
			{
				return 0;
			}
			return -1;
		}

		internal void Times10()
		{
			MultiplyByUInt32(10u);
		}

		internal void MultiplyByUInt32(uint factor)
		{
			switch (factor)
			{
			case 1u:
				return;
			case 0u:
				Zero();
				return;
			}
			if (used_digits_ != 0)
			{
				ulong num = 0uL;
				for (int i = 0; i < used_digits_; i++)
				{
					ulong num2 = (ulong)((long)factor * (long)bigits_[i]) + num;
					bigits_[i] = (uint)(num2 & 0xFFFFFFF);
					num = num2 >> 28;
				}
				while (num != 0L)
				{
					ValidateCapacity(used_digits_ + 1);
					bigits_[used_digits_] = (uint)(num & 0xFFFFFFF);
					used_digits_++;
					num >>= 28;
				}
			}
		}

		internal void MultiplyByUInt64(ulong factor)
		{
			switch (factor)
			{
			case 1uL:
				return;
			case 0uL:
				Zero();
				return;
			}
			ulong num = 0uL;
			ulong num2 = factor & 0xFFFFFFFFu;
			ulong num3 = factor >> 32;
			for (int i = 0; i < used_digits_; i++)
			{
				ulong num4 = num2 * bigits_[i];
				ulong num5 = num3 * bigits_[i];
				ulong num6 = (num & 0xFFFFFFF) + num4;
				bigits_[i] = (uint)(num6 & 0xFFFFFFF);
				num = (num >> 28) + (num6 >> 28) + (num5 << 4);
			}
			while (num != 0L)
			{
				ValidateCapacity(used_digits_ + 1);
				bigits_[used_digits_] = (uint)(num & 0xFFFFFFF);
				used_digits_++;
				num >>= 28;
			}
		}

		internal void ShiftLeft(int shift_amount)
		{
			if (used_digits_ != 0)
			{
				exponent_ += shift_amount / 28;
				int shift_amount2 = shift_amount % 28;
				ValidateCapacity(used_digits_ + 1);
				BigitsShiftLeft(shift_amount2);
			}
		}

		private void BigitsShiftLeft(int shift_amount)
		{
			uint num = 0u;
			for (int i = 0; i < used_digits_; i++)
			{
				uint num2 = bigits_[i] >> 28 - shift_amount;
				bigits_[i] = ((bigits_[i] << shift_amount) + num) & 0xFFFFFFF;
				num = num2;
			}
			if (num != 0)
			{
				bigits_[used_digits_] = num;
				used_digits_++;
			}
		}

		internal void AssignPowerUInt16(uint baseValue, int power_exponent)
		{
			if (power_exponent == 0)
			{
				AssignUInt16(1u);
				return;
			}
			Zero();
			int num = 0;
			while ((baseValue & 1) == 0)
			{
				baseValue >>= 1;
				num++;
			}
			int num2 = 0;
			uint num3 = baseValue;
			while (num3 != 0)
			{
				num3 >>= 1;
				num2++;
			}
			ValidateCapacity(num2 * power_exponent / 28 + 2);
			int num4 = 1;
			while (power_exponent >= num4)
			{
				num4 <<= 1;
			}
			num4 >>= 2;
			ulong num5 = baseValue;
			bool flag = false;
			while (num4 != 0 && num5 <= uint.MaxValue)
			{
				num5 *= num5;
				if ((power_exponent & num4) != 0)
				{
					ulong num6 = (ulong)(~((1L << 64 - num2) - 1));
					if ((num5 & num6) == 0)
					{
						num5 *= baseValue;
					}
					else
					{
						flag = true;
					}
				}
				num4 >>= 1;
			}
			AssignUInt64(num5);
			if (flag)
			{
				MultiplyByUInt32(baseValue);
			}
			while (num4 != 0)
			{
				Square();
				if ((power_exponent & num4) != 0)
				{
					MultiplyByUInt32(baseValue);
				}
				num4 >>= 1;
			}
			ShiftLeft(num * power_exponent);
		}

		private void Square()
		{
			int num = 2 * used_digits_;
			ValidateCapacity(num);
			if (256 <= used_digits_)
			{
				ExceptionHelper.ThrowNotImplementedException();
			}
			ulong num2 = 0uL;
			int num3 = used_digits_;
			for (int i = 0; i < used_digits_; i++)
			{
				bigits_[num3 + i] = bigits_[i];
			}
			for (int j = 0; j < used_digits_; j++)
			{
				int num4 = j;
				int num5 = 0;
				while (num4 >= 0)
				{
					uint num6 = bigits_[num3 + num4];
					uint num7 = bigits_[num3 + num5];
					num2 += (ulong)((long)num6 * (long)num7);
					num4--;
					num5++;
				}
				bigits_[j] = (uint)((int)num2 & 0xFFFFFFF);
				num2 >>= 28;
			}
			for (int k = used_digits_; k < num; k++)
			{
				int num8 = used_digits_ - 1;
				for (int l = k - num8; l < used_digits_; l++)
				{
					uint num9 = bigits_[num3 + num8];
					uint num10 = bigits_[num3 + l];
					num2 += (ulong)((long)num9 * (long)num10);
					num8--;
				}
				bigits_[k] = (uint)((int)num2 & 0xFFFFFFF);
				num2 >>= 28;
			}
			used_digits_ = num;
			exponent_ *= 2;
			Clamp();
		}
	}
	internal static class BignumDtoa
	{
		public static void NumberToString(double v, DtoaMode mode, int requested_digits, ref DtoaBuilder builder, out int decimal_point)
		{
			long d = BitConverter.DoubleToInt64Bits(v);
			ulong num = DoubleHelper.Significand((ulong)d);
			bool is_even = (num & 1) == 0;
			int exponent = DoubleHelper.Exponent((ulong)d);
			int num2 = EstimatePower(DoubleHelper.NormalizedExponent(num, exponent));
			if (mode == DtoaMode.Fixed && -num2 - 1 > requested_digits)
			{
				decimal_point = -requested_digits;
				return;
			}
			Bignum numerator = new Bignum();
			Bignum denominator = new Bignum();
			Bignum delta_minus = new Bignum();
			Bignum delta_plus = new Bignum();
			bool need_boundary_deltas = mode == DtoaMode.Shortest;
			InitialScaledStartValues(v, num2, need_boundary_deltas, numerator, denominator, delta_minus, delta_plus);
			FixupMultiply10(num2, is_even, out decimal_point, numerator, denominator, delta_minus, delta_plus);
			switch (mode)
			{
			case DtoaMode.Shortest:
				GenerateShortestDigits(numerator, denominator, delta_minus, delta_plus, is_even, ref builder);
				break;
			case DtoaMode.Fixed:
				BignumToFixed(requested_digits, ref decimal_point, numerator, denominator, ref builder);
				break;
			case DtoaMode.Precision:
				GenerateCountedDigits(requested_digits, ref decimal_point, numerator, denominator, ref builder);
				break;
			default:
				ExceptionHelper.ThrowArgumentOutOfRangeException();
				break;
			}
		}

		private static void GenerateShortestDigits(Bignum numerator, Bignum denominator, Bignum delta_minus, Bignum delta_plus, bool is_even, ref DtoaBuilder buffer)
		{
			if (Bignum.Equal(delta_minus, delta_plus))
			{
				delta_plus = delta_minus;
			}
			buffer.Reset();
			bool flag;
			bool flag2;
			while (true)
			{
				uint num = numerator.DivideModuloIntBignum(denominator);
				buffer.Append((char)(num + 48));
				flag = ((!is_even) ? Bignum.Less(numerator, delta_minus) : Bignum.LessEqual(numerator, delta_minus));
				flag2 = ((!is_even) ? (Bignum.PlusCompare(numerator, delta_plus, denominator) > 0) : (Bignum.PlusCompare(numerator, delta_plus, denominator) >= 0));
				if (flag || flag2)
				{
					break;
				}
				numerator.Times10();
				delta_minus.Times10();
				if (delta_minus != delta_plus)
				{
					delta_plus.Times10();
				}
			}
			if (flag && flag2)
			{
				int num2 = Bignum.PlusCompare(numerator, numerator, denominator);
				if (num2 >= 0)
				{
					if (num2 > 0)
					{
						buffer[buffer.Length - 1]++;
					}
					else if ((buffer[buffer.Length - 1] - 48) % 2 != 0)
					{
						buffer[buffer.Length - 1]++;
					}
				}
			}
			else if (!flag)
			{
				buffer[buffer.Length - 1]++;
			}
		}

		private static void GenerateCountedDigits(int count, ref int decimal_point, Bignum numerator, Bignum denominator, ref DtoaBuilder buffer)
		{
			for (int i = 0; i < count - 1; i++)
			{
				uint num = numerator.DivideModuloIntBignum(denominator);
				buffer.Append((char)(num + 48));
				numerator.Times10();
			}
			uint num2 = numerator.DivideModuloIntBignum(denominator);
			if (Bignum.PlusCompare(numerator, numerator, denominator) >= 0)
			{
				num2++;
			}
			buffer.Append((char)(num2 + 48));
			int num3 = count - 1;
			while (num3 > 0 && buffer[num3] == ':')
			{
				buffer[num3] = '0';
				buffer[num3 - 1]++;
				num3--;
			}
			if (buffer[0] == ':')
			{
				buffer[0] = '1';
				decimal_point++;
			}
		}

		private static void BignumToFixed(int requested_digits, ref int decimal_point, Bignum numerator, Bignum denominator, ref DtoaBuilder buffer)
		{
			if (-decimal_point > requested_digits)
			{
				decimal_point = -requested_digits;
				buffer.Reset();
			}
			else if (-decimal_point == requested_digits)
			{
				denominator.Times10();
				if (Bignum.PlusCompare(numerator, numerator, denominator) >= 0)
				{
					buffer[0] = '1';
					decimal_point++;
				}
				else
				{
					buffer.Reset();
				}
			}
			else
			{
				GenerateCountedDigits(decimal_point + requested_digits, ref decimal_point, numerator, denominator, ref buffer);
			}
		}

		private static int EstimatePower(int exponent)
		{
			return (int)System.Math.Ceiling((double)(exponent + 53 - 1) * 0.30102999566398114 - 1E-10);
		}

		private static void InitialScaledStartValuesPositiveExponent(double v, int estimated_power, bool need_boundary_deltas, Bignum numerator, Bignum denominator, Bignum delta_minus, Bignum delta_plus)
		{
			ulong num = (ulong)BitConverter.DoubleToInt64Bits(v);
			numerator.AssignUInt64(DoubleHelper.Significand(num));
			numerator.ShiftLeft(DoubleHelper.Exponent(num));
			denominator.AssignPowerUInt16(10u, estimated_power);
			if (need_boundary_deltas)
			{
				denominator.ShiftLeft(1);
				numerator.ShiftLeft(1);
				delta_plus.AssignUInt16(1u);
				delta_plus.ShiftLeft(DoubleHelper.Exponent(num));
				delta_minus.AssignUInt16(1u);
				delta_minus.ShiftLeft(DoubleHelper.Exponent(num));
				if ((num & 0xFFFFFFFFFFFFFL) == 0L)
				{
					denominator.ShiftLeft(1);
					numerator.ShiftLeft(1);
					delta_plus.ShiftLeft(1);
				}
			}
		}

		private static void InitialScaledStartValuesNegativeExponentPositivePower(double v, int estimated_power, bool need_boundary_deltas, Bignum numerator, Bignum denominator, Bignum delta_minus, Bignum delta_plus)
		{
			ulong num = (ulong)BitConverter.DoubleToInt64Bits(v);
			ulong value = DoubleHelper.Significand(num);
			int num2 = DoubleHelper.Exponent(num);
			numerator.AssignUInt64(value);
			denominator.AssignPowerUInt16(10u, estimated_power);
			denominator.ShiftLeft(-num2);
			if (need_boundary_deltas)
			{
				denominator.ShiftLeft(1);
				numerator.ShiftLeft(1);
				delta_plus.AssignUInt16(1u);
				delta_minus.AssignUInt16(1u);
				if ((num & 0xFFFFFFFFFFFFFL) == 0L)
				{
					denominator.ShiftLeft(1);
					numerator.ShiftLeft(1);
					delta_plus.ShiftLeft(1);
				}
			}
		}

		private static void InitialScaledStartValuesNegativeExponentNegativePower(double v, int estimated_power, bool need_boundary_deltas, Bignum numerator, Bignum denominator, Bignum delta_minus, Bignum delta_plus)
		{
			ulong num = (ulong)BitConverter.DoubleToInt64Bits(v);
			ulong factor = DoubleHelper.Significand(num);
			int num2 = DoubleHelper.Exponent(num);
			numerator.AssignPowerUInt16(10u, -estimated_power);
			if (need_boundary_deltas)
			{
				delta_plus.AssignBignum(numerator);
				delta_minus.AssignBignum(numerator);
			}
			numerator.MultiplyByUInt64(factor);
			denominator.AssignUInt16(1u);
			denominator.ShiftLeft(-num2);
			if (need_boundary_deltas)
			{
				numerator.ShiftLeft(1);
				denominator.ShiftLeft(1);
				ulong num3 = num;
				if ((num3 & 0xFFFFFFFFFFFFFL) == 0L && (num3 & 0x7FF0000000000000L) != 4503599627370496L)
				{
					numerator.ShiftLeft(1);
					denominator.ShiftLeft(1);
					delta_plus.ShiftLeft(1);
				}
			}
		}

		private static void InitialScaledStartValues(double v, int estimated_power, bool need_boundary_deltas, Bignum numerator, Bignum denominator, Bignum delta_minus, Bignum delta_plus)
		{
			if (DoubleHelper.Exponent((ulong)BitConverter.DoubleToInt64Bits(v)) >= 0)
			{
				InitialScaledStartValuesPositiveExponent(v, estimated_power, need_boundary_deltas, numerator, denominator, delta_minus, delta_plus);
			}
			else if (estimated_power >= 0)
			{
				InitialScaledStartValuesNegativeExponentPositivePower(v, estimated_power, need_boundary_deltas, numerator, denominator, delta_minus, delta_plus);
			}
			else
			{
				InitialScaledStartValuesNegativeExponentNegativePower(v, estimated_power, need_boundary_deltas, numerator, denominator, delta_minus, delta_plus);
			}
		}

		private static void FixupMultiply10(int estimated_power, bool is_even, out int decimal_point, Bignum numerator, Bignum denominator, Bignum delta_minus, Bignum delta_plus)
		{
			if ((!is_even) ? (Bignum.PlusCompare(numerator, delta_plus, denominator) > 0) : (Bignum.PlusCompare(numerator, delta_plus, denominator) >= 0))
			{
				decimal_point = estimated_power + 1;
				return;
			}
			decimal_point = estimated_power;
			numerator.Times10();
			if (Bignum.Equal(delta_minus, delta_plus))
			{
				delta_minus.Times10();
				delta_plus.AssignBignum(delta_minus);
			}
			else
			{
				delta_minus.Times10();
				delta_plus.Times10();
			}
		}
	}
	internal static class CachedPowers
	{
		private sealed class CachedPower
		{
			internal readonly ulong Significand;

			internal readonly short BinaryExponent;

			internal readonly short DecimalExponent;

			internal CachedPower(ulong significand, short binaryExponent, short decimalExponent)
			{
				Significand = significand;
				BinaryExponent = binaryExponent;
				DecimalExponent = decimalExponent;
			}
		}

		[StructLayout(LayoutKind.Auto)]
		internal readonly struct GetCachedPowerResult
		{
			internal readonly short decimalExponent;

			internal readonly DiyFp cMk;

			public GetCachedPowerResult(short decimalExponent, DiyFp cMk)
			{
				this.decimalExponent = decimalExponent;
				this.cMk = cMk;
			}
		}

		private const double Kd1Log210 = 0.30102999566398114;

		private static readonly CachedPower[] CACHED_POWERS = new CachedPower[87]
		{
			new CachedPower(18054884314459144840uL, -1220, -348),
			new CachedPower(13451937075301367670uL, -1193, -340),
			new CachedPower(10022474136428063862uL, -1166, -332),
			new CachedPower(14934650266808366570uL, -1140, -324),
			new CachedPower(11127181549972568877uL, -1113, -316),
			new CachedPower(16580792590934885855uL, -1087, -308),
			new CachedPower(12353653155963782858uL, -1060, -300),
			new CachedPower(18408377700990114895uL, -1034, -292),
			new CachedPower(13715310171984221708uL, -1007, -284),
			new CachedPower(10218702384817765436uL, -980, -276),
			new CachedPower(15227053142812498563uL, -954, -268),
			new CachedPower(11345038669416679861uL, -927, -260),
			new CachedPower(16905424996341287883uL, -901, -252),
			new CachedPower(12595523146049147757uL, -874, -244),
			new CachedPower(9384396036005875287uL, -847, -236),
			new CachedPower(13983839803942852151uL, -821, -228),
			new CachedPower(10418772551374772303uL, -794, -220),
			new CachedPower(15525180923007089351uL, -768, -212),
			new CachedPower(11567161174868858868uL, -741, -204),
			new CachedPower(17236413322193710309uL, -715, -196),
			new CachedPower(12842128665889583758uL, -688, -188),
			new CachedPower(9568131466127621947uL, -661, -180),
			new CachedPower(14257626930069360058uL, -635, -172),
			new CachedPower(10622759856335341974uL, -608, -164),
			new CachedPower(15829145694278690180uL, -582, -156),
			new CachedPower(11793632577567316726uL, -555, -148),
			new CachedPower(17573882009934360870uL, -529, -140),
			new CachedPower(13093562431584567480uL, -502, -132),
			new CachedPower(9755464219737475723uL, -475, -124),
			new CachedPower(14536774485912137811uL, -449, -116),
			new CachedPower(10830740992659433045uL, -422, -108),
			new CachedPower(16139061738043178685uL, -396, -100),
			new CachedPower(12024538023802026127uL, -369, -92),
			new CachedPower(17917957937422433684uL, -343, -84),
			new CachedPower(13349918974505688015uL, -316, -76),
			new CachedPower(9946464728195732843uL, -289, -68),
			new CachedPower(14821387422376473014uL, -263, -60),
			new CachedPower(11042794154864902060uL, -236, -52),
			new CachedPower(16455045573212060422uL, -210, -44),
			new CachedPower(12259964326927110867uL, -183, -36),
			new CachedPower(18268770466636286478uL, -157, -28),
			new CachedPower(13611294676837538539uL, -130, -20),
			new CachedPower(10141204801825835212uL, -103, -12),
			new CachedPower(15111572745182864684uL, -77, -4),
			new CachedPower(11258999068426240000uL, -50, 4),
			new CachedPower(16777216000000000000uL, -24, 12),
			new CachedPower(12500000000000000000uL, 3, 20),
			new CachedPower(9313225746154785156uL, 30, 28),
			new CachedPower(13877787807814456755uL, 56, 36),
			new CachedPower(10339757656912845936uL, 83, 44),
			new CachedPower(15407439555097886824uL, 109, 52),
			new CachedPower(11479437019748901445uL, 136, 60),
			new CachedPower(17105694144590052135uL, 162, 68),
			new CachedPower(12744735289059618216uL, 189, 76),
			new CachedPower(9495567745759798747uL, 216, 84),
			new CachedPower(14149498560666738074uL, 242, 92),
			new CachedPower(10542197943230523224uL, 269, 100),
			new CachedPower(15709099088952724970uL, 295, 108),
			new CachedPower(11704190886730495818uL, 322, 116),
			new CachedPower(17440603504673385349uL, 348, 124),
			new CachedPower(12994262207056124023uL, 375, 132),
			new CachedPower(9681479787123295682uL, 402, 140),
			new CachedPower(14426529090290212157uL, 428, 148),
			new CachedPower(10748601772107342003uL, 455, 156),
			new CachedPower(16016664761464807395uL, 481, 164),
			new CachedPower(11933345169920330789uL, 508, 172),
			new CachedPower(17782069995880619868uL, 534, 180),
			new CachedPower(13248674568444952270uL, 561, 188),
			new CachedPower(9871031767461413346uL, 588, 196),
			new CachedPower(14708983551653345445uL, 614, 204),
			new CachedPower(10959046745042015199uL, 641, 212),
			new CachedPower(16330252207878254650uL, 667, 220),
			new CachedPower(12166986024289022870uL, 694, 228),
			new CachedPower(18130221999122236476uL, 720, 236),
			new CachedPower(13508068024458167312uL, 747, 244),
			new CachedPower(10064294952495520794uL, 774, 252),
			new CachedPower(14996968138956309548uL, 800, 260),
			new CachedPower(11173611982879273257uL, 827, 268),
			new CachedPower(16649979327439178909uL, 853, 276),
			new CachedPower(12405201291620119593uL, 880, 284),
			new CachedPower(9242595204427927429uL, 907, 292),
			new CachedPower(13772540099066387757uL, 933, 300),
			new CachedPower(10261342003245940623uL, 960, 308),
			new CachedPower(15290591125556738113uL, 986, 316),
			new CachedPower(11392378155556871081uL, 1013, 324),
			new CachedPower(16975966327722178521uL, 1039, 332),
			new CachedPower(12648080533535911531uL, 1066, 340)
		};

		private const int kCachedPowersOffset = 348;

		private const int kDecimalExponentDistance = 8;

		private const int kMinDecimalExponent = -348;

		private const int kMaxDecimalExponent = 340;

		internal static GetCachedPowerResult GetCachedPowerForBinaryExponentRange(int min_exponent, int max_exponent)
		{
			double num = System.Math.Ceiling((double)(min_exponent + 64 - 1) * 0.30102999566398114);
			int num2 = (348 + (int)num - 1) / 8 + 1;
			CachedPower cachedPower = CACHED_POWERS[num2];
			return new GetCachedPowerResult(cMk: new DiyFp(cachedPower.Significand, cachedPower.BinaryExponent), decimalExponent: cachedPower.DecimalExponent);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct DiyFp
	{
		internal const int KSignificandSize = 64;

		private const ulong KUint64MSB = 9223372036854775808uL;

		public readonly ulong F;

		public readonly int E;

		internal DiyFp(ulong f, int e)
		{
			F = f;
			E = e;
		}

		internal static DiyFp Minus(in DiyFp a, in DiyFp b)
		{
			return new DiyFp(a.F - b.F, a.E);
		}

		internal static DiyFp Times(in DiyFp a, in DiyFp b)
		{
			ulong num = a.F >> 32;
			ulong num2 = a.F & 0xFFFFFFFFu;
			ulong num3 = b.F >> 32;
			ulong num4 = b.F & 0xFFFFFFFFu;
			ulong num5 = num * num3;
			ulong num6 = num2 * num3;
			ulong num7 = num * num4;
			ulong num8 = (num2 * num4 >> 32) + (num7 & 0xFFFFFFFFu) + (num6 & 0xFFFFFFFFu);
			num8 += 2147483648u;
			return new DiyFp(num5 + (num7 >> 32) + (num6 >> 32) + (num8 >> 32), a.E + b.E + 64);
		}

		internal static DiyFp Normalize(ulong f, int e)
		{
			while ((f & 0xFFC0000000000000uL) == 0L)
			{
				f <<= 10;
				e -= 10;
			}
			while ((f & 0x8000000000000000uL) == 0L)
			{
				f <<= 1;
				e--;
			}
			return new DiyFp(f, e);
		}

		public override string ToString()
		{
			return "[DiyFp f:" + F + ", e:" + E + "]";
		}
	}
	internal sealed class DoubleHelper
	{
		[StructLayout(LayoutKind.Auto)]
		internal readonly struct NormalizedBoundariesResult
		{
			internal readonly DiyFp Minus;

			internal readonly DiyFp Plus;

			public NormalizedBoundariesResult(DiyFp minus, DiyFp plus)
			{
				Minus = minus;
				Plus = plus;
			}
		}

		internal const ulong KExponentMask = 9218868437227405312uL;

		internal const ulong KSignificandMask = 4503599627370495uL;

		private const ulong KHiddenBit = 4503599627370496uL;

		private const int KSignificandSize = 52;

		private const int KExponentBias = 1075;

		private const int KDenormalExponent = -1074;

		private static DiyFp AsDiyFp(ulong d64)
		{
			return new DiyFp(Significand(d64), Exponent(d64));
		}

		internal static DiyFp AsNormalizedDiyFp(ulong d64)
		{
			ulong num = Significand(d64);
			int num2 = Exponent(d64);
			while ((num & 0x10000000000000L) == 0L)
			{
				num <<= 1;
				num2--;
			}
			num <<= 11;
			num2 -= 11;
			return new DiyFp(num, num2);
		}

		internal static int Exponent(ulong d64)
		{
			if (IsDenormal(d64))
			{
				return -1074;
			}
			return (int)((d64 & 0x7FF0000000000000L).UnsignedShift(52) & 0xFFFFFFFFu) - 1075;
		}

		internal static int NormalizedExponent(ulong significand, int exponent)
		{
			while ((significand & 0x10000000000000L) == 0L)
			{
				significand <<= 1;
				exponent--;
			}
			return exponent;
		}

		internal static ulong Significand(ulong d64)
		{
			ulong num = d64 & 0xFFFFFFFFFFFFFL;
			if (!IsDenormal(d64))
			{
				return num + 4503599627370496L;
			}
			return num;
		}

		private static bool IsDenormal(ulong d64)
		{
			return (d64 & 0x7FF0000000000000L) == 0;
		}

		private static bool IsSpecial(ulong d64)
		{
			return (d64 & 0x7FF0000000000000L) == 9218868437227405312L;
		}

		internal static NormalizedBoundariesResult NormalizedBoundaries(ulong d64)
		{
			DiyFp diyFp = AsDiyFp(d64);
			bool num = diyFp.F == 4503599627370496L;
			DiyFp plus = DiyFp.Normalize((diyFp.F << 1) + 1, diyFp.E - 1);
			DiyFp diyFp2 = ((!num || diyFp.E == -1074) ? new DiyFp((diyFp.F << 1) - 1, diyFp.E - 1) : new DiyFp((diyFp.F << 2) - 1, diyFp.E - 2));
			diyFp2 = new DiyFp(diyFp2.F << diyFp2.E - plus.E, plus.E);
			return new NormalizedBoundariesResult(diyFp2, plus);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal ref struct DtoaBuilder
	{
		internal readonly Span<char> _chars;

		internal int Length;

		public char this[int i]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _chars[i];
			}
			set
			{
				_chars[i] = value;
				Length = System.Math.Max(Length, i + 1);
			}
		}

		public DtoaBuilder(Span<char> initialBuffer)
		{
			Length = 0;
			_chars = initialBuffer;
		}

		internal void Append(char c)
		{
			_chars[Length++] = c;
		}

		internal void DecreaseLast()
		{
			_chars[Length - 1] -= '\u0001';
		}

		public void Reset()
		{
			Length = 0;
			_chars.Clear();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<char> Slice(int start, int length)
		{
			return _chars.Slice(start, length);
		}

		public override string ToString()
		{
			return "[chars:" + _chars.Slice(0, Length).ToString() + "]";
		}
	}
	internal enum DtoaMode
	{
		Shortest,
		Precision,
		Fixed
	}
	internal static class DtoaNumberFormatter
	{
		public static void DoubleToAscii(ref DtoaBuilder buffer, double v, DtoaMode mode, int requested_digits, out bool negative, out int point)
		{
			point = 0;
			negative = false;
			buffer.Reset();
			if (v < 0.0)
			{
				negative = true;
				v = 0.0 - v;
			}
			if (v == 0.0)
			{
				buffer[0] = '0';
				point = 1;
			}
			else if (mode != DtoaMode.Precision || requested_digits != 0)
			{
				bool flag = false;
				switch (mode)
				{
				case DtoaMode.Shortest:
					flag = FastDtoa.NumberToString(v, DtoaMode.Shortest, 0, out point, ref buffer);
					break;
				case DtoaMode.Fixed:
					ExceptionHelper.ThrowNotImplementedException();
					break;
				case DtoaMode.Precision:
					flag = FastDtoa.NumberToString(v, DtoaMode.Precision, requested_digits, out point, ref buffer);
					break;
				default:
					ExceptionHelper.ThrowArgumentOutOfRangeException();
					return;
				}
				if (!flag)
				{
					buffer.Reset();
					BignumDtoa.NumberToString(v, mode, requested_digits, ref buffer, out point);
				}
			}
		}
	}
	internal sealed class FastDtoa
	{
		public const int KFastDtoaMaximalLength = 17;

		private const int MinimalTargetExponent = -60;

		private const int MaximalTargetExponent = -32;

		private const int KTen4 = 10000;

		private const int KTen5 = 100000;

		private const int KTen6 = 1000000;

		private const int KTen7 = 10000000;

		private const int KTen8 = 100000000;

		private const int KTen9 = 1000000000;

		private static bool RoundWeed(ref DtoaBuilder buffer, ulong distanceTooHighW, ulong unsafeInterval, ulong rest, ulong tenKappa, ulong unit)
		{
			ulong num = distanceTooHighW - unit;
			ulong num2 = distanceTooHighW + unit;
			while (rest < num && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num || num - rest >= rest + tenKappa - num))
			{
				buffer.DecreaseLast();
				rest += tenKappa;
			}
			if (rest < num2 && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num2 || num2 - rest > rest + tenKappa - num2))
			{
				return false;
			}
			if (2 * unit <= rest)
			{
				return rest <= unsafeInterval - 4 * unit;
			}
			return false;
		}

		private static bool RoundWeedCounted(ref DtoaBuilder buffer, ulong rest, ulong ten_kappa, ulong unit, ref int kappa)
		{
			if (unit >= ten_kappa)
			{
				return false;
			}
			if (ten_kappa - unit <= unit)
			{
				return false;
			}
			if (ten_kappa - rest > rest && ten_kappa - 2 * rest >= 2 * unit)
			{
				return true;
			}
			if (rest > unit && ten_kappa - (rest - unit) <= rest - unit)
			{
				buffer._chars[buffer.Length - 1] += '\u0001';
				int num = buffer.Length - 1;
				while (num > 0 && buffer._chars[num] == ':')
				{
					buffer._chars[num] = '0';
					buffer._chars[num - 1] += '\u0001';
					num--;
				}
				if (buffer._chars[0] == ':')
				{
					buffer._chars[0] = '1';
					kappa++;
				}
				return true;
			}
			return false;
		}

		private static void BiggestPowerTen(uint number, int numberBits, out uint power, out int exponent)
		{
			switch (numberBits)
			{
			case 30:
			case 31:
			case 32:
				if (1000000000 <= number)
				{
					power = 1000000000u;
					exponent = 9;
					break;
				}
				goto case 27;
			case 27:
			case 28:
			case 29:
				if (100000000 <= number)
				{
					power = 100000000u;
					exponent = 8;
					break;
				}
				goto case 24;
			case 24:
			case 25:
			case 26:
				if (10000000 <= number)
				{
					power = 10000000u;
					exponent = 7;
					break;
				}
				goto case 20;
			case 20:
			case 21:
			case 22:
			case 23:
				if (1000000 <= number)
				{
					power = 1000000u;
					exponent = 6;
					break;
				}
				goto case 17;
			case 17:
			case 18:
			case 19:
				if (100000 <= number)
				{
					power = 100000u;
					exponent = 5;
					break;
				}
				goto case 14;
			case 14:
			case 15:
			case 16:
				if (10000 <= number)
				{
					power = 10000u;
					exponent = 4;
					break;
				}
				goto case 10;
			case 10:
			case 11:
			case 12:
			case 13:
				if (1000 <= number)
				{
					power = 1000u;
					exponent = 3;
					break;
				}
				goto case 7;
			case 7:
			case 8:
			case 9:
				if (100 <= number)
				{
					power = 100u;
					exponent = 2;
					break;
				}
				goto case 4;
			case 4:
			case 5:
			case 6:
				if (10 <= number)
				{
					power = 10u;
					exponent = 1;
					break;
				}
				goto case 1;
			case 1:
			case 2:
			case 3:
				if (1 <= number)
				{
					power = 1u;
					exponent = 0;
					break;
				}
				goto case 0;
			case 0:
				power = 0u;
				exponent = -1;
				break;
			default:
				power = 0u;
				exponent = 0;
				break;
			}
		}

		private static bool DigitGen(in DiyFp low, in DiyFp w, in DiyFp high, ref DtoaBuilder buffer, int mk, out int kappa)
		{
			ulong num = 1uL;
			DiyFp b = new DiyFp(low.F - num, low.E);
			DiyFp a = new DiyFp(high.F + num, high.E);
			DiyFp diyFp = DiyFp.Minus(in a, in b);
			DiyFp diyFp2 = new DiyFp((ulong)(1L << -w.E), w.E);
			uint num2 = (uint)(a.F.UnsignedShift(-diyFp2.E) & 0xFFFFFFFFu);
			ulong num3 = a.F & (diyFp2.F - 1);
			BiggestPowerTen(num2, 64 - -diyFp2.E, out var power, out var exponent);
			kappa = exponent + 1;
			while (kappa > 0)
			{
				int num4 = (int)(num2 / power);
				buffer.Append((char)(48 + num4));
				num2 %= power;
				kappa--;
				ulong num5 = ((ulong)num2 << -diyFp2.E) + num3;
				if (num5 < diyFp.F)
				{
					return RoundWeed(ref buffer, DiyFp.Minus(in a, in w).F, diyFp.F, num5, (ulong)power << -diyFp2.E, num);
				}
				power /= 10;
			}
			do
			{
				num3 *= 5;
				num *= 5;
				diyFp = new DiyFp(diyFp.F * 5, diyFp.E + 1);
				diyFp2 = new DiyFp(diyFp2.F.UnsignedShift(1), diyFp2.E + 1);
				int num6 = (int)(num3.UnsignedShift(-diyFp2.E) & 0xFFFFFFFFu);
				buffer.Append((char)(48 + num6));
				num3 &= diyFp2.F - 1;
				kappa--;
			}
			while (num3 >= diyFp.F);
			return RoundWeed(ref buffer, DiyFp.Minus(in a, in w).F * num, diyFp.F, num3, diyFp2.F, num);
		}

		private static bool DigitGenCounted(in DiyFp w, int requested_digits, ref DtoaBuilder buffer, out int kappa)
		{
			ulong num = 1uL;
			DiyFp diyFp = new DiyFp((ulong)(1L << -w.E), w.E);
			uint num2 = (uint)(w.F >> -diyFp.E);
			ulong num3 = w.F & (diyFp.F - 1);
			BiggestPowerTen(num2, 64 - -diyFp.E, out var power, out var exponent);
			kappa = exponent + 1;
			while (kappa > 0)
			{
				int num4 = (int)(num2 / power);
				buffer.Append((char)(48 + num4));
				requested_digits--;
				num2 %= power;
				kappa--;
				if (requested_digits == 0)
				{
					break;
				}
				power /= 10;
			}
			if (requested_digits == 0)
			{
				ulong rest = ((ulong)num2 << -diyFp.E) + num3;
				return RoundWeedCounted(ref buffer, rest, (ulong)power << -diyFp.E, num, ref kappa);
			}
			while (requested_digits > 0 && num3 > num)
			{
				num3 *= 10;
				num *= 10;
				int num5 = (int)(num3 >> -diyFp.E);
				buffer.Append((char)(48 + num5));
				requested_digits--;
				num3 &= diyFp.F - 1;
				kappa--;
			}
			if (requested_digits != 0)
			{
				return false;
			}
			return RoundWeedCounted(ref buffer, num3, diyFp.F, num, ref kappa);
		}

		private static bool Grisu3(double v, ref DtoaBuilder buffer, out int decimal_exponent)
		{
			long d = BitConverter.DoubleToInt64Bits(v);
			DiyFp a = DoubleHelper.AsNormalizedDiyFp((ulong)d);
			DoubleHelper.NormalizedBoundariesResult normalizedBoundariesResult = DoubleHelper.NormalizedBoundaries((ulong)d);
			DiyFp a2 = normalizedBoundariesResult.Minus;
			DiyFp a3 = normalizedBoundariesResult.Plus;
			CachedPowers.GetCachedPowerResult cachedPowerForBinaryExponentRange = CachedPowers.GetCachedPowerForBinaryExponentRange(-60 - (a.E + 64), -32 - (a.E + 64));
			short decimalExponent = cachedPowerForBinaryExponentRange.decimalExponent;
			DiyFp b = cachedPowerForBinaryExponentRange.cMk;
			DiyFp w = DiyFp.Times(in a, in b);
			int kappa;
			bool result = DigitGen(DiyFp.Times(in a2, in b), in w, DiyFp.Times(in a3, in b), ref buffer, decimalExponent, out kappa);
			decimal_exponent = -decimalExponent + kappa;
			return result;
		}

		private static bool Grisu3Counted(double v, int requested_digits, ref DtoaBuilder buffer, out int decimal_exponent)
		{
			DiyFp a = DoubleHelper.AsNormalizedDiyFp((ulong)BitConverter.DoubleToInt64Bits(v));
			CachedPowers.GetCachedPowerResult cachedPowerForBinaryExponentRange = CachedPowers.GetCachedPowerForBinaryExponentRange(-60 - (a.E + 64), -32 - (a.E + 64));
			short decimalExponent = cachedPowerForBinaryExponentRange.decimalExponent;
			DiyFp b = cachedPowerForBinaryExponentRange.cMk;
			int kappa;
			bool result = DigitGenCounted(DiyFp.Times(in a, in b), requested_digits, ref buffer, out kappa);
			decimal_exponent = -decimalExponent + kappa;
			return result;
		}

		public static bool NumberToString(double v, DtoaMode mode, int requested_digits, out int decimal_point, ref DtoaBuilder buffer)
		{
			bool flag = false;
			int decimal_exponent = 0;
			switch (mode)
			{
			case DtoaMode.Shortest:
				flag = Grisu3(v, ref buffer, out decimal_exponent);
				break;
			case DtoaMode.Precision:
				flag = Grisu3Counted(v, requested_digits, ref buffer, out decimal_exponent);
				break;
			default:
				ExceptionHelper.ThrowArgumentOutOfRangeException();
				break;
			}
			if (flag)
			{
				decimal_point = buffer.Length + decimal_exponent;
				return true;
			}
			decimal_point = -1;
			return false;
		}
	}
	internal static class NumberExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static long UnsignedShift(this long l, int shift)
		{
			return l >>> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ulong UnsignedShift(this ulong l, int shift)
		{
			return l >> shift;
		}
	}
}
namespace Jint.Native.Math
{
	internal sealed class MathInstance : ObjectInstance
	{
		private Random? _random;

		internal MathInstance(Engine engine, ObjectPrototype objectPrototype)
			: base(engine)
		{
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(45, checkExistingKeys: false)
			{
				["abs"] = new PropertyDescriptor(new ClrFunction(base.Engine, "abs", Abs, 1, PropertyFlag.Configurable), true, false, true),
				["acos"] = new PropertyDescriptor(new ClrFunction(base.Engine, "acos", Acos, 1, PropertyFlag.Configurable), true, false, true),
				["acosh"] = new PropertyDescriptor(new ClrFunction(base.Engine, "acosh", Acosh, 1, PropertyFlag.Configurable), true, false, true),
				["asin"] = new PropertyDescriptor(new ClrFunction(base.Engine, "asin", Asin, 1, PropertyFlag.Configurable), true, false, true),
				["asinh"] = new PropertyDescriptor(new ClrFunction(base.Engine, "asinh", Asinh, 1, PropertyFlag.Configurable), true, false, true),
				["atan"] = new PropertyDescriptor(new ClrFunction(base.Engine, "atan", Atan, 1, PropertyFlag.Configurable), true, false, true),
				["atanh"] = new PropertyDescriptor(new ClrFunction(base.Engine, "atanh", Atanh, 1, PropertyFlag.Configurable), true, false, true),
				["atan2"] = new PropertyDescriptor(new ClrFunction(base.Engine, "atan2", Atan2, 2, PropertyFlag.Configurable), true, false, true),
				["ceil"] = new PropertyDescriptor(new ClrFunction(base.Engine, "ceil", Ceil, 1, PropertyFlag.Configurable), true, false, true),
				["cos"] = new PropertyDescriptor(new ClrFunction(base.Engine, "cos", Cos, 1, PropertyFlag.Configurable), true, false, true),
				["cosh"] = new PropertyDescriptor(new ClrFunction(base.Engine, "cosh", Cosh, 1, PropertyFlag.Configurable), true, false, true),
				["exp"] = new PropertyDescriptor(new ClrFunction(base.Engine, "exp", Exp, 1, PropertyFlag.Configurable), true, false, true),
				["expm1"] = new PropertyDescriptor(new ClrFunction(base.Engine, "expm1", Expm1, 1, PropertyFlag.Configurable), true, false, true),
				["floor"] = new PropertyDescriptor(new ClrFunction(base.Engine, "floor", Floor, 1, PropertyFlag.Configurable), true, false, true),
				["log"] = new PropertyDescriptor(new ClrFunction(base.Engine, "log", Log, 1, PropertyFlag.Configurable), true, false, true),
				["log1p"] = new PropertyDescriptor(new ClrFunction(base.Engine, "log1p", Log1p, 1, PropertyFlag.Configurable), true, false, true),
				["log2"] = new PropertyDescriptor(new ClrFunction(base.Engine, "log2", Log2, 1, PropertyFlag.Configurable), true, false, true),
				["log10"] = new PropertyDescriptor(new ClrFunction(base.Engine, "log10", Log10, 1, PropertyFlag.Configurable), true, false, true),
				["max"] = new PropertyDescriptor(new ClrFunction(base.Engine, "max", Max, 2, PropertyFlag.Configurable), true, false, true),
				["min"] = new PropertyDescriptor(new ClrFunction(base.Engine, "min", Min, 2, PropertyFlag.Configurable), true, false, true),
				["pow"] = new PropertyDescriptor(new ClrFunction(base.Engine, "pow", Pow, 2, PropertyFlag.Configurable), true, false, true),
				["random"] = new PropertyDescriptor(new ClrFunction(base.Engine, "random", Random, 0, PropertyFlag.Configurable), true, false, true),
				["round"] = new PropertyDescriptor(new ClrFunction(base.Engine, "round", Round, 1, PropertyFlag.Configurable), true, false, true),
				["fround"] = new PropertyDescriptor(new ClrFunction(base.Engine, "fround", Fround, 1, PropertyFlag.Configurable), true, false, true),
				["sin"] = new PropertyDescriptor(new ClrFunction(base.Engine, "sin", Sin, 1, PropertyFlag.Configurable), true, false, true),
				["sinh"] = new PropertyDescriptor(new ClrFunction(base.Engine, "sinh", Sinh, 1, PropertyFlag.Configurable), true, false, true),
				["sqrt"] = new PropertyDescriptor(new ClrFunction(base.Engine, "sqrt", Sqrt, 1, PropertyFlag.Configurable), true, false, true),
				["tan"] = new PropertyDescriptor(new ClrFunction(base.Engine, "tan", Tan, 1, PropertyFlag.Configurable), true, false, true),
				["tanh"] = new PropertyDescriptor(new ClrFunction(base.Engine, "tanh", Tanh, 1, PropertyFlag.Configurable), true, false, true),
				["trunc"] = new PropertyDescriptor(new ClrFunction(base.Engine, "trunc", Truncate, 1, PropertyFlag.Configurable), true, false, true),
				["sign"] = new PropertyDescriptor(new ClrFunction(base.Engine, "sign", Sign, 1, PropertyFlag.Configurable), true, false, true),
				["cbrt"] = new PropertyDescriptor(new ClrFunction(base.Engine, "cbrt", Cbrt, 1, PropertyFlag.Configurable), true, false, true),
				["hypot"] = new PropertyDescriptor(new ClrFunction(base.Engine, "hypot", Hypot, 2, PropertyFlag.Configurable), true, false, true),
				["imul"] = new PropertyDescriptor(new ClrFunction(base.Engine, "imul", Imul, 2, PropertyFlag.Configurable), true, false, true),
				["clz32"] = new PropertyDescriptor(new ClrFunction(base.Engine, "clz32", Clz32, 1, PropertyFlag.Configurable), true, false, true),
				["E"] = new PropertyDescriptor(System.Math.E, false, false, false),
				["LN10"] = new PropertyDescriptor(System.Math.Log(10.0), false, false, false),
				["LN2"] = new PropertyDescriptor(System.Math.Log(2.0), false, false, false),
				["LOG2E"] = new PropertyDescriptor(System.Math.Log(System.Math.E, 2.0), false, false, false),
				["LOG10E"] = new PropertyDescriptor(System.Math.Log(System.Math.E, 10.0), false, false, false),
				["PI"] = new PropertyDescriptor(System.Math.PI, false, false, false),
				["SQRT1_2"] = new PropertyDescriptor(System.Math.Sqrt(0.5), false, false, false),
				["SQRT2"] = new PropertyDescriptor(System.Math.Sqrt(2.0), false, false, false)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor(new JsString("Math"), PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private static JsValue Abs(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				return JsNumber.PositiveZero;
			}
			if (double.IsInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			return System.Math.Abs(num);
		}

		private static JsValue Acos(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num) || num > 1.0 || num < -1.0)
			{
				return JsNumber.DoubleNaN;
			}
			if (num == 1.0)
			{
				return 0;
			}
			return System.Math.Acos(num);
		}

		private static JsValue Acosh(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num) || num < 1.0)
			{
				return JsNumber.DoubleNaN;
			}
			return System.Math.Log(num + System.Math.Sqrt(num * num - 1.0));
		}

		private static JsValue Asin(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num) || num > 1.0 || num < -1.0)
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return num;
			}
			return System.Math.Asin(num);
		}

		private static JsValue Asinh(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsInfinity(num) || NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return num;
			}
			return System.Math.Log(num + System.Math.Sqrt(num * num + 1.0));
		}

		private static JsValue Atan(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return num;
			}
			if (double.IsPositiveInfinity(num))
			{
				return System.Math.PI / 2.0;
			}
			if (double.IsNegativeInfinity(num))
			{
				return -System.Math.PI / 2.0;
			}
			return System.Math.Atan(num);
		}

		private static JsValue Atanh(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return num;
			}
			return 0.5 * System.Math.Log((1.0 + num) / (1.0 - num));
		}

		private static JsValue Atan2(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			double num2 = TypeConverter.ToNumber(arguments.At(1));
			if (double.IsNaN(num2) || double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (num > 0.0 && num2.Equals(0.0))
			{
				return System.Math.PI / 2.0;
			}
			if (NumberInstance.IsPositiveZero(num))
			{
				if (num2 > 0.0)
				{
					return JsNumber.PositiveZero;
				}
				if (NumberInstance.IsPositiveZero(num2))
				{
					return JsNumber.PositiveZero;
				}
				if (NumberInstance.IsNegativeZero(num2))
				{
					return JsNumber.PI;
				}
				if (num2 < 0.0)
				{
					return JsNumber.PI;
				}
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				if (num2 > 0.0)
				{
					return JsNumber.NegativeZero;
				}
				if (NumberInstance.IsPositiveZero(num2))
				{
					return JsNumber.NegativeZero;
				}
				if (NumberInstance.IsNegativeZero(num2))
				{
					return -System.Math.PI;
				}
				if (num2 < 0.0)
				{
					return -System.Math.PI;
				}
			}
			if (num < 0.0 && num2.Equals(0.0))
			{
				return -System.Math.PI / 2.0;
			}
			if (num > 0.0 && !double.IsInfinity(num))
			{
				if (double.IsPositiveInfinity(num2))
				{
					return JsNumber.PositiveZero;
				}
				if (double.IsNegativeInfinity(num2))
				{
					return JsNumber.PI;
				}
			}
			if (num < 0.0 && !double.IsInfinity(num))
			{
				if (double.IsPositiveInfinity(num2))
				{
					return JsNumber.NegativeZero;
				}
				if (double.IsNegativeInfinity(num2))
				{
					return -System.Math.PI;
				}
			}
			if (double.IsPositiveInfinity(num) && !double.IsInfinity(num2))
			{
				return System.Math.PI / 2.0;
			}
			if (double.IsNegativeInfinity(num) && !double.IsInfinity(num2))
			{
				return -System.Math.PI / 2.0;
			}
			if (double.IsPositiveInfinity(num) && double.IsPositiveInfinity(num2))
			{
				return System.Math.PI / 4.0;
			}
			if (double.IsPositiveInfinity(num) && double.IsNegativeInfinity(num2))
			{
				return System.Math.PI * 3.0 / 4.0;
			}
			if (double.IsNegativeInfinity(num) && double.IsPositiveInfinity(num2))
			{
				return -System.Math.PI / 4.0;
			}
			if (double.IsNegativeInfinity(num) && double.IsNegativeInfinity(num2))
			{
				return System.Math.PI * -3.0 / 4.0;
			}
			return System.Math.Atan2(num, num2);
		}

		private static JsValue Ceil(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num))
			{
				return JsNumber.PositiveZero;
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				return JsNumber.NegativeZero;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			return System.Math.Ceiling(num);
		}

		private static JsValue Cos(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num))
			{
				return 1;
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				return 1;
			}
			if (double.IsInfinity(num))
			{
				return JsNumber.DoubleNaN;
			}
			return System.Math.Cos(num);
		}

		private static JsValue Cosh(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num))
			{
				return 1;
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				return 1;
			}
			if (double.IsInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			return System.Math.Cosh(num);
		}

		private static JsValue Exp(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return 1;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.PositiveZero;
			}
			return System.Math.Exp(num);
		}

		private static JsValue Expm1(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num) || NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num) || double.IsPositiveInfinity(num))
			{
				return arguments.At(0);
			}
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.DoubleNegativeOne;
			}
			return System.Math.Exp(num) - 1.0;
		}

		private static JsValue Floor(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num))
			{
				return JsNumber.PositiveZero;
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				return JsNumber.NegativeZero;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			return System.Math.Floor(num);
		}

		private static JsValue Log(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (num < 0.0)
			{
				return JsNumber.DoubleNaN;
			}
			if (num == 0.0)
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (num == 1.0)
			{
				return JsNumber.PositiveZero;
			}
			return System.Math.Log(num);
		}

		private static JsValue Log1p(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (num < -1.0)
			{
				return JsNumber.DoubleNaN;
			}
			if (num == -1.0)
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			if (num == 0.0 || double.IsPositiveInfinity(num))
			{
				return arguments.At(0);
			}
			return System.Math.Log(1.0 + num);
		}

		private static JsValue Log2(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (num < 0.0)
			{
				return JsNumber.DoubleNaN;
			}
			if (num == 0.0)
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (num == 1.0)
			{
				return JsNumber.PositiveZero;
			}
			return System.Math.Log(num, 2.0);
		}

		private static JsValue Log10(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (num < 0.0)
			{
				return JsNumber.DoubleNaN;
			}
			if (num == 0.0)
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (num == 1.0)
			{
				return JsNumber.PositiveZero;
			}
			return System.Math.Log10(num);
		}

		private static JsValue Max(JsValue thisObject, JsValue[] arguments)
		{
			if (arguments.Length == 0)
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			double num = double.NegativeInfinity;
			double[] array = Coerced(arguments);
			foreach (double num2 in array)
			{
				if (double.IsNaN(num2))
				{
					return JsNumber.DoubleNaN;
				}
				if (NumberInstance.IsPositiveZero(num2) && NumberInstance.IsNegativeZero(num))
				{
					num = 0.0;
				}
				if (num2 > num)
				{
					num = num2;
				}
			}
			return num;
		}

		private static JsValue Min(JsValue thisObject, JsValue[] arguments)
		{
			if (arguments.Length == 0)
			{
				return JsNumber.DoublePositiveInfinity;
			}
			double num = double.PositiveInfinity;
			double[] array = Coerced(arguments);
			foreach (double num2 in array)
			{
				if (double.IsNaN(num2))
				{
					return JsNumber.DoubleNaN;
				}
				if (NumberInstance.IsNegativeZero(num2) && NumberInstance.IsPositiveZero(num))
				{
					num = JsNumber.NegativeZero._value;
				}
				if (num2 < num)
				{
					num = num2;
				}
			}
			return num;
		}

		private static JsValue Pow(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			double num2 = TypeConverter.ToNumber(arguments.At(1));
			if (num > 1.0 && num2 > 1.0 && num < 2147483647.0 && num2 < 2147483647.0)
			{
				return System.Math.Pow(num, num2);
			}
			if (num2 == 0.0)
			{
				return 1;
			}
			return HandlePowUnlikely(num2, num);
		}

		private static JsValue HandlePowUnlikely(double y, double x)
		{
			if (double.IsNaN(y))
			{
				return JsNumber.DoubleNaN;
			}
			if (double.IsNaN(x))
			{
				return JsNumber.DoubleNaN;
			}
			double num = System.Math.Abs(x);
			if (num > 1.0)
			{
				if (double.IsPositiveInfinity(y))
				{
					return JsNumber.DoublePositiveInfinity;
				}
				if (double.IsNegativeInfinity(y))
				{
					return JsNumber.PositiveZero;
				}
			}
			if (num == 1.0 && double.IsInfinity(y))
			{
				return JsNumber.DoubleNaN;
			}
			if (num < 1.0)
			{
				if (double.IsPositiveInfinity(y))
				{
					return 0;
				}
				if (double.IsNegativeInfinity(y))
				{
					return JsNumber.DoublePositiveInfinity;
				}
			}
			if (double.IsPositiveInfinity(x))
			{
				if (y > 0.0)
				{
					return JsNumber.DoublePositiveInfinity;
				}
				if (y < 0.0)
				{
					return JsNumber.PositiveZero;
				}
			}
			if (double.IsNegativeInfinity(x))
			{
				if (y > 0.0)
				{
					if (System.Math.Abs(y % 2.0).Equals(1.0))
					{
						return JsNumber.DoubleNegativeInfinity;
					}
					return JsNumber.DoublePositiveInfinity;
				}
				if (y < 0.0)
				{
					if (System.Math.Abs(y % 2.0).Equals(1.0))
					{
						return JsNumber.NegativeZero;
					}
					return JsNumber.PositiveZero;
				}
			}
			if (NumberInstance.IsPositiveZero(x))
			{
				if (y > 0.0)
				{
					return 0;
				}
				if (y < 0.0)
				{
					return JsNumber.DoublePositiveInfinity;
				}
			}
			if (NumberInstance.IsNegativeZero(x))
			{
				if (y > 0.0)
				{
					if (System.Math.Abs(y % 2.0).Equals(1.0))
					{
						return JsNumber.NegativeZero;
					}
					return JsNumber.PositiveZero;
				}
				if (y < 0.0)
				{
					if (System.Math.Abs(y % 2.0).Equals(1.0))
					{
						return JsNumber.DoubleNegativeInfinity;
					}
					return JsNumber.DoublePositiveInfinity;
				}
			}
			if (x < 0.0 && !double.IsInfinity(x) && !double.IsInfinity(y) && !y.Equals((int)y))
			{
				return JsNumber.DoubleNaN;
			}
			return System.Math.Pow(x, y);
		}

		private JsValue Random(JsValue thisObject, JsValue[] arguments)
		{
			if (_random == null)
			{
				_random = new Random();
			}
			return _random.NextDouble();
		}

		private static JsValue Round(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			double num2 = System.Math.Round(num);
			if (num2.Equals(num - 0.5))
			{
				return num2 + 1.0;
			}
			return num2;
		}

		private static JsValue Fround(JsValue thisObject, JsValue[] arguments)
		{
			return (float)TypeConverter.ToNumber(arguments.At(0));
		}

		private static JsValue Sin(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num))
			{
				return JsNumber.PositiveZero;
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				return JsNumber.NegativeZero;
			}
			if (double.IsInfinity(num))
			{
				return JsNumber.DoubleNaN;
			}
			return System.Math.Sin(num);
		}

		private static JsValue Sinh(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num))
			{
				return JsNumber.PositiveZero;
			}
			if (NumberInstance.IsNegativeZero(num))
			{
				return JsNumber.NegativeZero;
			}
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			return System.Math.Sinh(num);
		}

		private static JsValue Sqrt(JsValue thisObject, JsValue[] arguments)
		{
			return System.Math.Sqrt(TypeConverter.ToNumber(arguments.At(0)));
		}

		private static JsValue Tan(JsValue thisObject, JsValue[] arguments)
		{
			return System.Math.Tan(TypeConverter.ToNumber(arguments.At(0)));
		}

		private static JsValue Tanh(JsValue thisObject, JsValue[] arguments)
		{
			return System.Math.Tanh(TypeConverter.ToNumber(arguments.At(0)));
		}

		private static JsValue Truncate(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return num;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			return System.Math.Truncate(num);
		}

		private static JsValue Sign(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return num;
			}
			if (double.IsPositiveInfinity(num))
			{
				return 1;
			}
			if (double.IsNegativeInfinity(num))
			{
				return -1;
			}
			return System.Math.Sign(num);
		}

		private static JsValue Cbrt(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				return JsNumber.DoubleNaN;
			}
			if (NumberInstance.IsPositiveZero(num) || NumberInstance.IsNegativeZero(num))
			{
				return num;
			}
			if (double.IsPositiveInfinity(num))
			{
				return JsNumber.DoublePositiveInfinity;
			}
			if (double.IsNegativeInfinity(num))
			{
				return JsNumber.DoubleNegativeInfinity;
			}
			if (System.Math.Sign(num) >= 0)
			{
				return System.Math.Pow(num, 1.0 / 3.0);
			}
			return -1.0 * System.Math.Pow(System.Math.Abs(num), 1.0 / 3.0);
		}

		private static JsValue Hypot(JsValue thisObject, JsValue[] arguments)
		{
			double[] array = Coerced(arguments);
			double[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				if (double.IsInfinity(array2[i]))
				{
					return JsNumber.DoublePositiveInfinity;
				}
			}
			bool flag = true;
			double num = 0.0;
			array2 = array;
			foreach (double num2 in array2)
			{
				if (double.IsNaN(num2))
				{
					return JsNumber.DoubleNaN;
				}
				if (flag && num2 != 0.0)
				{
					flag = false;
				}
				num += num2 * num2;
			}
			if (flag)
			{
				return JsNumber.PositiveZero;
			}
			return System.Math.Sqrt(num);
		}

		private static double[] Coerced(JsValue[] arguments)
		{
			double[] array = new double[arguments.Length];
			for (int i = 0; i < arguments.Length; i++)
			{
				JsValue o = arguments[i];
				array[i] = TypeConverter.ToNumber(o);
			}
			return array;
		}

		private static JsValue Imul(JsValue thisObject, JsValue[] arguments)
		{
			int num = TypeConverter.ToInt32(arguments.At(0));
			int num2 = TypeConverter.ToInt32(arguments.At(1));
			return num * num2;
		}

		private static JsValue Clz32(JsValue thisObject, JsValue[] arguments)
		{
			int num = TypeConverter.ToInt32(arguments.At(0));
			if (num < 0)
			{
				return 0;
			}
			if (num == 0)
			{
				return 32;
			}
			int num2 = 0;
			int num3 = 16;
			while (num > 1)
			{
				int num4 = num >> num3;
				if (num4 != 0)
				{
					num = num4;
					num2 += num3;
				}
				num3 >>= 1;
			}
			return 31 - num2;
		}
	}
}
namespace Jint.Native.Map
{
	internal sealed class MapConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Map");

		private MapPrototype PrototypeObject { get; }

		internal MapConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new MapPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(0, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { ["groupBy"] = new PropertyDescriptor(new ClrFunction(base.Engine, "groupBy", GroupBy, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get [Symbol.species]", Species, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private static JsValue Species(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsMap jsMap = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Map.PrototypeObject, (Engine engine, Realm realm, object? _) => new JsMap(engine, realm));
			if (arguments.Length != 0 && !arguments[0].IsNullOrUndefined())
			{
				JsValue adder = jsMap.Get("set");
				IteratorInstance iterator = arguments.At(0).GetIterator(_realm);
				IteratorProtocol.AddEntriesFromIterable(jsMap, iterator, adder);
			}
			return jsMap;
		}

		private JsValue GroupBy(JsValue thisObject, JsValue[] arguments)
		{
			JsValue items = arguments.At(0);
			JsValue callbackfn = arguments.At(1);
			Dictionary<JsValue, JsArray> dictionary = GroupByHelper.GroupBy(_engine, _realm, items, callbackfn, mapMode: true);
			JsMap jsMap = (JsMap)ObjectInstance.Construct(_realm.Intrinsics.Map);
			foreach (KeyValuePair<JsValue, JsArray> item in dictionary)
			{
				jsMap.MapSet(item.Key, item.Value);
			}
			return jsMap;
		}
	}
	internal sealed class MapIteratorPrototype : IteratorPrototype
	{
		private sealed class MapIterator : IteratorInstance
		{
			private readonly OrderedDictionary<JsValue, JsValue> _map;

			private int _position;

			public MapIterator(Engine engine, JsMap map)
				: base(engine)
			{
				_map = map._map;
				_position = 0;
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (_position < _map.Count)
				{
					JsValue key = _map.GetKey(_position);
					JsValue value = _map[key];
					_position++;
					nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine, key, value);
					return true;
				}
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		internal MapIteratorPrototype(Engine engine, Realm realm, IteratorPrototype iteratorPrototype)
			: base(engine, realm, iteratorPrototype)
		{
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { [KnownKeys.Next] = new PropertyDescriptor(new ClrFunction(base.Engine, "next", base.Next, 0, PropertyFlag.Configurable), true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Map Iterator", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		internal IteratorInstance ConstructEntryIterator(JsMap map)
		{
			return new MapIterator(base.Engine, map)
			{
				_prototype = this
			};
		}

		internal IteratorInstance ConstructKeyIterator(JsMap map)
		{
			return new IteratorInstance.EnumerableIterator(base.Engine, map._map.Keys)
			{
				_prototype = this
			};
		}

		internal IteratorInstance ConstructValueIterator(JsMap map)
		{
			return new IteratorInstance.EnumerableIterator(base.Engine, map._map.Values)
			{
				_prototype = this
			};
		}
	}
	internal sealed class MapPrototype : Prototype
	{
		private readonly MapConstructor _mapConstructor;

		internal MapPrototype(Engine engine, Realm realm, MapConstructor mapConstructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_mapConstructor = mapConstructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(12, checkExistingKeys: false)
			{
				["length"] = new PropertyDescriptor(0, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_mapConstructor, PropertyFlag.NonEnumerable),
				["clear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "clear", Clear, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["delete"] = new PropertyDescriptor(new ClrFunction(base.Engine, "delete", Delete, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["entries"] = new PropertyDescriptor(new ClrFunction(base.Engine, "entries", Entries, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["forEach"] = new PropertyDescriptor(new ClrFunction(base.Engine, "forEach", ForEach, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["get"] = new PropertyDescriptor(new ClrFunction(base.Engine, "get", Get, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["has"] = new PropertyDescriptor(new ClrFunction(base.Engine, "has", Has, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["keys"] = new PropertyDescriptor(new ClrFunction(base.Engine, "keys", Keys, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["set"] = new PropertyDescriptor(new ClrFunction(base.Engine, "set", Set, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["values"] = new PropertyDescriptor(new ClrFunction(base.Engine, "values", Values, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["size"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get size", Size, 0, PropertyFlag.Configurable), null, PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(2);
			JsSymbol iterator = GlobalSymbolRegistry.Iterator;
			symbolDictionary[iterator] = new PropertyDescriptor(new ClrFunction(base.Engine, "iterator", Entries, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Map", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Size(JsValue thisObject, JsValue[] arguments)
		{
			AssertMapInstance(thisObject);
			return JsNumber.Create(0);
		}

		private JsValue Get(JsValue thisObject, JsValue[] arguments)
		{
			return AssertMapInstance(thisObject).MapGet(arguments.At(0));
		}

		private JsValue Clear(JsValue thisObject, JsValue[] arguments)
		{
			AssertMapInstance(thisObject).Clear();
			return JsValue.Undefined;
		}

		private JsValue Delete(JsValue thisObject, JsValue[] arguments)
		{
			if (!AssertMapInstance(thisObject).MapDelete(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsValue Set(JsValue thisObject, JsValue[] arguments)
		{
			AssertMapInstance(thisObject).MapSet(arguments.At(0), arguments.At(1));
			return thisObject;
		}

		private JsValue Has(JsValue thisObject, JsValue[] arguments)
		{
			if (!AssertMapInstance(thisObject).Has(arguments.At(0)))
			{
				return JsBoolean.False;
			}
			return JsBoolean.True;
		}

		private JsValue ForEach(JsValue thisObject, JsValue[] arguments)
		{
			JsMap jsMap = AssertMapInstance(thisObject);
			JsValue source = arguments.At(0);
			JsValue thisArg = arguments.At(1);
			ICallable callable = GetCallable(source);
			jsMap.ForEach(callable, thisArg);
			return JsValue.Undefined;
		}

		private ObjectInstance Entries(JsValue thisObject, JsValue[] arguments)
		{
			return AssertMapInstance(thisObject).Iterator();
		}

		private ObjectInstance Keys(JsValue thisObject, JsValue[] arguments)
		{
			return AssertMapInstance(thisObject).Keys();
		}

		private ObjectInstance Values(JsValue thisObject, JsValue[] arguments)
		{
			return AssertMapInstance(thisObject).Values();
		}

		private JsMap AssertMapInstance(JsValue thisObject)
		{
			if (thisObject is JsMap result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(_realm, "object must be a Map");
			return null;
		}
	}
}
namespace Jint.Native.Json
{
	internal sealed class JsonInstance : ObjectInstance
	{
		private readonly Realm _realm;

		internal JsonInstance(Engine engine, Realm realm, ObjectPrototype objectPrototype)
			: base(engine)
		{
			_realm = realm;
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false)
			{
				["parse"] = new PropertyDescriptor(new ClrFunction(base.Engine, "parse", Parse, 2, PropertyFlag.Configurable), true, false, true),
				["stringify"] = new PropertyDescriptor(new ClrFunction(base.Engine, "stringify", Stringify, 3, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("JSON", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private static JsValue InternalizeJSONProperty(JsValue holder, JsValue name, ICallable reviver)
		{
			JsValue jsValue = holder.Get(name);
			if (jsValue is ObjectInstance objectInstance)
			{
				if (objectInstance.IsArray())
				{
					ulong num = 0uL;
					for (ulong num2 = TypeConverter.ToLength(objectInstance.Get(CommonProperties.Length)); num < num2; num++)
					{
						JsValue jsValue2 = JsString.Create(num);
						JsValue jsValue3 = InternalizeJSONProperty(objectInstance, jsValue2, reviver);
						if (jsValue3.IsUndefined())
						{
							objectInstance.Delete(jsValue2);
						}
						else
						{
							objectInstance.CreateDataProperty(jsValue2, jsValue3);
						}
					}
				}
				else
				{
					foreach (JsValue item in objectInstance.EnumerableOwnProperties(EnumerableOwnPropertyNamesKind.Key))
					{
						JsValue jsValue4 = InternalizeJSONProperty(objectInstance, item, reviver);
						if (jsValue4.IsUndefined())
						{
							objectInstance.Delete(item);
						}
						else
						{
							objectInstance.CreateDataProperty(item, jsValue4);
						}
					}
				}
			}
			return reviver.Call(holder, name, jsValue);
		}

		private JsValue Parse(JsValue thisObject, JsValue[] arguments)
		{
			string code = TypeConverter.ToString(arguments.At(0));
			JsValue jsValue = arguments.At(1);
			JsValue jsValue2 = new JsonParser(_engine).Parse(code);
			if (jsValue.IsCallable)
			{
				ObjectInstance objectInstance = _realm.Intrinsics.Object.Construct(Arguments.Empty);
				JsString empty = JsString.Empty;
				objectInstance.CreateDataPropertyOrThrow(empty, jsValue2);
				return InternalizeJSONProperty(objectInstance, empty, (ICallable)jsValue);
			}
			return jsValue2;
		}

		private JsValue Stringify(JsValue thisObject, JsValue[] arguments)
		{
			JsValue value = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			JsValue space = arguments.At(2);
			if (value.IsUndefined() && jsValue.IsUndefined())
			{
				return JsValue.Undefined;
			}
			return new JsonSerializer(_engine).Serialize(value, jsValue, space);
		}
	}
	public sealed class JsonParser
	{
		[StructLayout(LayoutKind.Auto)]
		private ref struct State
		{
			public int CurrentDepth { get; set; }
		}

		private enum Tokens
		{
			NullLiteral,
			BooleanLiteral,
			String,
			Number,
			Punctuator,
			EOF
		}

		private sealed class Token
		{
			public Tokens Type;

			public char FirstCharacter;

			public JsValue Value = JsValue.Undefined;

			public string Text;

			public TextRange Range;
		}

		[StructLayout(LayoutKind.Auto)]
		private readonly struct TextRange
		{
			public int Start { get; }

			public int End { get; }

			public TextRange(int start, int end)
			{
				Start = start;
				End = end;
			}
		}

		private static class Messages
		{
			public const string InvalidCharacter = "Invalid character in JSON";

			public const string ExpectedHexadecimalDigit = "Expected hexadecimal digit in JSON";

			public const string UnexpectedToken = "Unexpected token '{0}' in JSON";

			public const string UnexpectedTokenIllegal = "Unexpected token ILLEGAL in JSON";

			public const string UnexpectedNumber = "Unexpected number in JSON";

			public const string UnexpectedString = "Unexpected string in JSON";

			public const string UnexpectedEOS = "Unexpected end of JSON input";

			public const string MaxDepthLevelReached = "Max. depth level of JSON reached";
		}

		private readonly Engine _engine;

		private readonly int _maxDepth;

		private int _index;

		private int _length;

		private Token _lookahead;

		private string _source;

		private readonly Token[] _tokenBuffer;

		private int _tokenBufferIndex;

		public JsonParser(Engine engine)
			: this(engine, engine.Options.Json.MaxParseDepth)
		{
		}

		public JsonParser(Engine engine, int maxDepth)
		{
			if (maxDepth < 0)
			{
				throw new ArgumentOutOfRangeException("maxDepth", "Max depth must be greater or equal to zero");
			}
			_maxDepth = maxDepth;
			_engine = engine;
			_tokenBuffer = new Token[5];
			for (int i = 0; i < _tokenBuffer.Length; i++)
			{
				_tokenBuffer[i] = new Token();
			}
			_tokenBufferIndex = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsDecimalDigit(char ch)
		{
			return (uint)(ch - 48) <= 9u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsLowerCaseHexAlpha(char ch)
		{
			return (uint)(ch - 97) <= 5u;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsUpperCaseHexAlpha(char ch)
		{
			return (uint)(ch - 65) <= 5u;
		}

		private static bool IsHexDigit(char ch)
		{
			if (!IsDecimalDigit(ch) && !IsLowerCaseHexAlpha(ch))
			{
				return IsUpperCaseHexAlpha(ch);
			}
			return true;
		}

		private static bool IsWhiteSpace(char ch)
		{
			if (ch != ' ' && ch != '\t' && ch != '\n')
			{
				return ch == '\r';
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsLineTerminator(char ch)
		{
			if (ch != '\n' && ch != '\r' && ch != '\u2028')
			{
				return ch == '\u2029';
			}
			return true;
		}

		private char ScanHexEscape()
		{
			int num = 0;
			for (int i = 0; i < 4; i++)
			{
				if (_index < _length + 1 && IsHexDigit(_source[_index]))
				{
					char value = char.ToLower(_source[_index++], CultureInfo.InvariantCulture);
					num = num * 16 + "0123456789abcdef".IndexOf(value);
				}
				else
				{
					ThrowError(_index, "Expected hexadecimal digit in JSON");
				}
			}
			return (char)num;
		}

		private char ReadToNextSignificantCharacter()
		{
			char c = ((_index < _length) ? _source[_index] : '\0');
			while (IsWhiteSpace(c))
			{
				if (++_index >= _length)
				{
					return '\0';
				}
				c = _source[_index];
			}
			return c;
		}

		private Token CreateToken(Tokens type, string text, char firstCharacter, JsValue value, in TextRange range)
		{
			Token obj = _tokenBuffer[_tokenBufferIndex++];
			if (_tokenBufferIndex >= _tokenBuffer.Length)
			{
				_tokenBufferIndex = 0;
			}
			obj.Type = type;
			obj.Text = text;
			obj.FirstCharacter = firstCharacter;
			obj.Value = value;
			obj.Range = range;
			return obj;
		}

		private Token ScanPunctuator()
		{
			int index = _index;
			char c = ((index < _source.Length) ? _source[_index] : '\0');
			string text = ScanPunctuatorValue(index, c);
			_index++;
			return CreateToken(Tokens.Punctuator, text, c, JsValue.Undefined, new TextRange(index, _index));
		}

		private string ScanPunctuatorValue(int start, char code)
		{
			switch (code)
			{
			case '.':
				return ".";
			case ',':
				return ",";
			case '{':
				return "{";
			case '}':
				return "}";
			case '[':
				return "[";
			case ']':
				return "]";
			case ':':
				return ":";
			default:
				ThrowError(start, "Unexpected token '{0}' in JSON", code);
				return null;
			}
		}

		private Token ScanNumericLiteral()
		{
			Span<char> initialBuffer = stackalloc char[64];
			using System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			int index = _index;
			char c = _source.CharCodeAt(_index);
			bool flag = true;
			if (c == '-')
			{
				valueStringBuilder.Append(c);
				c = _source.CharCodeAt(++_index);
			}
			if (c != '.')
			{
				char c2 = c;
				valueStringBuilder.Append(c);
				c = _source.CharCodeAt(++_index);
				if (valueStringBuilder.Length == 1 && c2 == '0')
				{
					flag = false;
					if (c > '\0' && IsDecimalDigit(c))
					{
						ThrowError(_index, "Unexpected token '{0}' in JSON", c);
					}
				}
				while (IsDecimalDigit(c = _source.CharCodeAt(_index)))
				{
					valueStringBuilder.Append(c);
					_index++;
				}
			}
			if (c == '.')
			{
				flag = false;
				valueStringBuilder.Append(c);
				_index++;
				while (IsDecimalDigit(c = _source.CharCodeAt(_index)))
				{
					valueStringBuilder.Append(c);
					_index++;
				}
			}
			if ((c == 'E' || c == 'e') ? true : false)
			{
				flag = false;
				valueStringBuilder.Append(c);
				c = _source.CharCodeAt(++_index);
				if ((c == '+' || c == '-') ? true : false)
				{
					valueStringBuilder.Append(c);
					c = _source.CharCodeAt(++_index);
				}
				if (IsDecimalDigit(c))
				{
					while (IsDecimalDigit(c = _source.CharCodeAt(_index)))
					{
						valueStringBuilder.Append(c);
						_index++;
					}
				}
				else
				{
					ThrowError(_index, "Unexpected token '{0}' in JSON", _source.CharCodeAt(_index));
				}
			}
			string text = valueStringBuilder.ToString();
			long result;
			JsNumber value = ((!flag || !long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out result) || result == 0L) ? new JsNumber(double.Parse(text, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture)) : JsNumber.Create(result));
			return CreateToken(Tokens.Number, text, '\0', value, new TextRange(index, _index));
		}

		private Token ScanBooleanLiteral()
		{
			int index = _index;
			if (ConsumeMatch("true"))
			{
				return CreateToken(Tokens.BooleanLiteral, "true", '\t', JsBoolean.True, new TextRange(index, _index));
			}
			if (ConsumeMatch("false"))
			{
				return CreateToken(Tokens.BooleanLiteral, "false", '\f', JsBoolean.False, new TextRange(index, _index));
			}
			ThrowError(index, "Unexpected token ILLEGAL in JSON");
			return null;
		}

		private bool ConsumeMatch(string text)
		{
			int index = _index;
			int length = text.Length;
			if (index + length - 1 < _source.Length && _source.AsSpan(index, length).SequenceEqual(text.AsSpan()))
			{
				_index += length;
				return true;
			}
			return false;
		}

		private Token ScanNullLiteral()
		{
			int index = _index;
			if (ConsumeMatch("null"))
			{
				return CreateToken(Tokens.NullLiteral, "null", 'n', JsValue.Null, new TextRange(index, _index));
			}
			ThrowError(index, "Unexpected token ILLEGAL in JSON");
			return null;
		}

		private Token ScanStringLiteral(ref State state)
		{
			char c = _source[_index];
			int index = _index;
			_index++;
			Span<char> initialBuffer = stackalloc char[64];
			using System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			while (_index < _length)
			{
				char c2 = _source[_index++];
				if (c2 == c)
				{
					c = '\0';
					break;
				}
				if (c2 <= '\u001f')
				{
					ThrowError(_index - 1, "Invalid character in JSON");
				}
				if (c2 == '\\')
				{
					c2 = _source.CharCodeAt(_index++);
					switch (c2)
					{
					case '"':
						valueStringBuilder.Append('"');
						break;
					case '\\':
						valueStringBuilder.Append('\\');
						break;
					case '/':
						valueStringBuilder.Append('/');
						break;
					case 'n':
						valueStringBuilder.Append('\n');
						break;
					case 'r':
						valueStringBuilder.Append('\r');
						break;
					case 't':
						valueStringBuilder.Append('\t');
						break;
					case 'u':
						valueStringBuilder.Append(ScanHexEscape());
						break;
					case 'b':
						valueStringBuilder.Append('\b');
						break;
					case 'f':
						valueStringBuilder.Append('\f');
						break;
					default:
						ThrowError(_index - 1, "Unexpected token '{0}' in JSON", c2);
						break;
					}
				}
				else
				{
					if (IsLineTerminator(c2))
					{
						break;
					}
					valueStringBuilder.Append(c2);
				}
			}
			if (c != 0)
			{
				ThrowError(_index, "Unexpected end of JSON input");
			}
			string text = valueStringBuilder.ToString();
			return CreateToken(Tokens.String, text, '"', new JsString(text), new TextRange(index, _index));
		}

		private Token Advance(ref State state)
		{
			char c = ReadToNextSignificantCharacter();
			switch (c)
			{
			case '\0':
				return CreateToken(Tokens.EOF, string.Empty, '\0', JsValue.Undefined, new TextRange(_index, _index));
			case '"':
				return ScanStringLiteral(ref state);
			case '-':
				if (IsDecimalDigit(_source.CharCodeAt(_index + 1)))
				{
					return ScanNumericLiteral();
				}
				return ScanPunctuator();
			default:
				if (IsDecimalDigit(c))
				{
					return ScanNumericLiteral();
				}
				switch (c)
				{
				case 'f':
				case 't':
					return ScanBooleanLiteral();
				case 'n':
					return ScanNullLiteral();
				default:
					return ScanPunctuator();
				}
			}
		}

		private Token Lex(ref State state)
		{
			Token lookahead = _lookahead;
			_index = lookahead.Range.End;
			_lookahead = Advance(ref state);
			_index = lookahead.Range.End;
			return lookahead;
		}

		private void Peek(ref State state)
		{
			int index = _index;
			_lookahead = Advance(ref state);
			_index = index;
		}

		[DoesNotReturn]
		private void ThrowDepthLimitReached(Token token)
		{
			ThrowError(token.Range.Start, "Max. depth level of JSON reached");
		}

		[DoesNotReturn]
		private void ThrowError(Token token, string messageFormat, params object[] arguments)
		{
			ThrowError(token.Range.Start, messageFormat, arguments);
		}

		[DoesNotReturn]
		private void ThrowError(int position, string messageFormat, params object[] arguments)
		{
			string value = string.Format(CultureInfo.InvariantCulture, messageFormat, arguments);
			ExceptionHelper.ThrowSyntaxError(_engine.Realm, $"{value} at position {position}");
		}

		private void ThrowUnexpected(Token token)
		{
			if (token.Type == Tokens.EOF)
			{
				ThrowError(token, "Unexpected end of JSON input");
			}
			if (token.Type == Tokens.Number)
			{
				ThrowError(token, "Unexpected number in JSON");
			}
			if (token.Type == Tokens.String)
			{
				ThrowError(token, "Unexpected string in JSON");
			}
			ThrowError(token, "Unexpected token '{0}' in JSON", token.Text);
		}

		private void Expect(ref State state, char value)
		{
			Token token = Lex(ref state);
			if (token.Type != Tokens.Punctuator || value != token.FirstCharacter)
			{
				ThrowUnexpected(token);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Match(char value)
		{
			if (_lookahead.Type == Tokens.Punctuator)
			{
				return value == _lookahead.FirstCharacter;
			}
			return false;
		}

		private JsArray ParseJsonArray(ref State state)
		{
			if (++state.CurrentDepth > _maxDepth)
			{
				ThrowDepthLimitReached(_lookahead);
			}
			List<JsValue> list = null;
			Expect(ref state, '[');
			int num = 0;
			JsArray jsArray = null;
			JsValue[] array = ArrayPool<JsValue>.Shared.Rent(16);
			try
			{
				while (!Match(']'))
				{
					array[num++] = ParseJsonValue(ref state);
					if (!Match(']'))
					{
						Expect(ref state, ',');
					}
					if (num >= array.Length)
					{
						if (list == null)
						{
							list = new List<JsValue>(array);
						}
						else
						{
							list.AddRange(array);
						}
						num = 0;
					}
				}
				if (num > 0)
				{
					if (list == null)
					{
						JsValue[] array2 = new JsValue[num];
						System.Array.Copy(array, array2, num);
						jsArray = new JsArray(_engine, array2);
					}
					else
					{
						for (int i = 0; i < num; i++)
						{
							list.Add(array[i]);
						}
					}
				}
				else if (list == null)
				{
					jsArray = new JsArray(_engine);
				}
			}
			finally
			{
				ArrayPool<JsValue>.Shared.Return(array);
			}
			Expect(ref state, ']');
			state.CurrentDepth--;
			return jsArray ?? new JsArray(_engine, list.ToArray());
		}

		private JsObject ParseJsonObject(ref State state)
		{
			if (++state.CurrentDepth > _maxDepth)
			{
				ThrowDepthLimitReached(_lookahead);
			}
			Expect(ref state, '{');
			JsObject jsObject = new JsObject(_engine);
			while (!Match('}'))
			{
				if (_lookahead.Type != Tokens.String)
				{
					ThrowUnexpected(Lex(ref state));
				}
				Token token = Lex(ref state);
				string text = token.Text;
				if (PropertyNameContainsInvalidCharacters(text))
				{
					ThrowError(token, "Invalid character in JSON");
				}
				Expect(ref state, ':');
				JsValue value = ParseJsonValue(ref state);
				jsObject.FastSetDataProperty(text, value);
				if (!Match('}'))
				{
					Expect(ref state, ',');
				}
			}
			Expect(ref state, '}');
			state.CurrentDepth--;
			return jsObject;
		}

		private static bool PropertyNameContainsInvalidCharacters(string propertyName)
		{
			foreach (char c in propertyName)
			{
				if (c != '\t' && c <= '\u001f')
				{
					return true;
				}
			}
			return false;
		}

		private JsValue ParseJsonValue(ref State state)
		{
			switch (_lookahead.Type)
			{
			case Tokens.NullLiteral:
			case Tokens.BooleanLiteral:
			case Tokens.String:
			case Tokens.Number:
				return Lex(ref state).Value;
			case Tokens.Punctuator:
				if (_lookahead.FirstCharacter == '[')
				{
					return ParseJsonArray(ref state);
				}
				if (_lookahead.FirstCharacter == '{')
				{
					return ParseJsonObject(ref state);
				}
				ThrowUnexpected(Lex(ref state));
				break;
			}
			ThrowUnexpected(Lex(ref state));
			return JsValue.Null;
		}

		public JsValue Parse(string code)
		{
			_source = code;
			_index = 0;
			_length = _source.Length;
			_lookahead = null;
			State state = default(State);
			Peek(ref state);
			JsValue result = ParseJsonValue(ref state);
			Peek(ref state);
			if (_lookahead.Type != Tokens.EOF)
			{
				ThrowError(_lookahead, "Unexpected token '{0}' in JSON", _lookahead.Text);
			}
			return result;
		}
	}
	internal static class StringExtensions
	{
		internal static char CharCodeAt(this string source, int index)
		{
			if (index > source.Length - 1)
			{
				return '\0';
			}
			return source[index];
		}
	}
	public sealed class JsonSerializer
	{
		private enum SerializeResult
		{
			NotUndefined,
			Undefined
		}

		private readonly struct PropertyEnumeration
		{
			public readonly List<JsValue> Keys;

			public readonly bool IsEmpty;

			private PropertyEnumeration(List<JsValue> keys, bool isEmpty)
			{
				Keys = keys;
				IsEmpty = isEmpty;
			}

			public static PropertyEnumeration FromList(List<JsValue> keys)
			{
				return new PropertyEnumeration(keys, keys.Count == 0);
			}

			public static PropertyEnumeration FromObjectInstance(ObjectInstance instance)
			{
				List<JsValue> ownPropertyKeys = instance.GetOwnPropertyKeys(Types.String);
				RemoveUnserializableProperties(instance, ownPropertyKeys);
				return new PropertyEnumeration(ownPropertyKeys, ownPropertyKeys.Count == 0);
			}

			private static void RemoveUnserializableProperties(ObjectInstance instance, List<JsValue> keys)
			{
				for (int i = 0; i < keys.Count; i++)
				{
					JsValue property = keys[i];
					PropertyDescriptor ownProperty = instance.GetOwnProperty(property);
					if (ownProperty == PropertyDescriptor.Undefined || !ownProperty.Enumerable)
					{
						keys.RemoveAt(i);
						i--;
					}
				}
			}
		}

		private readonly Engine _engine;

		private ObjectTraverseStack _stack;

		private string? _indent;

		private string _gap = string.Empty;

		private List<JsValue>? _propertyList;

		private JsValue _replacerFunction = JsValue.Undefined;

		private static readonly JsString toJsonProperty = new JsString("toJSON");

		public JsonSerializer(Engine engine)
		{
			_engine = engine;
		}

		public JsValue Serialize(JsValue value)
		{
			return Serialize(value, JsValue.Undefined, JsValue.Undefined);
		}

		public JsValue Serialize(JsValue value, JsValue replacer, JsValue space)
		{
			_stack = new ObjectTraverseStack(_engine);
			if (value.IsCallable && (object)replacer == JsValue.Undefined)
			{
				return JsValue.Undefined;
			}
			SetupReplacer(replacer);
			_gap = BuildSpacingGap(space);
			ObjectInstance objectInstance = _engine.Realm.Intrinsics.Object.Construct(Arguments.Empty);
			objectInstance.DefineOwnProperty(JsString.Empty, new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable));
			System.Text.ValueStringBuilder json = default(System.Text.ValueStringBuilder);
			string value2;
			try
			{
				if (SerializeJSONProperty(JsString.Empty, objectInstance, ref json) == SerializeResult.Undefined)
				{
					return JsValue.Undefined;
				}
			}
			finally
			{
				value2 = json.ToString();
			}
			return new JsString(value2);
		}

		private void SetupReplacer(JsValue replacer)
		{
			if (!(replacer is ObjectInstance objectInstance))
			{
				return;
			}
			if (objectInstance.IsCallable)
			{
				_replacerFunction = replacer;
			}
			else
			{
				if (!objectInstance.IsArray())
				{
					return;
				}
				_propertyList = new List<JsValue>();
				uint length = objectInstance.GetLength();
				for (int i = 0; i < length; i++)
				{
					JsString property = JsString.Create(i);
					JsValue jsValue = replacer.Get(property);
					JsValue jsValue2 = JsValue.Undefined;
					if (jsValue.IsString())
					{
						jsValue2 = jsValue;
					}
					else if (jsValue.IsNumber())
					{
						jsValue2 = TypeConverter.ToString(jsValue);
					}
					else if (jsValue.IsObject() && ((jsValue is StringInstance || jsValue is NumberInstance) ? true : false))
					{
						jsValue2 = TypeConverter.ToString(jsValue);
					}
					if (!jsValue2.IsUndefined() && !_propertyList.Contains(jsValue2))
					{
						_propertyList.Add(jsValue2);
					}
				}
			}
		}

		private static string BuildSpacingGap(JsValue space)
		{
			if (space.IsObject())
			{
				ObjectInstance objectInstance = space.AsObject();
				if (objectInstance.Class == ObjectClass.Number)
				{
					space = TypeConverter.ToNumber(objectInstance);
				}
				else if (objectInstance.Class == ObjectClass.String)
				{
					space = TypeConverter.ToJsString(objectInstance);
				}
			}
			if (space.IsNumber())
			{
				double value = ((JsNumber)space)._value;
				if (value > 0.0)
				{
					return new string(' ', (int)System.Math.Min(10.0, value));
				}
				return string.Empty;
			}
			if (space.IsString())
			{
				string text = space.ToString();
				if (text.Length > 10)
				{
					return text.Substring(0, 10);
				}
				return text;
			}
			return string.Empty;
		}

		private SerializeResult SerializeJSONProperty(JsValue key, JsValue holder, ref System.Text.ValueStringBuilder json)
		{
			JsValue jsValue = ReadUnwrappedValue(key, holder);
			if ((object)jsValue == JsValue.Null)
			{
				json.Append("null");
				return SerializeResult.NotUndefined;
			}
			if (jsValue.IsBoolean())
			{
				json.Append(((JsBoolean)jsValue)._value ? "true" : "false");
				return SerializeResult.NotUndefined;
			}
			if (jsValue.IsString())
			{
				QuoteJSONString(jsValue.ToString(), ref json);
				return SerializeResult.NotUndefined;
			}
			if (jsValue.IsNumber())
			{
				double value = ((JsNumber)jsValue)._value;
				if (jsValue.IsInteger())
				{
					json.Append(((long)value).ToString(CultureInfo.InvariantCulture));
					return SerializeResult.NotUndefined;
				}
				if (!double.IsNaN(value) && !double.IsInfinity(value))
				{
					if (TypeConverter.CanBeStringifiedAsLong(value))
					{
						json.Append(((long)value).ToString(CultureInfo.InvariantCulture));
						return SerializeResult.NotUndefined;
					}
					json.Append(NumberPrototype.ToNumberString(value));
					return SerializeResult.NotUndefined;
				}
				json.Append("null");
				return SerializeResult.NotUndefined;
			}
			if (jsValue.IsBigInt())
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Do not know how to serialize a BigInt");
			}
			if (jsValue is ObjectInstance objectInstance && !jsValue.IsCallable)
			{
				if (CanSerializesAsArray(objectInstance))
				{
					SerializeJSONArray(objectInstance, ref json);
					return SerializeResult.NotUndefined;
				}
				if (objectInstance is IObjectWrapper objectWrapper)
				{
					Func<object, string> serializeToJson = _engine.Options.Interop.SerializeToJson;
					if (serializeToJson != null)
					{
						json.Append(serializeToJson(objectWrapper.Target));
						return SerializeResult.NotUndefined;
					}
				}
				SerializeJSONObject(objectInstance, ref json);
				return SerializeResult.NotUndefined;
			}
			return SerializeResult.Undefined;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private JsValue ReadUnwrappedValue(JsValue key, JsValue holder)
		{
			JsValue jsValue = holder.Get(key);
			if (jsValue._type <= InternalTypes.Integer && _replacerFunction.IsUndefined())
			{
				return jsValue;
			}
			bool flag = jsValue is BigIntInstance || jsValue.IsBigInt();
			if (jsValue.IsObject() || flag)
			{
				JsValue value = jsValue.GetV(_engine.Realm, toJsonProperty);
				if (value.IsUndefined() && flag)
				{
					value = _engine.Realm.Intrinsics.BigInt.PrototypeObject.Get(toJsonProperty);
				}
				if (value.IsObject() && value.AsObject() is ICallable callable)
				{
					jsValue = callable.Call(jsValue, Arguments.From(TypeConverter.ToPropertyKey(key)));
				}
			}
			if (!_replacerFunction.IsUndefined())
			{
				jsValue = ((ICallable)_replacerFunction.AsObject()).Call(holder, Arguments.From(TypeConverter.ToPropertyKey(key), jsValue));
			}
			if (jsValue.IsObject())
			{
				JsValue jsValue2 = ((jsValue is NumberInstance) ? ((JsValue)TypeConverter.ToNumber(jsValue)) : ((jsValue is StringInstance) ? ((JsValue)TypeConverter.ToString(jsValue)) : ((jsValue is BooleanInstance booleanInstance) ? booleanInstance.BooleanData : ((!(jsValue is BigIntInstance bigIntInstance)) ? jsValue : bigIntInstance.BigIntData))));
				jsValue = jsValue2;
			}
			return jsValue;
		}

		private static bool CanSerializesAsArray(ObjectInstance value)
		{
			if (value is JsArray)
			{
				return true;
			}
			if (value is JsProxy jsProxy && CanSerializesAsArray(jsProxy._target))
			{
				return true;
			}
			if (value is ObjectWrapper { IsArrayLike: not false })
			{
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
		private unsafe static void QuoteJSONString(string value, ref System.Text.ValueStringBuilder json)
		{
			if (value.Length == 0)
			{
				json.Append("\"\"");
				return;
			}
			json.Append('"');
			fixed (char* ptr = value)
			{
				int num = value.Length;
				int num2 = 0;
				do
				{
					int index = JavaScriptEncoder.Default.FindFirstCharacterToEncode(ptr + num2, num);
					if (index < 0)
					{
						json.Append(value.AsSpan(num2));
						break;
					}
					index += num2;
					if (index - num2 > 0)
					{
						json.Append(value.AsSpan(num2, index - num2));
					}
					AppendJsonStringCharacter(value, ref index, ref json);
					num2 = index + 1;
					num = value.Length - num2;
				}
				while (num != 0);
			}
			json.Append('"');
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void AppendJsonStringCharacter(string value, ref int index, ref System.Text.ValueStringBuilder json)
		{
			char c = value[index];
			switch (c)
			{
			case '"':
				json.Append("\\\"");
				return;
			case '\\':
				json.Append("\\\\");
				return;
			case '\b':
				json.Append("\\b");
				return;
			case '\f':
				json.Append("\\f");
				return;
			case '\n':
				json.Append("\\n");
				return;
			case '\r':
				json.Append("\\r");
				return;
			case '\t':
				json.Append("\\t");
				return;
			}
			if (char.IsSurrogatePair(value, index))
			{
				json.Append(value.AsSpan(index, 2));
				index++;
			}
			else if (c < ' ' || char.IsSurrogate(c))
			{
				json.Append("\\u");
				int num = c;
				json.Append(num.ToString("x4", CultureInfo.InvariantCulture));
			}
			else
			{
				json.Append(c);
			}
		}

		private void SerializeJSONArray(ObjectInstance value, ref System.Text.ValueStringBuilder json)
		{
			uint num = TypeConverter.ToUint32(value.Get(CommonProperties.Length));
			if (num == 0)
			{
				json.Append("[]");
				return;
			}
			_stack.Enter(value);
			string indent = _indent;
			if (_gap.Length > 0)
			{
				_indent += _gap;
			}
			bool flag = false;
			for (int i = 0; i < num; i++)
			{
				if (flag)
				{
					json.Append(',');
				}
				else
				{
					json.Append('[');
				}
				if (_gap.Length > 0)
				{
					json.Append('\n');
					json.Append(_indent);
				}
				if (SerializeJSONProperty(i, value, ref json) == SerializeResult.Undefined)
				{
					json.Append("null");
				}
				flag = true;
			}
			if (!flag)
			{
				_stack.Exit();
				_indent = indent;
				json.Append("[]");
				return;
			}
			if (_gap.Length > 0)
			{
				json.Append('\n');
				json.Append(indent);
			}
			json.Append(']');
			_stack.Exit();
			_indent = indent;
		}

		private void SerializeJSONObject(ObjectInstance value, ref System.Text.ValueStringBuilder json)
		{
			PropertyEnumeration propertyEnumeration = ((_propertyList == null) ? PropertyEnumeration.FromObjectInstance(value) : PropertyEnumeration.FromList(_propertyList));
			if (propertyEnumeration.IsEmpty)
			{
				json.Append("{}");
				return;
			}
			_stack.Enter(value);
			string indent = _indent;
			if (_gap.Length > 0)
			{
				_indent += _gap;
			}
			bool flag = false;
			for (int i = 0; i < propertyEnumeration.Keys.Count; i++)
			{
				JsValue jsValue = propertyEnumeration.Keys[i];
				int length = json.Length;
				if (flag)
				{
					json.Append(',');
				}
				else
				{
					json.Append('{');
				}
				if (_gap.Length > 0)
				{
					json.Append('\n');
					json.Append(_indent);
				}
				QuoteJSONString(jsValue.ToString(), ref json);
				json.Append(':');
				if (_gap.Length > 0)
				{
					json.Append(' ');
				}
				if (SerializeJSONProperty(jsValue, value, ref json) == SerializeResult.Undefined)
				{
					json.Length = length;
				}
				else
				{
					flag = true;
				}
			}
			if (!flag)
			{
				_stack.Exit();
				_indent = indent;
				json.Append("{}");
				return;
			}
			if (_gap.Length > 0)
			{
				json.Append('\n');
				json.Append(indent);
			}
			json.Append('}');
			_stack.Exit();
			_indent = indent;
		}
	}
}
namespace Jint.Native.Iterator
{
	internal enum ArrayIteratorType
	{
		Key,
		Value,
		KeyAndValue
	}
	internal abstract class IteratorInstance : ObjectInstance
	{
		internal sealed class ObjectIterator : IteratorInstance
		{
			private readonly ObjectInstance _target;

			private readonly ICallable _nextMethod;

			public ObjectIterator(ObjectInstance target)
				: base(target.Engine)
			{
				_target = target;
				if (!(target.Get(CommonProperties.Next) is ICallable nextMethod))
				{
					ExceptionHelper.ThrowTypeError(target.Engine.Realm);
				}
				else
				{
					_nextMethod = nextMethod;
				}
			}

			public override bool TryIteratorStep(out ObjectInstance result)
			{
				result = IteratorNext();
				JsValue jsValue = result.Get(CommonProperties.Done);
				if (!jsValue.IsUndefined() && TypeConverter.ToBoolean(jsValue))
				{
					return false;
				}
				return true;
			}

			private ObjectInstance IteratorNext()
			{
				JsValue jsValue = _nextMethod.Call(_target, Arguments.Empty);
				ObjectInstance obj = jsValue as ObjectInstance;
				if ((object)obj == null)
				{
					ExceptionHelper.ThrowTypeError(_target.Engine.Realm, $"Iterator result {jsValue} is not an object");
				}
				return obj;
			}

			public override void Close(CompletionType completion)
			{
				if (!_target.TryGetValue(CommonProperties.Return, out JsValue value) || value.IsNullOrUndefined())
				{
					return;
				}
				ICallable callable = value as ICallable;
				if (callable == null)
				{
					ExceptionHelper.ThrowTypeError(_target.Engine.Realm, value?.ToString() + " is not a function");
				}
				JsValue value2 = JsValue.Undefined;
				try
				{
					value2 = callable.Call(_target, Arguments.Empty);
				}
				catch
				{
					if (completion != CompletionType.Throw)
					{
						throw;
					}
				}
				if (completion != CompletionType.Throw && !value2.IsObject())
				{
					ExceptionHelper.ThrowTypeError(_target.Engine.Realm, "Iterator returned non-object");
				}
			}
		}

		internal sealed class StringIterator : IteratorInstance
		{
			private readonly TextElementEnumerator _iterator;

			public StringIterator(Engine engine, string str)
				: base(engine)
			{
				_iterator = StringInfo.GetTextElementEnumerator(str);
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (_iterator.MoveNext())
				{
					nextItem = IteratorResult.CreateValueIteratorPosition(_engine, (string)_iterator.Current);
					return true;
				}
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		internal sealed class RegExpStringIterator : IteratorInstance
		{
			private readonly JsRegExp _iteratingRegExp;

			private readonly string _s;

			private readonly bool _global;

			private readonly bool _unicode;

			private bool _done;

			public RegExpStringIterator(Engine engine, ObjectInstance iteratingRegExp, string iteratedString, bool global, bool unicode)
				: base(engine)
			{
				JsRegExp jsRegExp = iteratingRegExp as JsRegExp;
				if ((object)jsRegExp == null)
				{
					ExceptionHelper.ThrowTypeError(engine.Realm);
				}
				_iteratingRegExp = jsRegExp;
				_s = iteratedString;
				_global = global;
				_unicode = unicode;
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (_done)
				{
					nextItem = CreateIterResultObject(JsValue.Undefined, done: true);
					return false;
				}
				JsValue jsValue = RegExpPrototype.RegExpExec(_iteratingRegExp, _s);
				if (jsValue.IsNull())
				{
					_done = true;
					nextItem = CreateIterResultObject(JsValue.Undefined, done: true);
					return false;
				}
				if (_global)
				{
					if (TypeConverter.ToString(jsValue.Get(JsString.NumberZeroString)) == "")
					{
						ulong num = TypeConverter.ToLength(_iteratingRegExp.Get(JsRegExp.PropertyLastIndex)) + 1;
						_iteratingRegExp.Set(JsRegExp.PropertyLastIndex, num, throwOnError: true);
					}
				}
				else
				{
					_done = true;
				}
				nextItem = CreateIterResultObject(jsValue, done: false);
				return true;
			}
		}

		internal sealed class EnumerableIterator : IteratorInstance
		{
			private readonly IEnumerator<JsValue> _enumerable;

			public EnumerableIterator(Engine engine, IEnumerable<JsValue> obj)
				: base(engine)
			{
				_enumerable = obj.GetEnumerator();
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				if (_enumerable.MoveNext())
				{
					nextItem = IteratorResult.CreateValueIteratorPosition(_engine, _enumerable.Current);
					return true;
				}
				nextItem = IteratorResult.CreateValueIteratorPosition(_engine, null, JsBoolean.True);
				return false;
			}
		}

		internal sealed class GeneratorIterator : IteratorInstance
		{
			private readonly GeneratorInstance _generator;

			public GeneratorIterator(Engine engine, GeneratorInstance generator)
				: base(engine)
			{
				_generator = generator;
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				nextItem = IteratorResult.CreateValueIteratorPosition(_engine, null, JsBoolean.True);
				return false;
			}
		}

		protected IteratorInstance(Engine engine)
			: base(engine)
		{
			_prototype = engine.Realm.Intrinsics.ArrayIteratorPrototype;
		}

		public override object ToObject()
		{
			ExceptionHelper.ThrowNotImplementedException();
			return null;
		}

		public abstract bool TryIteratorStep(out ObjectInstance nextItem);

		public virtual void Close(CompletionType completion)
		{
		}

		private IteratorResult CreateIterResultObject(JsValue value, bool done)
		{
			return new IteratorResult(_engine, value, JsBoolean.Create(done));
		}
	}
	internal abstract class IteratorProtocol
	{
		private readonly Engine _engine;

		private readonly IteratorInstance _iterator;

		private readonly int _argCount;

		protected virtual bool ShouldContinue => true;

		protected IteratorProtocol(Engine engine, IteratorInstance iterator, int argCount)
		{
			_engine = engine;
			_iterator = iterator;
			_argCount = argCount;
		}

		internal bool Execute()
		{
			JsValue[] array = _engine._jsValueArrayPool.RentArray(_argCount);
			bool result = false;
			try
			{
				while (ShouldContinue)
				{
					if (!_iterator.TryIteratorStep(out ObjectInstance nextItem))
					{
						result = true;
						break;
					}
					JsValue currentValue = nextItem.Get(CommonProperties.Value);
					ProcessItem(array, currentValue);
				}
			}
			catch
			{
				IteratorClose(CompletionType.Throw);
				throw;
			}
			finally
			{
				_engine._jsValueArrayPool.ReturnArray(array);
			}
			IterationEnd();
			return result;
		}

		protected void IteratorClose(CompletionType completionType)
		{
			_iterator.Close(completionType);
		}

		protected virtual void IterationEnd()
		{
		}

		protected abstract void ProcessItem(JsValue[] arguments, JsValue currentValue);

		internal static void AddEntriesFromIterable(ObjectInstance target, IteratorInstance iterable, object adder)
		{
			ICallable callable = adder as ICallable;
			if (callable == null)
			{
				ExceptionHelper.ThrowTypeError(target.Engine.Realm, "adder must be callable");
			}
			JsValue[] array = target.Engine._jsValueArrayPool.RentArray(2);
			bool flag = true;
			try
			{
				ObjectInstance nextItem;
				while (iterable.TryIteratorStep(out nextItem))
				{
					JsValue jsValue = nextItem.Get(CommonProperties.Value);
					flag = false;
					ObjectInstance obj = jsValue as ObjectInstance;
					if ((object)obj == null)
					{
						ExceptionHelper.ThrowTypeError(target.Engine.Realm, "iterator's value must be an object");
					}
					JsValue jsValue2 = obj.Get(JsString.NumberZeroString);
					JsValue jsValue3 = obj.Get(JsString.NumberOneString);
					array[0] = jsValue2;
					array[1] = jsValue3;
					callable.Call(target, array);
				}
			}
			catch
			{
				if (!flag)
				{
					iterable.Close(CompletionType.Throw);
				}
				throw;
			}
			finally
			{
				target.Engine._jsValueArrayPool.ReturnArray(array);
			}
		}
	}
	internal class IteratorPrototype : Prototype
	{
		internal IteratorPrototype(Engine engine, Realm realm, Prototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol iterator = GlobalSymbolRegistry.Iterator;
			symbolDictionary[iterator] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.iterator]", ToIterator, 0, PropertyFlag.Configurable), true, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private static JsValue ToIterator(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject;
		}

		internal JsValue Next(JsValue thisObject, JsValue[] arguments)
		{
			IteratorInstance obj = thisObject as IteratorInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			obj.TryIteratorStep(out ObjectInstance nextItem);
			return nextItem;
		}
	}
	internal sealed class IteratorResult : ObjectInstance
	{
		private readonly JsValue _value;

		private readonly JsBoolean _done;

		public IteratorResult(Engine engine, JsValue value, JsBoolean done)
			: base(engine)
		{
			_value = value;
			_done = done;
		}

		public static IteratorResult CreateValueIteratorPosition(Engine engine, JsValue? value = null, JsBoolean? done = null)
		{
			return new IteratorResult(engine, value ?? JsValue.Undefined, done ?? JsBoolean.False);
		}

		public static IteratorResult CreateKeyValueIteratorPosition(Engine engine, JsValue? key = null, JsValue? value = null)
		{
			bool flag = (object)key == null && (object)value == null;
			JsValue value2 = (flag ? JsValue.Undefined : new JsArray(engine, new JsValue[2] { key, value }));
			return new IteratorResult(engine, value2, JsBoolean.Create(flag));
		}

		public override JsValue Get(JsValue property, JsValue receiver)
		{
			if (CommonProperties.Value.Equals(property))
			{
				return _value;
			}
			if (CommonProperties.Done.Equals(property))
			{
				return _done;
			}
			return base.Get(property, receiver);
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (CommonProperties.Value.Equals(property))
			{
				return new PropertyDescriptor(_value, PropertyFlag.AllForbidden);
			}
			if (CommonProperties.Done.Equals(property))
			{
				return new PropertyDescriptor(_done, PropertyFlag.AllForbidden);
			}
			return base.GetOwnProperty(property);
		}

		public override object ToObject()
		{
			return this;
		}
	}
}
namespace Jint.Native.Intl
{
	internal sealed class CollatorConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Collator");

		public CollatorPrototype PrototypeObject { get; }

		public CollatorConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new CollatorPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class CollatorPrototype : Prototype
	{
		private readonly CollatorConstructor _constructor;

		public CollatorPrototype(Engine engine, Realm realm, CollatorConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.Collator", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class DateTimeFormatConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("DateTimeFormat");

		public DateTimeFormatPrototype PrototypeObject { get; }

		public DateTimeFormatConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new DateTimeFormatPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsValue locales = arguments.At(0);
			JsValue options = arguments.At(1);
			if (newTarget.IsUndefined())
			{
				newTarget = this;
			}
			JsObject jsObject = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.DateTimeFormat.PrototypeObject, (Engine engine, Realm _, object? _) => new JsObject(engine));
			InitializeDateTimeFormat(jsObject, locales, options);
			return jsObject;
		}

		private static void InitializeDateTimeFormat(JsObject dateTimeFormat, JsValue locales, JsValue options)
		{
		}
	}
	internal sealed class DateTimeFormatPrototype : Prototype
	{
		private readonly DateTimeFormatConstructor _constructor;

		public DateTimeFormatPrototype(Engine engine, Realm realm, DateTimeFormatConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.DateTimeFormat", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class DisplayNamesConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("DisplayNames");

		public DisplayNamesPrototype PrototypeObject { get; }

		public DisplayNamesConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new DisplayNamesPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class DisplayNamesPrototype : Prototype
	{
		private readonly DisplayNamesConstructor _constructor;

		public DisplayNamesPrototype(Engine engine, Realm realm, DisplayNamesConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.DisplayNames", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class IntlInstance : ObjectInstance
	{
		private readonly Realm _realm;

		internal IntlInstance(Engine engine, Realm realm, ObjectPrototype objectPrototype)
			: base(engine)
		{
			_realm = realm;
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(10, checkExistingKeys: false)
			{
				["Collator"] = new PropertyDescriptor(_realm.Intrinsics.Collator, false, false, true),
				["DateTimeFormat"] = new PropertyDescriptor(_realm.Intrinsics.DateTimeFormat, false, false, true),
				["DisplayNames"] = new PropertyDescriptor(_realm.Intrinsics.DisplayNames, false, false, true),
				["ListFormat"] = new PropertyDescriptor(_realm.Intrinsics.ListFormat, false, false, true),
				["Locale"] = new PropertyDescriptor(_realm.Intrinsics.Locale, false, false, true),
				["NumberFormat"] = new PropertyDescriptor(_realm.Intrinsics.NumberFormat, false, false, true),
				["PluralRules"] = new PropertyDescriptor(_realm.Intrinsics.PluralRules, false, false, true),
				["RelativeTimeFormat"] = new PropertyDescriptor(_realm.Intrinsics.RelativeTimeFormat, false, false, true),
				["Segmenter"] = new PropertyDescriptor(_realm.Intrinsics.Segmenter, false, false, true),
				["getCanonicalLocales "] = new PropertyDescriptor(new ClrFunction(base.Engine, "getCanonicalLocales ", GetCanonicalLocales, 1, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue GetCanonicalLocales(JsValue thisObject, JsValue[] arguments)
		{
			return new JsArray(_engine);
		}
	}
	internal sealed class ListFormatConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("ListFormat");

		public ListFormatPrototype PrototypeObject { get; }

		public ListFormatConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new ListFormatPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class ListFormatPrototype : Prototype
	{
		private readonly ListFormatConstructor _constructor;

		public ListFormatPrototype(Engine engine, Realm realm, ListFormatConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.ListFormat", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class LocaleConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Locale");

		public LocalePrototype PrototypeObject { get; }

		public LocaleConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new LocalePrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class LocalePrototype : Prototype
	{
		private readonly LocaleConstructor _constructor;

		public LocalePrototype(Engine engine, Realm realm, LocaleConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.Locale", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class NumberFormatConstructor : Constructor
	{
		private enum OptionType
		{
			Boolean,
			Number,
			String
		}

		private static readonly JsString _functionName = new JsString("NumberFormat");

		private static readonly HashSet<string> _sanctionedSingleUnitIdentifiers = new HashSet<string>(StringComparer.Ordinal)
		{
			"acre", "bit", "byte", "celsius", "centimeter", "day", "degree", "fahrenheit", "fluid-ounce", "foot",
			"gallon", "gigabit", "gigabyte", "gram", "hectare", "hour", "inch", "kilobit", "kilobyte", "kilogram",
			"kilometer", "liter", "megabit", "megabyte", "meter", "microsecond", "mile", "mile-scandinavian", "milliliter", "millimeter",
			"millisecond", "minute", "month", "nanosecond", "ounce", "percent", "petabyte", "pound", "second", "stone",
			"terabit", "terabyte", "week", "yard", "year"
		};

		public NumberFormatPrototype PrototypeObject { get; }

		public object LocaleData { get; private set; }

		public object AvailableLocales { get; private set; }

		public object RelevantExtensionKeys { get; private set; }

		public NumberFormatConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new NumberFormatPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			LocaleData = new object();
			AvailableLocales = new object();
			RelevantExtensionKeys = new object();
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsValue locales = arguments.At(0);
			JsValue opts = arguments.At(1);
			if (newTarget.IsUndefined())
			{
				newTarget = this;
			}
			JsObject jsObject = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.NumberFormat.PrototypeObject, (Engine engine, Realm _, object? _) => new JsObject(engine));
			InitializeNumberFormat(jsObject, locales, opts);
			return jsObject;
		}

		private JsObject InitializeNumberFormat(JsObject numberFormat, JsValue locales, JsValue opts)
		{
			JsArray requestedLocales = CanonicalizeLocaleList(locales);
			ObjectInstance options = CoerceOptionsToObject(opts);
			JsObject jsObject = new JsObject(_engine);
			JsValue option = GetOption(options, "localeMatcher", OptionType.String, new JsValue[2] { "lookup", "best fit" }, "best fit");
			jsObject["localeMatcher"] = option;
			JsValue option2 = GetOption(options, "numberingSystem", OptionType.String, System.Array.Empty<JsValue>(), JsValue.Undefined);
			option2.IsUndefined();
			jsObject["nu"] = option2;
			object localeData = LocaleData;
			JsObject jsObject2 = ResolveLocale(_engine.Realm.Intrinsics.NumberFormat.AvailableLocales, requestedLocales, jsObject, _engine.Realm.Intrinsics.NumberFormat.RelevantExtensionKeys, localeData);
			numberFormat["Locale"] = jsObject2["locale"];
			numberFormat["DataLocale"] = jsObject2["dataLocale"];
			numberFormat["NumberingSystem"] = jsObject2["nu"];
			SetNumberFormatUnitOptions(numberFormat, options);
			JsValue jsValue = numberFormat["Style"];
			int mxfdDefault;
			int mnfdDefault;
			if (jsValue == "currency")
			{
				mxfdDefault = (mnfdDefault = CurrencyDigits(numberFormat["Currency"]));
			}
			else
			{
				mnfdDefault = 0;
				mxfdDefault = ((!(jsValue == "percent")) ? 3 : 0);
			}
			JsValue option3 = GetOption(options, "notation", OptionType.String, new JsValue[4] { "standard", "scientific", "engineering", "compact" }, "standard");
			numberFormat["Notation"] = option3;
			SetNumberFormatDigitOptions(numberFormat, options, mnfdDefault, mxfdDefault, option3.ToString());
			JsValue option4 = GetOption(options, "compactDisplay", OptionType.String, new JsValue[2] { "short", "long" }, "short");
			if (option3 == "compact")
			{
				numberFormat["CompactDisplay"] = option4;
			}
			JsValue option5 = GetOption(options, "useGrouping", OptionType.Boolean, System.Array.Empty<JsValue>(), JsBoolean.True);
			numberFormat["UseGrouping"] = option5;
			JsValue option6 = GetOption(options, "signDisplay", OptionType.String, new JsValue[4] { "auto", "never", "always", "exceptZero" }, "auto");
			numberFormat["SignDisplay"] = option6;
			return numberFormat;
		}

		private JsObject ResolveLocale(object availableLocales, JsArray requestedLocales, JsObject options, object relevantExtensionKeys, object localeData)
		{
			return new JsObject(_engine);
		}

		private static void SetNumberFormatDigitOptions(JsObject numberFormat, ObjectInstance options, int mnfdDefault, int mxfdDefault, string notation)
		{
		}

		private static int CurrencyDigits(JsValue currency)
		{
			return 2;
		}

		private void SetNumberFormatUnitOptions(JsObject intlObj, JsValue options)
		{
			JsValue option = GetOption(options, "style", OptionType.String, new JsValue[4] { "decimal", "percent", "currency", "unit" }, "decimal");
			intlObj["Style"] = option;
			JsValue option2 = GetOption(options, "currency", OptionType.String, System.Array.Empty<JsValue>(), JsValue.Undefined);
			if (option2.IsUndefined())
			{
				if (option == "currency")
				{
					ExceptionHelper.ThrowTypeError(_realm, "No currency found when style currency requested");
				}
			}
			else if (!IsWellFormedCurrencyCode(option2))
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid currency code");
			}
			JsValue option3 = GetOption(options, "currencyDisplay", OptionType.String, new JsValue[4] { "code", "symbol", "narrowSymbol", "name" }, "symbol");
			JsValue option4 = GetOption(options, "currencySign", OptionType.String, new JsValue[2] { "standard", "accounting" }, "standard");
			JsValue option5 = GetOption(options, "unit", OptionType.String, System.Array.Empty<JsValue>(), JsValue.Undefined);
			if (option5.IsUndefined())
			{
				if (option == "unit")
				{
					ExceptionHelper.ThrowTypeError(_realm, "No unit found when style unit requested");
				}
			}
			else if (!IsWellFormedUnitIdentifier(option5))
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid unit");
			}
			JsValue option6 = GetOption(options, "unitDisplay", OptionType.String, new JsValue[3] { "short", "narrow", "long" }, "short");
			if (option == "currency")
			{
				intlObj["Currency"] = option2.ToString().ToUpperInvariant();
				intlObj["CurrencyDisplay"] = option3;
				intlObj["CurrencySign"] = option4;
			}
			if (option == "unit")
			{
				intlObj["Unit"] = option5;
				intlObj["UnitDisplay"] = option6;
			}
		}

		private static bool IsWellFormedUnitIdentifier(JsValue unitIdentifier)
		{
			string text = unitIdentifier.ToString();
			if (IsSanctionedSingleUnitIdentifier(text))
			{
				return true;
			}
			int num = text.IndexOf("-per-", StringComparison.Ordinal);
			if (num == -1 || text.IndexOf("-per-", num + 1, StringComparison.Ordinal) != -1)
			{
				return false;
			}
			string unitIdentifier2 = text.Substring(0, num);
			string unitIdentifier3 = text.Substring(num + 5);
			if (IsSanctionedSingleUnitIdentifier(unitIdentifier2) && IsSanctionedSingleUnitIdentifier(unitIdentifier3))
			{
				return true;
			}
			return false;
		}

		private static bool IsSanctionedSingleUnitIdentifier(string unitIdentifier)
		{
			return _sanctionedSingleUnitIdentifiers.Contains(unitIdentifier);
		}

		private static bool IsWellFormedCurrencyCode(JsValue currency)
		{
			string text = currency.ToString();
			if (text.Length == 3 && char.IsLetter(text[0]) && char.IsLetter(text[1]))
			{
				return char.IsLetter(text[2]);
			}
			return false;
		}

		private ObjectInstance CoerceOptionsToObject(JsValue options)
		{
			if (options.IsUndefined())
			{
				return ObjectInstance.OrdinaryObjectCreate(_engine, null);
			}
			return TypeConverter.ToObject(_realm, options);
		}

		private JsArray CanonicalizeLocaleList(JsValue locales)
		{
			return new JsArray(_engine);
		}

		private JsValue GetOption<T>(JsValue options, string property, OptionType type, T[] values, T defaultValue) where T : JsValue
		{
			JsValue jsValue = options.Get(property);
			if (jsValue.IsUndefined())
			{
				if (defaultValue == "required")
				{
					ExceptionHelper.ThrowRangeError(_realm, "Required value missing");
				}
				return defaultValue;
			}
			switch (type)
			{
			case OptionType.Boolean:
				jsValue = TypeConverter.ToBoolean(jsValue);
				break;
			case OptionType.Number:
			{
				double num = TypeConverter.ToNumber(jsValue);
				if (double.IsNaN(num))
				{
					ExceptionHelper.ThrowRangeError(_realm, "Invalid number value");
				}
				jsValue = num;
				break;
			}
			case OptionType.String:
				jsValue = TypeConverter.ToString(jsValue);
				break;
			default:
				ExceptionHelper.ThrowArgumentOutOfRangeException("type", "Unknown type");
				break;
			}
			if (values.Length != 0)
			{
				if (System.Array.IndexOf(values, jsValue) == -1)
				{
					ExceptionHelper.ThrowRangeError(_realm, "Value not part of list");
				}
			}
			return jsValue;
		}
	}
	internal sealed class NumberFormatPrototype : Prototype
	{
		private readonly NumberFormatConstructor _constructor;

		public NumberFormatPrototype(Engine engine, Realm realm, NumberFormatConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.NumberFormat", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class PluralRulesConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("PluralRules");

		public PluralRulesPrototype PrototypeObject { get; }

		public PluralRulesConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new PluralRulesPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsValue locales = arguments.At(0);
			JsValue options = arguments.At(1);
			if (newTarget.IsUndefined())
			{
				newTarget = this;
			}
			JsObject jsObject = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.PluralRules.PrototypeObject, (Engine engine, Realm _, object? _) => new JsObject(engine));
			InitializePluralRules(jsObject, locales, options);
			return jsObject;
		}

		private static void InitializePluralRules(JsObject pluralRules, JsValue locales, JsValue options)
		{
		}
	}
	internal sealed class PluralRulesPrototype : Prototype
	{
		private readonly PluralRulesConstructor _constructor;

		public PluralRulesPrototype(Engine engine, Realm realm, PluralRulesConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.PluralRules", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class RelativeTimeFormatConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("RelativeTimeFormat");

		public RelativeTimeFormatPrototype PrototypeObject { get; }

		public RelativeTimeFormatConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new RelativeTimeFormatPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsValue locales = arguments.At(0);
			JsValue options = arguments.At(1);
			if (newTarget.IsUndefined())
			{
				newTarget = this;
			}
			JsObject jsObject = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.RelativeTimeFormat.PrototypeObject, (Engine engine, Realm _, object? _) => new JsObject(engine));
			InitializeRelativeTimeFormat(jsObject, locales, options);
			return jsObject;
		}

		private static void InitializeRelativeTimeFormat(JsObject relativeTimeFormat, JsValue locales, JsValue options)
		{
		}
	}
	internal sealed class RelativeTimeFormatPrototype : Prototype
	{
		private readonly RelativeTimeFormatConstructor _constructor;

		public RelativeTimeFormatPrototype(Engine engine, Realm realm, RelativeTimeFormatConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.RelativeTimeFormat", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class SegmenterConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Segmenter");

		public SegmenterPrototype PrototypeObject { get; }

		public SegmenterConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new SegmenterPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class SegmenterPrototype : Prototype
	{
		private readonly SegmenterConstructor _constructor;

		public SegmenterPrototype(Engine engine, Realm realm, SegmenterConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false) { ["constructor"] = new PropertyDescriptor(_constructor, true, false, true) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Intl.Segmenter", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
}
namespace Jint.Native.Global
{
	public sealed class GlobalObject : ObjectInstance
	{
		private readonly Realm _realm;

		private readonly StringBuilder _stringBuilder = new StringBuilder();

		private const string UriReservedString = ";/?:@&=+$,";

		private const string UriUnescapedString = "-_.!~*'()";

		private static readonly SearchValues<char> UriUnescaped = SearchValues.Create("-_.!~*'()");

		private static readonly SearchValues<char> UnescapedUriSet = SearchValues.Create(";/?:@&=+$,-_.!~*'()#");

		private static readonly SearchValues<char> ReservedUriSet = SearchValues.Create(";/?:@&=+$,#");

		private static readonly SearchValues<char> EscapeAllowList = SearchValues.Create("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_ + -./");

		private static readonly Key propertyAggregateError = "AggregateError";

		private static readonly Key propertyArray = "Array";

		private static readonly Key propertyArrayBuffer = "ArrayBuffer";

		private static readonly Key propertyAtomics = "Atomics";

		private static readonly Key propertyBigInt = "BigInt";

		private static readonly Key propertyBigInt64Array = "BigInt64Array";

		private static readonly Key propertyBigUint64Array = "BigUint64Array";

		private static readonly Key propertyBoolean = "Boolean";

		private static readonly Key propertyDataView = "DataView";

		private static readonly Key propertyDate = "Date";

		private static readonly Key propertyError = "Error";

		private static readonly Key propertyEvalError = "EvalError";

		private static readonly Key propertyFinalizationRegistry = "FinalizationRegistry";

		private static readonly Key propertyFloat32Array = "Float32Array";

		private static readonly Key propertyFloat64Array = "Float64Array";

		private static readonly Key propertyFunction = "Function";

		private static readonly Key propertyGeneratorFunction = "Generator";

		private static readonly Key propertyInt16Array = "Int16Array";

		private static readonly Key propertyInt32Array = "Int32Array";

		private static readonly Key propertyInt8Array = "Int8Array";

		private static readonly Key propertyJSON = "JSON";

		private static readonly Key propertyMap = "Map";

		private static readonly Key propertyMath = "Math";

		private static readonly Key propertyNumber = "Number";

		private static readonly Key propertyObject = "Object";

		private static readonly Key propertyPromise = "Promise";

		private static readonly Key propertyProxy = "Proxy";

		private static readonly Key propertyRangeError = "RangeError";

		private static readonly Key propertyReferenceError = "ReferenceError";

		private static readonly Key propertyReflect = "Reflect";

		private static readonly Key propertyRegExp = "RegExp";

		private static readonly Key propertySet = "Set";

		private static readonly Key propertyShadowRealm = "ShadowRealm";

		private static readonly Key propertySharedArrayBuffer = "SharedArrayBuffer";

		private static readonly Key propertyString = "String";

		private static readonly Key propertySymbol = "Symbol";

		private static readonly Key propertySyntaxError = "SyntaxError";

		private static readonly Key propertyTypeError = "TypeError";

		private static readonly Key propertyTypedArray = "TypedArray";

		private static readonly Key propertyURIError = "URIError";

		private static readonly Key propertyUint16Array = "Uint16Array";

		private static readonly Key propertyUint32Array = "Uint32Array";

		private static readonly Key propertyUint8Array = "Uint8Array";

		private static readonly Key propertyUint8ClampedArray = "Uint8ClampedArray";

		private static readonly Key propertyWeakMap = "WeakMap";

		private static readonly Key propertyWeakRef = "WeakRef";

		private static readonly Key propertyWeakSet = "WeakSet";

		private static readonly Key propertyNaN = "NaN";

		private static readonly Key propertyInfinity = "Infinity";

		private static readonly Key propertyUndefined = "undefined";

		private static readonly Key propertyParseInt = "parseInt";

		private static readonly Key propertyParseFloat = "parseFloat";

		private static readonly Key propertyIsNaN = "isNaN";

		private static readonly Key propertyIsFinite = "isFinite";

		private static readonly Key propertyDecodeURI = "decodeURI";

		private static readonly Key propertyDecodeURIComponent = "decodeURIComponent";

		private static readonly Key propertyEncodeURI = "encodeURI";

		private static readonly Key propertyEncodeURIComponent = "encodeURIComponent";

		private static readonly Key propertyEscape = "escape";

		private static readonly Key propertyUnescape = "unescape";

		private static readonly Key propertyGlobalThis = "globalThis";

		private static readonly Key propertyEval = "eval";

		private static readonly Key propertyToString = "toString";

		private static readonly PropertyDescriptor _propertyDescriptorNan = new PropertyDescriptor(JsNumber.DoubleNaN, PropertyFlag.AllForbidden);

		private static readonly PropertyDescriptor _propertyDescriptorPositiveInfinity = new PropertyDescriptor(JsNumber.DoublePositiveInfinity, PropertyFlag.AllForbidden);

		private static readonly PropertyDescriptor _propertyDescriptorUndefined = new PropertyDescriptor(JsValue.Undefined, PropertyFlag.AllForbidden);

		internal GlobalObject(Engine engine, Realm realm)
			: base(engine, ObjectClass.Object, InternalTypes.Object | InternalTypes.PlainObject)
		{
			_realm = realm;
		}

		private JsValue ToStringString(JsValue thisObject, JsValue[] arguments)
		{
			return _realm.Intrinsics.Object.PrototypeObject.ToObjectString(thisObject, Arguments.Empty);
		}

		internal static JsValue ParseInt(JsValue thisObject, JsValue[] arguments)
		{
			string text = StringPrototype.TrimEx(TypeConverter.ToString(arguments.At(0)));
			ReadOnlySpan<char> readOnlySpan = text.AsSpan();
			int num = ((arguments.Length > 1) ? TypeConverter.ToInt32(arguments[1]) : 0);
			bool flag = readOnlySpan.Length > 1 && text.StartsWith("0x", StringComparison.OrdinalIgnoreCase);
			bool flag2 = true;
			switch (num)
			{
			case 0:
				num = (flag ? 16 : 10);
				break;
			default:
				return JsNumber.DoubleNaN;
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			case 7:
			case 8:
			case 9:
			case 10:
			case 11:
			case 12:
			case 13:
			case 14:
			case 15:
			case 17:
			case 18:
			case 19:
			case 20:
			case 21:
			case 22:
			case 23:
			case 24:
			case 25:
			case 26:
			case 27:
			case 28:
			case 29:
			case 30:
			case 31:
			case 32:
			case 33:
			case 34:
			case 35:
			case 36:
				flag2 = false;
				break;
			case 16:
				break;
			}
			if (num == 10 && int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return JsNumber.Create(result);
			}
			int num2 = 1;
			if (readOnlySpan.Length > 0)
			{
				char c = readOnlySpan[0];
				if (c == '-')
				{
					num2 = -1;
				}
				if ((c == '+' || c == '-') ? true : false)
				{
					readOnlySpan = readOnlySpan.Slice(1);
				}
			}
			if (flag2 && flag)
			{
				readOnlySpan = readOnlySpan.Slice(2);
			}
			if (readOnlySpan.Length == 0)
			{
				return double.NaN;
			}
			bool flag3 = false;
			double num3 = 0.0;
			double num4 = 1.0;
			for (int num5 = readOnlySpan.Length - 1; num5 >= 0; num5--)
			{
				char c2 = readOnlySpan[num5];
				int num6;
				switch (c2)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					num6 = c2 - 48;
					break;
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
				case 'g':
				case 'h':
				case 'i':
				case 'j':
				case 'k':
				case 'l':
				case 'm':
				case 'n':
				case 'o':
				case 'p':
				case 'q':
				case 'r':
				case 's':
				case 't':
				case 'u':
				case 'v':
				case 'w':
				case 'x':
				case 'y':
				case 'z':
					num6 = c2 - 97 + 10;
					break;
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
				case 'G':
				case 'H':
				case 'I':
				case 'J':
				case 'K':
				case 'L':
				case 'M':
				case 'N':
				case 'O':
				case 'P':
				case 'Q':
				case 'R':
				case 'S':
				case 'T':
				case 'U':
				case 'V':
				case 'W':
				case 'X':
				case 'Y':
				case 'Z':
					num6 = c2 - 65 + 10;
					break;
				default:
					num6 = -1;
					break;
				}
				int num7 = num6;
				if (num7 == -1 || num7 >= num)
				{
					flag3 = false;
					num3 = 0.0;
					num4 = 1.0;
				}
				else
				{
					flag3 = true;
					num3 += (double)num7 * num4;
					num4 *= (double)num;
				}
			}
			if (!flag3)
			{
				return JsNumber.DoubleNaN;
			}
			return JsNumber.Create((double)num2 * num3);
		}

		internal static JsValue ParseFloat(JsValue thisObject, JsValue[] arguments)
		{
			string text = StringPrototype.TrimStartEx(TypeConverter.ToString(arguments.At(0)));
			if (string.IsNullOrWhiteSpace(text))
			{
				return JsNumber.DoubleNaN;
			}
			int num = 0;
			if (!char.IsDigit(text[0]))
			{
				if (text[0] == '-')
				{
					num++;
					if (text.Length > 1 && text[1] == 'I' && text.StartsWith("-Infinity", StringComparison.Ordinal))
					{
						return JsNumber.DoubleNegativeInfinity;
					}
				}
				if (text[0] == '+')
				{
					num++;
					if (text.Length > 1 && text[1] == 'I' && text.StartsWith("+Infinity", StringComparison.Ordinal))
					{
						return JsNumber.DoublePositiveInfinity;
					}
				}
				if (text.StartsWith("Infinity", StringComparison.Ordinal))
				{
					return JsNumber.DoublePositiveInfinity;
				}
				if (text.StartsWith("NaN", StringComparison.Ordinal))
				{
					return JsNumber.DoubleNaN;
				}
			}
			bool flag = false;
			bool flag2 = false;
			while (num < text.Length)
			{
				char c = text[num];
				if (Character.IsDecimalDigit(c))
				{
					num++;
					continue;
				}
				if (c == '.')
				{
					if (flag)
					{
						break;
					}
					num++;
					flag = true;
					continue;
				}
				if ((c == 'E' || c == 'e') ? true : false)
				{
					if (flag2)
					{
						break;
					}
					num++;
					flag2 = true;
					continue;
				}
				bool flag3 = ((c == '+' || c == '-') ? true : false);
				bool flag4 = flag3;
				if (flag4)
				{
					char c2 = text[num - 1];
					bool flag5 = ((c2 == 'E' || c2 == 'e') ? true : false);
					flag4 = flag5;
				}
				if (!flag4)
				{
					break;
				}
				num++;
			}
			while (flag2 && num > 0 && !Character.IsDecimalDigit(text[num - 1]))
			{
				num--;
			}
			if (double.TryParse(text.AsSpan(0, num), NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return JsNumber.DoubleNaN;
		}

		private static JsValue IsNaN(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			if ((object)jsValue == JsNumber.DoubleNaN)
			{
				return true;
			}
			return double.IsNaN(TypeConverter.ToNumber(jsValue));
		}

		private static JsValue IsFinite(JsValue thisObject, JsValue[] arguments)
		{
			if (arguments.Length != 1)
			{
				return false;
			}
			double d = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(d) || double.IsInfinity(d))
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsValidHexaChar(char c)
		{
			return Uri.IsHexDigit(c);
		}

		private JsValue EncodeUri(JsValue thisObject, JsValue[] arguments)
		{
			string uriString = TypeConverter.ToString(arguments.At(0));
			return Encode(uriString, UnescapedUriSet);
		}

		private JsValue EncodeUriComponent(JsValue thisObject, JsValue[] arguments)
		{
			string uriString = TypeConverter.ToString(arguments.At(0));
			return Encode(uriString, UriUnescaped);
		}

		private JsValue Encode(string uriString, SearchValues<char> unescapedUriSet)
		{
			int length = uriString.Length;
			_stringBuilder.EnsureCapacity(uriString.Length);
			_stringBuilder.Clear();
			Span<byte> span = stackalloc byte[4];
			int num = 0;
			while (true)
			{
				if (num < length)
				{
					char c = uriString[num];
					if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || unescapedUriSet.Contains(c))
					{
						_stringBuilder.Append(c);
					}
					else
					{
						if (c >= '\udc00' && c <= '\udbff')
						{
							break;
						}
						int num2;
						if (c < '\ud800' || c > '\udbff')
						{
							num2 = c;
						}
						else
						{
							num++;
							if (num == length)
							{
								break;
							}
							int num3 = uriString[num];
							if ((num3 < 56320 || num3 > 57343) ? true : false)
							{
								break;
							}
							num2 = (c - 55296) * 1024 + (num3 - 56320) + 65536;
						}
						int num4 = 1;
						if (num2 <= 2047)
						{
							if (num2 >= 0 && num2 <= 127)
							{
								span[0] = (byte)num2;
							}
							else
							{
								num4 = 2;
								span[0] = (byte)(0xC0 | (num2 >> 6));
								span[1] = (byte)(0x80 | (num2 & 0x3F));
							}
						}
						else if (num2 <= 57343)
						{
							if (num2 > 55295)
							{
								break;
							}
							num4 = 3;
							span[0] = (byte)(0xE0 | (num2 >> 12));
							span[1] = (byte)(0x80 | ((num2 >> 6) & 0x3F));
							span[2] = (byte)(0x80 | (num2 & 0x3F));
						}
						else if (num2 <= 65535)
						{
							num4 = 3;
							span[0] = (byte)(0xE0 | (num2 >> 12));
							span[1] = (byte)(0x80 | ((num2 >> 6) & 0x3F));
							span[2] = (byte)(0x80 | (num2 & 0x3F));
						}
						else
						{
							num4 = 4;
							span[0] = (byte)(0xF0 | (num2 >> 18));
							span[1] = (byte)(0x80 | ((num2 >> 12) & 0x3F));
							span[2] = (byte)(0x80 | ((num2 >> 6) & 0x3F));
							span[3] = (byte)(0x80 | (num2 & 0x3F));
						}
						for (int i = 0; i < num4; i++)
						{
							byte b = span[i];
							char value = "0123456789ABCDEF"[b / 16];
							char value2 = "0123456789ABCDEF"[b % 16];
							_stringBuilder.Append('%').Append(value).Append(value2);
						}
					}
					num++;
					continue;
				}
				return _stringBuilder.ToString();
			}
			_engine.SignalError(ExceptionHelper.CreateUriError(_realm, "URI malformed"));
			return JsEmpty.Instance;
		}

		private JsValue DecodeUri(JsValue thisObject, JsValue[] arguments)
		{
			string uriString = TypeConverter.ToString(arguments.At(0));
			return Decode(uriString, ReservedUriSet);
		}

		private JsValue DecodeUriComponent(JsValue thisObject, JsValue[] arguments)
		{
			string uriString = TypeConverter.ToString(arguments.At(0));
			return Decode(uriString, null);
		}

		private JsValue Decode(string uriString, SearchValues<char>? reservedSet)
		{
			int length = uriString.Length;
			_stringBuilder.EnsureCapacity(length);
			_stringBuilder.Clear();
			Span<byte> span = stackalloc byte[4];
			int num = 0;
			while (true)
			{
				if (num < length)
				{
					char c = uriString[num];
					if (c != '%')
					{
						_stringBuilder.Append(c);
					}
					else
					{
						int num2 = num;
						if (num + 2 >= length)
						{
							break;
						}
						char c2 = uriString[num + 1];
						char c3 = uriString[num + 2];
						if (!IsValidHexaChar(c2) || !IsValidHexaChar(c3))
						{
							break;
						}
						byte b = StringToIntBase16(uriString.AsSpan(num + 1, 2));
						num += 2;
						if ((b & 0x80) == 0)
						{
							c = (char)b;
							if (reservedSet == null || !reservedSet.Contains(c))
							{
								_stringBuilder.Append(c);
							}
							else
							{
								_stringBuilder.Append(uriString, num2, num - num2 + 1);
							}
						}
						else
						{
							int i;
							for (i = 0; ((b << i) & 0x80) != 0; i++)
							{
							}
							if (i == 1 || i > 4)
							{
								break;
							}
							span[0] = b;
							if (num + 3 * (i - 1) >= length)
							{
								break;
							}
							for (int j = 1; j < i; j++)
							{
								num++;
								if (uriString[num] != '%')
								{
									goto end_IL_01c8;
								}
								char c4 = uriString[num + 1];
								c3 = uriString[num + 2];
								if (!IsValidHexaChar(c4) || !IsValidHexaChar(c3))
								{
									goto end_IL_01c8;
								}
								b = StringToIntBase16(uriString.AsSpan(num + 1, 2));
								if ((b & 0xC0) != 128)
								{
									goto end_IL_01c8;
								}
								num += 2;
								span[j] = b;
							}
							_stringBuilder.Append(Encoding.UTF8.GetString(span.Slice(0, i)));
						}
					}
					num++;
					continue;
				}
				return _stringBuilder.ToString();
				continue;
				end_IL_01c8:
				break;
			}
			_engine.SignalError(ExceptionHelper.CreateUriError(_realm, "URI malformed"));
			return JsEmpty.Instance;
		}

		private static byte StringToIntBase16(ReadOnlySpan<char> s)
		{
			int i = 0;
			int length = s.Length;
			if (s[i] == '+')
			{
				i++;
			}
			if (i + 1 < length && s[i] == '0' && (s[i + 1] == 'x' || s[i + 1] == 'X'))
			{
				i += 2;
			}
			uint num = 0u;
			int result;
			for (; i < s.Length && IsDigit(s[i], 16, out result); i++)
			{
				num = num * 16 + (uint)result;
			}
			return (byte)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsDigit(char c, int radix, out int result)
		{
			int num;
			switch (c)
			{
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				num = (result = c - 48);
				break;
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
				num = (result = c - 65 + 10);
				break;
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
				num = (result = c - 97 + 10);
				break;
			default:
				result = -1;
				return false;
			}
			return num < radix;
		}

		private JsValue Escape(JsValue thisObject, JsValue[] arguments)
		{
			string text = TypeConverter.ToString(arguments.At(0));
			int length = text.Length;
			_stringBuilder.EnsureCapacity(length);
			_stringBuilder.Clear();
			for (int i = 0; i < length; i++)
			{
				char c = text[i];
				if (EscapeAllowList.Contains(c))
				{
					_stringBuilder.Append(c);
				}
				else if (c < 'Ā')
				{
					_stringBuilder.Append('%').AppendFormat(CultureInfo.InvariantCulture, "{0:X2}", (int)c);
				}
				else
				{
					_stringBuilder.Append("%u").AppendFormat(CultureInfo.InvariantCulture, "{0:X4}", (int)c);
				}
			}
			return _stringBuilder.ToString();
		}

		private JsValue Unescape(JsValue thisObject, JsValue[] arguments)
		{
			string text = TypeConverter.ToString(arguments.At(0));
			int length = text.Length;
			_stringBuilder.EnsureCapacity(length);
			_stringBuilder.Clear();
			for (int i = 0; i < length; i++)
			{
				char c = text[i];
				if (c == '%')
				{
					if (i <= length - 6 && text[i + 1] == 'u' && text.Skip(i + 2).Take(4).All(IsValidHexaChar))
					{
						c = (char)int.Parse(string.Join(string.Empty, text.Skip(i + 2).Take(4)), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
						i += 5;
					}
					else if (i <= length - 3 && text.Skip(i + 1).Take(2).All(IsValidHexaChar))
					{
						c = (char)int.Parse(string.Join(string.Empty, text.Skip(i + 1).Take(2)), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
						i += 2;
					}
				}
				_stringBuilder.Append(c);
			}
			return _stringBuilder.ToString();
		}

		internal bool HasProperty(Key property)
		{
			return GetOwnProperty(property) != PropertyDescriptor.Undefined;
		}

		private bool DefineOwnProperty(Key property, PropertyDescriptor desc)
		{
			PropertyDescriptor ownProperty = GetOwnProperty(property);
			if (ownProperty == desc)
			{
				return true;
			}
			if ((ownProperty._flags & PropertyFlag.MutableBinding) != PropertyFlag.None)
			{
				ownProperty._value = desc.Value;
				return true;
			}
			return ObjectInstance.ValidateAndApplyPropertyDescriptor(this, new JsString(property), extensible: true, desc, ownProperty);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal PropertyDescriptor GetOwnProperty(Key property)
		{
			base.Properties.TryGetValue(property, out PropertyDescriptor value);
			return value ?? PropertyDescriptor.Undefined;
		}

		internal bool SetFromMutableBinding(Key property, JsValue value, bool strict)
		{
			if (!_properties.TryGetValue(property, out PropertyDescriptor value2))
			{
				if (strict)
				{
					ExceptionHelper.ThrowReferenceNameError(_realm, property.Name);
				}
				_properties[property] = new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable | PropertyFlag.MutableBinding);
				return true;
			}
			if (value2.IsDataDescriptor())
			{
				if (!value2.Writable || value2.IsAccessorDescriptor())
				{
					return false;
				}
				if ((value2._flags & PropertyFlag.MutableBinding) != PropertyFlag.None)
				{
					value2._value = value;
					return true;
				}
				return DefineOwnProperty(property, new PropertyDescriptor(value, PropertyFlag.None));
			}
			if (!(value2.Set is ICallable callable))
			{
				return false;
			}
			callable.Call(this, value);
			return true;
		}

		protected override void Initialize()
		{
			StringDictionarySlim<PropertyDescriptor> stringDictionarySlim = new StringDictionarySlim<PropertyDescriptor>(64);
			stringDictionarySlim.AddDangerous(in propertyAggregateError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.AggregateError, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyArray, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyArrayBuffer, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.ArrayBuffer, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyAtomics, new LazyPropertyDescriptor(this, (object? state) => JsValue.Undefined, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyBigInt, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.BigInt, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyBigInt64Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.BigInt64Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyBigUint64Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.BigUint64Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyBoolean, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Boolean, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyDataView, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.DataView, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyDate, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Date, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Error, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyEvalError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.EvalError, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyFinalizationRegistry, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.FinalizationRegistry, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyFloat32Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Float32Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyFloat64Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Float64Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyFunction, new PropertyDescriptor(_realm.Intrinsics.Function, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyGeneratorFunction, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.GeneratorFunction, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyInt16Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Int16Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyInt32Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Int32Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyInt8Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Int8Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyJSON, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Json, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyMap, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Map, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyMath, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Math, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyNumber, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Number, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyObject, new PropertyDescriptor(_realm.Intrinsics.Object, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyPromise, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Promise, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyProxy, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Proxy, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyRangeError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.RangeError, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyReferenceError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.ReferenceError, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyReflect, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Reflect, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyRegExp, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.RegExp, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertySet, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Set, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyShadowRealm, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.ShadowRealm, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertySharedArrayBuffer, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.SharedArrayBuffer, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyString, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.String, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertySymbol, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Symbol, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertySyntaxError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.SyntaxError, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyTypeError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.TypeError, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyTypedArray, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.TypedArray, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyURIError, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.UriError, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyUint16Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Uint16Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyUint32Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Uint32Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyUint8Array, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Uint8Array, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyUint8ClampedArray, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Uint8ClampedArray, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyWeakMap, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.WeakMap, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyWeakRef, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.WeakRef, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyWeakSet, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.WeakSet, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyNaN, _propertyDescriptorNan);
			stringDictionarySlim.AddDangerous(in propertyInfinity, _propertyDescriptorPositiveInfinity);
			stringDictionarySlim.AddDangerous(in propertyUndefined, _propertyDescriptorUndefined);
			stringDictionarySlim.AddDangerous(in propertyParseInt, new LazyPropertyDescriptor(this, (object? state) => new ClrFunction(((GlobalObject)state)._engine, "parseInt", ParseInt, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyParseFloat, new LazyPropertyDescriptor(this, (object? state) => new ClrFunction(((GlobalObject)state)._engine, "parseFloat", ParseFloat, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyIsNaN, new LazyPropertyDescriptor(this, (object? state) => new ClrFunction(((GlobalObject)state)._engine, "isNaN", IsNaN, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyIsFinite, new LazyPropertyDescriptor(this, (object? state) => new ClrFunction(((GlobalObject)state)._engine, "isFinite", IsFinite, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyDecodeURI, new LazyPropertyDescriptor(this, delegate(object? state)
			{
				GlobalObject globalObject = (GlobalObject)state;
				return new ClrFunction(globalObject._engine, "decodeURI", globalObject.DecodeUri, 1, PropertyFlag.Configurable);
			}, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyDecodeURIComponent, new LazyPropertyDescriptor(this, delegate(object? state)
			{
				GlobalObject globalObject = (GlobalObject)state;
				return new ClrFunction(globalObject._engine, "decodeURIComponent", globalObject.DecodeUriComponent, 1, PropertyFlag.Configurable);
			}, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyEncodeURI, new LazyPropertyDescriptor(this, delegate(object? state)
			{
				GlobalObject globalObject = (GlobalObject)state;
				return new ClrFunction(globalObject._engine, "encodeURI", globalObject.EncodeUri, 1, PropertyFlag.Configurable);
			}, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyEncodeURIComponent, new LazyPropertyDescriptor(this, delegate(object? state)
			{
				GlobalObject globalObject = (GlobalObject)state;
				return new ClrFunction(globalObject._engine, "encodeURIComponent", globalObject.EncodeUriComponent, 1, PropertyFlag.Configurable);
			}, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyEscape, new LazyPropertyDescriptor(this, delegate(object? state)
			{
				GlobalObject globalObject = (GlobalObject)state;
				return new ClrFunction(globalObject._engine, "escape", globalObject.Escape, 1, PropertyFlag.Configurable);
			}, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyUnescape, new LazyPropertyDescriptor(this, delegate(object? state)
			{
				GlobalObject globalObject = (GlobalObject)state;
				return new ClrFunction(globalObject._engine, "unescape", globalObject.Unescape, 1, PropertyFlag.Configurable);
			}, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyGlobalThis, new PropertyDescriptor(this, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyEval, new LazyPropertyDescriptor(this, (object? state) => ((GlobalObject)state)._realm.Intrinsics.Eval, PropertyFlag.Writable | PropertyFlag.Configurable));
			stringDictionarySlim.AddDangerous(in propertyToString, new LazyPropertyDescriptor(this, delegate(object? state)
			{
				GlobalObject globalObject = (GlobalObject)state;
				return new ClrFunction(globalObject._engine, "toString", globalObject.ToStringString, 1);
			}, PropertyFlag.Writable | PropertyFlag.Configurable));
			SetProperties(stringDictionarySlim);
		}
	}
}
namespace Jint.Native.Generator
{
	internal sealed class GeneratorFunctionConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("GeneratorFunction");

		public GeneratorFunctionPrototype PrototypeObject { get; }

		internal GeneratorFunctionConstructor(Engine engine, Realm realm, FunctionPrototype prototype, IteratorPrototype iteratorPrototype)
			: base(engine, realm, _functionName)
		{
			PrototypeObject = new GeneratorFunctionPrototype(engine, this, prototype, iteratorPrototype);
			_prototype = PrototypeObject;
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, thisObject);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			return _realm.Intrinsics.Function.CreateDynamicFunction(this, newTarget, FunctionKind.Generator, arguments);
		}
	}
	internal sealed class GeneratorFunctionPrototype : Prototype
	{
		private readonly GeneratorFunctionConstructor? _constructor;

		public GeneratorPrototype PrototypeObject { get; }

		internal GeneratorFunctionPrototype(Engine engine, GeneratorFunctionConstructor constructor, FunctionPrototype prototype, IteratorPrototype iteratorPrototype)
			: base(engine, engine.Realm)
		{
			_constructor = constructor;
			_prototype = prototype;
			PrototypeObject = new GeneratorPrototype(engine, this, iteratorPrototype);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false)
			{
				[KnownKeys.Constructor] = new PropertyDescriptor(_constructor, PropertyFlag.Configurable),
				[KnownKeys.Prototype] = new PropertyDescriptor(PrototypeObject, PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("GeneratorFunction", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
	internal sealed class GeneratorInstance : ObjectInstance
	{
		internal GeneratorState _generatorState;

		private Jint.Runtime.Environments.ExecutionContext _generatorContext;

		private readonly JsValue? _generatorBrand;

		private JintStatementList _generatorBody;

		public JsValue? _nextValue;

		public JsValue? _error;

		public GeneratorInstance(Engine engine)
			: base(engine)
		{
		}

		public JsValue GeneratorStart(JintStatementList generatorBody)
		{
			Jint.Runtime.Environments.ExecutionContext generatorContext = _engine.UpdateGenerator(this);
			_generatorBody = generatorBody;
			_generatorContext = generatorContext;
			_generatorState = GeneratorState.SuspendedStart;
			return JsValue.Undefined;
		}

		public ObjectInstance GeneratorResume(JsValue? value, JsValue? generatorBrand)
		{
			if (GeneratorValidate(generatorBrand) == GeneratorState.Completed)
			{
				return new IteratorResult(_engine, JsValue.Undefined, JsBoolean.True);
			}
			Jint.Runtime.Environments.ExecutionContext genContext = _generatorContext;
			_ = ref _engine.ExecutionContext;
			_nextValue = value;
			EvaluationContext activeEvaluationContext = _engine._activeEvaluationContext;
			return ResumeExecution(in genContext, activeEvaluationContext);
		}

		public JsValue GeneratorResumeAbrupt(in Completion abruptCompletion, JsValue? generatorBrand)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			GeneratorState generatorState = GeneratorValidate(generatorBrand);
			if (generatorState == GeneratorState.SuspendedStart)
			{
				_generatorState = GeneratorState.Completed;
				generatorState = GeneratorState.Completed;
			}
			if (generatorState == GeneratorState.Completed)
			{
				if (abruptCompletion.Type == CompletionType.Return)
				{
					return new IteratorResult(_engine, abruptCompletion.Value, JsBoolean.True);
				}
				ExceptionHelper.ThrowJavaScriptException(_engine, abruptCompletion.Value, default(Location));
			}
			Jint.Runtime.Environments.ExecutionContext genContext = _generatorContext;
			_ = ref _engine.ExecutionContext;
			_nextValue = ((abruptCompletion.Type == CompletionType.Return) ? abruptCompletion.Value : null);
			_error = ((abruptCompletion.Type == CompletionType.Throw) ? abruptCompletion.Value : null);
			if ((object)_error != null)
			{
				ExceptionHelper.ThrowJavaScriptException(_engine, _error, default(Location));
			}
			return ResumeExecution(in genContext, new EvaluationContext(_engine));
		}

		private ObjectInstance ResumeExecution(in Jint.Runtime.Environments.ExecutionContext genContext, EvaluationContext context)
		{
			_generatorState = GeneratorState.Executing;
			_engine.EnterExecutionContext(in genContext);
			Completion result = _generatorBody.Execute(context);
			_engine.LeaveExecutionContext();
			ObjectInstance result2 = null;
			if (result.Type == CompletionType.Normal)
			{
				_generatorState = GeneratorState.Completed;
				result2 = IteratorResult.CreateValueIteratorPosition(_engine, result.Value, JsBoolean.True);
			}
			else if (result.Type == CompletionType.Return)
			{
				if (_generatorState == GeneratorState.SuspendedYield)
				{
					result2 = IteratorResult.CreateValueIteratorPosition(_engine, result.Value, JsBoolean.False);
				}
				else
				{
					_generatorState = GeneratorState.Completed;
					result2 = IteratorResult.CreateValueIteratorPosition(_engine, result.Value, JsBoolean.True);
				}
			}
			if (result.Type == CompletionType.Throw)
			{
				_generatorState = GeneratorState.Completed;
				ExceptionHelper.ThrowJavaScriptException(_engine, result.Value, in result);
			}
			return result2;
		}

		private GeneratorState GeneratorValidate(JsValue? generatorBrand)
		{
			if ((object)generatorBrand != _generatorBrand)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Generator brand differs from attached brand");
			}
			if (_generatorState == GeneratorState.Executing)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Generator state was unexpectedly executing");
			}
			return _generatorState;
		}
	}
	internal enum GeneratorKind
	{
		NonGenerator,
		Sync,
		Async
	}
	internal sealed class GeneratorPrototype : ObjectInstance
	{
		private readonly GeneratorFunctionPrototype _constructor;

		internal GeneratorPrototype(Engine engine, GeneratorFunctionPrototype constructor, IteratorPrototype iteratorPrototype)
			: base(engine)
		{
			_constructor = constructor;
			_prototype = iteratorPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(4, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.Configurable),
				["next"] = new PropertyDescriptor(new ClrFunction(base.Engine, "next", Next, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["return"] = new PropertyDescriptor(new ClrFunction(base.Engine, "return", Return, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["throw"] = new PropertyDescriptor(new ClrFunction(base.Engine, "throw", Throw, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Generator", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private ObjectInstance Next(JsValue thisObject, JsValue[] arguments)
		{
			GeneratorInstance generatorInstance = AssertGeneratorInstance(thisObject);
			JsValue value = arguments.At(0, null);
			return generatorInstance.GeneratorResume(value, null);
		}

		private JsValue Return(JsValue thisObject, JsValue[] arguments)
		{
			GeneratorInstance generatorInstance = AssertGeneratorInstance(thisObject);
			JsValue value = arguments.At(0);
			return generatorInstance.GeneratorResumeAbrupt(new Completion(CompletionType.Return, value, null), null);
		}

		private JsValue Throw(JsValue thisObject, JsValue[] arguments)
		{
			GeneratorInstance generatorInstance = AssertGeneratorInstance(thisObject);
			JsValue value = arguments.At(0);
			return generatorInstance.GeneratorResumeAbrupt(new Completion(CompletionType.Throw, value, null), null);
		}

		private GeneratorInstance AssertGeneratorInstance(JsValue thisObj)
		{
			GeneratorInstance obj = thisObj as GeneratorInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "object must be a Generator instance");
			}
			return obj;
		}
	}
	internal enum GeneratorState
	{
		Undefined,
		SuspendedStart,
		SuspendedYield,
		Executing,
		Completed
	}
}
namespace Jint.Native.Function
{
	public sealed class BindFunction : ObjectInstance, IConstructor, ICallable
	{
		private readonly Realm _realm;

		public JsValue BoundTargetFunction { get; }

		public JsValue BoundThis { get; }

		public JsValue[] BoundArguments { get; }

		internal override bool IsConstructor => BoundTargetFunction.IsConstructor;

		public BindFunction(Engine engine, Realm realm, ObjectInstance? proto, ObjectInstance targetFunction, JsValue boundThis, JsValue[] boundArgs)
			: base(engine, ObjectClass.Function)
		{
			_realm = realm;
			_prototype = proto;
			BoundTargetFunction = targetFunction;
			BoundThis = boundThis;
			BoundArguments = boundArgs;
		}

		JsValue ICallable.Call(JsValue thisObject, JsValue[] arguments)
		{
			Function obj = BoundTargetFunction as Function;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue[] array = CreateArguments(arguments);
			JsValue result = obj.Call(BoundThis, array);
			_engine._jsValueArrayPool.ReturnArray(array);
			return result;
		}

		ObjectInstance IConstructor.Construct(JsValue[] arguments, JsValue newTarget)
		{
			IConstructor obj = BoundTargetFunction as IConstructor;
			if (obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue[] array = CreateArguments(arguments);
			if ((object)this == newTarget)
			{
				newTarget = BoundTargetFunction;
			}
			ObjectInstance result = obj.Construct(array, newTarget);
			_engine._jsValueArrayPool.ReturnArray(array);
			return result;
		}

		internal override bool OrdinaryHasInstance(JsValue v)
		{
			Function obj = BoundTargetFunction as Function;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return obj.OrdinaryHasInstance(v);
		}

		private JsValue[] CreateArguments(JsValue[] arguments)
		{
			JsValue[] array = _engine._jsValueArrayPool.RentArray(BoundArguments.Length + arguments.Length);
			System.Array.Copy(BoundArguments, array, BoundArguments.Length);
			System.Array.Copy(arguments, 0, array, BoundArguments.Length, arguments.Length);
			return array;
		}

		public override string ToString()
		{
			return "function () { [native code] }";
		}
	}
	internal sealed class ClassDefinition
	{
		private sealed class ClassFieldFunction : Node, IFunction
		{
			private readonly NodeList<Node> _nodeList;

			private readonly BlockStatement _statement;

			public Identifier? Id => null;

			public ref readonly NodeList<Node> Params => ref _nodeList;

			public StatementListItem Body => (StatementListItem)(object)_statement;

			public bool Generator => false;

			public bool Expression => false;

			public bool Strict => true;

			public bool Async => false;

			public ClassFieldFunction(Expression expression)
				: base((Nodes)26)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				NodeList<Statement> val = NodeList.Create<Statement>((IEnumerable<Statement>)(object)new ReturnStatement[1]
				{
					new ReturnStatement(expression)
				});
				_statement = new BlockStatement(ref val);
			}

			protected override object Accept(AstVisitor visitor)
			{
				throw new NotImplementedException();
			}
		}

		private sealed class ClassStaticBlockFunction : Node, IFunction
		{
			private readonly BlockStatement _statement;

			private readonly NodeList<Node> _params;

			public Identifier? Id => null;

			public ref readonly NodeList<Node> Params => ref _params;

			public StatementListItem Body => (StatementListItem)(object)_statement;

			public bool Generator => false;

			public bool Expression => false;

			public bool Strict => false;

			public bool Async => false;

			public ClassStaticBlockFunction(StaticBlock staticBlock)
				: base((Nodes)57)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				_statement = new BlockStatement(staticBlock.Body);
				_params = default(NodeList<Node>);
			}

			protected override object Accept(AstVisitor visitor)
			{
				throw new NotImplementedException();
			}
		}

		private static readonly MethodDefinition _superConstructor;

		internal static CallExpression _defaultSuperCall;

		internal static readonly MethodDefinition _emptyConstructor;

		internal readonly string? _className;

		private readonly Expression? _superClass;

		private readonly ClassBody _body;

		static ClassDefinition()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_004d: Expected O, but got Unknown
			JavaScriptParser val = new JavaScriptParser();
			_superConstructor = CreateConstructorMethodDefinition(val, "class temp extends X { constructor(...args) { super(...args); } }");
			_defaultSuperCall = (CallExpression)((ExpressionStatement)((NodeList<Statement>)_superConstructor.Value.Body.Body)[0]).Expression;
			_emptyConstructor = CreateConstructorMethodDefinition(val, "class temp { constructor() {} }");
			static MethodDefinition CreateConstructorMethodDefinition(JavaScriptParser parser, string source)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Expected O, but got Unknown
				return (MethodDefinition)((NodeList<ClassElement>)((ClassDeclaration)((NodeList<Statement>)((Program)parser.ParseScript(source, (string)null, false)).Body)[0]).Body.Body)[0];
			}
		}

		public ClassDefinition(string? className, Expression? superClass, ClassBody body)
		{
			_className = className;
			_superClass = superClass;
			_body = body;
		}

		public JsValue BuildConstructor(EvaluationContext context, Jint.Runtime.Environments.Environment env)
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Invalid comparison between Unknown and I4
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Invalid comparison between Unknown and I4
			using (new StrictModeScope(strict: true, force: true))
			{
				Engine engine = context.Engine;
				DeclarativeEnvironment declarativeEnvironment = JintEnvironment.NewDeclarativeEnvironment(engine, env);
				if (_className != null)
				{
					declarativeEnvironment.CreateImmutableBinding(_className);
				}
				PrivateEnvironment privateEnvironment = engine.ExecutionContext.PrivateEnvironment;
				PrivateEnvironment privateEnvironment2 = JintEnvironment.NewPrivateEnvironment(engine, privateEnvironment);
				ObjectInstance prototype = null;
				ObjectInstance functionPrototype = null;
				if (_superClass == null)
				{
					prototype = engine.Realm.Intrinsics.Object.PrototypeObject;
					functionPrototype = engine.Realm.Intrinsics.Function.PrototypeObject;
				}
				else
				{
					engine.UpdateLexicalEnvironment(declarativeEnvironment);
					JsValue value = JintExpression.Build(_superClass).GetValue(context);
					engine.UpdateLexicalEnvironment(env);
					if (value.IsNull())
					{
						prototype = null;
						functionPrototype = engine.Realm.Intrinsics.Function.PrototypeObject;
					}
					else if (!value.IsConstructor)
					{
						ExceptionHelper.ThrowTypeError(engine.Realm, "super class is not a constructor");
					}
					else
					{
						JsValue jsValue = value.Get(CommonProperties.Prototype);
						if (jsValue is ObjectInstance objectInstance)
						{
							prototype = objectInstance;
						}
						else if (!jsValue.IsNull())
						{
							ExceptionHelper.ThrowTypeError(engine.Realm, "cannot resolve super class prototype chain");
							return null;
						}
						functionPrototype = (ObjectInstance)value;
					}
				}
				ObjectInstance objectInstance2 = new JsObject(engine)
				{
					_prototype = prototype
				};
				HashSet<PrivateIdentifier> hashSet = new HashSet<PrivateIdentifier>(PrivateIdentifierNameComparer._instance);
				MethodDefinition val = null;
				ref NodeList<ClassElement> body = _body.Body;
				NodeList<ClassElement> val2 = body;
				for (int i = 0; i < val2.Count; i++)
				{
					ClassElement obj = val2[i];
					MethodDefinition val3 = (MethodDefinition)(object)((obj is MethodDefinition) ? obj : null);
					if (val3 != null && (int)((ClassProperty)val3).Kind == 4)
					{
						val = val3;
					}
					hashSet.Clear();
					((Node)(object)obj).PrivateBoundIdentifiers(hashSet);
					foreach (PrivateIdentifier item2 in hashSet)
					{
						privateEnvironment2.Names.Add(item2, new PrivateName(item2));
					}
				}
				if (val == null)
				{
					val = ((_superClass != null) ? _superConstructor : _emptyConstructor);
				}
				engine.UpdateLexicalEnvironment(declarativeEnvironment);
				engine.UpdatePrivateEnvironment(privateEnvironment2);
				ScriptFunction closure;
				try
				{
					closure = val.DefineMethod<MethodDefinition>(objectInstance2, functionPrototype).Closure;
					closure.SetFunctionName(_className ?? "");
					closure.MakeConstructor(writableProperty: false, objectInstance2);
					closure._constructorKind = ((_superClass != null) ? ConstructorKind.Derived : ConstructorKind.Base);
					closure.MakeClassConstructor();
					objectInstance2.CreateMethodProperty(CommonProperties.Constructor, closure);
					List<PrivateElement> list = new List<PrivateElement>();
					List<PrivateElement> list2 = new List<PrivateElement>();
					List<ClassFieldDefinition> list3 = new List<ClassFieldDefinition>();
					List<object> list4 = new List<object>();
					Enumerator<ClassElement> enumerator2 = body.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							ClassElement current2 = enumerator2.Current;
							MethodDefinition val4 = (MethodDefinition)(object)((current2 is MethodDefinition) ? current2 : null);
							if (val4 != null && (int)((ClassProperty)val4).Kind == 4)
							{
								continue;
							}
							val4 = (MethodDefinition)(object)((current2 is MethodDefinition) ? current2 : null);
							if (val4 != null)
							{
								if (val4.Static)
								{
									goto IL_032a;
								}
							}
							else
							{
								AccessorProperty val5 = (AccessorProperty)(object)((current2 is AccessorProperty) ? current2 : null);
								if (val5 != null)
								{
									if (val5.Static)
									{
										goto IL_032a;
									}
								}
								else
								{
									PropertyDefinition val6 = (PropertyDefinition)(object)((current2 is PropertyDefinition) ? current2 : null);
									if (val6 != null)
									{
										if (val6.Static)
										{
											goto IL_032a;
										}
									}
									else if (current2 is StaticBlock)
									{
										goto IL_032a;
									}
								}
							}
							bool flag = false;
							goto IL_0332;
							IL_032a:
							flag = true;
							goto IL_0332;
							IL_0332:
							bool flag2 = flag;
							ObjectInstance target = ((!flag2) ? objectInstance2 : closure);
							object obj2 = ClassElementEvaluation(engine, target, current2);
							PrivateElement privateElement = obj2 as PrivateElement;
							if (privateElement != null)
							{
								List<PrivateElement> list5 = ((!flag2) ? list : list2);
								int num = list5.FindIndex((PrivateElement x) => string.Equals(x.Key.Description, privateElement.Key.Description, StringComparison.Ordinal));
								if (num != -1)
								{
									PrivateElement privateElement2 = list5[num];
									PrivateElement value2 = (((object)privateElement.Get == null) ? new PrivateElement
									{
										Key = privateElement2.Key,
										Kind = PrivateElementKind.Accessor,
										Get = privateElement2.Get,
										Set = privateElement.Set
									} : new PrivateElement
									{
										Key = privateElement2.Key,
										Kind = PrivateElementKind.Accessor,
										Get = privateElement.Get,
										Set = privateElement2.Set
									});
									list5[num] = value2;
								}
								else
								{
									list5.Add(privateElement);
								}
							}
							else if (obj2 is ClassFieldDefinition item)
							{
								if (!flag2)
								{
									list3.Add(item);
								}
								else
								{
									list4.Add(obj2);
								}
							}
							else if (obj2 is ClassStaticBlockDefinition)
							{
								list4.Add(obj2);
							}
						}
					}
					finally
					{
						((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
					if (_className != null)
					{
						declarativeEnvironment.InitializeBinding(_className, closure);
					}
					closure._privateMethods = list;
					closure._fields = list3;
					for (int num2 = 0; num2 < list2.Count; num2++)
					{
						closure.PrivateMethodOrAccessorAdd(list2[num2]);
					}
					for (int num3 = 0; num3 < list4.Count; num3++)
					{
						object obj3 = list4[num3];
						if (obj3 is ClassFieldDefinition fieldRecord)
						{
							ObjectInstance.DefineField(closure, fieldRecord);
						}
						else
						{
							engine.Call(((ClassStaticBlockDefinition)obj3).BodyFunction, closure);
						}
					}
				}
				finally
				{
					engine.UpdateLexicalEnvironment(env);
					engine.UpdatePrivateEnvironment(privateEnvironment);
				}
				return closure;
			}
		}

		private static object? ClassElementEvaluation(Engine engine, ObjectInstance target, ClassElement e)
		{
			PropertyDefinition val = (PropertyDefinition)(object)((e is PropertyDefinition) ? e : null);
			if (val == null)
			{
				MethodDefinition val2 = (MethodDefinition)(object)((e is MethodDefinition) ? e : null);
				if (val2 == null)
				{
					StaticBlock val3 = (StaticBlock)(object)((e is StaticBlock) ? e : null);
					if (val3 != null)
					{
						return ClassStaticBlockDefinitionEvaluation(engine, target, val3);
					}
					return null;
				}
				return ClassDefinition.MethodDefinitionEvaluation<MethodDefinition>(engine, target, val2, enumerable: false);
			}
			return ClassFieldDefinitionEvaluation(engine, target, val);
		}

		private static ClassFieldDefinition ClassFieldDefinitionEvaluation(Engine engine, ObjectInstance homeObject, PropertyDefinition fieldDefinition)
		{
			JsValue key = fieldDefinition.GetKey<PropertyDefinition>(engine);
			ScriptFunction scriptFunction = null;
			if (fieldDefinition.Value != null)
			{
				Intrinsics intrinsics = engine.Realm.Intrinsics;
				Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
				PrivateEnvironment privateEnvironment = engine.ExecutionContext.PrivateEnvironment;
				JintFunctionDefinition function = new JintFunctionDefinition((IFunction)(object)new ClassFieldFunction(fieldDefinition.Value));
				scriptFunction = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.Function.PrototypeObject, function, FunctionThisMode.Global, lexicalEnvironment, privateEnvironment);
				scriptFunction.MakeMethod(homeObject);
				scriptFunction._classFieldInitializerName = key;
			}
			return new ClassFieldDefinition
			{
				Name = key,
				Initializer = scriptFunction
			};
		}

		private static ClassStaticBlockDefinition ClassStaticBlockDefinitionEvaluation(Engine engine, ObjectInstance homeObject, StaticBlock o)
		{
			Intrinsics intrinsics = engine.Realm.Intrinsics;
			JintFunctionDefinition function = new JintFunctionDefinition((IFunction)(object)new ClassStaticBlockFunction(o));
			Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
			PrivateEnvironment privateEnvironment = engine.ExecutionContext.PrivateEnvironment;
			ScriptFunction scriptFunction = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.Function.PrototypeObject, function, FunctionThisMode.Global, lexicalEnvironment, privateEnvironment);
			scriptFunction.MakeMethod(homeObject);
			return new ClassStaticBlockDefinition
			{
				BodyFunction = scriptFunction
			};
		}

		internal static PrivateElement? MethodDefinitionEvaluation<T>(Engine engine, ObjectInstance obj, T method, bool enumerable) where T : IProperty
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			Node value = ((IProperty)method).Value;
			IFunction val = (IFunction)(object)((value is IFunction) ? value : null);
			if (val == null)
			{
				ExceptionHelper.ThrowSyntaxError(obj.Engine.Realm);
			}
			if ((int)((IProperty)method).Kind != 1 && (int)((IProperty)method).Kind != 2 && !val.Generator)
			{
				AstExtensions.Record record = method.DefineMethod(obj);
				record.Closure.SetFunctionName(record.Key);
				return DefineMethodProperty(obj, record.Key, record.Closure, enumerable);
			}
			bool flag = (int)((IProperty)method).Kind == 1;
			JintFunctionDefinition jintFunctionDefinition = new JintFunctionDefinition(val);
			Intrinsics intrinsics = engine.Realm.Intrinsics;
			JsValue jsValue = TypeConverter.ToPropertyKey(method.TryGetKey(engine));
			Jint.Runtime.Environments.Environment lexicalEnvironment = engine.ExecutionContext.LexicalEnvironment;
			PrivateEnvironment privateEnvironment = engine.ExecutionContext.PrivateEnvironment;
			if (val.Generator)
			{
				ScriptFunction scriptFunction = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.GeneratorFunction.PrototypeObject, jintFunctionDefinition, jintFunctionDefinition.ThisMode, lexicalEnvironment, privateEnvironment);
				scriptFunction.MakeMethod(obj);
				scriptFunction.SetFunctionName(jsValue);
				JsObject value2 = ObjectInstance.OrdinaryObjectCreate(engine, intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject);
				scriptFunction.DefinePropertyOrThrow(CommonProperties.Prototype, new PropertyDescriptor(value2, PropertyFlag.Writable));
				return DefineMethodProperty(obj, jsValue, scriptFunction, enumerable);
			}
			ScriptFunction scriptFunction2 = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.Function.PrototypeObject, jintFunctionDefinition, jintFunctionDefinition.ThisMode, lexicalEnvironment, privateEnvironment);
			scriptFunction2.MakeMethod(obj);
			scriptFunction2.SetFunctionName(jsValue, flag ? "get" : "set");
			Expression key = ((IProperty)method).Key;
			PrivateIdentifier val2 = (PrivateIdentifier)(object)((key is PrivateIdentifier) ? key : null);
			if (val2 != null)
			{
				return new PrivateElement
				{
					Key = privateEnvironment.Names[val2],
					Kind = PrivateElementKind.Accessor,
					Get = (flag ? scriptFunction2 : null),
					Set = ((!flag) ? scriptFunction2 : null)
				};
			}
			GetSetPropertyDescriptor desc = new GetSetPropertyDescriptor(flag ? scriptFunction2 : null, (!flag) ? scriptFunction2 : null, PropertyFlag.Configurable);
			obj.DefinePropertyOrThrow(jsValue, desc);
			return null;
		}

		private static PrivateElement? DefineMethodProperty(ObjectInstance homeObject, JsValue key, ScriptFunction closure, bool enumerable)
		{
			if (key.IsPrivateName())
			{
				return new PrivateElement
				{
					Key = (PrivateName)key,
					Kind = PrivateElementKind.Method,
					Value = closure
				};
			}
			PropertyDescriptor desc = new PropertyDescriptor(closure, enumerable ? PropertyFlag.ConfigurableEnumerableWritable : PropertyFlag.NonEnumerable);
			homeObject.DefinePropertyOrThrow(key, desc);
			return null;
		}
	}
	internal enum ConstructorKind
	{
		Base,
		Derived
	}
	public sealed class EvalFunction : Function
	{
		private sealed class EvalScriptAnalyzer : AstVisitor
		{
			public bool _containsArguments;

			public bool _containsNewTarget;

			public bool _containsSuperCall;

			public bool _containsSuperProperty;

			protected override object VisitIdentifier(Identifier identifier)
			{
				_containsArguments |= string.Equals(identifier.Name, "arguments", StringComparison.Ordinal);
				return identifier;
			}

			protected override object VisitMetaProperty(MetaProperty metaProperty)
			{
				_containsNewTarget |= string.Equals(metaProperty.Meta.Name, "new", StringComparison.Ordinal) && string.Equals(metaProperty.Property.Name, "target", StringComparison.Ordinal);
				return metaProperty;
			}

			protected override object? VisitMemberExpression(MemberExpression memberExpression)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Invalid comparison between Unknown and I4
				_containsSuperProperty |= (int)((Node)memberExpression.Object).Type == 58;
				return ((AstVisitor)this).VisitMemberExpression(memberExpression);
			}

			protected override object? VisitCallExpression(CallExpression callExpression)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Invalid comparison between Unknown and I4
				_containsSuperCall |= (int)((Node)callExpression.Callee).Type == 58;
				return ((AstVisitor)this).VisitCallExpression(callExpression);
			}
		}

		private static readonly JsString _functionName = new JsString("eval");

		internal EvalFunction(Engine engine, Realm realm, FunctionPrototype functionPrototype)
			: base(engine, realm, _functionName, StrictModeScope.IsStrictModeCode ? FunctionThisMode.Strict : FunctionThisMode.Global)
		{
			_prototype = functionPrototype;
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			Realm realm = _engine.ExecutionContext.Realm;
			JsValue x = arguments.At(0);
			return PerformEval(x, realm, strictCaller: false, direct: false);
		}

		internal unsafe JsValue PerformEval(JsValue x, Realm callerRealm, bool strictCaller, bool direct)
		{
			//IL_00f3: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			if (!x.IsString())
			{
				return x;
			}
			Realm realm = _realm;
			_engine._host.EnsureCanCompileStrings(callerRealm, realm);
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			if (direct)
			{
				Jint.Runtime.Environments.Environment thisEnvironment = _engine.ExecutionContext.GetThisEnvironment();
				if (thisEnvironment is FunctionEnvironment functionEnvironment)
				{
					Function functionObject = functionEnvironment._functionObject;
					flag = true;
					flag2 = thisEnvironment.HasSuperBinding();
					if (functionObject._constructorKind == ConstructorKind.Derived)
					{
						flag3 = true;
					}
					if (!string.IsNullOrEmpty(((functionObject as ScriptFunction)?._classFieldInitializerName)?.ToString()))
					{
						flag4 = true;
					}
				}
			}
			Script val = null;
			ParserOptions activeParserOptions = _engine.GetActiveParserOptions();
			ParserOptions obj;
			if (activeParserOptions.Tolerant && !activeParserOptions.AllowReturnOutsideFunction)
			{
				obj = activeParserOptions;
			}
			else
			{
				obj = activeParserOptions.<Clone>$();
				obj.set_Tolerant(true);
				obj.AllowReturnOutsideFunction = false;
			}
			ParserOptions parserOptions = obj;
			JavaScriptParser parserFor = _engine.GetParserFor(parserOptions);
			try
			{
				val = parserFor.ParseScript(x.ToString(), (string)null, strictCaller);
			}
			catch (ParserException ex)
			{
				ParserException ex2 = ex;
				if (string.Equals(ex2.Description, "Invalid left-hand side in assignment", StringComparison.Ordinal))
				{
					ExceptionHelper.ThrowReferenceError(callerRealm, (string?)null);
				}
				else
				{
					ExceptionHelper.ThrowSyntaxError(callerRealm, ((Exception)(object)ex2).Message);
				}
			}
			NodeList<Statement> body = Unsafe.Read<NodeList<Statement>>((void*)((Program)val).Body);
			if (body.Count == 0)
			{
				return JsValue.Undefined;
			}
			EvalScriptAnalyzer evalScriptAnalyzer = new EvalScriptAnalyzer();
			((AstVisitor)evalScriptAnalyzer).Visit((Node)(object)val);
			if (!flag && evalScriptAnalyzer._containsNewTarget)
			{
				ExceptionHelper.ThrowSyntaxError(realm, "new.target expression is not allowed here");
			}
			if (!flag2 && evalScriptAnalyzer._containsSuperProperty)
			{
				ExceptionHelper.ThrowSyntaxError(realm, "'super' keyword unexpected here");
			}
			if (!flag3 && evalScriptAnalyzer._containsSuperCall)
			{
				ExceptionHelper.ThrowSyntaxError(realm, "'super' keyword unexpected here");
			}
			if (flag4 && evalScriptAnalyzer._containsArguments)
			{
				ExceptionHelper.ThrowSyntaxError(realm, "'arguments' is not allowed in class field initializer or static initialization block");
			}
			bool flag5 = ((Program)val).Strict || _engine._isStrict;
			Jint.Runtime.Environments.ExecutionContext executionContext = _engine.ExecutionContext;
			using (new StrictModeScope(flag5))
			{
				Jint.Runtime.Environments.Environment environment;
				Jint.Runtime.Environments.Environment environment2;
				PrivateEnvironment privateEnvironment;
				if (direct)
				{
					environment = JintEnvironment.NewDeclarativeEnvironment(_engine, executionContext.LexicalEnvironment);
					environment2 = executionContext.VariableEnvironment;
					privateEnvironment = executionContext.PrivateEnvironment;
				}
				else
				{
					environment = JintEnvironment.NewDeclarativeEnvironment(_engine, realm.GlobalEnv);
					environment2 = realm.GlobalEnv;
					privateEnvironment = null;
				}
				if (flag5)
				{
					environment2 = environment;
				}
				base.Engine.EnterExecutionContext(environment, environment2, realm, privateEnvironment);
				try
				{
					base.Engine.EvalDeclarationInstantiation(val, environment2, environment, privateEnvironment, flag5);
					Completion result = new JintScript(val).Execute(_engine._activeEvaluationContext);
					JsValue valueOrDefault = result.GetValueOrDefault();
					if (result.Type == CompletionType.Throw)
					{
						ExceptionHelper.ThrowJavaScriptException(_engine, valueOrDefault, in result);
						return null;
					}
					return valueOrDefault;
				}
				finally
				{
					base.Engine.LeaveExecutionContext();
				}
			}
		}
	}
	[DebuggerDisplay("{ToString(),nq}")]
	public abstract class Function : ObjectInstance, ICallable
	{
		private sealed class ObjectInstanceWithConstructor : ObjectInstance
		{
			private PropertyDescriptor? _constructor;

			public ObjectInstanceWithConstructor(Engine engine, ObjectInstance thisObj)
				: base(engine)
			{
				_constructor = new PropertyDescriptor(thisObj, PropertyFlag.NonEnumerable);
			}

			public override IEnumerable<KeyValuePair<JsValue, PropertyDescriptor>> GetOwnProperties()
			{
				if (_constructor != null)
				{
					yield return new KeyValuePair<JsValue, PropertyDescriptor>(CommonProperties.Constructor, _constructor);
				}
				foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in base.GetOwnProperties())
				{
					yield return ownProperty;
				}
			}

			public override PropertyDescriptor GetOwnProperty(JsValue property)
			{
				if (CommonProperties.Constructor.Equals(property))
				{
					return _constructor ?? PropertyDescriptor.Undefined;
				}
				return base.GetOwnProperty(property);
			}

			protected internal override void SetOwnProperty(JsValue property, PropertyDescriptor desc)
			{
				if (CommonProperties.Constructor.Equals(property))
				{
					_constructor = desc;
				}
				else
				{
					base.SetOwnProperty(property, desc);
				}
			}

			public override void RemoveOwnProperty(JsValue property)
			{
				if (CommonProperties.Constructor.Equals(property))
				{
					_constructor = null;
				}
				else
				{
					base.RemoveOwnProperty(property);
				}
			}
		}

		protected PropertyDescriptor? _prototypeDescriptor;

		protected internal PropertyDescriptor? _length;

		internal PropertyDescriptor? _nameDescriptor;

		internal Jint.Runtime.Environments.Environment? _environment;

		internal readonly JintFunctionDefinition _functionDefinition;

		internal readonly FunctionThisMode _thisMode;

		internal JsValue _homeObject = JsValue.Undefined;

		internal ConstructorKind _constructorKind;

		internal Realm _realm;

		internal PrivateEnvironment? _privateEnvironment;

		private readonly IScriptOrModule? _scriptOrModule;

		private static readonly char[] _functionNameTrimStartChars = new char[1] { '#' };

		private static readonly JsString _functionNameAnonymous = new JsString("anonymous");

		public IFunction FunctionDeclaration => _functionDefinition.Function;

		internal override bool IsCallable => true;

		public bool Strict => _thisMode == FunctionThisMode.Strict;

		internal override bool IsConstructor => this is IConstructor;

		protected Function(Engine engine, Realm realm, JsString? name)
			: this(engine, realm, name, FunctionThisMode.Global, ObjectClass.Function)
		{
		}

		internal Function(Engine engine, Realm realm, JintFunctionDefinition function, Jint.Runtime.Environments.Environment env, FunctionThisMode thisMode)
			: this(engine, realm, (!string.IsNullOrWhiteSpace(function.Name)) ? new JsString(function.Name) : null, thisMode)
		{
			_functionDefinition = function;
			_environment = env;
		}

		internal Function(Engine engine, Realm realm, JsString? name, FunctionThisMode thisMode = FunctionThisMode.Global, ObjectClass objectClass = ObjectClass.Function)
			: base(engine, objectClass)
		{
			if ((object)name != null)
			{
				_nameDescriptor = new PropertyDescriptor(name, PropertyFlag.Configurable);
			}
			_realm = realm;
			_thisMode = thisMode;
			_scriptOrModule = _engine.GetActiveScriptOrModule();
		}

		JsValue ICallable.Call(JsValue thisObject, JsValue[] arguments)
		{
			return Call(thisObject, arguments);
		}

		protected internal abstract JsValue Call(JsValue thisObject, JsValue[] arguments);

		public override IEnumerable<KeyValuePair<JsValue, PropertyDescriptor>> GetOwnProperties()
		{
			if (_prototypeDescriptor != null)
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(CommonProperties.Prototype, _prototypeDescriptor);
			}
			if (_length != null)
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(CommonProperties.Length, _length);
			}
			if (_nameDescriptor != null)
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(CommonProperties.Name, GetOwnProperty(CommonProperties.Name));
			}
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in base.GetOwnProperties())
			{
				yield return ownProperty;
			}
		}

		internal sealed override IEnumerable<JsValue> GetInitialOwnStringPropertyKeys()
		{
			if (_length != null)
			{
				yield return CommonProperties.Length;
			}
			if (_nameDescriptor != null)
			{
				yield return CommonProperties.Name;
			}
			if (_prototypeDescriptor != null)
			{
				yield return CommonProperties.Prototype;
			}
		}

		public override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (CommonProperties.Prototype.Equals(property))
			{
				return _prototypeDescriptor ?? PropertyDescriptor.Undefined;
			}
			if (CommonProperties.Length.Equals(property))
			{
				return _length ?? PropertyDescriptor.Undefined;
			}
			if (CommonProperties.Name.Equals(property))
			{
				return _nameDescriptor ?? PropertyDescriptor.Undefined;
			}
			return base.GetOwnProperty(property);
		}

		protected internal override void SetOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			if (CommonProperties.Prototype.Equals(property))
			{
				_prototypeDescriptor = desc;
			}
			else if (CommonProperties.Length.Equals(property))
			{
				_length = desc;
			}
			else if (CommonProperties.Name.Equals(property))
			{
				_nameDescriptor = desc;
			}
			else
			{
				base.SetOwnProperty(property, desc);
			}
		}

		public override void RemoveOwnProperty(JsValue property)
		{
			if (CommonProperties.Prototype.Equals(property))
			{
				_prototypeDescriptor = null;
			}
			if (CommonProperties.Length.Equals(property))
			{
				_length = null;
			}
			if (CommonProperties.Name.Equals(property))
			{
				_nameDescriptor = null;
			}
			base.RemoveOwnProperty(property);
		}

		internal void SetFunctionName(JsValue name, string? prefix = null, bool force = false)
		{
			if (force || _nameDescriptor == null || !(UnwrapJsValue(_nameDescriptor) != JsString.Empty))
			{
				if (name is JsSymbol jsSymbol)
				{
					name = (jsSymbol._value.IsUndefined() ? JsString.Empty : new JsString("[" + jsSymbol._value?.ToString() + "]"));
				}
				else if (name is PrivateName privateName)
				{
					name = "#" + privateName.Description;
				}
				if (!string.IsNullOrWhiteSpace(prefix))
				{
					name = prefix + " " + name;
				}
				_nameDescriptor = new PropertyDescriptor(name, PropertyFlag.Configurable);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal T OrdinaryCreateFromConstructor<T, TState>(JsValue constructor, Func<Intrinsics, ObjectInstance> intrinsicDefaultProto, Func<Engine, Realm, TState?, T> objectCreator, TState? state = default(TState?)) where T : ObjectInstance
		{
			ObjectInstance prototypeFromConstructor = GetPrototypeFromConstructor(constructor, intrinsicDefaultProto);
			T val = objectCreator(_engine, _realm, state);
			val._prototype = prototypeFromConstructor;
			return val;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ObjectInstance GetPrototypeFromConstructor(JsValue constructor, Func<Intrinsics, ObjectInstance> intrinsicDefaultProto)
		{
			ObjectInstance objectInstance = constructor.Get(CommonProperties.Prototype) as ObjectInstance;
			if ((object)objectInstance == null)
			{
				Realm functionRealm = GetFunctionRealm(constructor);
				objectInstance = intrinsicDefaultProto(functionRealm.Intrinsics);
			}
			return objectInstance;
		}

		internal Realm GetFunctionRealm(JsValue obj)
		{
			if (obj is Function { _realm: not null } function)
			{
				return function._realm;
			}
			if (obj is BindFunction bindFunction)
			{
				return GetFunctionRealm(bindFunction.BoundTargetFunction);
			}
			if (obj is JsProxy jsProxy)
			{
				if ((object)jsProxy._handler == null)
				{
					ExceptionHelper.ThrowTypeErrorNoEngine();
				}
				return GetFunctionRealm(jsProxy._target);
			}
			return _engine.ExecutionContext.Realm;
		}

		internal void MakeMethod(ObjectInstance homeObject)
		{
			_homeObject = homeObject;
		}

		internal void OrdinaryCallBindThis(in Jint.Runtime.Environments.ExecutionContext calleeContext, JsValue thisArgument)
		{
			if (_thisMode != FunctionThisMode.Lexical)
			{
				Realm realm = _realm;
				FunctionEnvironment obj = (FunctionEnvironment)calleeContext.LexicalEnvironment;
				JsValue value = ((_thisMode == FunctionThisMode.Strict) ? thisArgument : (((object)thisArgument != null && !thisArgument.IsNullOrUndefined()) ? TypeConverter.ToObject(realm, thisArgument) : realm.GlobalEnv.GlobalThisValue));
				obj.BindThisValue(value);
			}
		}

		internal ref readonly Jint.Runtime.Environments.ExecutionContext PrepareForOrdinaryCall(JsValue newTarget)
		{
			_ = ref _engine.ExecutionContext;
			FunctionEnvironment functionEnvironment = JintEnvironment.NewFunctionEnvironment(_engine, this, newTarget);
			Realm realm = _realm;
			Jint.Runtime.Environments.ExecutionContext context = new Jint.Runtime.Environments.ExecutionContext(_scriptOrModule, functionEnvironment, functionEnvironment, _privateEnvironment, realm, null, this);
			_engine.EnterExecutionContext(in context);
			return ref _engine.ExecutionContext;
		}

		internal void MakeConstructor(bool writableProperty = true, ObjectInstance? prototype = null)
		{
			_constructorKind = ConstructorKind.Base;
			if ((object)prototype == null)
			{
				prototype = new ObjectInstanceWithConstructor(_engine, this)
				{
					_prototype = _realm.Intrinsics.Object.PrototypeObject
				};
			}
			_prototypeDescriptor = new PropertyDescriptor(prototype, writableProperty, false, false);
		}

		internal void SetFunctionLength(JsNumber length)
		{
			DefinePropertyOrThrow(CommonProperties.Length, new PropertyDescriptor(length, false, false, true));
		}

		public override string ToString()
		{
			JsValue jsValue = ((_nameDescriptor != null) ? UnwrapJsValue(_nameDescriptor) : JsString.Empty);
			string text = "";
			if (!jsValue.IsUndefined())
			{
				text = TypeConverter.ToString(jsValue);
			}
			text = text.TrimStart(_functionNameTrimStartChars);
			return "function " + text + "() { [native code] }";
		}

		internal Function CreateDynamicFunction(ObjectInstance constructor, JsValue newTarget, FunctionKind kind, JsValue[] arguments)
		{
			//IL_02d7: Expected O, but got Unknown
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Expected O, but got Unknown
			Realm realm = _engine.ExecutionContext.Realm;
			Realm realm2 = _engine.ExecutionContext.Realm;
			_engine._host.EnsureCanCompileStrings(realm, realm2);
			if (newTarget.IsUndefined())
			{
				newTarget = constructor;
			}
			Func<Intrinsics, ObjectInstance> intrinsicDefaultProto = null;
			switch (kind)
			{
			case FunctionKind.Normal:
				intrinsicDefaultProto = (Intrinsics intrinsics) => intrinsics.Function.PrototypeObject;
				break;
			case FunctionKind.Async:
				intrinsicDefaultProto = (Intrinsics intrinsics) => intrinsics.AsyncFunction.PrototypeObject;
				break;
			case FunctionKind.Generator:
				intrinsicDefaultProto = (Intrinsics intrinsics) => intrinsics.GeneratorFunction.PrototypeObject;
				break;
			default:
				ExceptionHelper.ThrowArgumentOutOfRangeException("kind", kind.ToString());
				break;
			}
			int num = arguments.Length;
			string text = "";
			string text2 = "";
			if (num == 1)
			{
				text2 = TypeConverter.ToString(arguments[0]);
			}
			else if (num > 1)
			{
				text = TypeConverter.ToString(arguments[0]);
				for (int num2 = 1; num2 < num - 1; num2++)
				{
					JsValue jsValue = arguments[num2];
					text = text + "," + TypeConverter.ToString(jsValue);
				}
				text2 = TypeConverter.ToString(arguments[num - 1]);
			}
			IFunction val = null;
			try
			{
				string text3 = null;
				if (num == 0)
				{
					switch (kind)
					{
					case FunctionKind.Normal:
						text3 = "function f(){}";
						break;
					case FunctionKind.Generator:
						text3 = "function* f(){}";
						break;
					case FunctionKind.Async:
						text3 = "async function f(){}";
						break;
					case FunctionKind.AsyncGenerator:
						ExceptionHelper.ThrowNotImplementedException("Async generators not implemented");
						break;
					default:
						ExceptionHelper.ThrowArgumentOutOfRangeException("kind", kind.ToString());
						break;
					}
				}
				else
				{
					switch (kind)
					{
					case FunctionKind.Normal:
						text3 = "function f(";
						break;
					case FunctionKind.Async:
						text3 = "async function f(";
						break;
					case FunctionKind.Generator:
						text3 = "function* f(";
						break;
					case FunctionKind.AsyncGenerator:
						ExceptionHelper.ThrowNotImplementedException("Async generators not implemented");
						break;
					default:
						ExceptionHelper.ThrowArgumentOutOfRangeException("kind", kind.ToString());
						break;
					}
					text3 = ((!text.Contains('/')) ? (text3 + text) : (text3 + "\n" + text + "\n"));
					text3 += ")";
					text3 = ((!text2.Contains('/')) ? (text3 + "{" + text2 + "}") : (text3 + "{\n" + text2 + "\n}"));
				}
				ParserOptions val2 = _engine.GetActiveParserOptions();
				if (!val2.AllowReturnOutsideFunction)
				{
					ParserOptions obj = val2.<Clone>$();
					obj.AllowReturnOutsideFunction = true;
					val2 = obj;
				}
				val = (IFunction)((NodeList<Statement>)((Program)new JavaScriptParser(val2).ParseScript(text3, (string)null, _engine._isStrict)).Body)[0];
			}
			catch (ParserException ex)
			{
				ParserException ex2 = ex;
				ExceptionHelper.ThrowSyntaxError(_engine.ExecutionContext.Realm, ((Exception)(object)ex2).Message);
			}
			ObjectInstance prototypeFromConstructor = GetPrototypeFromConstructor(newTarget, intrinsicDefaultProto);
			GlobalEnvironment globalEnv = _realm.GlobalEnv;
			PrivateEnvironment privateScope = null;
			JintFunctionDefinition function = new JintFunctionDefinition(val);
			Function function2 = OrdinaryFunctionCreate(prototypeFromConstructor, function, val.Strict ? FunctionThisMode.Strict : FunctionThisMode.Global, globalEnv, privateScope);
			function2.SetFunctionName(_functionNameAnonymous, null, force: true);
			switch (kind)
			{
			case FunctionKind.Generator:
			{
				JsObject value = ObjectInstance.OrdinaryObjectCreate(_engine, _realm.Intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject);
				function2.DefinePropertyOrThrow(CommonProperties.Prototype, new PropertyDescriptor(value, PropertyFlag.Writable));
				break;
			}
			case FunctionKind.AsyncGenerator:
				ExceptionHelper.ThrowNotImplementedException("async generators not implemented");
				break;
			case FunctionKind.Normal:
				function2.MakeConstructor();
				break;
			}
			return function2;
		}

		internal ScriptFunction OrdinaryFunctionCreate(ObjectInstance functionPrototype, JintFunctionDefinition function, FunctionThisMode thisMode, Jint.Runtime.Environments.Environment scope, PrivateEnvironment? privateScope)
		{
			return new ScriptFunction(_engine, function, scope, thisMode, functionPrototype)
			{
				_privateEnvironment = privateScope,
				_realm = _realm
			};
		}
	}
	public sealed class FunctionConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Function");

		internal FunctionPrototype PrototypeObject { get; }

		internal FunctionConstructor(Engine engine, Realm realm, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			PrototypeObject = new FunctionPrototype(engine, realm, objectPrototype);
			_prototype = PrototypeObject;
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, thisObject);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			return CreateDynamicFunction(this, newTarget, FunctionKind.Normal, arguments);
		}

		internal Function InstantiateFunctionObject(JintFunctionDefinition functionDeclaration, Jint.Runtime.Environments.Environment scope, PrivateEnvironment? privateEnv)
		{
			IFunction function = functionDeclaration.Function;
			if (!function.Generator)
			{
				if (!function.Async)
				{
					return InstantiateOrdinaryFunctionObject(functionDeclaration, scope, privateEnv);
				}
				return InstantiateAsyncFunctionObject(functionDeclaration, scope, privateEnv);
			}
			return InstantiateGeneratorFunctionObject(functionDeclaration, scope, privateEnv);
		}

		private ScriptFunction InstantiateAsyncFunctionObject(JintFunctionDefinition functionDeclaration, Jint.Runtime.Environments.Environment env, PrivateEnvironment? privateEnv)
		{
			ScriptFunction scriptFunction = OrdinaryFunctionCreate(_realm.Intrinsics.AsyncFunction.PrototypeObject, functionDeclaration, functionDeclaration.ThisMode, env, privateEnv);
			scriptFunction.SetFunctionName(functionDeclaration.Name ?? "default");
			return scriptFunction;
		}

		private ScriptFunction InstantiateOrdinaryFunctionObject(JintFunctionDefinition functionDeclaration, Jint.Runtime.Environments.Environment env, PrivateEnvironment? privateEnv)
		{
			ScriptFunction scriptFunction = OrdinaryFunctionCreate(_realm.Intrinsics.Function.PrototypeObject, functionDeclaration, functionDeclaration.ThisMode, env, privateEnv);
			string text = functionDeclaration.Name ?? "default";
			scriptFunction.SetFunctionName(text);
			scriptFunction.MakeConstructor();
			return scriptFunction;
		}

		private ScriptFunction InstantiateGeneratorFunctionObject(JintFunctionDefinition functionDeclaration, Jint.Runtime.Environments.Environment scope, PrivateEnvironment? privateScope)
		{
			FunctionThisMode thisMode = ((functionDeclaration.Strict || _engine._isStrict) ? FunctionThisMode.Strict : FunctionThisMode.Global);
			Identifier id = functionDeclaration.Function.Id;
			string text = ((id != null) ? id.Name : null) ?? "default";
			ScriptFunction scriptFunction = OrdinaryFunctionCreate(_realm.Intrinsics.GeneratorFunction.PrototypeObject, functionDeclaration, thisMode, scope, privateScope);
			scriptFunction.SetFunctionName(text);
			scriptFunction.DefinePropertyOrThrow(desc: new PropertyDescriptor(ObjectInstance.OrdinaryObjectCreate(_engine, _realm.Intrinsics.GeneratorFunction.PrototypeObject.PrototypeObject), PropertyFlag.Writable), property: CommonProperties.Prototype);
			return scriptFunction;
		}
	}
	internal enum FunctionKind
	{
		Normal,
		Async,
		Generator,
		AsyncGenerator
	}
	internal sealed class FunctionPrototype : Function
	{
		internal FunctionPrototype(Engine engine, Realm realm, ObjectPrototype objectPrototype)
			: base(engine, realm, JsString.Empty)
		{
			_prototype = objectPrototype;
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Configurable);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(7, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_realm.Intrinsics.Function, PropertyFlag.NonEnumerable),
				["toString"] = new PropertyDescriptor(new ClrFunction(_engine, "toString", ToString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["apply"] = new PropertyDescriptor(new ClrFunction(_engine, "apply", Apply, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["call"] = new PropertyDescriptor(new ClrFunction(_engine, "call", CallImpl, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["bind"] = new PropertyDescriptor(new ClrFunction(_engine, "bind", Bind, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["arguments"] = new GetSetPropertyDescriptor.ThrowerPropertyDescriptor(_engine, PropertyFlag.Configurable),
				["caller"] = new GetSetPropertyDescriptor.ThrowerPropertyDescriptor(_engine, PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol hasInstance = GlobalSymbolRegistry.HasInstance;
			symbolDictionary[hasInstance] = new PropertyDescriptor(new ClrFunction(_engine, "[Symbol.hasInstance]", HasInstance, 1, PropertyFlag.Configurable), PropertyFlag.AllForbidden);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private static JsValue HasInstance(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject.OrdinaryHasInstance(arguments.At(0));
		}

		private JsValue Bind(JsValue thisObject, JsValue[] arguments)
		{
			if (!(thisObject is ICallable callable) || !(callable is ObjectInstance objectInstance))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Bind must be called on a function");
				return null;
			}
			JsValue boundThis = arguments.At(0);
			BindFunction bindFunction = BoundFunctionCreate(objectInstance, boundThis, arguments.Skip(1));
			JsNumber value;
			if (objectInstance.HasOwnProperty(CommonProperties.Length))
			{
				JsValue jsValue = objectInstance.Get(CommonProperties.Length);
				if (!(jsValue is JsNumber jsNumber))
				{
					value = JsNumber.PositiveZero;
				}
				else if (jsNumber.IsPositiveInfinity())
				{
					value = jsNumber;
				}
				else if (jsNumber.IsNegativeInfinity())
				{
					value = JsNumber.PositiveZero;
				}
				else
				{
					long num = (long)TypeConverter.ToIntegerOrInfinity(jsValue);
					int num2 = System.Math.Max(0, arguments.Length - 1);
					value = JsNumber.Create((ulong)System.Math.Max(num - num2, 0L));
				}
			}
			else
			{
				value = JsNumber.PositiveZero;
			}
			bindFunction.DefinePropertyOrThrow(CommonProperties.Length, new PropertyDescriptor(value, PropertyFlag.Configurable));
			JsValue jsValue2 = objectInstance.Get(CommonProperties.Name);
			if (!jsValue2.IsString())
			{
				jsValue2 = JsString.Empty;
			}
			bindFunction.SetFunctionName(jsValue2, "bound");
			return bindFunction;
		}

		private BindFunction BoundFunctionCreate(ObjectInstance targetFunction, JsValue boundThis, JsValue[] boundArgs)
		{
			ObjectInstance prototypeOf = targetFunction.GetPrototypeOf();
			return new BindFunction(_engine, _realm, prototypeOf, targetFunction, boundThis, boundArgs);
		}

		private JsValue ToString(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject.IsObject() && thisObject.IsCallable)
			{
				return thisObject.ToString();
			}
			ExceptionHelper.ThrowTypeError(_realm, "Function.prototype.toString requires that 'this' be a Function");
			return null;
		}

		private JsValue Apply(JsValue thisObject, JsValue[] arguments)
		{
			ICallable callable = thisObject as ICallable;
			if (callable == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue thisObject2 = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			if (jsValue.IsNullOrUndefined())
			{
				return callable.Call(thisObject2, Arguments.Empty);
			}
			JsValue[] arguments2 = CreateListFromArrayLike(_realm, jsValue);
			return callable.Call(thisObject2, arguments2);
		}

		internal static JsValue[] CreateListFromArrayLike(Realm realm, JsValue argArray, Types? elementTypes = null)
		{
			ObjectInstance obj = argArray as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(realm);
			}
			ArrayOperations arrayOperations = ArrayOperations.For(obj, forWrite: false);
			if (elementTypes.HasValue)
			{
				return arrayOperations.GetAll(elementTypes.Value);
			}
			return arrayOperations.GetAll();
		}

		private JsValue CallImpl(JsValue thisObject, JsValue[] arguments)
		{
			ICallable obj = thisObject as ICallable;
			if (obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue[] array = System.Array.Empty<JsValue>();
			if (arguments.Length > 1)
			{
				array = new JsValue[arguments.Length - 1];
				System.Array.Copy(arguments, 1, array, 0, arguments.Length - 1);
			}
			return obj.Call(arguments.At(0), array);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return JsValue.Undefined;
		}
	}
	internal enum FunctionThisMode
	{
		Lexical,
		Strict,
		Global
	}
	public sealed class ScriptFunction : Function, IConstructor
	{
		internal bool _isClassConstructor;

		internal JsValue? _classFieldInitializerName;

		internal List<PrivateElement>? _privateMethods;

		internal List<ClassFieldDefinition>? _fields;

		internal override bool IsConstructor
		{
			get
			{
				if (!_homeObject.IsUndefined() && !_isClassConstructor)
				{
					return false;
				}
				IFunction val = _functionDefinition?.Function;
				if (val != null && !(val is ArrowFunctionExpression) && !val.Generator)
				{
					return !val.Async;
				}
				return false;
			}
		}

		public ScriptFunction(Engine engine, IFunction functionDeclaration, bool strict, ObjectInstance? proto = null)
			: this(engine, new JintFunctionDefinition(functionDeclaration), JintEnvironment.NewDeclarativeEnvironment(engine, engine.ExecutionContext.LexicalEnvironment), strict ? FunctionThisMode.Strict : FunctionThisMode.Global, proto)
		{
		}

		internal ScriptFunction(Engine engine, JintFunctionDefinition function, Jint.Runtime.Environments.Environment env, FunctionThisMode thisMode, ObjectInstance? proto = null)
			: base(engine, engine.Realm, function, env, thisMode)
		{
			_prototype = proto ?? _engine.Realm.Intrinsics.Function.PrototypeObject;
			_length = new LazyPropertyDescriptor(null, (object? _) => JsNumber.Create(function.Initialize().Length), PropertyFlag.Configurable);
			if (!function.Strict && !(function.Function is ArrowFunctionExpression) && !function.Function.Generator)
			{
				SetProperty(KnownKeys.Arguments, new GetSetPropertyDescriptor.ThrowerPropertyDescriptor(engine, PropertyFlag.Configurable));
				SetProperty(KnownKeys.Caller, new PropertyDescriptor(JsValue.Undefined, PropertyFlag.Configurable));
			}
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			bool strict = _functionDefinition.Strict || _thisMode == FunctionThisMode.Strict;
			using (new StrictModeScope(strict, force: true))
			{
				try
				{
					ref readonly Jint.Runtime.Environments.ExecutionContext reference = ref PrepareForOrdinaryCall(JsValue.Undefined);
					if (_isClassConstructor)
					{
						ExceptionHelper.ThrowTypeError(reference.Realm, "Class constructor " + _functionDefinition.Name + " cannot be invoked without 'new'");
					}
					OrdinaryCallBindThis(in reference, thisObject);
					EvaluationContext evaluationContext = _engine._activeEvaluationContext ?? new EvaluationContext(_engine);
					Completion result = _functionDefinition.EvaluateBody(evaluationContext, this, arguments);
					if (result.Type == CompletionType.Throw)
					{
						ExceptionHelper.ThrowJavaScriptException(_engine, result.Value, in result);
					}
					if (evaluationContext.DebugMode)
					{
						_engine.Debugger.OnReturnPoint((Node)(object)_functionDefinition.Function.Body, (result.Type == CompletionType.Normal) ? JsValue.Undefined : result.Value);
					}
					if (result.Type == CompletionType.Return)
					{
						return result.Value;
					}
				}
				finally
				{
					_engine.LeaveExecutionContext();
				}
				return JsValue.Undefined;
			}
		}

		ObjectInstance IConstructor.Construct(JsValue[] arguments, JsValue newTarget)
		{
			Jint.Runtime.Environments.ExecutionContext executionContext = _engine.ExecutionContext;
			ConstructorKind constructorKind = _constructorKind;
			JsValue jsValue = JsValue.Undefined;
			if (constructorKind == ConstructorKind.Base)
			{
				jsValue = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Object.PrototypeObject, (Engine engine, Realm _, object? _) => new JsObject(engine));
			}
			ref readonly Jint.Runtime.Environments.ExecutionContext reference = ref PrepareForOrdinaryCall(newTarget);
			FunctionEnvironment functionEnvironment = (FunctionEnvironment)reference.LexicalEnvironment;
			bool strict = _thisMode == FunctionThisMode.Strict;
			using (new StrictModeScope(strict, force: true))
			{
				try
				{
					if (constructorKind == ConstructorKind.Base)
					{
						OrdinaryCallBindThis(in reference, jsValue);
						((ObjectInstance)jsValue).InitializeInstanceElements(this);
					}
					EvaluationContext evaluationContext = _engine._activeEvaluationContext ?? new EvaluationContext(_engine);
					Completion result = _functionDefinition.EvaluateBody(evaluationContext, this, arguments);
					if (evaluationContext.DebugMode && result.Type != CompletionType.Throw && (object)_functionDefinition.Function != ClassDefinition._emptyConstructor.Value)
					{
						_engine.Debugger.OnReturnPoint((Node)(object)_functionDefinition.Function.Body, (result.Type == CompletionType.Normal) ? jsValue : result.Value);
					}
					if (result.Type == CompletionType.Return)
					{
						if (result.Value is ObjectInstance result2)
						{
							return result2;
						}
						if (constructorKind == ConstructorKind.Base)
						{
							return (ObjectInstance)jsValue;
						}
						if (!result.Value.IsUndefined())
						{
							ExceptionHelper.ThrowTypeError(executionContext.Realm);
						}
					}
					else if (result.Type == CompletionType.Throw)
					{
						ExceptionHelper.ThrowJavaScriptException(_engine, result.Value, in result);
					}
				}
				finally
				{
					_engine.LeaveExecutionContext();
				}
			}
			return (ObjectInstance)functionEnvironment.GetThisBinding();
		}

		internal void MakeClassConstructor()
		{
			_isClassConstructor = true;
		}
	}
	internal sealed class ThrowTypeError : Function
	{
		public ThrowTypeError(Engine engine, Realm realm)
			: base(engine, realm, null)
		{
			_length = PropertyDescriptor.AllForbiddenDescriptor.NumberZero;
			_nameDescriptor = new PropertyDescriptor(JsString.Empty, PropertyFlag.AllForbidden);
			_environment = realm.GlobalEnv;
			PreventExtensions();
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			ExceptionHelper.ThrowTypeError(_realm);
			return null;
		}
	}
}
namespace Jint.Native.FinalizationRegistry
{
	internal sealed class FinalizationRegistryConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("FinalizationRegistry");

		public FinalizationRegistryPrototype PrototypeObject { get; }

		public FinalizationRegistryConstructor(Engine engine, Realm realm, FunctionConstructor functionConstructor, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			PrototypeObject = new FinalizationRegistryPrototype(engine, realm, this, objectPrototype);
			_prototype = functionConstructor.PrototypeObject;
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, thisObject);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (!(arguments.At(0) is ICallable state))
			{
				ExceptionHelper.ThrowTypeError(_realm, "cleanup must be callable");
				return null;
			}
			return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.FinalizationRegistry.PrototypeObject, (Engine engine, Realm realm, ICallable? cleanupCallback) => new FinalizationRegistryInstance(engine, realm, cleanupCallback), state);
		}
	}
	internal sealed record Cell(JsValue WeakRefTarget, JsValue HeldValue, JsValue? UnregisterToken);
	internal sealed class FinalizationRegistryInstance : ObjectInstance
	{
		private sealed class Observer
		{
			private readonly JobCallback _callable;

			public Observer(JobCallback callable)
			{
				_callable = callable;
			}

			~Observer()
			{
				_callable.Callback.Call(JsValue.Undefined);
			}
		}

		private readonly Realm _realm;

		private readonly JobCallback _callable;

		private readonly ConditionalWeakTable<JsValue, List<Observer>> _cells = new ConditionalWeakTable<JsValue, List<Observer>>();

		private readonly Dictionary<JsValue, List<Observer>> _byToken = new Dictionary<JsValue, List<Observer>>();

		public FinalizationRegistryInstance(Engine engine, Realm realm, ICallable cleanupCallback)
			: base(engine)
		{
			_realm = realm;
			_callable = engine._host.MakeJobCallBack(cleanupCallback);
		}

		public static void CleanupFinalizationRegistry(ICallable? callback)
		{
		}

		public void AddCell(Cell cell)
		{
			Observer item = new Observer(_callable);
			_cells.GetOrCreateValue(cell.WeakRefTarget).Add(item);
			if ((object)cell.UnregisterToken != null)
			{
				if (!_byToken.TryGetValue(cell.UnregisterToken, out List<Observer> value))
				{
					value = (_byToken[cell.UnregisterToken] = new List<Observer>());
				}
				value.Add(item);
			}
		}

		public JsValue Remove(JsValue unregisterToken)
		{
			if (_byToken.TryGetValue(unregisterToken, out List<Observer> value))
			{
				bool num = value.Count > 0;
				value.Clear();
				return num;
			}
			return false;
		}
	}
	internal sealed class FinalizationRegistryPrototype : Prototype
	{
		private readonly FinalizationRegistryConstructor _constructor;

		public FinalizationRegistryPrototype(Engine engine, Realm realm, FinalizationRegistryConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, realm)
		{
			_constructor = constructor;
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(4, checkExistingKeys: false)
			{
				[KnownKeys.Constructor] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["register"] = new PropertyDescriptor(new ClrFunction(base.Engine, "register", Register, 2, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["unregister"] = new PropertyDescriptor(new ClrFunction(base.Engine, "unregister", Unregister, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["cleanupSome"] = new PropertyDescriptor(new ClrFunction(base.Engine, "cleanupSome", CleanupSome, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("FinalizationRegistry", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Register(JsValue thisObject, JsValue[] arguments)
		{
			FinalizationRegistryInstance finalizationRegistryInstance = AssertFinalizationRegistryInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			JsValue jsValue3 = arguments.At(2);
			if (!jsValue.CanBeHeldWeakly(_engine.GlobalSymbolRegistry))
			{
				ExceptionHelper.ThrowTypeError(_realm, "target must be an object or symbol");
			}
			if (JsValue.SameValue(jsValue, jsValue2))
			{
				ExceptionHelper.ThrowTypeError(_realm, "target and holdings must not be same");
			}
			if (!jsValue3.CanBeHeldWeakly(_engine.GlobalSymbolRegistry) && !jsValue3.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm, jsValue3?.ToString() + " must be an object");
			}
			Cell cell = new Cell(jsValue, jsValue2, jsValue3);
			finalizationRegistryInstance.AddCell(cell);
			return JsValue.Undefined;
		}

		private JsValue Unregister(JsValue thisObject, JsValue[] arguments)
		{
			FinalizationRegistryInstance finalizationRegistryInstance = AssertFinalizationRegistryInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			if (!jsValue.CanBeHeldWeakly(_engine.GlobalSymbolRegistry))
			{
				ExceptionHelper.ThrowTypeError(_realm, jsValue?.ToString() + " must be an object or symbol");
			}
			return finalizationRegistryInstance.Remove(jsValue);
		}

		private JsValue CleanupSome(JsValue thisObject, JsValue[] arguments)
		{
			AssertFinalizationRegistryInstance(thisObject);
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsUndefined() && !(jsValue is ICallable))
			{
				ExceptionHelper.ThrowTypeError(_realm, jsValue?.ToString() + " must be callable");
			}
			FinalizationRegistryInstance.CleanupFinalizationRegistry(jsValue as ICallable);
			return JsValue.Undefined;
		}

		private FinalizationRegistryInstance AssertFinalizationRegistryInstance(JsValue thisObject)
		{
			if (thisObject is FinalizationRegistryInstance result)
			{
				return result;
			}
			ExceptionHelper.ThrowTypeError(_realm, "object must be a FinalizationRegistry");
			return null;
		}
	}
}
namespace Jint.Native.Error
{
	public sealed class ErrorConstructor : Constructor
	{
		private readonly Func<Intrinsics, ObjectInstance> _intrinsicDefaultProto;

		internal ErrorPrototype PrototypeObject { get; }

		internal ErrorConstructor(Engine engine, Realm realm, ObjectInstance functionPrototype, ObjectInstance objectPrototype, JsString name, Func<Intrinsics, ObjectInstance> intrinsicDefaultProto)
			: base(engine, realm, name)
		{
			_intrinsicDefaultProto = intrinsicDefaultProto;
			_prototype = functionPrototype;
			PrototypeObject = new ErrorPrototype(engine, realm, this, objectPrototype, name);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, this);
		}

		public ObjectInstance Construct(string? message = null)
		{
			return Construct((message == null) ? System.Array.Empty<JsValue>() : new JsValue[1] { message }, this);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsError jsError = OrdinaryCreateFromConstructor(newTarget, _intrinsicDefaultProto, (Engine engine, Realm _, object? _) => new JsError(engine));
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsUndefined())
			{
				JsString v = TypeConverter.ToJsString(jsValue);
				jsError.CreateNonEnumerableDataPropertyOrThrow(CommonProperties.Message, v);
			}
			JsValue jsValue2 = BuildStackString();
			if ((object)jsValue2 != null)
			{
				PropertyDescriptor desc = new PropertyDescriptor(jsValue2, PropertyFlag.NonEnumerable);
				jsError.DefinePropertyOrThrow(CommonProperties.Stack, desc);
			}
			JsValue jsValue3 = arguments.At(1);
			if (!jsValue3.IsUndefined())
			{
				jsError.InstallErrorCause(jsValue3);
			}
			return jsError;
			JsValue? BuildStackString()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				SyntaxElement lastSyntaxElement = _engine.GetLastSyntaxElement();
				if (lastSyntaxElement == null)
				{
					return null;
				}
				JintCallStack callStack = _engine.CallStack;
				CallStackElement item;
				return callStack.BuildCallStackString(excludeTop: ((callStack.TryPeek(out item) ? item.Function : null) == this) ? 1 : 0, location: lastSyntaxElement.Location);
			}
		}
	}
	public class ErrorInstance : ObjectInstance
	{
		private protected ErrorInstance(Engine engine, ObjectClass objectClass)
			: base(engine, objectClass)
		{
		}

		internal void InstallErrorCause(JsValue options)
		{
			if (options is ObjectInstance objectInstance && objectInstance.HasProperty("cause"))
			{
				JsValue v = objectInstance.Get("cause");
				CreateNonEnumerableDataPropertyOrThrow("cause", v);
			}
		}

		public override string ToString()
		{
			return base.Engine.Realm.Intrinsics.Error.PrototypeObject.ToString(this, Arguments.Empty).ToObject()?.ToString() ?? "";
		}
	}
	internal sealed class ErrorPrototype : ErrorInstance
	{
		private readonly JsString _name;

		private readonly Realm _realm;

		private readonly ErrorConstructor _constructor;

		internal ErrorPrototype(Engine engine, Realm realm, ErrorConstructor constructor, ObjectInstance prototype, JsString name)
			: base(engine, ObjectClass.Object)
		{
			_realm = realm;
			_name = name;
			_constructor = constructor;
			_prototype = prototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(3, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["message"] = new PropertyDescriptor("", PropertyFlag.Writable | PropertyFlag.Configurable),
				["name"] = new PropertyDescriptor(_name, PropertyFlag.Writable | PropertyFlag.Configurable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
		}

		public JsValue ToString(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance? objectInstance = thisObject.TryCast<ObjectInstance>();
			if ((object)objectInstance == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue jsValue = objectInstance.Get("name", this);
			string text = (jsValue.IsUndefined() ? "Error" : TypeConverter.ToString(jsValue));
			JsValue jsValue2 = objectInstance.Get("message", this);
			string text2 = (jsValue2.IsUndefined() ? "" : TypeConverter.ToString(jsValue2));
			if (text == "")
			{
				return text2;
			}
			if (text2 == "")
			{
				return text;
			}
			return text + ": " + text2;
		}
	}
}
namespace Jint.Native.Date
{
	internal sealed class DateConstructor : Constructor
	{
		internal static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

		private static readonly JsString _functionName = new JsString("Date");

		private readonly ITimeSystem _timeSystem;

		internal DatePrototype PrototypeObject { get; }

		internal DateConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new DatePrototype(engine, this, objectPrototype);
			_length = new PropertyDescriptor(7, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
			_timeSystem = engine.Options.TimeSystem;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(3, checkExistingKeys: false)
			{
				["parse"] = new PropertyDescriptor(new ClrFunction(base.Engine, "parse", Parse, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["UTC"] = new PropertyDescriptor(new ClrFunction(base.Engine, "UTC", Utc, 7, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["now"] = new PropertyDescriptor(new ClrFunction(base.Engine, "now", Now, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
		}

		private JsValue Parse(JsValue thisObject, JsValue[] arguments)
		{
			string date = TypeConverter.ToString(arguments.At(0));
			return ParseFromString(date).ToJsValue();
		}

		private DatePresentation ParseFromString(string date)
		{
			if (_timeSystem.TryParse(date, out var epochMilliseconds))
			{
				return epochMilliseconds;
			}
			return DatePresentation.NaN;
		}

		private static JsValue Utc(JsValue thisObject, JsValue[] arguments)
		{
			double num = TypeConverter.ToNumber(arguments.At(0));
			double month = TypeConverter.ToNumber(arguments.At(1, JsNumber.PositiveZero));
			double date = TypeConverter.ToNumber(arguments.At(2, JsNumber.PositiveOne));
			double hour = TypeConverter.ToNumber(arguments.At(3, JsNumber.PositiveZero));
			double min = TypeConverter.ToNumber(arguments.At(4, JsNumber.PositiveZero));
			double sec = TypeConverter.ToNumber(arguments.At(5, JsNumber.PositiveZero));
			double ms = TypeConverter.ToNumber(arguments.At(6, JsNumber.PositiveZero));
			double num2 = TypeConverter.ToInteger(num);
			if (!double.IsNaN(num) && 0.0 <= num2 && num2 <= 99.0)
			{
				num = num2 + 1900.0;
			}
			return DatePrototype.MakeDate(DatePrototype.MakeDay(num, month, date), DatePrototype.MakeTime(hour, min, sec, ms)).TimeClip().ToJsValue();
		}

		private JsValue Now(JsValue thisObject, JsValue[] arguments)
		{
			return (long)(_timeSystem.GetUtcNow().DateTime - Epoch).TotalMilliseconds;
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return PrototypeObject.ToString(Construct(Arguments.Empty, thisObject), Arguments.Empty);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (arguments.Length == 0 || newTarget.IsUndefined())
			{
				return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Date.PrototypeObject, (Engine engine, Realm _, double dateValue) => new JsDate(engine, dateValue), (_timeSystem.GetUtcNow().DateTime - Epoch).TotalMilliseconds);
			}
			return ConstructUnlikely(arguments, newTarget);
		}

		private JsDate ConstructUnlikely(JsValue[] arguments, JsValue newTarget)
		{
			DatePresentation state;
			if (arguments.Length == 1)
			{
				if (arguments[0] is JsDate jsDate)
				{
					return Construct(jsDate._dateValue);
				}
				JsValue jsValue = TypeConverter.ToPrimitive(arguments[0]);
				if (jsValue.IsString())
				{
					DatePresentation time = ParseFromString(jsValue.ToString());
					return Construct(time);
				}
				state = TypeConverter.ToNumber(jsValue);
			}
			else
			{
				double num = TypeConverter.ToNumber(arguments.At(0));
				double month = TypeConverter.ToNumber(arguments.At(1));
				double date = TypeConverter.ToNumber(arguments.At(2, JsNumber.PositiveOne));
				double hour = TypeConverter.ToNumber(arguments.At(3, JsNumber.PositiveZero));
				double min = TypeConverter.ToNumber(arguments.At(4, JsNumber.PositiveZero));
				double sec = TypeConverter.ToNumber(arguments.At(5, JsNumber.PositiveZero));
				double ms = TypeConverter.ToNumber(arguments.At(6, JsNumber.PositiveZero));
				double num2 = TypeConverter.ToInteger(num);
				if (!double.IsNaN(num) && 0.0 <= num2 && num2 <= 99.0)
				{
					num += 1900.0;
				}
				DatePresentation t = DatePrototype.MakeDate(DatePrototype.MakeDay(num, month, date), DatePrototype.MakeTime(hour, min, sec, ms));
				state = PrototypeObject.Utc(t).TimeClip();
			}
			return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Date.PrototypeObject, (Engine engine, Realm _, DatePresentation dateValue) => new JsDate(engine, dateValue), state);
		}

		public JsDate Construct(DateTimeOffset value)
		{
			return Construct(value.UtcDateTime);
		}

		public JsDate Construct(DateTime value)
		{
			return Construct(FromDateTime(value));
		}

		public JsDate Construct(long time)
		{
			return OrdinaryCreateFromConstructor(JsValue.Undefined, (Intrinsics intrinsics) => intrinsics.Date.PrototypeObject, (Engine engine, Realm _, long dateValue) => new JsDate(engine, dateValue), time);
		}

		private JsDate Construct(DatePresentation time)
		{
			return OrdinaryCreateFromConstructor(JsValue.Undefined, (Intrinsics intrinsics) => intrinsics.Date.PrototypeObject, (Engine engine, Realm _, DatePresentation dateValue) => new JsDate(engine, dateValue), time);
		}

		internal DatePresentation FromDateTime(DateTime dt, bool negative = false)
		{
			if (dt == DateTime.MinValue)
			{
				return DatePresentation.MinValue;
			}
			if (dt == DateTime.MaxValue)
			{
				return DatePresentation.MaxValue;
			}
			bool num = dt.Kind == DateTimeKind.Unspecified;
			DateTime dateTime = ((dt.Kind == DateTimeKind.Local) ? dt.ToUniversalTime() : DateTime.SpecifyKind(dt, DateTimeKind.Utc));
			DatePresentation datePresentation = ((!negative) ? ((DatePresentation)(long)(dateTime - Epoch).TotalMilliseconds) : DatePrototype.MakeDate(DatePrototype.MakeDay(-1 * dateTime.Year, dateTime.Month - 1, dateTime.Day), DatePrototype.MakeTime(dateTime.Hour, dateTime.Minute, dateTime.Second, dateTime.Millisecond)));
			if (num)
			{
				datePresentation = PrototypeObject.Utc(datePresentation);
			}
			return datePresentation;
		}
	}
	internal static class DateExtensions
	{
		public static DateTime ToDateTime(this double t)
		{
			return DateConstructor.Epoch.AddMilliseconds(t);
		}

		internal static DatePresentation TimeClip(this double time)
		{
			if (double.IsInfinity(time) || double.IsNaN(time))
			{
				return new DatePresentation(0L, DateFlags.NaN);
			}
			if (System.Math.Abs(time) > 8640000000000000.0)
			{
				return new DatePresentation(0L, DateFlags.NaN);
			}
			return new DatePresentation((long)time, DateFlags.None);
		}
	}
	internal sealed class DatePrototype : Prototype
	{
		[StructLayout(LayoutKind.Auto)]
		private readonly record struct Date(int Year, int Month, int Day);

		private const double MinYear = -1000000.0;

		private const double MaxYear = 1000000.0;

		private const double MinMonth = -10000000.0;

		private const double MaxMonth = 10000000.0;

		private readonly DateConstructor _constructor;

		private readonly ITimeSystem _timeSystem;

		private const int HoursPerDay = 24;

		private const int MinutesPerHour = 60;

		private const int SecondsPerMinute = 60;

		private const int MsPerSecond = 1000;

		private const int MsPerMinute = 60000;

		private const int MsPerHour = 3600000;

		private const long MsPerDay = 86400000L;

		private static readonly int[] _dayFromMonth = new int[12]
		{
			0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
			304, 334
		};

		private static readonly int[] _dayFromMonthLeapYear = new int[12]
		{
			0, 31, 60, 91, 121, 152, 182, 213, 244, 274,
			305, 335
		};

		private static readonly int[] kDaysInMonths = new int[12]
		{
			31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
			30, 31
		};

		private static readonly string[] _dayNames = new string[7] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };

		private static readonly string[] _monthNames = new string[12]
		{
			"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
			"Nov", "Dec"
		};

		internal DatePrototype(Engine engine, DateConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, engine.Realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
			_timeSystem = engine.Options.TimeSystem;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(50, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toDateString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toDateString", ToDateString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toTimeString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toTimeString", ToTimeString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleString", ToLocaleString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleDateString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleDateString", ToLocaleDateString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleTimeString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleTimeString", ToLocaleTimeString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["valueOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getTime"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getTime", GetTime, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getFullYear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getFullYear", GetFullYear, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getYear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getYear", GetYear, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCFullYear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCFullYear", GetUTCFullYear, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getMonth"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getMonth", GetMonth, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCMonth"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCMonth", GetUTCMonth, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getDate"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getDate", GetDate, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCDate"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCDate", GetUTCDate, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getDay"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getDay", GetDay, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCDay"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCDay", GetUTCDay, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getHours"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getHours", GetHours, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCHours"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCHours", GetUTCHours, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getMinutes"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getMinutes", GetMinutes, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCMinutes"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCMinutes", GetUTCMinutes, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getSeconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getSeconds", GetSeconds, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCSeconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCSeconds", GetUTCSeconds, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getMilliseconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getMilliseconds", GetMilliseconds, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUTCMilliseconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUTCMilliseconds", GetUTCMilliseconds, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getTimezoneOffset"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getTimezoneOffset", GetTimezoneOffset, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setTime"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setTime", SetTime, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setMilliseconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setMilliseconds", SetMilliseconds, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUTCMilliseconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUTCMilliseconds", SetUTCMilliseconds, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setSeconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setSeconds", SetSeconds, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUTCSeconds"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUTCSeconds", SetUTCSeconds, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setMinutes"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setMinutes", SetMinutes, 3, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUTCMinutes"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUTCMinutes", SetUTCMinutes, 3, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setHours"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setHours", SetHours, 4, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUTCHours"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUTCHours", SetUTCHours, 4, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setDate"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setDate", SetDate, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUTCDate"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUTCDate", SetUTCDate, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setMonth"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setMonth", SetMonth, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUTCMonth"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUTCMonth", SetUTCMonth, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setFullYear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setFullYear", SetFullYear, 3, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setYear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setYear", SetYear, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUTCFullYear"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUTCFullYear", SetUTCFullYear, 3, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toUTCString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toUTCString", ToUtcString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toISOString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toISOString", ToISOString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toJSON"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toJSON", ToJson, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toPrimitive = GlobalSymbolRegistry.ToPrimitive;
			symbolDictionary[toPrimitive] = new PropertyDescriptor(new ClrFunction(base.Engine, "[Symbol.toPrimitive]", ToPrimitive, 1, PropertyFlag.Configurable), PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue ToPrimitive(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance obj = thisObject as ObjectInstance;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsString())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			string a = jsValue.ToString();
			Types hint = Types.Empty;
			if (string.Equals(a, "default", StringComparison.Ordinal) || string.Equals(a, "string", StringComparison.Ordinal))
			{
				hint = Types.String;
			}
			else if (string.Equals(a, "number", StringComparison.Ordinal))
			{
				hint = Types.Number;
			}
			else
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			return TypeConverter.OrdinaryToPrimitive(obj, hint);
		}

		private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
		{
			return ThisTimeValue(thisObject).ToJsValue();
		}

		private DatePresentation ThisTimeValue(JsValue thisObject)
		{
			if (thisObject is JsDate jsDate)
			{
				return jsDate._dateValue;
			}
			ExceptionHelper.ThrowTypeError(_realm, "this is not a Date object");
			return default(DatePresentation);
		}

		internal JsValue ToString(JsValue thisObject, JsValue[] arg2)
		{
			DatePresentation tv = ThisTimeValue(thisObject);
			return ToDateString(tv);
		}

		private JsValue ToDateString(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return "Invalid Date";
			}
			return DateString(LocalTime(t));
		}

		private JsValue ToDateString(DatePresentation tv)
		{
			if (tv.IsNaN)
			{
				return "Invalid Date";
			}
			DatePresentation datePresentation = LocalTime(tv);
			return DateString(datePresentation) + " " + TimeString(datePresentation) + TimeZoneString(tv);
		}

		private JsValue ToTimeString(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation datePresentation = ThisTimeValue(thisObject);
			if (datePresentation.IsNaN)
			{
				return "Invalid Date";
			}
			return TimeString(LocalTime(datePresentation)) + TimeZoneString(datePresentation);
		}

		private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return "Invalid Date";
			}
			return ToLocalTime(t).ToString("F", base.Engine.Options.Culture);
		}

		private JsValue ToLocaleDateString(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return "Invalid Date";
			}
			return ToLocalTime(t).ToString("D", base.Engine.Options.Culture);
		}

		private JsValue ToLocaleTimeString(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return "Invalid Date";
			}
			return ToLocalTime(t).ToString("T", base.Engine.Options.Culture);
		}

		private JsValue GetTime(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation datePresentation = ThisTimeValue(thisObject);
			if (datePresentation.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return datePresentation.ToJsValue();
		}

		private JsValue GetFullYear(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return YearFromTime(LocalTime(t));
		}

		private JsValue GetYear(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return YearFromTime(LocalTime(t)) - 1900;
		}

		private JsValue GetUTCFullYear(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return YearFromTime(t);
		}

		private JsValue GetMonth(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return MonthFromTime(LocalTime(t));
		}

		private JsValue GetUTCMonth(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return MonthFromTime(t);
		}

		private JsValue GetDate(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return DateFromTime(LocalTime(t));
		}

		private JsValue GetUTCDate(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return DateFromTime(t);
		}

		private JsValue GetDay(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return WeekDay(LocalTime(t));
		}

		private JsValue GetUTCDay(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return WeekDay(t);
		}

		private JsValue GetHours(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return HourFromTime(LocalTime(t));
		}

		private JsValue GetUTCHours(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return HourFromTime(t);
		}

		private JsValue GetMinutes(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return MinFromTime(LocalTime(t));
		}

		private JsValue GetUTCMinutes(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return MinFromTime(t);
		}

		private JsValue GetSeconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return SecFromTime(LocalTime(t));
		}

		private JsValue GetUTCSeconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return SecFromTime(t);
		}

		private JsValue GetMilliseconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return MsFromTime(LocalTime(t));
		}

		private JsValue GetUTCMilliseconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return MsFromTime(t);
		}

		private JsValue GetTimezoneOffset(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			return (int)((double)t.Value - (double)LocalTime(t).Value) / 60000;
		}

		private JsValue SetTime(JsValue thisObject, JsValue[] arguments)
		{
			ThisTimeValue(thisObject);
			double num = TypeConverter.ToNumber(arguments.At(0));
			DatePresentation datePresentation = num.TimeClip();
			((JsDate)thisObject)._dateValue = num;
			return datePresentation.ToJsValue();
		}

		private JsValue SetMilliseconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = LocalTime(ThisTimeValue(thisObject));
			double ms = TypeConverter.ToNumber(arguments.At(0));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			double time = MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ms);
			DatePresentation dateValue = Utc(MakeDate(Day(t), time)).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetUTCMilliseconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			double ms = TypeConverter.ToNumber(arguments.At(0));
			if (t.IsNaN)
			{
				return double.NaN;
			}
			double time = MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ms);
			DatePresentation dateValue = MakeDate(Day(t), time).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetSeconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = LocalTime(ThisTimeValue(thisObject));
			double sec = TypeConverter.ToNumber(arguments.At(0));
			double ms = ((arguments.Length <= 1) ? ((double)MsFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation t2 = MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), sec, ms));
			DatePresentation dateValue = Utc(t2).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetUTCSeconds(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			double sec = TypeConverter.ToNumber(arguments.At(0));
			double ms = ((arguments.Length <= 1) ? ((double)MsFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation dateValue = MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), sec, ms)).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetMinutes(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = LocalTime(ThisTimeValue(thisObject));
			double min = TypeConverter.ToNumber(arguments.At(0));
			double sec = ((arguments.Length <= 1) ? ((double)SecFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			double ms = ((arguments.Length <= 2) ? ((double)MsFromTime(t)) : TypeConverter.ToNumber(arguments.At(2)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation t2 = MakeDate(Day(t), MakeTime(HourFromTime(t), min, sec, ms));
			DatePresentation dateValue = Utc(t2).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetUTCMinutes(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			double min = TypeConverter.ToNumber(arguments.At(0));
			double sec = ((arguments.Length <= 1) ? ((double)SecFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			double ms = ((arguments.Length <= 2) ? ((double)MsFromTime(t)) : TypeConverter.ToNumber(arguments.At(2)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation dateValue = MakeDate(Day(t), MakeTime(HourFromTime(t), min, sec, ms)).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetHours(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = LocalTime(ThisTimeValue(thisObject));
			double hour = TypeConverter.ToNumber(arguments.At(0));
			double min = ((arguments.Length <= 1) ? ((double)MinFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			double sec = ((arguments.Length <= 2) ? ((double)SecFromTime(t)) : TypeConverter.ToNumber(arguments.At(2)));
			double ms = ((arguments.Length <= 3) ? ((double)MsFromTime(t)) : TypeConverter.ToNumber(arguments.At(3)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation t2 = MakeDate(Day(t), MakeTime(hour, min, sec, ms));
			DatePresentation dateValue = Utc(t2).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetUTCHours(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			double hour = TypeConverter.ToNumber(arguments.At(0));
			double min = ((arguments.Length <= 1) ? ((double)MinFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			double sec = ((arguments.Length <= 2) ? ((double)SecFromTime(t)) : TypeConverter.ToNumber(arguments.At(2)));
			double ms = ((arguments.Length <= 3) ? ((double)MsFromTime(t)) : TypeConverter.ToNumber(arguments.At(3)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation dateValue = MakeDate(Day(t), MakeTime(hour, min, sec, ms)).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetDate(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = LocalTime(ThisTimeValue(thisObject));
			double date = TypeConverter.ToNumber(arguments.At(0));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			YearMonthDayFromTime(t).Deconstruct(out var Year, out var Month, out var _);
			int num = Year;
			int num2 = Month;
			DatePresentation t2 = MakeDate(MakeDay(num, num2, date), TimeWithinDay(t));
			DatePresentation dateValue = Utc(t2).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetUTCDate(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			double date = TypeConverter.ToNumber(arguments.At(0));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation dateValue = MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), date), TimeWithinDay(t)).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetMonth(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = LocalTime(ThisTimeValue(thisObject));
			double month = TypeConverter.ToNumber(arguments.At(0));
			double date = ((arguments.Length <= 1) ? ((double)DateFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation t2 = MakeDate(MakeDay(YearFromTime(t), month, date), TimeWithinDay(t));
			DatePresentation dateValue = Utc(t2).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetUTCMonth(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			double month = TypeConverter.ToNumber(arguments.At(0));
			double date = ((arguments.Length <= 1) ? ((double)DateFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			if (t.IsNaN)
			{
				return JsNumber.DoubleNaN;
			}
			DatePresentation dateValue = MakeDate(MakeDay(YearFromTime(t), month, date), TimeWithinDay(t)).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetFullYear(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			DatePresentation t2 = (t.IsNaN ? ((DatePresentation)0L) : LocalTime(t));
			double year = TypeConverter.ToNumber(arguments.At(0));
			double month = ((arguments.Length <= 1) ? ((double)MonthFromTime(t2)) : TypeConverter.ToNumber(arguments.At(1)));
			double date = ((arguments.Length <= 2) ? ((double)DateFromTime(t2)) : TypeConverter.ToNumber(arguments.At(2)));
			DatePresentation t3 = MakeDate(MakeDay(year, month, date), TimeWithinDay(t2));
			DatePresentation dateValue = Utc(t3).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue SetYear(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation t = ThisTimeValue(thisObject);
			DatePresentation t2 = (t.IsNaN ? ((DatePresentation)0L) : LocalTime(t));
			double num = TypeConverter.ToNumber(arguments.At(0));
			if (double.IsNaN(num))
			{
				((JsDate)thisObject)._dateValue = double.NaN;
				return JsNumber.DoubleNaN;
			}
			double num2 = TypeConverter.ToInteger(num);
			if (num >= 0.0 && num <= 99.0)
			{
				num2 += 1900.0;
			}
			double day = MakeDay(num2, MonthFromTime(t2), DateFromTime(t2));
			DatePresentation datePresentation = Utc(MakeDate(day, TimeWithinDay(t2)));
			((JsDate)thisObject)._dateValue = datePresentation.TimeClip();
			return datePresentation.ToJsValue();
		}

		private JsValue SetUTCFullYear(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation datePresentation = ThisTimeValue(thisObject);
			DatePresentation t = (datePresentation.IsNaN ? ((DatePresentation)0L) : datePresentation);
			double year = TypeConverter.ToNumber(arguments.At(0));
			double month = ((arguments.Length <= 1) ? ((double)MonthFromTime(t)) : TypeConverter.ToNumber(arguments.At(1)));
			double date = ((arguments.Length <= 2) ? ((double)DateFromTime(t)) : TypeConverter.ToNumber(arguments.At(2)));
			DatePresentation dateValue = MakeDate(MakeDay(year, month, date), TimeWithinDay(t)).TimeClip();
			((JsDate)thisObject)._dateValue = dateValue;
			return dateValue.ToJsValue();
		}

		private JsValue ToUtcString(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation datePresentation = ThisTimeValue(thisObject);
			if (!IsFinite(datePresentation))
			{
				return "Invalid Date";
			}
			string value = _dayNames[WeekDay(datePresentation)];
			string value2 = _monthNames[MonthFromTime(datePresentation)];
			string value3 = DateFromTime(datePresentation).ToString("00", CultureInfo.InvariantCulture);
			string value4 = YearFromTime(datePresentation).ToString("0000", CultureInfo.InvariantCulture);
			return $"{value}, {value3} {value2} {value4} {TimeString(datePresentation)}";
		}

		private JsValue ToISOString(JsValue thisObject, JsValue[] arguments)
		{
			DatePresentation datePresentation = ThisTimeValue(thisObject);
			DatePresentation t = datePresentation;
			if (t.IsNaN)
			{
				ExceptionHelper.ThrowRangeError(_realm);
			}
			if (((JsDate)thisObject).DateTimeRangeValid)
			{
				DateTime dateTime = datePresentation.ToDateTime();
				return $"{dateTime.Year:0000}-{dateTime.Month:00}-{dateTime.Day:00}T{dateTime.Hour:00}:{dateTime.Minute:00}:{dateTime.Second:00}.{dateTime.Millisecond:000}Z";
			}
			int num = HourFromTime(t);
			int num2 = MinFromTime(t);
			int num3 = SecFromTime(t);
			int num4 = MsFromTime(t);
			if (num < 0)
			{
				num += 24;
			}
			if (num2 < 0)
			{
				num2 += 60;
			}
			if (num3 < 0)
			{
				num3 += 60;
			}
			if (num4 < 0)
			{
				num4 += 1000;
			}
			YearMonthDayFromTime(t).Deconstruct(out var Year, out var Month, out var Day);
			int num5 = Year;
			int num6 = Month;
			int value = Day;
			num6++;
			string text = $"{num5:0000}-{num6:00}-{value:00}T{num:00}:{num2:00}:{num3:00}.{num4:000}Z";
			if (num5 > 9999)
			{
				text = "+" + text;
			}
			return text;
		}

		private JsValue ToJson(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			JsValue jsValue = TypeConverter.ToPrimitive(objectInstance, Types.Number);
			if (jsValue.IsNumber() && !IsFinite(((JsNumber)jsValue)._value))
			{
				return JsValue.Null;
			}
			return Invoke(objectInstance, "toISOString", Arguments.Empty);
		}

		private static int Day(DatePresentation t)
		{
			return (int)System.Math.Floor((double)t.Value / 86400000.0);
		}

		private static long TimeWithinDay(DatePresentation t)
		{
			long num = t.Value % 86400000;
			if (num < 0)
			{
				num += 86400000;
			}
			return num;
		}

		private static int DaysInYear(double y)
		{
			if (y % 4.0 != 0.0)
			{
				return 365;
			}
			if (y % 4.0 == 0.0 && y % 100.0 != 0.0)
			{
				return 366;
			}
			if (y % 100.0 == 0.0 && y % 400.0 != 0.0)
			{
				return 365;
			}
			if (y % 400.0 == 0.0)
			{
				return 366;
			}
			return 365;
		}

		private static int DayFromYear(DatePresentation y)
		{
			return (int)((double)(365 * (y.Value - 1970)) + System.Math.Floor((double)(y.Value - 1969) / 4.0) - System.Math.Floor((double)(y.Value - 1901) / 100.0) + System.Math.Floor((double)(y.Value - 1601) / 400.0));
		}

		private static long TimeFromYear(DatePresentation y)
		{
			return 86400000L * (long)DayFromYear(y);
		}

		private static int YearFromTime(DatePresentation t)
		{
			YearMonthDayFromTime(t).Deconstruct(out var Year, out var _, out var _);
			return Year;
		}

		private static int InLeapYear(DatePresentation t)
		{
			switch (DaysInYear(YearFromTime(t)))
			{
			case 365:
				return 0;
			case 366:
				return 1;
			default:
				ExceptionHelper.ThrowArgumentException();
				return 0;
			}
		}

		private static int MonthFromTime(DatePresentation t)
		{
			int num = DayWithinYear(t);
			int num2 = InLeapYear(t);
			if (num < 31)
			{
				return 0;
			}
			if (num < 59 + num2)
			{
				return 1;
			}
			if (num < 90 + num2)
			{
				return 2;
			}
			if (num < 120 + num2)
			{
				return 3;
			}
			if (num < 151 + num2)
			{
				return 4;
			}
			if (num < 181 + num2)
			{
				return 5;
			}
			if (num < 212 + num2)
			{
				return 6;
			}
			if (num < 243 + num2)
			{
				return 7;
			}
			if (num < 273 + num2)
			{
				return 8;
			}
			if (num < 304 + num2)
			{
				return 9;
			}
			if (num < 334 + num2)
			{
				return 10;
			}
			if (num < 365 + num2)
			{
				return 11;
			}
			ExceptionHelper.ThrowInvalidOperationException();
			return 0;
		}

		private static int DayWithinYear(DatePresentation t)
		{
			return Day(t) - DayFromYear(YearFromTime(t));
		}

		private static int DateFromTime(DatePresentation t)
		{
			int num = MonthFromTime(t);
			int num2 = DayWithinYear(t);
			switch (num)
			{
			case 0:
				return num2 + 1;
			case 1:
				return num2 - 30;
			case 2:
				return num2 - 58 - InLeapYear(t);
			case 3:
				return num2 - 89 - InLeapYear(t);
			case 4:
				return num2 - 119 - InLeapYear(t);
			case 5:
				return num2 - 150 - InLeapYear(t);
			case 6:
				return num2 - 180 - InLeapYear(t);
			case 7:
				return num2 - 211 - InLeapYear(t);
			case 8:
				return num2 - 242 - InLeapYear(t);
			case 9:
				return num2 - 272 - InLeapYear(t);
			case 10:
				return num2 - 303 - InLeapYear(t);
			case 11:
				return num2 - 333 - InLeapYear(t);
			default:
				ExceptionHelper.ThrowInvalidOperationException();
				return 0;
			}
		}

		private static int WeekDay(DatePresentation t)
		{
			int num = (Day(t) + 4) % 7;
			if (num < 0)
			{
				return num + 7;
			}
			return num;
		}

		private DateTime ToLocalTime(DatePresentation t)
		{
			double totalMilliseconds = _timeSystem.GetUtcOffset(t.Value).TotalMilliseconds;
			return (t + totalMilliseconds).ToDateTime();
		}

		private DatePresentation LocalTime(DatePresentation t)
		{
			if (t.IsNaN)
			{
				return DatePresentation.NaN;
			}
			double totalMilliseconds = _timeSystem.GetUtcOffset(t.Value).TotalMilliseconds;
			return t + totalMilliseconds;
		}

		internal DatePresentation Utc(DatePresentation t)
		{
			double totalMilliseconds = _timeSystem.GetUtcOffset(t.Value).TotalMilliseconds;
			return t - totalMilliseconds;
		}

		private static int HourFromTime(DatePresentation t)
		{
			double num = System.Math.Floor((double)t.Value / 3600000.0) % 24.0;
			if (num < 0.0)
			{
				num += 24.0;
			}
			return (int)num;
		}

		private static int MinFromTime(DatePresentation t)
		{
			double num = System.Math.Floor((double)t.Value / 60000.0) % 60.0;
			if (num < 0.0)
			{
				num += 60.0;
			}
			return (int)num;
		}

		private static int SecFromTime(DatePresentation t)
		{
			double num = System.Math.Floor((double)t.Value / 1000.0) % 60.0;
			if (num < 0.0)
			{
				num += 60.0;
			}
			return (int)num;
		}

		private static int MsFromTime(DatePresentation t)
		{
			long num = t.Value % 1000;
			if (num < 0)
			{
				num += 1000;
			}
			return (int)num;
		}

		internal static double MakeTime(double hour, double min, double sec, double ms)
		{
			if (!AreFinite(hour, min, sec, ms))
			{
				return double.NaN;
			}
			double num = TypeConverter.ToInteger(hour);
			double num2 = TypeConverter.ToInteger(min);
			double num3 = TypeConverter.ToInteger(sec);
			double num4 = TypeConverter.ToInteger(ms);
			return num * 3600000.0 + num2 * 60000.0 + num3 * 1000.0 + num4;
		}

		internal static double MakeDay(double year, double month, double date)
		{
			if (year < -1000000.0 || year > 1000000.0 || month < -10000000.0 || month > 10000000.0 || !AreFinite(year, month, date))
			{
				return double.NaN;
			}
			long num = (long)TypeConverter.ToInteger(year);
			long num2 = (long)TypeConverter.ToInteger(month);
			long num3 = (long)TypeConverter.ToInteger(date);
			num += num2 / 12;
			num2 %= 12;
			if (num2 < 0)
			{
				num2 += 12;
				num--;
			}
			long num4 = 365 * (num + 399999) + (num + 399999) / 4 - (num + 399999) / 100 + (num + 399999) / 400 - 146816162;
			num4 = ((num % 4 == 0L && (num % 100 != 0L || num % 400 == 0L)) ? (num4 + _dayFromMonthLeapYear[num2]) : (num4 + _dayFromMonth[num2]));
			return num4 + num3 - 1;
		}

		internal static DatePresentation MakeDate(double day, double time)
		{
			if (!AreFinite(day, time))
			{
				return DatePresentation.NaN;
			}
			return new DatePresentation((long)(day * 86400000.0 + time), DateFlags.None);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFinite(double value)
		{
			if (!double.IsNaN(value))
			{
				return !double.IsInfinity(value);
			}
			return false;
		}

		private static bool AreFinite(double value1, double value2)
		{
			if (IsFinite(value1))
			{
				return IsFinite(value2);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFinite(DatePresentation value)
		{
			return value.IsFinite;
		}

		private static bool AreFinite(double value1, double value2, double value3)
		{
			if (IsFinite(value1) && IsFinite(value2))
			{
				return IsFinite(value3);
			}
			return false;
		}

		private static bool AreFinite(double value1, double value2, double value3, double value4)
		{
			if (IsFinite(value1) && IsFinite(value2) && IsFinite(value3))
			{
				return IsFinite(value4);
			}
			return false;
		}

		private static Date YearMonthDayFromTime(DatePresentation t)
		{
			return YearMonthDayFromDays((long)System.Math.Floor((double)(t.Value / 1000 / 60 / 60) / 24.0));
		}

		private static Date YearMonthDayFromDays(long days)
		{
			days += 146816528;
			long num = 400 * (days / 146097) - 400000;
			days %= 146097;
			days--;
			long num2 = days / 36524;
			days %= 36524;
			num += 100 * num2;
			days++;
			long num3 = days / 1461;
			days %= 1461;
			num += 4 * num3;
			days--;
			long num4 = days / 365;
			days %= 365;
			num += num4;
			bool flag = (num2 == 0L || num3 != 0L) && num4 == 0;
			days += (flag ? 1 : 0);
			int month = 0;
			int day = 0;
			if (days >= 59 + (flag ? 1 : 0))
			{
				days -= 59 + (flag ? 1 : 0);
				for (int i = 2; i < 12; i++)
				{
					if (days < kDaysInMonths[i])
					{
						month = i;
						day = (int)(days + 1);
						break;
					}
					days -= kDaysInMonths[i];
				}
			}
			else if (days < 31)
			{
				month = 0;
				day = (int)(days + 1);
			}
			else
			{
				month = 1;
				day = (int)(days - 31 + 1);
			}
			return new Date((int)num, month, day);
		}

		private static string DateString(DatePresentation tv)
		{
			string text = _dayNames[WeekDay(tv)];
			string text2 = _monthNames[MonthFromTime(tv)];
			int val = DateFromTime(tv);
			string text3 = System.Math.Max(1, val).ToString("00", CultureInfo.InvariantCulture);
			int num = YearFromTime(tv);
			string text4 = ((num < 0) ? "-" : "");
			string text5 = System.Math.Abs(num).ToString("0000", CultureInfo.InvariantCulture);
			return text + " " + text2 + " " + text3 + " " + text4 + text5;
		}

		private static string TimeString(DatePresentation t)
		{
			string text = HourFromTime(t).ToString("00", CultureInfo.InvariantCulture);
			string text2 = MinFromTime(t).ToString("00", CultureInfo.InvariantCulture);
			string text3 = SecFromTime(t).ToString("00", CultureInfo.InvariantCulture);
			return text + ":" + text2 + ":" + text3 + " GMT";
		}

		private string TimeZoneString(DatePresentation tv)
		{
			double totalMilliseconds = _timeSystem.GetUtcOffset(tv.Value).TotalMilliseconds;
			string text;
			double num;
			if (totalMilliseconds >= 0.0)
			{
				text = "+";
				num = totalMilliseconds;
			}
			else
			{
				text = "-";
				num = -1.0 * totalMilliseconds;
			}
			string text2 = MinFromTime(num).ToString("00", CultureInfo.InvariantCulture);
			string text3 = HourFromTime(num).ToString("00", CultureInfo.InvariantCulture);
			string text4 = " (" + _timeSystem.DefaultTimeZone.StandardName + ")";
			return text + text3 + text2 + text4;
		}

		public override string ToString()
		{
			return "Date.prototype";
		}
	}
	[Flags]
	internal enum DateTokenFlags : byte
	{
		None = 0,
		NonNumeric = 1,
		NonWeekday = 2,
		NonMonth = 4,
		NonTime = 8,
		NonAlphaZone = 0x10,
		NonNumericZone = 0x20,
		HasColon = 0x40,
		HasSign = 0x80
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct DateToken
	{
		public DateTokenFlags Flags { get; }

		public int Start { get; }

		public int Length { get; }

		public bool IsNumeric => (Flags & DateTokenFlags.NonNumeric) == 0;

		public bool IsWeekday => (Flags & DateTokenFlags.NonWeekday) == 0;

		public bool IsMonth => (Flags & DateTokenFlags.NonMonth) == 0;

		public bool IsTimeOfDay
		{
			get
			{
				if ((Flags & DateTokenFlags.NonTime) == 0)
				{
					return (Flags & DateTokenFlags.HasColon) != 0;
				}
				return false;
			}
		}

		public bool IsNumericZone
		{
			get
			{
				if ((Flags & DateTokenFlags.NonNumericZone) == 0)
				{
					return (Flags & DateTokenFlags.HasSign) != 0;
				}
				return false;
			}
		}

		public bool IsAlphaZone => (Flags & DateTokenFlags.NonAlphaZone) == 0;

		public bool IsTimeZone
		{
			get
			{
				if (!IsNumericZone)
				{
					return IsAlphaZone;
				}
				return true;
			}
		}

		public DateToken(DateTokenFlags flags, int start, int length)
		{
			Flags = flags;
			Start = start;
			Length = length;
		}
	}
	internal static class DateUtils
	{
		private const string MonthCharacters = "JanuaryFebruaryMarchAprilMayJuneJulyAugustSeptemberOctoberNovemberDecember";

		private const string WeekdayCharacters = "SundayMondayTuesdayWednesdayThursdayFridaySaturday";

		private const string AlphaZoneCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

		private const string NumericZoneCharacters = "+-0123456789";

		private const string NumericCharacters = "0123456789";

		private const string TimeCharacters = "0123456789:";

		private static readonly string[] Months;

		private static readonly string[] WeekDays;

		private static readonly Dictionary<string, int> timezones;

		private static readonly DateTokenFlags[] datetok;

		static DateUtils()
		{
			Months = new string[12]
			{
				"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
				"Nov", "Dec"
			};
			WeekDays = new string[7] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
			timezones = new Dictionary<string, int>(StringComparer.Ordinal)
			{
				{ "UT", 0 },
				{ "UTC", 0 },
				{ "GMT", 0 },
				{ "EDT", -400 },
				{ "EST", -500 },
				{ "CDT", -500 },
				{ "CST", -600 },
				{ "MDT", -600 },
				{ "MST", -700 },
				{ "PDT", -700 },
				{ "PST", -800 },
				{ "A", 100 },
				{ "B", 200 },
				{ "C", 300 },
				{ "D", 400 },
				{ "E", 500 },
				{ "F", 600 },
				{ "G", 700 },
				{ "H", 800 },
				{ "I", 900 },
				{ "K", 1000 },
				{ "L", 1100 },
				{ "M", 1200 },
				{ "N", -100 },
				{ "O", -200 },
				{ "P", -300 },
				{ "Q", -400 },
				{ "R", -500 },
				{ "S", -600 },
				{ "T", -700 },
				{ "U", -800 },
				{ "V", -900 },
				{ "W", -1000 },
				{ "X", -1100 },
				{ "Y", -1200 },
				{ "Z", 0 }
			};
			datetok = new DateTokenFlags[256];
			char[] array = new char[2];
			for (int i = 0; i < 256; i++)
			{
				if (i >= 65 && i <= 90)
				{
					array[1] = (char)(i + 32);
					array[0] = (char)i;
				}
				else if (i >= 97 && i <= 122)
				{
					array[0] = (char)(i - 32);
					array[1] = (char)i;
				}
				if ("+-0123456789".IndexOf((char)i) == -1)
				{
					datetok[i] |= DateTokenFlags.NonNumericZone;
				}
				if ("ABCDEFGHIJKLMNOPQRSTUVWXYZ".IndexOf((char)i) == -1)
				{
					datetok[i] |= DateTokenFlags.NonAlphaZone;
				}
				if ("SundayMondayTuesdayWednesdayThursdayFridaySaturday".IndexOfAny(array) == -1)
				{
					datetok[i] |= DateTokenFlags.NonWeekday;
				}
				if ("0123456789".IndexOf((char)i) == -1)
				{
					datetok[i] |= DateTokenFlags.NonNumeric;
				}
				if ("JanuaryFebruaryMarchAprilMayJuneJulyAugustSeptemberOctoberNovemberDecember".IndexOfAny(array) == -1)
				{
					datetok[i] |= DateTokenFlags.NonMonth;
				}
				if ("0123456789:".IndexOf((char)i) == -1)
				{
					datetok[i] |= DateTokenFlags.NonTime;
				}
			}
			datetok[58] |= DateTokenFlags.HasColon;
			datetok[43] |= DateTokenFlags.HasSign;
			datetok[45] |= DateTokenFlags.HasSign;
		}

		private static bool TryGetWeekday(in DateToken token, byte[] text, out DayOfWeek weekday)
		{
			weekday = DayOfWeek.Sunday;
			if (!token.IsWeekday || token.Length < 3)
			{
				return false;
			}
			string value = Encoding.ASCII.GetString(text, token.Start, 3);
			for (int i = 0; i < WeekDays.Length; i++)
			{
				if (WeekDays[i].Equals(value, StringComparison.OrdinalIgnoreCase))
				{
					weekday = (DayOfWeek)i;
					return true;
				}
			}
			return false;
		}

		private static bool TryGetDayOfMonth(in DateToken token, byte[] text, out int day)
		{
			int endIndex = token.Start + token.Length;
			int index = token.Start;
			day = 0;
			if (!token.IsNumeric)
			{
				return false;
			}
			if (!ParseUtils.TryParseInt32(text, ref index, endIndex, out day))
			{
				return false;
			}
			if (day <= 0 || day > 31)
			{
				return false;
			}
			return true;
		}

		private static bool TryGetMonth(in DateToken token, byte[] text, out int month)
		{
			month = 0;
			if (!token.IsMonth || token.Length < 3)
			{
				return false;
			}
			string value = Encoding.ASCII.GetString(text, token.Start, 3);
			for (int i = 0; i < Months.Length; i++)
			{
				if (Months[i].Equals(value, StringComparison.OrdinalIgnoreCase))
				{
					month = i + 1;
					return true;
				}
			}
			return false;
		}

		private static bool TryGetYear(in DateToken token, byte[] text, out int year)
		{
			int endIndex = token.Start + token.Length;
			int index = token.Start;
			year = 0;
			if (!token.IsNumeric)
			{
				return false;
			}
			if (!ParseUtils.TryParseInt32(text, ref index, endIndex, out year))
			{
				return false;
			}
			if (year < 100)
			{
				year += ((year < 70) ? 2000 : 1900);
			}
			return year >= 1969;
		}

		private static bool TryGetTimeOfDay(in DateToken token, byte[] text, out int hour, out int minute, out int second)
		{
			int num = token.Start + token.Length;
			int index = token.Start;
			hour = (minute = (second = 0));
			if (!token.IsTimeOfDay)
			{
				return false;
			}
			if (!ParseUtils.TryParseInt32(text, ref index, num, out hour) || hour > 23)
			{
				return false;
			}
			if (index >= num || text[index++] != 58)
			{
				return false;
			}
			if (!ParseUtils.TryParseInt32(text, ref index, num, out minute) || minute > 59)
			{
				return false;
			}
			if (index >= num || text[index++] != 58)
			{
				return true;
			}
			if (!ParseUtils.TryParseInt32(text, ref index, num, out second) || second > 59)
			{
				return false;
			}
			return index == num;
		}

		private static bool TryGetTimeZone(in DateToken token, byte[] text, out int tzone)
		{
			tzone = 0;
			if (token.IsNumericZone)
			{
				int num = token.Start + token.Length;
				int start = token.Start;
				int num2;
				if (text[start] == 45)
				{
					num2 = -1;
				}
				else
				{
					if (text[start] != 43)
					{
						return false;
					}
					num2 = 1;
				}
				start++;
				if (!ParseUtils.TryParseInt32(text, ref start, num, out tzone) || start != num)
				{
					return false;
				}
				tzone *= num2;
			}
			else if (token.IsAlphaZone)
			{
				if (token.Length > 3)
				{
					return false;
				}
				string key = Encoding.ASCII.GetString(text, token.Start, token.Length);
				if (!timezones.TryGetValue(key, out tzone))
				{
					return false;
				}
			}
			else if (token.IsNumeric)
			{
				int num3 = token.Start + token.Length;
				int index = token.Start;
				if (!ParseUtils.TryParseInt32(text, ref index, num3, out tzone) || index != num3)
				{
					return false;
				}
			}
			if (tzone < -1200 || tzone > 1400)
			{
				return false;
			}
			return true;
		}

		private static bool IsTokenDelimeter(byte c)
		{
			if (c != 45 && c != 47 && c != 44)
			{
				return c.IsWhitespace();
			}
			return true;
		}

		private static IEnumerable<DateToken> TokenizeDate(byte[] text, int startIndex, int length)
		{
			int endIndex = startIndex + length;
			for (int index = startIndex; index < endIndex; index++)
			{
				if (!ParseUtils.SkipCommentsAndWhiteSpace(text, ref index, endIndex, throwOnError: false))
				{
					break;
				}
				if (index >= endIndex)
				{
					break;
				}
				DateTokenFlags dateTokenFlags;
				if ((dateTokenFlags = datetok[text[index]]) != DateTokenFlags.None)
				{
					int num = index++;
					while (index < endIndex && !IsTokenDelimeter(text[index]))
					{
						dateTokenFlags |= datetok[text[index++]];
					}
					yield return new DateToken(dateTokenFlags, num, index - num);
				}
			}
		}

		private static bool TryParseStandardDateFormat(List<DateToken> tokens, byte[] text, out DateTimeOffset date)
		{
			int num = 0;
			date = default(DateTimeOffset);
			if (tokens.Count < 5)
			{
				return false;
			}
			if (TryGetWeekday(tokens[num], text, out var _))
			{
				if (tokens.Count < 6)
				{
					return false;
				}
				num++;
			}
			if (!TryGetDayOfMonth(tokens[num++], text, out var day))
			{
				return false;
			}
			if (!TryGetMonth(tokens[num++], text, out var month))
			{
				return false;
			}
			if (!TryGetYear(tokens[num++], text, out var year))
			{
				return false;
			}
			if (!TryGetTimeOfDay(tokens[num++], text, out var hour, out var minute, out var second))
			{
				return false;
			}
			if (!TryGetTimeZone(tokens[num], text, out var tzone))
			{
				tzone = 0;
			}
			int minutes = tzone % 100;
			int hours = tzone / 100;
			TimeSpan offset = new TimeSpan(hours, minutes, 0);
			try
			{
				date = new DateTimeOffset(year, month, day, hour, minute, second, offset);
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
			return true;
		}

		private static bool TryParseUnknownDateFormat(IList<DateToken> tokens, byte[] text, out DateTimeOffset date)
		{
			int? num = null;
			int? num2 = null;
			int? num3 = null;
			int? num4 = null;
			int hour = 0;
			int minute = 0;
			int second = 0;
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			for (int i = 0; i < tokens.Count; i++)
			{
				int month;
				if (!flag2 && TryGetWeekday(tokens[i], text, out var _))
				{
					flag2 = true;
				}
				else if ((!num2.HasValue || flag) && TryGetMonth(tokens[i], text, out month))
				{
					if (flag)
					{
						flag = false;
						num = num2;
					}
					num2 = month;
				}
				else if (!flag3 && TryGetTimeOfDay(tokens[i], text, out hour, out minute, out second))
				{
					flag3 = true;
				}
				else if (!num4.HasValue && tokens[i].IsTimeZone && TryGetTimeZone(tokens[i], text, out month))
				{
					num4 = month;
				}
				else
				{
					if (!tokens[i].IsNumeric)
					{
						continue;
					}
					if (tokens[i].Length == 4)
					{
						if (!num3.HasValue)
						{
							if (TryGetYear(tokens[i], text, out month))
							{
								num3 = month;
							}
						}
						else if (!num4.HasValue && TryGetTimeZone(tokens[i], text, out month))
						{
							num4 = month;
						}
					}
					else if (tokens[i].Length <= 2)
					{
						int endIndex = tokens[i].Start + tokens[i].Length;
						int index = tokens[i].Start;
						ParseUtils.TryParseInt32(text, ref index, endIndex, out month);
						if (!num2.HasValue && month > 0 && month <= 12)
						{
							flag = true;
							num2 = month;
						}
						else if (!num.HasValue && month > 0 && month <= 31)
						{
							num = month;
						}
						else if (!num3.HasValue && month >= 69)
						{
							num3 = 1900 + month;
						}
					}
				}
			}
			if (!num3.HasValue || !num2.HasValue || !num.HasValue)
			{
				date = default(DateTimeOffset);
				return false;
			}
			if (!flag3)
			{
				hour = (minute = (second = 0));
			}
			TimeSpan offset;
			if (num4.HasValue)
			{
				int minutes = num4.Value % 100;
				int hours = num4.Value / 100;
				offset = new TimeSpan(hours, minutes, 0);
			}
			else
			{
				offset = new TimeSpan(0L);
			}
			try
			{
				date = new DateTimeOffset(num3.Value, num2.Value, num.Value, hour, minute, second, offset);
			}
			catch (ArgumentOutOfRangeException)
			{
				date = default(DateTimeOffset);
				return false;
			}
			return true;
		}

		public static bool TryParse(byte[] buffer, int startIndex, int length, out DateTimeOffset date)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (startIndex < 0 || startIndex > buffer.Length)
			{
				throw new ArgumentOutOfRangeException("startIndex");
			}
			if (length < 0 || length > buffer.Length - startIndex)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			List<DateToken> tokens = new List<DateToken>(TokenizeDate(buffer, startIndex, length));
			if (TryParseStandardDateFormat(tokens, buffer, out date))
			{
				return true;
			}
			if (TryParseUnknownDateFormat(tokens, buffer, out date))
			{
				return true;
			}
			date = default(DateTimeOffset);
			return false;
		}

		public static bool TryParse(string text, out DateTimeOffset date)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			byte[] bytes = Encoding.UTF8.GetBytes(text);
			return TryParse(bytes, 0, bytes.Length, out date);
		}
	}
	internal static class ParseUtils
	{
		public static bool TryParseInt32(byte[] text, ref int index, int endIndex, out int value)
		{
			int num = index;
			value = 0;
			while (index < endIndex && text[index] >= 48 && text[index] <= 57)
			{
				int num2 = text[index] - 48;
				if (value > 214748364)
				{
					return false;
				}
				if (value == 214748364 && num2 > 7)
				{
					return false;
				}
				value = value * 10 + num2;
				index++;
			}
			return index > num;
		}

		public static bool SkipWhiteSpace(byte[] text, ref int index, int endIndex)
		{
			int num = index;
			while (index < endIndex && text[index].IsWhitespace())
			{
				index++;
			}
			return index > num;
		}

		public static bool SkipComment(byte[] text, ref int index, int endIndex)
		{
			bool flag = false;
			int num = 1;
			index++;
			while (index < endIndex && num > 0)
			{
				if (text[index] == 92)
				{
					flag = !flag;
				}
				else if (!flag)
				{
					if (text[index] == 40)
					{
						num++;
					}
					else if (text[index] == 41)
					{
						num--;
					}
					flag = false;
				}
				else
				{
					flag = false;
				}
				index++;
			}
			return num == 0;
		}

		public static bool SkipCommentsAndWhiteSpace(byte[] text, ref int index, int endIndex, bool throwOnError)
		{
			SkipWhiteSpace(text, ref index, endIndex);
			while (index < endIndex && text[index] == 40)
			{
				int value = index;
				if (!SkipComment(text, ref index, endIndex))
				{
					if (throwOnError)
					{
						throw new ArgumentException($"Incomplete comment token at offset {value}");
					}
					return false;
				}
				SkipWhiteSpace(text, ref index, endIndex);
			}
			return true;
		}
	}
	[Flags]
	internal enum CharType : ushort
	{
		None = 0,
		IsAscii = 1,
		IsAtom = 2,
		IsAttrChar = 4,
		IsBlank = 8,
		IsControl = 0x10,
		IsDomainSafe = 0x20,
		IsEncodedPhraseSafe = 0x40,
		IsEncodedWordSafe = 0x80,
		IsQuotedPrintableSafe = 0x100,
		IsSpace = 0x200,
		IsSpecial = 0x400,
		IsTokenSpecial = 0x800,
		IsWhitespace = 0x1000,
		IsXDigit = 0x2000,
		IsPhraseAtom = 0x4000
	}
	internal static class ByteExtensions
	{
		private const string AtomSafeCharacters = "!#$%&'*+-/=?^_`{|}~";

		private const string AttributeSpecials = "*'%";

		private const string DomainSpecials = "[]\\\r \t";

		private const string EncodedWordSpecials = "()<>@,;:\"/[]?.=_";

		private const string EncodedPhraseSpecials = "!*+-/=_";

		private const string Specials = "()<>[]:;@\\,.\"";

		private const string TokenSpecials = "()<>@,;:\\\"/[]?=";

		private const string Whitespace = " \t\r\n";

		private static readonly CharType[] table;

		private static void RemoveFlags(string values, CharType bit)
		{
			for (int i = 0; i < values.Length; i++)
			{
				table[(byte)values[i]] &= (CharType)(ushort)(~(int)bit);
			}
		}

		private static void SetFlags(string values, CharType bit, CharType bitcopy, bool remove)
		{
			if (remove)
			{
				for (int i = 0; i < 128; i++)
				{
					table[i] |= bit;
				}
				for (int i = 0; i < values.Length; i++)
				{
					table[(uint)values[i]] &= (CharType)(ushort)(~(int)bit);
				}
				return;
			}
			for (int i = 0; i < values.Length; i++)
			{
				table[(uint)values[i]] |= bit;
			}
			if (bitcopy == CharType.None)
			{
				return;
			}
			for (int i = 0; i < 256; i++)
			{
				if ((table[i] & bitcopy) != CharType.None)
				{
					table[i] |= bit;
				}
			}
		}

		static ByteExtensions()
		{
			table = new CharType[256];
			for (int i = 0; i < 256; i++)
			{
				if (i < 127)
				{
					if (i < 32)
					{
						table[i] |= CharType.IsControl;
					}
					if (i > 32)
					{
						table[i] |= CharType.IsAttrChar;
					}
					if ((i >= 33 && i <= 60) || (i >= 62 && i <= 126) || i == 32)
					{
						table[i] |= CharType.IsEncodedWordSafe | CharType.IsQuotedPrintableSafe;
					}
					if ((i >= 48 && i <= 57) || (i >= 97 && i <= 122) || (i >= 65 && i <= 90))
					{
						table[i] |= CharType.IsAtom | CharType.IsEncodedPhraseSafe | CharType.IsPhraseAtom;
					}
					if ((i >= 48 && i <= 57) || (i >= 97 && i <= 102) || (i >= 65 && i <= 70))
					{
						table[i] |= CharType.IsXDigit;
					}
					table[i] |= CharType.IsAscii;
				}
				else
				{
					if (i == 127)
					{
						table[i] |= CharType.IsAscii;
					}
					else
					{
						table[i] |= CharType.IsAtom | CharType.IsPhraseAtom;
					}
					table[i] |= CharType.IsControl;
				}
			}
			table[9] |= CharType.IsBlank | CharType.IsQuotedPrintableSafe;
			table[32] |= CharType.IsBlank | CharType.IsSpace;
			SetFlags(" \t\r\n", CharType.IsWhitespace, CharType.None, remove: false);
			SetFlags("!#$%&'*+-/=?^_`{|}~", CharType.IsAtom | CharType.IsPhraseAtom, CharType.None, remove: false);
			SetFlags("()<>@,;:\\\"/[]?=", CharType.IsTokenSpecial, CharType.IsControl, remove: false);
			SetFlags("()<>[]:;@\\,.\"", CharType.IsSpecial, CharType.None, remove: false);
			SetFlags("[]\\\r \t", CharType.IsDomainSafe, CharType.None, remove: true);
			RemoveFlags("()<>[]:;@\\,.\"", CharType.IsAtom | CharType.IsPhraseAtom);
			RemoveFlags("()<>@,;:\"/[]?.=_", CharType.IsEncodedWordSafe);
			RemoveFlags("*'%()<>@,;:\\\"/[]?=", CharType.IsAttrChar);
			SetFlags("!*+-/=_", CharType.IsEncodedPhraseSafe, CharType.None, remove: false);
			table[91] |= CharType.IsPhraseAtom;
			table[93] |= CharType.IsPhraseAtom;
		}

		public static bool IsWhitespace(this byte c)
		{
			return (table[c] & CharType.IsWhitespace) != 0;
		}
	}
}
namespace Jint.Native.DataView
{
	internal sealed class DataViewConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("DataView");

		private DataViewPrototype PrototypeObject { get; }

		internal DataViewConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new DataViewPrototype(engine, this, objectPrototype);
			_length = new PropertyDescriptor(1, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsArrayBuffer jsArrayBuffer = arguments.At(0) as JsArrayBuffer;
			JsValue value = arguments.At(1);
			JsValue value2 = arguments.At(2);
			if ((object)jsArrayBuffer == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "First argument to DataView constructor must be an ArrayBuffer");
			}
			uint num = TypeConverter.ToIndex(_realm, value);
			if (jsArrayBuffer.IsDetachedBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			uint arrayBufferByteLength = (uint)jsArrayBuffer.ArrayBufferByteLength;
			if (num > arrayBufferByteLength)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Start offset " + num + " is outside the bounds of the buffer");
			}
			bool isFixedLengthArrayBuffer = jsArrayBuffer.IsFixedLengthArrayBuffer;
			uint num2;
			if (value2.IsUndefined())
			{
				num2 = ((!isFixedLengthArrayBuffer) ? uint.MaxValue : (arrayBufferByteLength - num));
			}
			else
			{
				num2 = TypeConverter.ToIndex(_realm, value2);
				if (num + num2 > arrayBufferByteLength)
				{
					ExceptionHelper.ThrowRangeError(_realm, "Invalid DataView length");
				}
			}
			JsDataView jsDataView = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.DataView.PrototypeObject, (Engine engine, Realm _, object? _) => new JsDataView(engine));
			if (jsArrayBuffer.IsDetachedBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			arrayBufferByteLength = (uint)jsArrayBuffer.ArrayBufferByteLength;
			if (num > arrayBufferByteLength)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid DataView offset");
			}
			if (!value2.IsUndefined() && num + num2 > arrayBufferByteLength)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid DataView length");
			}
			jsDataView._viewedArrayBuffer = jsArrayBuffer;
			jsDataView._byteLength = num2;
			jsDataView._byteOffset = num;
			return jsDataView;
		}
	}
	internal sealed class DataViewPrototype : Prototype
	{
		internal readonly record struct DataViewWithBufferWitnessRecord(JsDataView Object, int CachedBufferByteLength)
		{
			public bool IsViewOutOfBounds
			{
				get
				{
					JsDataView jsDataView = Object;
					int cachedBufferByteLength = CachedBufferByteLength;
					if (cachedBufferByteLength == -1)
					{
						return true;
					}
					uint byteOffset = jsDataView._byteOffset;
					long num = ((jsDataView._byteLength != uint.MaxValue) ? ((long)(byteOffset + jsDataView._byteLength)) : ((long)cachedBufferByteLength));
					if (byteOffset > cachedBufferByteLength || num > cachedBufferByteLength)
					{
						return true;
					}
					return false;
				}
			}

			public long ViewByteLength
			{
				get
				{
					JsDataView jsDataView = Object;
					if (jsDataView._byteLength != uint.MaxValue)
					{
						return jsDataView._byteLength;
					}
					uint byteOffset = jsDataView._byteOffset;
					return CachedBufferByteLength - byteOffset;
				}
			}
		}

		private readonly DataViewConstructor _constructor;

		internal DataViewPrototype(Engine engine, DataViewConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, engine.Realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(24, checkExistingKeys: false)
			{
				["buffer"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get buffer", Buffer, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["byteLength"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get byteLength", ByteLength, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["byteOffset"] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get byteOffset", ByteOffset, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["getBigInt64"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getBigInt64", GetBigInt64, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getBigUint64"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getBigUint64", GetBigUint64, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getFloat32"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getFloat32", GetFloat32, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getFloat64"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getFloat64", GetFloat64, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getInt8"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getInt8", GetInt8, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getInt16"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getInt16", GetInt16, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getInt32"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getInt32", GetInt32, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUint8"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUint8", GetUint8, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUint16"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUint16", GetUint16, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["getUint32"] = new PropertyDescriptor(new ClrFunction(base.Engine, "getUint32", GetUint32, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setBigInt64"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setBigInt64", SetBigInt64, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setBigUint64"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setBigUint64", SetBigUint64, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setFloat32"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setFloat32", SetFloat32, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setFloat64"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setFloat64", SetFloat64, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setInt8"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setInt8", SetInt8, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setInt16"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setInt16", SetInt16, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setInt32"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setInt32", SetInt32, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUint8"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUint8", SetUint8, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUint16"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUint16", SetUint16, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["setUint32"] = new PropertyDescriptor(new ClrFunction(base.Engine, "setUint32", SetUint32, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("DataView", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Buffer(JsValue thisObject, JsValue[] arguments)
		{
			JsDataView obj = thisObject as JsDataView;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method get DataView.prototype.buffer called on incompatible receiver " + thisObject);
			}
			return obj._viewedArrayBuffer;
		}

		private JsValue ByteLength(JsValue thisObject, JsValue[] arguments)
		{
			JsDataView obj = thisObject as JsDataView;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method get DataView.prototype.byteLength called on incompatible receiver " + thisObject);
			}
			DataViewWithBufferWitnessRecord dataViewWithBufferWitnessRecord = MakeDataViewWithBufferWitnessRecord(obj, ArrayBufferOrder.SeqCst);
			if (dataViewWithBufferWitnessRecord.IsViewOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Offset is outside the bounds of the DataView");
			}
			obj._viewedArrayBuffer.AssertNotDetached();
			return JsNumber.Create(dataViewWithBufferWitnessRecord.ViewByteLength);
		}

		private JsValue ByteOffset(JsValue thisObject, JsValue[] arguments)
		{
			JsDataView obj = thisObject as JsDataView;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method get DataView.prototype.byteOffset called on incompatible receiver " + thisObject);
			}
			if (MakeDataViewWithBufferWitnessRecord(obj, ArrayBufferOrder.SeqCst).IsViewOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Offset is outside the bounds of the DataView");
			}
			obj._viewedArrayBuffer.AssertNotDetached();
			return JsNumber.Create(obj._byteOffset);
		}

		private JsValue GetBigInt64(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1), TypedArrayElementType.BigInt64);
		}

		private JsValue GetBigUint64(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1), TypedArrayElementType.BigUint64);
		}

		private JsValue GetFloat32(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1, JsBoolean.False), TypedArrayElementType.Float32);
		}

		private JsValue GetFloat64(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1, JsBoolean.False), TypedArrayElementType.Float64);
		}

		private JsValue GetInt8(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), JsBoolean.True, TypedArrayElementType.Int8);
		}

		private JsValue GetInt16(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1, JsBoolean.False), TypedArrayElementType.Int16);
		}

		private JsValue GetInt32(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1, JsBoolean.False), TypedArrayElementType.Int32);
		}

		private JsValue GetUint8(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), JsBoolean.True, TypedArrayElementType.Uint8);
		}

		private JsValue GetUint16(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1, JsBoolean.False), TypedArrayElementType.Uint16);
		}

		private JsValue GetUint32(JsValue thisObject, JsValue[] arguments)
		{
			return GetViewValue(thisObject, arguments.At(0), arguments.At(1, JsBoolean.False), TypedArrayElementType.Uint32);
		}

		private JsValue SetBigInt64(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2), TypedArrayElementType.BigInt64, arguments.At(1));
		}

		private JsValue SetBigUint64(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2), TypedArrayElementType.BigUint64, arguments.At(1));
		}

		private JsValue SetFloat32(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2, JsBoolean.False), TypedArrayElementType.Float32, arguments.At(1));
		}

		private JsValue SetFloat64(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2, JsBoolean.False), TypedArrayElementType.Float64, arguments.At(1));
		}

		private JsValue SetInt8(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), JsBoolean.True, TypedArrayElementType.Int8, arguments.At(1));
		}

		private JsValue SetInt16(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2, JsBoolean.False), TypedArrayElementType.Int16, arguments.At(1));
		}

		private JsValue SetInt32(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2, JsBoolean.False), TypedArrayElementType.Int32, arguments.At(1));
		}

		private JsValue SetUint8(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), JsBoolean.True, TypedArrayElementType.Uint8, arguments.At(1));
		}

		private JsValue SetUint16(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2, JsBoolean.False), TypedArrayElementType.Uint16, arguments.At(1));
		}

		private JsValue SetUint32(JsValue thisObject, JsValue[] arguments)
		{
			return SetViewValue(thisObject, arguments.At(0), arguments.At(2, JsBoolean.False), TypedArrayElementType.Uint32, arguments.At(1));
		}

		private JsValue GetViewValue(JsValue view, JsValue requestIndex, JsValue isLittleEndian, TypedArrayElementType type)
		{
			if (!(view is JsDataView jsDataView))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method called on incompatible receiver " + view);
				return JsValue.Undefined;
			}
			uint num = TypeConverter.ToIndex(_realm, requestIndex);
			bool value = TypeConverter.ToBoolean(isLittleEndian);
			JsArrayBuffer viewedArrayBuffer = jsDataView._viewedArrayBuffer;
			viewedArrayBuffer.AssertNotDetached();
			uint byteOffset = jsDataView._byteOffset;
			DataViewWithBufferWitnessRecord dataViewWithBufferWitnessRecord = MakeDataViewWithBufferWitnessRecord(jsDataView, ArrayBufferOrder.Unordered);
			if (dataViewWithBufferWitnessRecord.IsViewOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Offset is outside the bounds of the DataView");
			}
			long viewByteLength = dataViewWithBufferWitnessRecord.ViewByteLength;
			byte elementSize = type.GetElementSize();
			if ((int)(num + elementSize) > viewByteLength)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Offset is outside the bounds of the DataView");
			}
			int byteIndex = (int)((int)num + byteOffset);
			return viewedArrayBuffer.GetValueFromBuffer(byteIndex, type, isTypedArray: false, ArrayBufferOrder.Unordered, value).ToJsValue();
		}

		private static DataViewWithBufferWitnessRecord MakeDataViewWithBufferWitnessRecord(JsDataView obj, ArrayBufferOrder order)
		{
			JsArrayBuffer viewedArrayBuffer = obj._viewedArrayBuffer;
			int cachedBufferByteLength = (((object)viewedArrayBuffer == null || !viewedArrayBuffer.IsDetachedBuffer) ? IntrinsicTypedArrayPrototype.ArrayBufferByteLength(viewedArrayBuffer, order) : (-1));
			return new DataViewWithBufferWitnessRecord(obj, cachedBufferByteLength);
		}

		private JsValue SetViewValue(JsValue view, JsValue requestIndex, JsValue isLittleEndian, TypedArrayElementType type, JsValue value)
		{
			JsDataView obj = view as JsDataView;
			if ((object)obj == null)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method called on incompatible receiver " + view);
			}
			uint num = TypeConverter.ToIndex(_realm, requestIndex);
			TypedArrayValue value2 = ((!type.IsBigIntElementType()) ? ((TypedArrayValue)TypeConverter.ToNumber(value)) : ((TypedArrayValue)TypeConverter.ToBigInt(value)));
			bool value3 = TypeConverter.ToBoolean(isLittleEndian);
			JsArrayBuffer viewedArrayBuffer = obj._viewedArrayBuffer;
			viewedArrayBuffer.AssertNotDetached();
			uint byteOffset = obj._byteOffset;
			DataViewWithBufferWitnessRecord dataViewWithBufferWitnessRecord = MakeDataViewWithBufferWitnessRecord(obj, ArrayBufferOrder.Unordered);
			if (dataViewWithBufferWitnessRecord.IsViewOutOfBounds)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Offset is outside the bounds of the DataView");
			}
			long viewByteLength = dataViewWithBufferWitnessRecord.ViewByteLength;
			byte elementSize = type.GetElementSize();
			if (num + elementSize > viewByteLength)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Offset is outside the bounds of the DataView");
			}
			int byteIndex = (int)(num + byteOffset);
			viewedArrayBuffer.SetValueInBuffer(byteIndex, type, value2, isTypedArray: false, ArrayBufferOrder.Unordered, value3);
			return JsValue.Undefined;
		}
	}
}
namespace Jint.Native.Boolean
{
	internal sealed class BooleanConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("Boolean");

		public BooleanPrototype PrototypeObject { get; }

		internal BooleanConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new BooleanPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			if (arguments.Length == 0)
			{
				return false;
			}
			return TypeConverter.ToBoolean(arguments[0]);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsBoolean jsBoolean = (TypeConverter.ToBoolean(arguments.At(0)) ? JsBoolean.True : JsBoolean.False);
			if (newTarget.IsUndefined())
			{
				return Construct(jsBoolean);
			}
			return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Boolean.PrototypeObject, (Engine engine, Realm realm, JsBoolean? state) => new BooleanInstance(engine, state), jsBoolean);
		}

		public BooleanInstance Construct(JsBoolean value)
		{
			return new BooleanInstance(base.Engine, value)
			{
				_prototype = PrototypeObject
			};
		}
	}
	internal class BooleanInstance : ObjectInstance, IJsPrimitive
	{
		Types IJsPrimitive.Type => Types.Boolean;

		JsValue IJsPrimitive.PrimitiveValue => BooleanData;

		public JsBoolean BooleanData { get; }

		public BooleanInstance(Engine engine, JsBoolean value)
			: base(engine, ObjectClass.Boolean)
		{
			BooleanData = value;
		}
	}
	internal sealed class BooleanPrototype : BooleanInstance
	{
		private readonly Realm _realm;

		private readonly BooleanConstructor _constructor;

		internal BooleanPrototype(Engine engine, Realm realm, BooleanConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, JsBoolean.False)
		{
			_prototype = objectPrototype;
			_realm = realm;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(3, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToBooleanString, 0, PropertyFlag.Configurable), true, false, true),
				["valueOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
		}

		private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject._type == InternalTypes.Boolean)
			{
				return thisObject;
			}
			if (thisObject is BooleanInstance booleanInstance)
			{
				return booleanInstance.BooleanData;
			}
			ExceptionHelper.ThrowTypeError(_realm);
			return JsValue.Undefined;
		}

		private JsString ToBooleanString(JsValue thisObject, JsValue[] arguments)
		{
			if (!((JsBoolean)ValueOf(thisObject, Arguments.Empty))._value)
			{
				return JsString.FalseString;
			}
			return JsString.TrueString;
		}
	}
}
namespace Jint.Native.BigInt
{
	internal sealed class BigIntConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("BigInt");

		public BigIntPrototype PrototypeObject { get; }

		public BigIntConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new BigIntPrototype(engine, this, objectPrototype);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(2, checkExistingKeys: false)
			{
				["asIntN"] = new PropertyDescriptor(new ClrFunction(base.Engine, "asIntN", AsIntN, 2, PropertyFlag.Configurable), true, false, true),
				["asUintN"] = new PropertyDescriptor(new ClrFunction(base.Engine, "asUintN", AsUintN, 2, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
		}

		private JsValue AsIntN(JsValue thisObject, JsValue[] arguments)
		{
			int num = (int)TypeConverter.ToIndex(_realm, arguments.At(0));
			BigInteger bigInteger = TypeConverter.BigIntegerModulo(arguments.At(1).ToBigInteger(_engine), BigInteger.Pow(2, num));
			if (num > 0 && bigInteger >= BigInteger.Pow(2, num - 1))
			{
				return bigInteger - BigInteger.Pow(2, num);
			}
			return bigInteger;
		}

		private JsValue AsUintN(JsValue thisObject, JsValue[] arguments)
		{
			int exponent = (int)TypeConverter.ToIndex(_realm, arguments.At(0));
			return TypeConverter.BigIntegerModulo(arguments.At(1).ToBigInteger(_engine), BigInteger.Pow(2, exponent));
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			if (arguments.Length == 0)
			{
				return JsBigInt.Zero;
			}
			JsValue jsValue = TypeConverter.ToPrimitive(arguments.At(0), Types.Number);
			if (jsValue.IsNumber())
			{
				return NumberToBigInt((JsNumber)jsValue);
			}
			return jsValue.ToBigInteger(_engine);
		}

		private JsBigInt NumberToBigInt(JsNumber value)
		{
			if (TypeConverter.IsIntegralNumber(value._value))
			{
				return JsBigInt.Create((long)value._value);
			}
			ExceptionHelper.ThrowRangeError(_realm, "The number " + value?.ToString() + " cannot be converted to a BigInt because it is not an integer");
			return null;
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsBigInt jsBigInt = ((arguments.Length != 0) ? JsBigInt.Create(arguments[0].ToBigInteger(_engine)) : JsBigInt.Zero);
			if (newTarget.IsUndefined())
			{
				return Construct(jsBigInt);
			}
			return OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.BigInt.PrototypeObject, (Engine engine, Realm realm, JsBigInt? state) => new BigIntInstance(engine, state), jsBigInt);
		}

		public BigIntInstance Construct(JsBigInt value)
		{
			return new BigIntInstance(base.Engine, value)
			{
				_prototype = PrototypeObject
			};
		}
	}
	internal sealed class BigIntInstance : ObjectInstance, IJsPrimitive
	{
		Types IJsPrimitive.Type => Types.BigInt;

		JsValue IJsPrimitive.PrimitiveValue => BigIntData;

		public JsBigInt BigIntData { get; }

		public BigIntInstance(Engine engine, JsBigInt value)
			: base(engine, ObjectClass.Object, InternalTypes.Object)
		{
			BigIntData = value;
		}
	}
	internal sealed class BigIntPrototype : Prototype
	{
		private readonly BigIntConstructor _constructor;

		internal BigIntPrototype(Engine engine, BigIntConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, engine.Realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(4, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, true, false, true),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToBigIntString, 0, PropertyFlag.Configurable), true, false, true),
				["toLocaleString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleString", ToLocaleString, 0, PropertyFlag.Configurable), true, false, true),
				["valueOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "valueOf", ValueOf, 0, PropertyFlag.Configurable), true, false, true)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("BigInt", false, false, true);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
		{
			arguments.At(0);
			arguments.At(1);
			return ThisBigIntValue(thisObject)._value.ToString("R", CultureInfo.InvariantCulture);
		}

		private JsValue ValueOf(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is BigIntInstance bigIntInstance)
			{
				return bigIntInstance.BigIntData;
			}
			if (thisObject is JsBigInt)
			{
				return thisObject;
			}
			ExceptionHelper.ThrowTypeError(_realm);
			return null;
		}

		private JsValue ToBigIntString(JsValue thisObject, JsValue[] arguments)
		{
			JsBigInt jsBigInt = ThisBigIntValue(thisObject);
			JsValue jsValue = arguments.At(0);
			int num = (jsValue.IsUndefined() ? 10 : ((int)TypeConverter.ToIntegerOrInfinity(jsValue)));
			if ((num < 2 || num > 36) ? true : false)
			{
				ExceptionHelper.ThrowRangeError(_realm, "radix must be between 2 and 36");
			}
			BigInteger bigInteger = jsBigInt._value;
			if (bigInteger == BigInteger.Zero)
			{
				return JsString.NumberZeroString;
			}
			if (num == 10)
			{
				return bigInteger.ToString("R", CultureInfo.InvariantCulture);
			}
			bool flag = bigInteger < 0L;
			if (flag)
			{
				bigInteger = -bigInteger;
			}
			Span<char> initialBuffer = stackalloc char[64];
			System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer);
			for (; bigInteger > 0L; bigInteger /= (BigInteger)num)
			{
				int index = (int)(bigInteger % num);
				valueStringBuilder.Append("0123456789abcdefghijklmnopqrstuvwxyz"[index]);
			}
			if (flag)
			{
				valueStringBuilder.Append('-');
			}
			valueStringBuilder.Reverse();
			return valueStringBuilder.ToString();
		}

		private JsBigInt ThisBigIntValue(JsValue value)
		{
			if (!(value is JsBigInt result))
			{
				if (value is BigIntInstance bigIntInstance)
				{
					return bigIntInstance.BigIntData;
				}
				ExceptionHelper.ThrowTypeError(_realm);
				return null;
			}
			return result;
		}
	}
}
namespace Jint.Native.AsyncFunction
{
	internal sealed class AsyncFunctionConstructor : Constructor
	{
		private static readonly JsString _functionName = new JsString("AsyncFunction");

		public AsyncFunctionPrototype PrototypeObject { get; }

		public AsyncFunctionConstructor(Engine engine, Realm realm, FunctionConstructor functionConstructor)
			: base(engine, realm, _functionName)
		{
			PrototypeObject = new AsyncFunctionPrototype(engine, realm, this, functionConstructor.PrototypeObject);
			_prototype = functionConstructor;
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
			_length = new PropertyDescriptor(JsNumber.PositiveOne, PropertyFlag.Configurable);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, thisObject);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			return CreateDynamicFunction(this, newTarget, FunctionKind.Async, arguments);
		}
	}
	internal sealed class AsyncFunctionPrototype : Prototype
	{
		private readonly AsyncFunctionConstructor _constructor;

		public AsyncFunctionPrototype(Engine engine, Realm realm, AsyncFunctionConstructor constructor, FunctionPrototype objectPrototype)
			: base(engine, realm)
		{
			_constructor = constructor;
			_prototype = objectPrototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { [KnownKeys.Constructor] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("AsyncFunction", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}
	}
}
namespace Jint.Native.ArrayBuffer
{
	public sealed class ArrayBufferConstructor : Constructor
	{
		private readonly record struct ConstructState(byte[]? Block, ulong ByteLength, uint? MaxByteLength);

		private static readonly JsString _functionName = new JsString("ArrayBuffer");

		private ArrayBufferPrototype PrototypeObject { get; }

		internal ArrayBufferConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new ArrayBufferPrototype(engine, this, objectPrototype);
			_length = new PropertyDescriptor(1, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { ["isView"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "isView", IsView, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get [Symbol.species]", Species, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		public JsArrayBuffer Construct(byte[] data)
		{
			return CreateJsArrayBuffer(this, data, (ulong)data.Length, null);
		}

		public JsArrayBuffer Construct(ulong byteLength, uint? maxByteLength = null)
		{
			return AllocateArrayBuffer(this, byteLength, maxByteLength);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsValue value = arguments.At(0);
			JsValue options = arguments.At(1);
			uint num = TypeConverter.ToIndex(_realm, value);
			uint? arrayBufferMaxByteLengthOption = options.GetArrayBufferMaxByteLengthOption();
			return AllocateArrayBuffer(newTarget, num, arrayBufferMaxByteLengthOption);
		}

		private static JsValue Species(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject;
		}

		private static JsValue IsView(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			bool flag = ((jsValue is JsDataView || jsValue is JsTypedArray) ? true : false);
			return flag;
		}

		internal JsArrayBuffer AllocateArrayBuffer(JsValue constructor, ulong byteLength, uint? maxByteLength = null)
		{
			if (maxByteLength.HasValue && byteLength > maxByteLength)
			{
				ExceptionHelper.ThrowRangeError(_realm);
			}
			return CreateJsArrayBuffer(constructor, null, byteLength, maxByteLength);
		}

		private JsArrayBuffer CreateJsArrayBuffer(JsValue constructor, byte[]? block, ulong byteLength, uint? maxByteLength)
		{
			return OrdinaryCreateFromConstructor(constructor, (Intrinsics intrinsics) => intrinsics.ArrayBuffer.PrototypeObject, (Engine engine, Realm _, ConstructState state) => new JsArrayBuffer(engine, System.Array.Empty<byte>(), state.MaxByteLength)
			{
				_arrayBufferData = (state.Block ?? ((state.ByteLength != 0) ? JsArrayBuffer.CreateByteDataBlock(engine.Realm, state.ByteLength) : System.Array.Empty<byte>()))
			}, new ConstructState(block, byteLength, maxByteLength));
		}
	}
	internal enum ArrayBufferOrder
	{
		Init,
		SeqCst,
		Unordered
	}
	internal sealed class ArrayBufferPrototype : Prototype
	{
		private enum PreserveResizability
		{
			PreserveResizability,
			FixedLength
		}

		private readonly ArrayBufferConstructor _constructor;

		internal ArrayBufferPrototype(Engine engine, ArrayBufferConstructor constructor, ObjectPrototype objectPrototype)
			: base(engine, engine.Realm)
		{
			_prototype = objectPrototype;
			_constructor = constructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(4, checkExistingKeys: false)
			{
				["byteLength"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get byteLength", ByteLength, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				[KnownKeys.Constructor] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["detached"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get detached", Detached, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["maxByteLength"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get maxByteLength", MaxByteLength, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["resizable"] = new GetSetPropertyDescriptor(new ClrFunction(_engine, "get resizable", Resizable, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable),
				["resize"] = new PropertyDescriptor(new ClrFunction(_engine, "resize", Resize, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["slice"] = new PropertyDescriptor(new ClrFunction(_engine, "slice", Slice, 2, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["transfer"] = new PropertyDescriptor(new ClrFunction(_engine, "transfer", Transfer, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable),
				["transferToFixedLength"] = new PropertyDescriptor(new ClrFunction(_engine, "transferToFixedLength", TransferToFixedLength, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable)
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("ArrayBuffer", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue Detached(JsValue thisObject, JsValue[] arguments)
		{
			JsArrayBuffer jsArrayBuffer = thisObject as JsArrayBuffer;
			if ((object)jsArrayBuffer == null || jsArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method ArrayBuffer.prototype.detached called on incompatible receiver " + thisObject);
			}
			return jsArrayBuffer.IsDetachedBuffer;
		}

		private JsValue MaxByteLength(JsValue thisObject, JsValue[] arguments)
		{
			JsArrayBuffer jsArrayBuffer = thisObject as JsArrayBuffer;
			if ((object)jsArrayBuffer == null || jsArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method ArrayBuffer.prototype.maxByteLength called on incompatible receiver " + thisObject);
			}
			if (jsArrayBuffer.IsDetachedBuffer)
			{
				return JsNumber.PositiveZero;
			}
			return (long)(jsArrayBuffer.IsFixedLengthArrayBuffer ? jsArrayBuffer.ArrayBufferByteLength : jsArrayBuffer._arrayBufferMaxByteLength.GetValueOrDefault());
		}

		private JsValue Resizable(JsValue thisObject, JsValue[] arguments)
		{
			JsArrayBuffer jsArrayBuffer = thisObject as JsArrayBuffer;
			if ((object)jsArrayBuffer == null || jsArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method ArrayBuffer.prototype.resizable called on incompatible receiver " + thisObject);
			}
			return !jsArrayBuffer.IsFixedLengthArrayBuffer;
		}

		private JsValue Resize(JsValue thisObject, JsValue[] arguments)
		{
			JsArrayBuffer jsArrayBuffer = thisObject as JsArrayBuffer;
			if ((object)jsArrayBuffer == null || jsArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method ArrayBuffer.prototype.resize called on incompatible receiver " + thisObject);
			}
			JsValue value = arguments.At(0);
			uint newByteLength = TypeConverter.ToIndex(_realm, value);
			jsArrayBuffer.AssertNotDetached();
			jsArrayBuffer.Resize(newByteLength);
			return JsValue.Undefined;
		}

		private JsValue ByteLength(JsValue thisObject, JsValue[] arguments)
		{
			JsArrayBuffer jsArrayBuffer = thisObject as JsArrayBuffer;
			if ((object)jsArrayBuffer == null || jsArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method ArrayBuffer.prototype.byteLength called on incompatible receiver " + thisObject);
			}
			if (jsArrayBuffer.IsDetachedBuffer)
			{
				return JsNumber.PositiveZero;
			}
			return JsNumber.Create(jsArrayBuffer.ArrayBufferByteLength);
		}

		private JsValue Slice(JsValue thisObject, JsValue[] arguments)
		{
			JsArrayBuffer jsArrayBuffer = thisObject as JsArrayBuffer;
			if ((object)jsArrayBuffer == null || jsArrayBuffer.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method ArrayBuffer.prototype.slice called on incompatible receiver " + thisObject);
			}
			jsArrayBuffer.AssertNotDetached();
			JsValue argument = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			int arrayBufferByteLength = jsArrayBuffer.ArrayBufferByteLength;
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			int num2 = ((num != double.NegativeInfinity) ? ((!(num < 0.0)) ? ((int)System.Math.Min(num, arrayBufferByteLength)) : ((int)System.Math.Max((double)arrayBufferByteLength + num, 0.0))) : 0);
			int num3 = num2;
			double num4 = ((!jsValue.IsUndefined()) ? TypeConverter.ToIntegerOrInfinity(jsValue) : ((double)arrayBufferByteLength));
			num2 = ((num4 != double.NegativeInfinity) ? ((!(num4 < 0.0)) ? ((int)System.Math.Min(num4, arrayBufferByteLength)) : ((int)System.Math.Max((double)arrayBufferByteLength + num4, 0.0))) : 0);
			int num5 = System.Math.Max(num2 - num3, 0);
			JsArrayBuffer jsArrayBuffer2 = ObjectInstance.Construct(ObjectInstance.SpeciesConstructor(jsArrayBuffer, _realm.Intrinsics.ArrayBuffer), new JsValue[1] { JsNumber.Create(num5) }) as JsArrayBuffer;
			if ((object)jsArrayBuffer2 == null)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (jsArrayBuffer2.IsSharedArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (jsArrayBuffer2.IsDetachedBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if ((object)jsArrayBuffer2 == jsArrayBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (jsArrayBuffer2.ArrayBufferByteLength < num5)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			if (jsArrayBuffer2.IsDetachedBuffer)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			byte[]? arrayBufferData = jsArrayBuffer.ArrayBufferData;
			byte[] arrayBufferData2 = jsArrayBuffer2.ArrayBufferData;
			System.Array.Copy(arrayBufferData, num3, arrayBufferData2, 0, num5);
			return jsArrayBuffer2;
		}

		private JsValue Transfer(JsValue thisObject, JsValue[] arguments)
		{
			return ArrayBufferCopyAndDetach(thisObject, arguments.At(0), PreserveResizability.PreserveResizability);
		}

		private JsValue TransferToFixedLength(JsValue thisObject, JsValue[] arguments)
		{
			return ArrayBufferCopyAndDetach(thisObject, arguments.At(0), PreserveResizability.FixedLength);
		}

		private JsValue ArrayBufferCopyAndDetach(JsValue o, JsValue newLength, PreserveResizability preserveResizability)
		{
			if (!(o is JsArrayBuffer { IsSharedArrayBuffer: false } jsArrayBuffer))
			{
				ExceptionHelper.ThrowTypeError(_realm, "Method ArrayBuffer.prototype.ArrayBufferCopyAndDetach called on incompatible receiver " + o);
				return JsValue.Undefined;
			}
			uint num = ((!newLength.IsUndefined()) ? TypeConverter.ToIndex(_realm, newLength) : ((uint)jsArrayBuffer.ArrayBufferByteLength));
			jsArrayBuffer.AssertNotDetached();
			uint? maxByteLength = null;
			if (preserveResizability == PreserveResizability.PreserveResizability && jsArrayBuffer._arrayBufferMaxByteLength.HasValue)
			{
				maxByteLength = (uint)jsArrayBuffer._arrayBufferMaxByteLength.Value;
			}
			if (!jsArrayBuffer._arrayBufferDetachKey.IsUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			JsArrayBuffer jsArrayBuffer2 = _engine.Realm.Intrinsics.ArrayBuffer.AllocateArrayBuffer(_engine.Realm.Intrinsics.ArrayBuffer, num, maxByteLength);
			long length = System.Math.Min(num, jsArrayBuffer.ArrayBufferByteLength);
			byte[]? arrayBufferData = jsArrayBuffer.ArrayBufferData;
			byte[] arrayBufferData2 = jsArrayBuffer2.ArrayBufferData;
			System.Array.Copy(arrayBufferData, 0L, arrayBufferData2, 0L, length);
			jsArrayBuffer.DetachArrayBuffer();
			return jsArrayBuffer2;
		}
	}
}
namespace Jint.Native.Array
{
	public sealed class ArrayConstructor : Constructor
	{
		private sealed class ArrayProtocol : IteratorProtocol
		{
			private readonly JsValue _thisArg;

			private readonly ArrayOperations _instance;

			private readonly ICallable? _callable;

			private long _index = -1L;

			public ArrayProtocol(Engine engine, JsValue thisArg, ObjectInstance instance, IteratorInstance iterator, ICallable? callable)
				: base(engine, iterator, 2)
			{
				_thisArg = thisArg;
				_instance = ArrayOperations.For(instance, forWrite: true);
				_callable = callable;
			}

			protected override void ProcessItem(JsValue[] arguments, JsValue currentValue)
			{
				_index++;
				JsValue value;
				if (_callable != null)
				{
					arguments[0] = currentValue;
					arguments[1] = _index;
					value = _callable.Call(_thisArg, arguments);
				}
				else
				{
					value = currentValue;
				}
				_instance.CreateDataPropertyOrThrow((ulong)_index, value);
			}

			protected override void IterationEnd()
			{
				_instance.SetLength((ulong)(_index + 1));
			}
		}

		private static readonly JsString _functionName = new JsString("Array");

		public ArrayPrototype PrototypeObject { get; }

		internal ArrayConstructor(Engine engine, Realm realm, FunctionPrototype functionPrototype, ObjectPrototype objectPrototype)
			: base(engine, realm, _functionName)
		{
			_prototype = functionPrototype;
			PrototypeObject = new ArrayPrototype(engine, realm, this, objectPrototype);
			_length = new PropertyDescriptor(1, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(3, checkExistingKeys: false)
			{
				["from"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "from", From, 1, PropertyFlag.Configurable), PropertyFlag.NonEnumerable)),
				["isArray"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "isArray", IsArray, 1), PropertyFlag.NonEnumerable)),
				["of"] = new PropertyDescriptor(new PropertyDescriptor(new ClrFunction(base.Engine, "of", Of, 0, PropertyFlag.Configurable), PropertyFlag.NonEnumerable))
			};
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol species = GlobalSymbolRegistry.Species;
			symbolDictionary[species] = new GetSetPropertyDescriptor(new ClrFunction(base.Engine, "get [Symbol.species]", Species, 0, PropertyFlag.Configurable), JsValue.Undefined, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private JsValue From(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			JsValue jsValue2 = arguments.At(1);
			ICallable callable = ((!jsValue2.IsUndefined()) ? GetCallable(jsValue2) : null);
			JsValue thisArg = arguments.At(2);
			if (jsValue.IsNullOrUndefined())
			{
				ExceptionHelper.ThrowTypeError(_realm, "Cannot convert undefined or null to object");
			}
			ICallable method = ObjectInstance.GetMethod(_realm, jsValue, GlobalSymbolRegistry.Iterator);
			if (method != null)
			{
				ObjectInstance objectInstance = (((object)this == thisObject || !(thisObject is IConstructor constructor)) ? ArrayCreate(0uL) : constructor.Construct(System.Array.Empty<JsValue>(), thisObject));
				IteratorInstance iterator = jsValue.GetIterator(_realm, GeneratorKind.Sync, method);
				new ArrayProtocol(_engine, thisArg, objectInstance, iterator, callable).Execute();
				return objectInstance;
			}
			if (jsValue is IObjectWrapper { Target: IEnumerable target })
			{
				return ConstructArrayFromIEnumerable(target);
			}
			ArrayOperations source = ArrayOperations.For(_realm, jsValue, forWrite: false);
			return ConstructArrayFromArrayLike(thisObject, source, callable, thisArg);
		}

		private ObjectInstance ConstructArrayFromArrayLike(JsValue thisObj, ArrayOperations source, ICallable? callable, JsValue thisArg)
		{
			uint length = source.GetLength();
			ObjectInstance objectInstance;
			if ((object)thisObj != this && thisObj is IConstructor f)
			{
				JsValue[] argumentsList = new JsValue[1] { length };
				objectInstance = ObjectInstance.Construct(f, argumentsList);
			}
			else
			{
				objectInstance = ArrayCreate(length);
			}
			JsValue[] array = ((callable != null) ? _engine._jsValueArrayPool.RentArray(2) : null);
			ArrayOperations arrayOperations = ArrayOperations.For(objectInstance, forWrite: true);
			uint num = 0u;
			for (uint num2 = 0u; num2 < length; num2++)
			{
				JsValue jsValue = source.Get(num2);
				if (callable != null)
				{
					array[0] = jsValue;
					array[1] = num2;
					jsValue = callable.Call(thisArg, array);
					length = source.GetLength();
				}
				arrayOperations.CreateDataPropertyOrThrow(num2, jsValue);
				num++;
			}
			if (callable != null)
			{
				_engine._jsValueArrayPool.ReturnArray(array);
			}
			arrayOperations.SetLength(length);
			return objectInstance;
		}

		private JsValue Of(JsValue thisObject, JsValue[] arguments)
		{
			int num = arguments.Length;
			ObjectInstance objectInstance = ((!thisObject.IsConstructor) ? _realm.Intrinsics.Array.Construct(num) : ((IConstructor)thisObject).Construct(new JsValue[1] { num }, thisObject));
			if (objectInstance is JsArray jsArray)
			{
				for (uint num2 = 0u; num2 < arguments.Length; num2++)
				{
					JsValue value = arguments[num2];
					jsArray.SetIndexValue(num2, value, num2 == arguments.Length - 1);
				}
			}
			else
			{
				for (uint num3 = 0u; num3 < arguments.Length; num3++)
				{
					JsValue v = arguments[num3];
					JsValue p = JsString.Create(num3);
					objectInstance.CreateDataPropertyOrThrow(p, v);
				}
				objectInstance.Set(CommonProperties.Length, num, throwOnError: true);
			}
			return objectInstance;
		}

		private static JsValue Species(JsValue thisObject, JsValue[] arguments)
		{
			return thisObject;
		}

		private static JsValue IsArray(JsValue thisObject, JsValue[] arguments)
		{
			return IsArray(arguments.At(0));
		}

		private static JsValue IsArray(JsValue o)
		{
			if (!(o is ObjectInstance objectInstance))
			{
				return JsBoolean.False;
			}
			return objectInstance.IsArray();
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, thisObject);
		}

		public JsArray Construct(JsValue[] arguments)
		{
			return (JsArray)Construct(arguments, this);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			if (newTarget.IsUndefined())
			{
				newTarget = this;
			}
			ObjectInstance prototypeFromConstructor = _realm.Intrinsics.Function.GetPrototypeFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.Array.PrototypeObject);
			ulong capacity = (ulong)((arguments.Length != 0) ? arguments.Length : 0);
			if (arguments.Length == 1 && arguments[0].IsNumber())
			{
				double value = ((JsNumber)arguments[0])._value;
				ValidateLength(value);
				capacity = (ulong)value;
			}
			return Construct(arguments, capacity, prototypeFromConstructor);
		}

		public JsArray Construct(int capacity)
		{
			return Construct(System.Array.Empty<JsValue>(), (uint)capacity);
		}

		public JsArray Construct(uint capacity)
		{
			return Construct(System.Array.Empty<JsValue>(), capacity);
		}

		public JsArray Construct(JsValue[] arguments, uint capacity)
		{
			return Construct(arguments, capacity, PrototypeObject);
		}

		private JsArray Construct(JsValue[] arguments, ulong capacity, ObjectInstance prototypeObject)
		{
			JsArray jsArray;
			if (arguments.Length == 1)
			{
				JsValue jsValue = arguments[0];
				if (!(jsValue is JsNumber jsNumber))
				{
					if (!(jsValue is IObjectWrapper objectWrapper))
					{
						if (jsValue is JsArray instance)
						{
							jsArray = (JsArray)ConstructArrayFromArrayLike(JsValue.Undefined, ArrayOperations.For(instance, forWrite: false), null, this);
						}
						else
						{
							jsArray = ArrayCreate(capacity, prototypeObject);
							jsArray._length._value = JsNumber.PositiveZero;
							jsArray.Push(arguments);
						}
					}
					else
					{
						jsArray = ((objectWrapper.Target is IEnumerable enumerable) ? ConstructArrayFromIEnumerable(enumerable) : ArrayCreate(0uL, prototypeObject));
					}
				}
				else
				{
					ValidateLength(jsNumber._value);
					jsArray = ArrayCreate((ulong)jsNumber._value, prototypeObject);
				}
			}
			else
			{
				jsArray = ArrayCreate((ulong)arguments.Length, prototypeObject);
				jsArray._length._value = JsNumber.PositiveZero;
				if (arguments.Length != 0)
				{
					jsArray.Push(arguments);
				}
			}
			return jsArray;
		}

		internal JsArray ArrayCreate(ulong length, ObjectInstance? proto = null)
		{
			if (length > uint.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid array length " + length);
			}
			if ((object)proto == null)
			{
				proto = PrototypeObject;
			}
			return new JsArray(base.Engine, (uint)length, (uint)length)
			{
				_prototype = proto
			};
		}

		private JsArray ConstructArrayFromIEnumerable(IEnumerable enumerable)
		{
			JsArray jsArray = Construct(Arguments.Empty);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(1);
			foreach (object item in enumerable)
			{
				JsValue jsValue = JsValue.FromObject(base.Engine, item);
				array[0] = jsValue;
				_realm.Intrinsics.Array.PrototypeObject.Push(jsArray, array);
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return jsArray;
		}

		public JsArray ConstructFast(JsValue[] contents)
		{
			JsArray jsArray = ArrayCreate((ulong)contents.Length);
			for (int i = 0; i < contents.Length; i++)
			{
				jsArray.SetIndexValue((uint)i, contents[i], updateLength: false);
			}
			return jsArray;
		}

		internal JsArray ConstructFast(List<JsValue> contents)
		{
			JsArray jsArray = ArrayCreate((ulong)contents.Count);
			for (int i = 0; i < contents.Count; i++)
			{
				jsArray.SetIndexValue((uint)i, contents[i], updateLength: false);
			}
			return jsArray;
		}

		internal ObjectInstance ArraySpeciesCreate(ObjectInstance originalArray, ulong length)
		{
			if (!originalArray.IsArray())
			{
				return ArrayCreate(length);
			}
			JsValue jsValue = originalArray.Get(CommonProperties.Constructor);
			if (jsValue.IsConstructor)
			{
				Realm realm = _engine.ExecutionContext.Realm;
				Realm functionRealm = GetFunctionRealm(jsValue);
				if (realm != functionRealm && (object)jsValue == functionRealm.Intrinsics.Array)
				{
					jsValue = JsValue.Undefined;
				}
			}
			if (jsValue.IsObject())
			{
				jsValue = jsValue.Get(GlobalSymbolRegistry.Species);
				if (jsValue.IsNull())
				{
					jsValue = JsValue.Undefined;
				}
			}
			if (jsValue.IsUndefined())
			{
				return ArrayCreate(length);
			}
			if (!jsValue.IsConstructor)
			{
				ExceptionHelper.ThrowTypeError(_realm, $"{jsValue} is not a constructor");
			}
			return ((IConstructor)jsValue).Construct(new JsValue[1] { JsNumber.Create(length) }, jsValue);
		}

		internal JsArray CreateArrayFromList<T>(List<T> values) where T : JsValue
		{
			JsArray jsArray = ArrayCreate((uint)values.Count);
			int i;
			for (i = 0; i < values.Count; i++)
			{
				T value = values[i];
				jsArray.SetIndexValue((uint)i, value, updateLength: false);
			}
			jsArray.SetLength((uint)i);
			return jsArray;
		}

		internal JsArray CreateArrayFromList<T>(T[] values) where T : JsValue
		{
			JsArray jsArray = ArrayCreate((uint)values.Length);
			int i;
			for (i = 0; i < values.Length; i++)
			{
				T value = values[i];
				jsArray.SetIndexValue((uint)i, value, updateLength: false);
			}
			jsArray.SetLength((uint)i);
			return jsArray;
		}

		private void ValidateLength(double length)
		{
			if (length < 0.0 || length > 9007199254740991.0 || (double)(long)length != length)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid array length");
			}
		}
	}
	public class ArrayInstance : ObjectInstance, IEnumerable<JsValue>, IEnumerable
	{
		private readonly record struct IndexedEntry(int Index, JsValue Value);

		internal PropertyDescriptor? _length;

		private const int MaxDenseArrayLength = 10000000;

		internal JsValue?[]? _dense;

		private Dictionary<uint, PropertyDescriptor?>? _sparse;

		private ObjectChangeFlags _objectChangeFlags;

		private ArrayConstructor? _constructor;

		internal sealed override bool IsArrayLike => true;

		internal sealed override bool HasOriginalIterator => (object)Get(GlobalSymbolRegistry.Iterator) == _constructor?.PrototypeObject._originalIteratorFunction;

		internal bool CanUseFastAccess
		{
			get
			{
				if ((_objectChangeFlags & ObjectChangeFlags.NonDefaultDataDescriptorUsage) != ObjectChangeFlags.None)
				{
					return false;
				}
				if (!(_prototype is ArrayPrototype arrayPrototype) || (object)_prototype != _constructor?.PrototypeObject)
				{
					return false;
				}
				if ((arrayPrototype._objectChangeFlags & ObjectChangeFlags.ArrayIndex) != ObjectChangeFlags.None)
				{
					return false;
				}
				if (!(arrayPrototype.Prototype is ObjectPrototype objectPrototype) || (object)objectPrototype != _constructor.PrototypeObject.Prototype)
				{
					return false;
				}
				return (objectPrototype._objectChangeFlags & ObjectChangeFlags.ArrayIndex) == 0;
			}
		}

		internal sealed override bool IsIntegerIndexedArray => true;

		public JsValue this[uint index]
		{
			get
			{
				TryGetValue(index, out JsValue value);
				return value;
			}
			set
			{
				SetIndexValue(index, value, updateLength: true);
			}
		}

		public JsValue this[int index]
		{
			get
			{
				JsValue value;
				if (index >= 0)
				{
					TryGetValue((uint)index, out value);
				}
				else
				{
					TryGetValue(JsNumber.Create(index), out value);
				}
				return value;
			}
			set
			{
				if (index >= 0)
				{
					SetIndexValue((uint)index, value, updateLength: true);
				}
				else
				{
					Set(index, value);
				}
			}
		}

		private protected ArrayInstance(Engine engine, InternalTypes type)
			: base(engine, ObjectClass.Object, type)
		{
			_dense = System.Array.Empty<JsValue>();
		}

		private protected ArrayInstance(Engine engine, uint capacity = 0u, uint length = 0u)
			: base(engine, ObjectClass.Object, InternalTypes.Object | InternalTypes.Array)
		{
			InitializePrototypeAndValidateCapacity(engine, capacity);
			if (capacity < 10000000)
			{
				_dense = ((capacity != 0) ? new JsValue[capacity] : System.Array.Empty<JsValue>());
			}
			else
			{
				_sparse = new Dictionary<uint, PropertyDescriptor>(1024);
			}
			_length = new PropertyDescriptor(length, PropertyFlag.OnlyWritable);
		}

		private protected ArrayInstance(Engine engine, JsValue[] items)
			: base(engine, ObjectClass.Object, InternalTypes.Object | InternalTypes.Array)
		{
			InitializePrototypeAndValidateCapacity(engine, 0u);
			_dense = items;
			_length = new PropertyDescriptor(items.Length, PropertyFlag.OnlyWritable);
		}

		private void InitializePrototypeAndValidateCapacity(Engine engine, uint capacity)
		{
			_constructor = engine.Realm.Intrinsics.Array;
			_prototype = _constructor.PrototypeObject;
			if (capacity != 0 && capacity > engine.Options.Constraints.MaxArraySize)
			{
				ThrowMaximumArraySizeReachedException(engine, capacity);
			}
		}

		internal sealed override bool IsArray()
		{
			return true;
		}

		public sealed override bool DefineOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			if (CommonProperties.Length.Equals(property))
			{
				return DefineLength(desc);
			}
			uint index;
			bool flag = IsArrayIndex(property, out index);
			TrackChanges(property, desc, flag);
			if (flag)
			{
				ConvertToSparse();
				return DefineOwnProperty(index, desc);
			}
			return base.DefineOwnProperty(property, desc);
		}

		private bool DefineLength(PropertyDescriptor desc)
		{
			JsValue value = desc.Value;
			if ((object)value == null)
			{
				return base.DefineOwnProperty(CommonProperties.Length, desc);
			}
			PropertyDescriptor propertyDescriptor = new PropertyDescriptor(desc);
			uint num = TypeConverter.ToUint32(value);
			if ((double)num != TypeConverter.ToNumber(value))
			{
				ExceptionHelper.ThrowRangeError(_engine.Realm);
			}
			PropertyDescriptor length = _length;
			uint num2 = (uint)TypeConverter.ToNumber(length.Value);
			propertyDescriptor.Value = num;
			if (num >= num2)
			{
				return base.DefineOwnProperty(CommonProperties.Length, propertyDescriptor);
			}
			if (!length.Writable)
			{
				return false;
			}
			bool flag;
			if (!propertyDescriptor.WritableSet || propertyDescriptor.Writable)
			{
				flag = true;
			}
			else
			{
				flag = false;
				propertyDescriptor.Writable = true;
			}
			if (!base.DefineOwnProperty(CommonProperties.Length, propertyDescriptor))
			{
				return false;
			}
			JsValue?[]? dense = _dense;
			if (((dense != null) ? dense.Length : _sparse.Count) < num2 - num)
			{
				if (_dense != null)
				{
					for (uint num3 = 0u; num3 < _dense.Length; num3++)
					{
						if ((object)_dense[num3] != null && num3 >= num && num3 < num2 && !Delete(num3))
						{
							propertyDescriptor.Value = num3 + 1;
							if (!flag)
							{
								propertyDescriptor.Writable = false;
							}
							base.DefineOwnProperty(CommonProperties.Length, propertyDescriptor);
							return false;
						}
					}
				}
				else
				{
					List<uint> list = new List<uint>(_sparse.Keys);
					int count = list.Count;
					for (int i = 0; i < count; i++)
					{
						uint num4 = list[i];
						if (num4 >= num && num4 < num2 && !Delete(TypeConverter.ToString(num4)))
						{
							propertyDescriptor.Value = JsNumber.Create(num4 + 1);
							if (!flag)
							{
								propertyDescriptor.Writable = false;
							}
							base.DefineOwnProperty(CommonProperties.Length, propertyDescriptor);
							return false;
						}
					}
				}
			}
			else
			{
				while (num < num2)
				{
					num2--;
					if (!Delete(num2))
					{
						propertyDescriptor.Value = num2 + 1;
						if (!flag)
						{
							propertyDescriptor.Writable = false;
						}
						base.DefineOwnProperty(CommonProperties.Length, propertyDescriptor);
						return false;
					}
				}
			}
			if (!flag)
			{
				base.DefineOwnProperty(CommonProperties.Length, new PropertyDescriptor(null, PropertyFlag.WritableSet));
			}
			return true;
		}

		private bool DefineOwnProperty(uint index, PropertyDescriptor desc)
		{
			PropertyDescriptor length = _length;
			uint num = (uint)TypeConverter.ToNumber(length.Value);
			if (index >= num && !length.Writable)
			{
				return false;
			}
			if (!base.DefineOwnProperty(index, desc))
			{
				return false;
			}
			if (index >= num)
			{
				length.Value = index + 1;
				base.DefineOwnProperty(CommonProperties.Length, length);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal override uint GetLength()
		{
			return (uint)GetJsNumberLength()._value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private JsNumber GetJsNumberLength()
		{
			if (_length != null)
			{
				return (JsNumber)_length._value;
			}
			return JsNumber.PositiveZero;
		}

		protected sealed override bool TryGetProperty(JsValue property, [NotNullWhen(true)] out PropertyDescriptor? descriptor)
		{
			if (CommonProperties.Length.Equals(property))
			{
				descriptor = _length;
				return _length != null;
			}
			return base.TryGetProperty(property, out descriptor);
		}

		public sealed override List<JsValue> GetOwnPropertyKeys(Types types = Types.String | Types.Symbol)
		{
			if ((types & Types.String) == 0)
			{
				return base.GetOwnPropertyKeys(types);
			}
			JsValue[] dense = _dense;
			List<JsValue> list = new List<JsValue>((dense == null) ? 1 : dense.Length);
			if (dense != null)
			{
				long num = System.Math.Min(dense.Length, GetLength());
				for (int i = 0; i < num; i++)
				{
					if ((object)dense[i] != null)
					{
						list.Add(JsString.Create(i));
					}
				}
			}
			else
			{
				foreach (KeyValuePair<uint, PropertyDescriptor> item in _sparse)
				{
					list.Add(JsString.Create(item.Key));
				}
			}
			if (_length != null)
			{
				list.Add(CommonProperties.Length);
			}
			list.AddRange(base.GetOwnPropertyKeys(types));
			return list;
		}

		public IEnumerable<KeyValuePair<string, JsValue>> GetEntries(bool includeLength = false)
		{
			foreach (var (num2, value) in Enumerate())
			{
				yield return new KeyValuePair<string, JsValue>(TypeConverter.ToString(num2), value);
			}
			if (includeLength && _length != null)
			{
				yield return new KeyValuePair<string, JsValue>(CommonProperties.Length._value, _length.Value);
			}
		}

		public sealed override IEnumerable<KeyValuePair<JsValue, PropertyDescriptor>> GetOwnProperties()
		{
			JsValue?[] temp = _dense;
			if (temp != null)
			{
				long length = System.Math.Min(temp.Length, GetLength());
				for (uint i = 0u; i < length; i++)
				{
					JsValue jsValue = temp[i];
					if ((object)jsValue == null)
					{
						continue;
					}
					if (_sparse == null || !_sparse.TryGetValue(i, out PropertyDescriptor value) || value == null)
					{
						if (_sparse == null)
						{
							_sparse = new Dictionary<uint, PropertyDescriptor>();
						}
						value = (_sparse[i] = new PropertyDescriptor(jsValue, PropertyFlag.ConfigurableEnumerableWritable));
					}
					yield return new KeyValuePair<JsValue, PropertyDescriptor>(TypeConverter.ToString(i), value);
				}
			}
			else if (_sparse != null)
			{
				foreach (KeyValuePair<uint, PropertyDescriptor> item in _sparse)
				{
					PropertyDescriptor value2 = item.Value;
					if (value2 != null)
					{
						yield return new KeyValuePair<JsValue, PropertyDescriptor>(TypeConverter.ToString(item.Key), value2);
					}
				}
			}
			if (_length != null)
			{
				yield return new KeyValuePair<JsValue, PropertyDescriptor>(CommonProperties.Length, _length);
			}
			foreach (KeyValuePair<JsValue, PropertyDescriptor> ownProperty in base.GetOwnProperties())
			{
				yield return ownProperty;
			}
		}

		public sealed override PropertyDescriptor GetOwnProperty(JsValue property)
		{
			if (CommonProperties.Length.Equals(property))
			{
				return _length ?? PropertyDescriptor.Undefined;
			}
			if (IsArrayIndex(property, out var index))
			{
				if (TryGetDescriptor(index, createIfMissing: true, out PropertyDescriptor descriptor))
				{
					return descriptor;
				}
				return PropertyDescriptor.Undefined;
			}
			return base.GetOwnProperty(property);
		}

		internal JsValue Get(uint index)
		{
			if (!TryGetValue(index, out JsValue value))
			{
				return base.Prototype?.Get(JsString.Create(index)) ?? JsValue.Undefined;
			}
			return value;
		}

		public sealed override JsValue Get(JsValue property, JsValue receiver)
		{
			if (IsSafeSelfTarget(receiver) && IsArrayIndex(property, out var index) && TryGetValue(index, out JsValue value))
			{
				return value;
			}
			if (CommonProperties.Length.Equals(property))
			{
				JsValue jsValue = _length?._value;
				if ((object)jsValue != null)
				{
					return jsValue;
				}
			}
			return base.Get(property, receiver);
		}

		public sealed override bool Set(JsValue property, JsValue value, JsValue receiver)
		{
			if (IsSafeSelfTarget(receiver) && CanUseFastAccess)
			{
				if ((object)property != CommonProperties.Length && IsArrayIndex(property, out var index))
				{
					SetIndexValue(index, value, updateLength: true);
					return true;
				}
				if (CommonProperties.Length.Equals(property))
				{
					PropertyDescriptor length = _length;
					if (length != null && length.Writable && value is JsNumber jsNumber && jsNumber.IsInteger() && jsNumber._value <= 10000000.0 && jsNumber._value >= (double)GetLength())
					{
						_length.Value = jsNumber;
						return true;
					}
				}
			}
			return base.Set(property, value, receiver);
		}

		private bool IsSafeSelfTarget(JsValue receiver)
		{
			if ((object)receiver == this)
			{
				return Extensible;
			}
			return false;
		}

		public sealed override bool HasProperty(JsValue property)
		{
			if (IsArrayIndex(property, out var index) && (object)GetValue(index, unwrapFromNonDataDescriptor: false) != null)
			{
				return true;
			}
			return base.HasProperty(property);
		}

		internal bool HasProperty(ulong index)
		{
			if (index < uint.MaxValue)
			{
				JsValue[] dense = _dense;
				if (dense != null)
				{
					if (index < (uint)dense.Length && (object)dense[index] != null)
					{
						return true;
					}
				}
				else if (_sparse.ContainsKey((uint)index))
				{
					return true;
				}
			}
			return base.HasProperty(index);
		}

		protected internal sealed override void SetOwnProperty(JsValue property, PropertyDescriptor desc)
		{
			uint index;
			bool flag = IsArrayIndex(property, out index);
			TrackChanges(property, desc, flag);
			if (flag)
			{
				WriteArrayValue(index, desc);
			}
			else if (CommonProperties.Length.Equals(property))
			{
				_length = desc;
			}
			else
			{
				base.SetOwnProperty(property, desc);
			}
		}

		private void TrackChanges(JsValue property, PropertyDescriptor desc, bool isArrayIndex)
		{
			EnsureInitialized();
			if (isArrayIndex)
			{
				if (!desc.IsDefaultArrayValueDescriptor() && desc.Flags != PropertyFlag.None)
				{
					_objectChangeFlags |= ObjectChangeFlags.NonDefaultDataDescriptorUsage;
				}
				if (GetType() != typeof(JsArray))
				{
					_objectChangeFlags |= ObjectChangeFlags.ArrayIndex;
				}
			}
			else
			{
				_objectChangeFlags |= (ObjectChangeFlags)((!property.IsSymbol()) ? 1 : 2);
			}
		}

		public sealed override void RemoveOwnProperty(JsValue property)
		{
			if (IsArrayIndex(property, out var index))
			{
				Delete(index);
			}
			if (CommonProperties.Length.Equals(property))
			{
				_length = null;
			}
			base.RemoveOwnProperty(property);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsArrayIndex(JsValue p, out uint index)
		{
			if (p.IsNumber())
			{
				double value = ((JsNumber)p)._value;
				uint num = (index = (uint)value);
				if (value == (double)num)
				{
					return num != uint.MaxValue;
				}
				return false;
			}
			index = ((!p.IsSymbol()) ? ParseArrayIndex(p.ToString()) : uint.MaxValue);
			return index != uint.MaxValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ParseArrayIndex(string p)
		{
			if (p.Length == 0 || (p.Length > 1 && !IsInRange(p[0], '1', '9')) || !uint.TryParse(p, out var result))
			{
				return uint.MaxValue;
			}
			return result;
		}

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetIndexValue(uint index, JsValue? value, bool updateLength)
		{
			if (updateLength)
			{
				EnsureCorrectLength(index);
			}
			WriteArrayValue(index, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void EnsureCorrectLength(uint index)
		{
			uint length = GetLength();
			if (index >= length)
			{
				SetLength(index + 1);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetLength(ulong length)
		{
			SetLength(JsNumber.Create(length));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void SetLength(JsNumber length)
		{
			if (Extensible && _length._flags == PropertyFlag.OnlyWritable)
			{
				_length.Value = length;
			}
			else
			{
				Set(CommonProperties.Length, length, throwOnError: true);
			}
		}

		internal uint GetSmallestIndex()
		{
			if (_dense != null)
			{
				return 0u;
			}
			uint num = 0u;
			if (_sparse.Count > 0 && _sparse.Count < 100 && !_sparse.ContainsKey(0u))
			{
				num = uint.MaxValue;
				foreach (uint key in _sparse.Keys)
				{
					num = System.Math.Min(key, num);
				}
			}
			return num;
		}

		internal bool DeletePropertyOrThrow(uint index)
		{
			if (!Delete(index))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return true;
		}

		private bool Delete(uint index)
		{
			JsValue deletedValue;
			return Delete(index, unwrapFromNonDataDescriptor: false, out deletedValue);
		}

		private bool Delete(uint index, bool unwrapFromNonDataDescriptor, out JsValue? deletedValue)
		{
			TryGetDescriptor(index, createIfMissing: false, out PropertyDescriptor descriptor);
			JsValue[] dense = _dense;
			if (dense != null && index < (uint)dense.Length && (descriptor == null || descriptor.Configurable))
			{
				deletedValue = dense[index];
				dense[index] = null;
				return true;
			}
			if (descriptor == null)
			{
				deletedValue = null;
				return true;
			}
			if (descriptor.Configurable)
			{
				_sparse.Remove(index);
				deletedValue = ((descriptor.IsDataDescriptor() || unwrapFromNonDataDescriptor) ? UnwrapJsValue(descriptor) : null);
				return true;
			}
			deletedValue = null;
			return false;
		}

		internal bool DeleteAt(uint index)
		{
			JsValue[] dense = _dense;
			if (dense != null)
			{
				if (index < (uint)dense.Length)
				{
					dense[index] = null;
					return true;
				}
				return false;
			}
			return _sparse.Remove(index);
		}

		private bool TryGetDescriptor(uint index, bool createIfMissing, [NotNullWhen(true)] out PropertyDescriptor? descriptor)
		{
			if (!createIfMissing && _sparse == null)
			{
				descriptor = null;
				return false;
			}
			descriptor = null;
			JsValue[] dense = _dense;
			if (dense != null)
			{
				if (index < (uint)dense.Length)
				{
					JsValue jsValue = dense[index];
					if ((object)jsValue != null)
					{
						if (_sparse == null || !_sparse.TryGetValue(index, out descriptor) || descriptor == null)
						{
							if (_sparse == null)
							{
								_sparse = new Dictionary<uint, PropertyDescriptor>();
							}
							_sparse[index] = (descriptor = new PropertyDescriptor(jsValue, PropertyFlag.ConfigurableEnumerableWritable));
						}
						descriptor.Value = jsValue;
						return true;
					}
				}
				return false;
			}
			_sparse?.TryGetValue(index, out descriptor);
			return descriptor != null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool TryGetValue(uint index, out JsValue value)
		{
			value = GetValue(index, unwrapFromNonDataDescriptor: true);
			if ((object)value != null)
			{
				return true;
			}
			return TryGetValueUnlikely(index, out value);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private bool TryGetValueUnlikely(uint index, out JsValue value)
		{
			if (!CanUseFastAccess)
			{
				ObjectInstance prototype = base.Prototype;
				JsValue property = index;
				while ((object)prototype != null)
				{
					PropertyDescriptor ownProperty = prototype.GetOwnProperty(property);
					if (ownProperty != PropertyDescriptor.Undefined)
					{
						value = UnwrapJsValue(ownProperty);
						return true;
					}
					prototype = prototype.Prototype;
				}
			}
			value = JsValue.Undefined;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private JsValue? GetValue(uint index, bool unwrapFromNonDataDescriptor)
		{
			JsValue[] dense = _dense;
			if (dense != null)
			{
				if (index < (uint)dense.Length)
				{
					return dense[index];
				}
				return null;
			}
			return GetValueUnlikely(index, unwrapFromNonDataDescriptor);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private JsValue? GetValueUnlikely(uint index, bool unwrapFromNonDataDescriptor)
		{
			JsValue result = null;
			if (_sparse.TryGetValue(index, out PropertyDescriptor value) && value != null)
			{
				result = ((value.IsDataDescriptor() || unwrapFromNonDataDescriptor) ? UnwrapJsValue(value) : null);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void WriteArrayValue(uint index, PropertyDescriptor descriptor)
		{
			JsValue[] dense = _dense;
			if (dense != null && descriptor.IsDefaultArrayValueDescriptor())
			{
				if (index < (uint)dense.Length)
				{
					dense[index] = descriptor.Value;
				}
				else
				{
					WriteArrayValueUnlikely(index, descriptor.Value);
				}
			}
			else
			{
				WriteArrayValueUnlikely(index, descriptor);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void WriteArrayValue(uint index, JsValue? value)
		{
			JsValue[] dense = _dense;
			if (dense != null && index < (uint)dense.Length)
			{
				dense[index] = value;
			}
			else
			{
				WriteArrayValueUnlikely(index, value);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void WriteArrayValueUnlikely(uint index, JsValue? value)
		{
			JsValue[] dense = _dense;
			long num = ((dense != null && index >= (uint)dense.Length) ? (System.Math.Max(index, System.Math.Max(dense.Length, 2)) * 2) : 0);
			if (dense != null && index < 10000000 && num < 10000000 && index < dense.Length + 50)
			{
				EnsureCapacity((uint)num);
				_dense[index] = value;
			}
			else
			{
				ConvertToSparse();
				_sparse[index] = new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable);
			}
		}

		private void WriteArrayValueUnlikely(uint index, PropertyDescriptor? value)
		{
			if (_sparse == null)
			{
				ConvertToSparse();
			}
			_sparse[index] = value;
		}

		private void ConvertToSparse()
		{
			JsValue[] dense = _dense;
			if (dense == null)
			{
				return;
			}
			if (_sparse == null)
			{
				_sparse = new Dictionary<uint, PropertyDescriptor>();
			}
			for (uint num = 0u; num < (uint)dense.Length; num++)
			{
				JsValue jsValue = dense[num];
				if ((object)jsValue != null)
				{
					_sparse.TryGetValue(num, out PropertyDescriptor value);
					if (value == null)
					{
						value = new PropertyDescriptor(jsValue, PropertyFlag.ConfigurableEnumerableWritable);
					}
					value.Value = jsValue;
					_sparse[num] = value;
				}
				else
				{
					_sparse.Remove(num);
				}
			}
			_dense = null;
		}

		internal void EnsureCapacity(uint capacity, bool force = false)
		{
			JsValue[] dense = _dense;
			if (dense != null && (force || (capacity <= 10000000 && capacity > (uint)dense.Length)))
			{
				if (capacity > _engine.Options.Constraints.MaxArraySize)
				{
					ThrowMaximumArraySizeReachedException(_engine, capacity);
				}
				JsValue[] array = new JsValue[capacity];
				System.Array.Copy(dense, array, dense.Length);
				_dense = array;
			}
		}

		public JsValue[] ToArray()
		{
			uint length = GetLength();
			JsValue[] array = new JsValue[length];
			for (uint num = 0u; num < length; num++)
			{
				TryGetValue(num, out JsValue value);
				array[num] = value;
			}
			return array;
		}

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

		public IEnumerator<JsValue> GetEnumerator()
		{
			foreach (IndexedEntry item in Enumerate())
			{
				item.Deconstruct(out int _, out JsValue Value);
				yield return Value;
			}
		}

		private IEnumerable<IndexedEntry> Enumerate()
		{
			if (!CanUseFastAccess)
			{
				uint length = GetLength();
				for (uint i = 0u; i < length; i++)
				{
					TryGetValue(i, out JsValue value);
					yield return new IndexedEntry((int)i, value);
				}
				yield break;
			}
			JsValue?[] temp = _dense;
			if (temp != null)
			{
				long length2 = System.Math.Min(temp.Length, GetLength());
				for (int j = 0; j < length2; j++)
				{
					JsValue jsValue = temp[j];
					if ((object)jsValue != null)
					{
						yield return new IndexedEntry(j, jsValue);
					}
				}
				yield break;
			}
			foreach (KeyValuePair<uint, PropertyDescriptor> item in _sparse)
			{
				PropertyDescriptor value2 = item.Value;
				if (value2 != null)
				{
					yield return new IndexedEntry((int)item.Key, value2.Value);
				}
			}
		}

		public void Push(JsValue value)
		{
			uint length = GetLength();
			uint num = length + 1;
			JsValue[] dense = _dense;
			bool num2 = dense != null && num <= dense.Length;
			double num3 = length;
			if (num2)
			{
				dense[(uint)num3] = value;
			}
			else
			{
				WriteValueSlow(num3, value);
			}
			if (num3 < 4294967295.0 && CanSetLength())
			{
				_length.Value = num;
			}
			else if (!Set(CommonProperties.Length, num))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
		}

		public uint Push(JsValue[] values)
		{
			uint length = GetLength();
			long num = length + values.Length;
			if (_dense != null && length != 0 && values.Length > length * 2 && num <= 10000000)
			{
				EnsureCapacity((uint)num);
			}
			_ = _dense;
			ulong num2 = length;
			foreach (JsValue value in values)
			{
				if (num2 < uint.MaxValue)
				{
					WriteArrayValue((uint)num2, value);
				}
				else
				{
					DefineOwnProperty(num2, new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable));
				}
				num2++;
			}
			if (num2 < uint.MaxValue && CanSetLength())
			{
				_length.Value = num2;
			}
			else if (!Set(CommonProperties.Length, num))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			return (uint)num2;
		}

		public JsValue Pop()
		{
			JsNumber jsNumberLength = GetJsNumberLength();
			if (JsNumber.PositiveZero.Equals(jsNumberLength))
			{
				SetLength(jsNumberLength);
				return JsValue.Undefined;
			}
			uint num = (uint)jsNumberLength._value - 1;
			if (!Delete(num, unwrapFromNonDataDescriptor: true, out JsValue deletedValue))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm);
			}
			SetLength(num);
			return deletedValue ?? JsValue.Undefined;
		}

		private bool CanSetLength()
		{
			if (!_length.IsAccessorDescriptor())
			{
				return _length.Writable;
			}
			JsValue set = _length.Set;
			if ((object)set != null)
			{
				return !set.IsUndefined();
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void WriteValueSlow(double n, JsValue value)
		{
			if (n < 4294967295.0)
			{
				WriteArrayValue((uint)n, value);
			}
			else
			{
				DefinePropertyOrThrow((uint)n, new PropertyDescriptor(value, PropertyFlag.ConfigurableEnumerableWritable));
			}
		}

		internal JsArray Map(JsValue[] arguments)
		{
			JsValue source = arguments.At(0);
			JsValue thisObject = arguments.At(1);
			uint length = GetLength();
			ICallable callable = GetCallable(source);
			JsArray jsArray = _engine.Realm.Intrinsics.Array.ArrayCreate(length);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = this;
			for (uint num = 0u; num < length; num++)
			{
				if (TryGetValue(num, out JsValue value))
				{
					array[0] = value;
					array[1] = num;
					JsValue jsValue = callable.Call(thisObject, array);
					if (jsArray._dense != null && num < (uint)jsArray._dense.Length)
					{
						jsArray._dense[num] = jsValue;
					}
					else
					{
						jsArray.WriteArrayValue(num, jsValue);
					}
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return jsArray;
		}

		internal sealed override bool FindWithCallback(JsValue[] arguments, out ulong index, out JsValue value, bool visitUnassigned, bool fromEnd = false)
		{
			JsValue thisObject = arguments.At(1);
			JsValue source = arguments.At(0);
			ICallable callable = GetCallable(source);
			uint length = GetLength();
			if (length == 0)
			{
				index = 0uL;
				value = JsValue.Undefined;
				return false;
			}
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = this;
			if (!fromEnd)
			{
				for (uint num = 0u; num < length; num++)
				{
					if (TryGetValue(num, out JsValue value2) || visitUnassigned)
					{
						if ((object)value2 == null)
						{
							value2 = JsValue.Undefined;
						}
						array[0] = value2;
						array[1] = num;
						if (TypeConverter.ToBoolean(callable.Call(thisObject, array)))
						{
							index = num;
							value = value2;
							return true;
						}
					}
				}
			}
			else
			{
				for (long num2 = length - 1; num2 >= 0; num2--)
				{
					uint num3 = (uint)num2;
					if (TryGetValue(num3, out JsValue value3) || visitUnassigned)
					{
						if ((object)value3 == null)
						{
							value3 = JsValue.Undefined;
						}
						array[0] = value3;
						array[1] = num3;
						if (TypeConverter.ToBoolean(callable.Call(thisObject, array)))
						{
							index = num3;
							value = value3;
							return true;
						}
					}
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			index = 0uL;
			value = JsValue.Undefined;
			return false;
		}

		internal void CopyValues(JsArray source, uint sourceStartIndex, uint targetStartIndex, uint length)
		{
			if (length == 0)
			{
				return;
			}
			JsValue[] dense = source._dense;
			if (dense != null)
			{
				EnsureCapacity((uint)(targetStartIndex + dense.LongLength));
			}
			JsValue[] dense2 = _dense;
			if (dense2 != null && dense != null && (uint)dense2.Length >= targetStartIndex + length && (object)dense2[targetStartIndex] == null)
			{
				uint num = 0u;
				uint num2 = sourceStartIndex;
				while (num2 < sourceStartIndex + length)
				{
					JsValue value;
					if (num2 < (uint)dense.Length)
					{
						value = dense[num2];
					}
					else
					{
						source.TryGetValue(num2, out value);
					}
					dense2[targetStartIndex + num] = value;
					num2++;
					num++;
				}
				return;
			}
			for (uint num3 = sourceStartIndex; num3 < length; num3++)
			{
				if (source.TryGetValue(num3, out JsValue value2))
				{
					SetIndexValue(targetStartIndex, value2, updateLength: false);
				}
				targetStartIndex++;
			}
		}

		public sealed override string ToString()
		{
			return "(" + (_length?._value.AsNumber() ?? 0.0) + ")[]";
		}

		private static void ThrowMaximumArraySizeReachedException(Engine engine, uint capacity)
		{
			ExceptionHelper.ThrowMemoryLimitExceededException($"The array size {capacity} is larger than maximum allowed ({engine.Options.Constraints.MaxArraySize})");
		}
	}
	internal static class ArrayPropertyDescriptorExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsDefaultArrayValueDescriptor(this PropertyDescriptor propertyDescriptor)
		{
			if (propertyDescriptor.Flags == PropertyFlag.ConfigurableEnumerableWritable)
			{
				return propertyDescriptor.IsDataDescriptor();
			}
			return false;
		}
	}
	internal sealed class ArrayIteratorPrototype : IteratorPrototype
	{
		private sealed class ArrayIterator : IteratorInstance
		{
			private readonly ArrayIteratorType _kind;

			private readonly JsArray _array;

			private uint _position;

			private bool _closed;

			public ArrayIterator(Engine engine, JsArray array, ArrayIteratorType kind)
				: base(engine)
			{
				_kind = kind;
				_array = array;
				_position = 0u;
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				uint length = _array.GetLength();
				uint position = _position;
				if (!_closed && position < length)
				{
					_array.TryGetValue(position, out JsValue value);
					nextItem = _kind switch
					{
						ArrayIteratorType.Key => IteratorResult.CreateValueIteratorPosition(_engine, JsNumber.Create(position)), 
						ArrayIteratorType.Value => IteratorResult.CreateValueIteratorPosition(_engine, value), 
						_ => IteratorResult.CreateKeyValueIteratorPosition(_engine, JsNumber.Create(position), value), 
					};
					_position++;
					return true;
				}
				_closed = true;
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		private sealed class ArrayLikeIterator : IteratorInstance
		{
			private readonly ArrayIteratorType _kind;

			private readonly JsTypedArray? _typedArray;

			private readonly ArrayOperations? _operations;

			private uint _position;

			private bool _closed;

			public ArrayLikeIterator(Engine engine, ObjectInstance objectInstance, ArrayIteratorType kind)
				: base(engine)
			{
				_kind = kind;
				_typedArray = objectInstance as JsTypedArray;
				if ((object)_typedArray == null)
				{
					_operations = ArrayOperations.For(objectInstance, forWrite: false);
				}
				_position = 0u;
			}

			public override bool TryIteratorStep(out ObjectInstance nextItem)
			{
				uint num;
				if ((object)_typedArray != null)
				{
					_typedArray._viewedArrayBuffer.AssertNotDetached();
					IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord typedArrayWithBufferWitnessRecord = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(_typedArray, ArrayBufferOrder.SeqCst);
					if (!_closed && typedArrayWithBufferWitnessRecord.IsTypedArrayOutOfBounds)
					{
						ExceptionHelper.ThrowTypeError(_typedArray.Engine.Realm, "TypedArray is out of bounds");
					}
					num = typedArrayWithBufferWitnessRecord.TypedArrayLength;
				}
				else
				{
					num = _operations.GetLength();
				}
				if (!_closed && _position < num)
				{
					if ((object)_typedArray != null)
					{
						nextItem = _kind switch
						{
							ArrayIteratorType.Key => IteratorResult.CreateValueIteratorPosition(_engine, JsNumber.Create(_position)), 
							ArrayIteratorType.Value => IteratorResult.CreateValueIteratorPosition(_engine, _typedArray[(int)_position]), 
							_ => IteratorResult.CreateKeyValueIteratorPosition(_engine, JsNumber.Create(_position), _typedArray[(int)_position]), 
						};
					}
					else
					{
						_operations.TryGetValue(_position, out JsValue value);
						nextItem = _kind switch
						{
							ArrayIteratorType.Key => IteratorResult.CreateValueIteratorPosition(_engine, JsNumber.Create(_position)), 
							ArrayIteratorType.Value => IteratorResult.CreateValueIteratorPosition(_engine, value), 
							_ => IteratorResult.CreateKeyValueIteratorPosition(_engine, JsNumber.Create(_position), value), 
						};
					}
					_position++;
					return true;
				}
				_closed = true;
				nextItem = IteratorResult.CreateKeyValueIteratorPosition(_engine);
				return false;
			}
		}

		private ClrFunction? _originalNextFunction;

		internal bool HasOriginalNext => (object)Get(CommonProperties.Next) == _originalNextFunction;

		internal ArrayIteratorPrototype(Engine engine, Realm realm, IteratorPrototype objectPrototype)
			: base(engine, realm, objectPrototype)
		{
		}

		protected override void Initialize()
		{
			_originalNextFunction = new ClrFunction(base.Engine, "next", base.Next, 0, PropertyFlag.Configurable);
			PropertyDictionary properties = new PropertyDictionary(1, checkExistingKeys: false) { [KnownKeys.Next] = new PropertyDescriptor(_originalNextFunction, PropertyFlag.NonEnumerable) };
			SetProperties(properties);
			SymbolDictionary symbolDictionary = new SymbolDictionary(1);
			JsSymbol toStringTag = GlobalSymbolRegistry.ToStringTag;
			symbolDictionary[toStringTag] = new PropertyDescriptor("Array Iterator", PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		internal IteratorInstance Construct(ObjectInstance array, ArrayIteratorType kind)
		{
			if (!HasOriginalNext)
			{
				return new IteratorInstance.ObjectIterator(this);
			}
			if (!(array is JsArray array2))
			{
				return new ArrayLikeIterator(base.Engine, array, kind)
				{
					_prototype = this
				};
			}
			return new ArrayIterator(base.Engine, array2, kind)
			{
				_prototype = this
			};
		}
	}
	internal abstract class ArrayOperations : IEnumerable<JsValue>, IEnumerable
	{
		internal sealed class ArrayLikeIterator : IEnumerator<JsValue>, IEnumerator, IDisposable
		{
			private readonly ArrayOperations _obj;

			private ulong _current;

			private bool _initialized;

			private readonly uint _length;

			public JsValue Current
			{
				get
				{
					if (_initialized)
					{
						if (!_obj.TryGetValue(_current, out JsValue value))
						{
							return JsValue.Undefined;
						}
						return value;
					}
					return JsValue.Undefined;
				}
			}

			object? IEnumerator.Current => Current;

			public ArrayLikeIterator(ArrayOperations obj)
			{
				_obj = obj;
				_length = obj.GetLength();
				Reset();
			}

			public void Dispose()
			{
			}

			public bool MoveNext()
			{
				if (!_initialized)
				{
					_initialized = true;
				}
				else
				{
					_current++;
				}
				return _current < _length;
			}

			public void Reset()
			{
				_initialized = false;
				_current = 0uL;
			}
		}

		private sealed class ObjectOperations : ArrayOperations<ObjectInstance>
		{
			public ObjectOperations(ObjectInstance target)
				: base(target)
			{
			}

			private double GetIntegerLength()
			{
				JsValue jsValue = _target.Get(CommonProperties.Length);
				if ((object)jsValue != null)
				{
					return TypeConverter.ToInteger(jsValue);
				}
				return 0.0;
			}

			public override ulong GetSmallestIndex(ulong length)
			{
				return _target.GetSmallestIndex(length);
			}

			public override uint GetLength()
			{
				double integerLength = GetIntegerLength();
				return (uint)((integerLength >= 0.0) ? integerLength : 0.0);
			}

			public override ulong GetLongLength()
			{
				double integerLength = GetIntegerLength();
				if (integerLength <= 0.0)
				{
					return 0uL;
				}
				return (ulong)System.Math.Min(integerLength, 9007199254740991.0);
			}

			public override void SetLength(ulong length)
			{
				_target.Set(CommonProperties.Length, length, throwOnError: true);
			}

			public override void EnsureCapacity(ulong capacity)
			{
			}

			public override JsValue Get(ulong index)
			{
				return _target.Get(JsString.Create(index));
			}

			public override bool TryGetValue(ulong index, out JsValue value)
			{
				JsValue property = JsString.Create(index);
				bool flag = _target.HasProperty(property);
				value = (flag ? _target.Get(property) : JsValue.Undefined);
				return flag;
			}

			public override void CreateDataPropertyOrThrow(ulong index, JsValue value)
			{
				_target.CreateDataPropertyOrThrow(JsString.Create(index), value);
			}

			public override void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true)
			{
				_target.Set(JsString.Create(index), value, throwOnError);
			}

			public override void DeletePropertyOrThrow(ulong index)
			{
				_target.DeletePropertyOrThrow(JsString.Create(index));
			}

			public override bool HasProperty(ulong index)
			{
				return Target.HasProperty(index);
			}
		}

		private sealed class JsArrayOperations : ArrayOperations<JsArray>
		{
			public JsArrayOperations(JsArray target)
				: base(target)
			{
			}

			public override ulong GetSmallestIndex(ulong length)
			{
				return _target.GetSmallestIndex();
			}

			public override uint GetLength()
			{
				return (uint)((JsNumber)_target._length._value)._value;
			}

			public override ulong GetLongLength()
			{
				return (ulong)((JsNumber)_target._length._value)._value;
			}

			public override void SetLength(ulong length)
			{
				_target.SetLength(length);
			}

			public override void EnsureCapacity(ulong capacity)
			{
				_target.EnsureCapacity((uint)capacity);
			}

			public override bool TryGetValue(ulong index, out JsValue value)
			{
				return _target.TryGetValue((uint)index, out value);
			}

			public override JsValue Get(ulong index)
			{
				return _target.Get((uint)index);
			}

			public override JsValue[] GetAll(Types elementTypes = Types.Undefined | Types.Null | Types.Boolean | Types.String | Types.Number | Types.Symbol | Types.Object, bool skipHoles = false)
			{
				uint length = _target.GetLength();
				if (_target._dense == null || _target._dense.Length < length)
				{
					return base.GetAll(elementTypes);
				}
				uint num = 0u;
				JsValue[] array = new JsValue[length];
				for (uint num2 = 0u; num2 < (uint)array.Length; num2++)
				{
					JsValue jsValue = _target._dense[num2];
					if ((object)jsValue == null)
					{
						jsValue = _target.Prototype?.Get(num2) ?? JsValue.Undefined;
					}
					if ((jsValue.Type & elementTypes) == 0)
					{
						ExceptionHelper.ThrowTypeErrorNoEngine("invalid type");
					}
					array[num++] = jsValue ?? JsValue.Undefined;
				}
				return array;
			}

			public override void DeletePropertyOrThrow(ulong index)
			{
				_target.DeletePropertyOrThrow((uint)index);
			}

			public override void CreateDataPropertyOrThrow(ulong index, JsValue value)
			{
				_target.SetIndexValue((uint)index, value, updateLength: false);
			}

			public override void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true)
			{
				_target.SetIndexValue((uint)index, value, updateLength);
			}

			public override bool HasProperty(ulong index)
			{
				return _target.HasProperty(index);
			}
		}

		private sealed class JsTypedArrayOperations : ArrayOperations
		{
			private readonly JsTypedArray _target;

			public override ObjectInstance Target => _target;

			public JsTypedArrayOperations(JsTypedArray target)
			{
				_target = target;
			}

			public override ulong GetSmallestIndex(ulong length)
			{
				return 0uL;
			}

			public override uint GetLength()
			{
				if (!_target.IsConcatSpreadable)
				{
					return _target.GetLength();
				}
				JsValue jsValue = _target.Get(CommonProperties.Length);
				if ((object)jsValue != null)
				{
					return (uint)TypeConverter.ToInteger(jsValue);
				}
				return 0u;
			}

			public override ulong GetLongLength()
			{
				return GetLength();
			}

			public override void SetLength(ulong length)
			{
			}

			public override void EnsureCapacity(ulong capacity)
			{
			}

			public override JsValue Get(ulong index)
			{
				return _target[(int)index];
			}

			public override bool TryGetValue(ulong index, out JsValue value)
			{
				if (_target.IsValidIntegerIndex(index))
				{
					value = _target[(int)index];
					return true;
				}
				value = JsValue.Undefined;
				return false;
			}

			public override void CreateDataPropertyOrThrow(ulong index, JsValue value)
			{
				_target.CreateDataPropertyOrThrow(index, value);
			}

			public override void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true)
			{
				_target[(int)index] = value;
			}

			public override void DeletePropertyOrThrow(ulong index)
			{
				_target.DeletePropertyOrThrow(index);
			}

			public override bool HasProperty(ulong index)
			{
				return _target.HasProperty(index);
			}
		}

		private sealed class JsStringOperations : ArrayOperations
		{
			private readonly Realm _realm;

			private readonly JsString _target;

			private ObjectInstance? _wrappedTarget;

			public override ObjectInstance Target => _wrappedTarget ?? (_wrappedTarget = _realm.Intrinsics.String.Construct(_target));

			public JsStringOperations(Realm realm, JsString target)
			{
				_realm = realm;
				_target = target;
			}

			public JsStringOperations(Realm realm, StringInstance stringInstance)
				: this(realm, stringInstance.StringData)
			{
				_wrappedTarget = stringInstance;
			}

			public override ulong GetSmallestIndex(ulong length)
			{
				return 0uL;
			}

			public override uint GetLength()
			{
				return (uint)_target.Length;
			}

			public override ulong GetLongLength()
			{
				return GetLength();
			}

			public override void SetLength(ulong length)
			{
				throw new NotSupportedException();
			}

			public override void EnsureCapacity(ulong capacity)
			{
			}

			public override JsValue Get(ulong index)
			{
				if (index >= (ulong)_target.Length)
				{
					return JsValue.Undefined;
				}
				return _target[(int)index];
			}

			public override bool TryGetValue(ulong index, out JsValue value)
			{
				if (index < (ulong)_target.Length)
				{
					value = _target[(int)index];
					return true;
				}
				value = JsValue.Undefined;
				return false;
			}

			public override bool HasProperty(ulong index)
			{
				return index < (ulong)_target.Length;
			}

			public override void CreateDataPropertyOrThrow(ulong index, JsValue value)
			{
				throw new NotSupportedException();
			}

			public override void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true)
			{
				throw new NotSupportedException();
			}

			public override void DeletePropertyOrThrow(ulong index)
			{
				throw new NotSupportedException();
			}
		}

		private sealed class ArrayReadOperations : ArrayOperations
		{
			private readonly JsArray _target;

			private readonly JsValue?[] _data;

			private readonly uint _length;

			public override ObjectInstance Target => _target;

			public ArrayReadOperations(JsArray target)
			{
				_target = target;
				_data = target._dense ?? System.Array.Empty<JsValue>();
				_length = target.Length;
			}

			public override ulong GetSmallestIndex(ulong length)
			{
				return 0uL;
			}

			public override uint GetLength()
			{
				return _length;
			}

			public override ulong GetLongLength()
			{
				return _length;
			}

			public override void SetLength(ulong length)
			{
				throw new NotSupportedException();
			}

			public override void EnsureCapacity(ulong capacity)
			{
			}

			public override JsValue Get(ulong index)
			{
				return ((index < (ulong)_data.Length) ? _data[(uint)index] : JsValue.Undefined) ?? JsValue.Undefined;
			}

			public override bool TryGetValue(ulong index, out JsValue value)
			{
				if (index < _length)
				{
					value = _data[(uint)index];
					return (object)value != null;
				}
				value = JsValue.Undefined;
				return false;
			}

			public override bool HasProperty(ulong index)
			{
				if (index < _length)
				{
					return (object)_data[index] != null;
				}
				return false;
			}

			public override void CreateDataPropertyOrThrow(ulong index, JsValue value)
			{
				throw new NotSupportedException();
			}

			public override void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true)
			{
				throw new NotSupportedException();
			}

			public override void DeletePropertyOrThrow(ulong index)
			{
				throw new NotSupportedException();
			}
		}

		private sealed class IndexWrappedOperations : ArrayOperations
		{
			private readonly ObjectWrapper _target;

			private readonly ICollection _collection;

			private readonly IList _list;

			public override ObjectInstance Target => _target;

			public IndexWrappedOperations(ObjectWrapper wrapper)
			{
				_target = wrapper;
				_collection = (ICollection)wrapper.Target;
				_list = (IList)wrapper.Target;
			}

			public override ulong GetSmallestIndex(ulong length)
			{
				return 0uL;
			}

			public override uint GetLength()
			{
				return (uint)_collection.Count;
			}

			public override ulong GetLongLength()
			{
				return GetLength();
			}

			public override void SetLength(ulong length)
			{
				if (_list == null)
				{
					throw new NotSupportedException();
				}
				while (_list.Count > (int)length)
				{
					_list.RemoveAt(_list.Count - 1);
				}
				while (_list.Count < (int)length)
				{
					_list.Add(null);
				}
			}

			public override void EnsureCapacity(ulong capacity)
			{
			}

			public override JsValue Get(ulong index)
			{
				if (index >= (ulong)_collection.Count)
				{
					return JsValue.Undefined;
				}
				return ReadValue((int)index);
			}

			public override bool TryGetValue(ulong index, out JsValue value)
			{
				if (index < (ulong)_collection.Count)
				{
					value = ReadValue((int)index);
					return true;
				}
				value = JsValue.Undefined;
				return false;
			}

			private JsValue ReadValue(int index)
			{
				if (_list != null)
				{
					if ((uint)index >= _list.Count)
					{
						return JsValue.Undefined;
					}
					return JsValue.FromObject(_target.Engine, _list[index]);
				}
				return JsValue.FromObject(_target.Engine, _target._typeDescriptor.IntegerIndexerProperty.GetValue(Target, new object[1] { index }));
			}

			public override bool HasProperty(ulong index)
			{
				return index < (ulong)_collection.Count;
			}

			public override void CreateDataPropertyOrThrow(ulong index, JsValue value)
			{
				_target.CreateDataPropertyOrThrow(index, value);
			}

			public override void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true)
			{
				if (updateLength && _list != null && index >= (ulong)_list.Count)
				{
					SetLength(index + 1);
				}
				_target[(int)index] = value;
			}

			public override void DeletePropertyOrThrow(ulong index)
			{
				_target.DeletePropertyOrThrow(index);
			}
		}

		private sealed class ArrayLikeOperations : ArrayOperations
		{
			private readonly ArrayLikeWrapper _target;

			public override ObjectInstance Target => _target;

			public ArrayLikeOperations(ArrayLikeWrapper wrapper)
			{
				_target = wrapper;
			}

			public override ulong GetSmallestIndex(ulong length)
			{
				return 0uL;
			}

			public override uint GetLength()
			{
				return (uint)_target.Length;
			}

			public override ulong GetLongLength()
			{
				return GetLength();
			}

			public override void SetLength(ulong length)
			{
				while (_target.Length > (int)length)
				{
					_target.RemoveAt(_target.Length - 1);
				}
				while (_target.Length < (int)length)
				{
					_target.AddDefault();
				}
			}

			public override void EnsureCapacity(ulong capacity)
			{
				_target.EnsureCapacity((int)capacity);
			}

			public override JsValue Get(ulong index)
			{
				if (index >= (ulong)_target.Length)
				{
					return JsValue.Undefined;
				}
				return ReadValue((int)index);
			}

			public override bool TryGetValue(ulong index, out JsValue value)
			{
				if (index < (ulong)_target.Length)
				{
					value = ReadValue((int)index);
					return true;
				}
				value = JsValue.Undefined;
				return false;
			}

			private JsValue ReadValue(int index)
			{
				if ((uint)index >= _target.Length)
				{
					return JsValue.Undefined;
				}
				return JsValue.FromObject(_target.Engine, _target.GetAt(index));
			}

			public override bool HasProperty(ulong index)
			{
				return index < (ulong)_target.Length;
			}

			public override void CreateDataPropertyOrThrow(ulong index, JsValue value)
			{
				_target.CreateDataPropertyOrThrow(index, value);
			}

			public override void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true)
			{
				EnsureCapacity(index + 1);
				_target.SetAt((int)index, value);
			}

			public override void DeletePropertyOrThrow(ulong index)
			{
				_target.DeletePropertyOrThrow(index);
			}
		}

		protected internal const ulong MaxArrayLength = 4294967295uL;

		protected internal const ulong MaxArrayLikeLength = 9007199254740991uL;

		public abstract ObjectInstance Target { get; }

		public static ArrayOperations For(Realm realm, JsValue value, bool forWrite)
		{
			if (!forWrite)
			{
				if (value.IsString())
				{
					return new JsStringOperations(realm, (JsString)value);
				}
				if (value is StringInstance stringInstance)
				{
					return new JsStringOperations(realm, stringInstance);
				}
				if (value is JsArray { CanUseFastAccess: not false } jsArray)
				{
					long num = jsArray.Length;
					JsValue?[]? dense = jsArray._dense;
					if (num <= ((dense != null) ? dense.Length : (-1)))
					{
						return new ArrayReadOperations(jsArray);
					}
				}
			}
			return For(TypeConverter.ToObject(realm, value), forWrite);
		}

		public static ArrayOperations For(ObjectInstance instance, bool forWrite)
		{
			if (instance is JsArray { CanUseFastAccess: not false } jsArray)
			{
				return new JsArrayOperations(jsArray);
			}
			if (instance is JsTypedArray target)
			{
				return new JsTypedArrayOperations(target);
			}
			if (instance is ArrayLikeWrapper wrapper)
			{
				return new ArrayLikeOperations(wrapper);
			}
			if (instance is ObjectWrapper objectWrapper && objectWrapper._typeDescriptor.IsArrayLike && objectWrapper.Target is ICollection)
			{
				return new IndexWrappedOperations(objectWrapper);
			}
			return new ObjectOperations(instance);
		}

		public abstract ulong GetSmallestIndex(ulong length);

		public abstract uint GetLength();

		public abstract ulong GetLongLength();

		public abstract void SetLength(ulong length);

		public abstract void EnsureCapacity(ulong capacity);

		public abstract JsValue Get(ulong index);

		public virtual JsValue[] GetAll(Types elementTypes = Types.Undefined | Types.Null | Types.Boolean | Types.String | Types.Number | Types.Symbol | Types.Object, bool skipHoles = false)
		{
			uint num = 0u;
			JsValue[] array = new JsValue[GetLength()];
			for (uint num2 = 0u; num2 < (uint)array.Length; num2++)
			{
				JsValue jsValue = ((skipHoles && !HasProperty(num2)) ? JsValue.Undefined : Get(num2));
				if ((jsValue.Type & elementTypes) == 0)
				{
					ExceptionHelper.ThrowTypeErrorNoEngine("invalid type");
				}
				array[num++] = jsValue;
			}
			return array;
		}

		public abstract bool TryGetValue(ulong index, out JsValue value);

		public abstract bool HasProperty(ulong index);

		public abstract void CreateDataPropertyOrThrow(ulong index, JsValue value);

		public abstract void Set(ulong index, JsValue value, bool updateLength = false, bool throwOnError = true);

		public abstract void DeletePropertyOrThrow(ulong index);

		public ArrayLikeIterator GetEnumerator()
		{
			return new ArrayLikeIterator(this);
		}

		IEnumerator<JsValue> IEnumerable<JsValue>.GetEnumerator()
		{
			return new ArrayLikeIterator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new ArrayLikeIterator(this);
		}
	}
	internal abstract class ArrayOperations<T> : ArrayOperations where T : ObjectInstance
	{
		protected readonly T _target;

		public override ObjectInstance Target => _target;

		protected ArrayOperations(T target)
		{
			_target = target;
		}
	}
	public sealed class ArrayPrototype : ArrayInstance
	{
		internal sealed class ArrayComparer : IComparer<JsValue>
		{
			public static readonly ArrayComparer Default = new ArrayComparer(null, null);

			private readonly Engine? _engine;

			private readonly ICallable? _compare;

			private readonly JsValue[] _comparableArray = new JsValue[2];

			public static ArrayComparer WithFunction(Engine engine, ICallable? compare)
			{
				if (compare != null)
				{
					return new ArrayComparer(engine, compare);
				}
				return Default;
			}

			private ArrayComparer(Engine? engine, ICallable? compare)
			{
				_engine = engine;
				_compare = compare;
			}

			public int Compare(JsValue? x, JsValue? y)
			{
				bool num = (object)x == null;
				bool flag = (object)y == null;
				if (num)
				{
					if (flag)
					{
						return 0;
					}
					return 1;
				}
				if (flag)
				{
					return -1;
				}
				bool flag2 = x.IsUndefined();
				bool flag3 = y.IsUndefined();
				if (flag2 && flag3)
				{
					return 0;
				}
				if (flag2)
				{
					return 1;
				}
				if (flag3)
				{
					return -1;
				}
				if (_compare != null)
				{
					_engine.RunBeforeExecuteStatementChecks(null);
					_comparableArray[0] = x;
					_comparableArray[1] = y;
					double num2 = TypeConverter.ToNumber(_compare.Call(JsValue.Undefined, _comparableArray));
					if (num2 < 0.0)
					{
						return -1;
					}
					if (num2 > 0.0)
					{
						return 1;
					}
					return 0;
				}
				string strA = TypeConverter.ToString(x);
				string strB = TypeConverter.ToString(y);
				return string.CompareOrdinal(strA, strB);
			}
		}

		private readonly Realm _realm;

		private readonly ArrayConstructor _constructor;

		internal ClrFunction? _originalIteratorFunction;

		internal ArrayPrototype(Engine engine, Realm realm, ArrayConstructor arrayConstructor, ObjectPrototype objectPrototype)
			: base(engine, InternalTypes.Object)
		{
			_prototype = objectPrototype;
			_length = new PropertyDescriptor(JsNumber.PositiveZero, PropertyFlag.Writable);
			_realm = realm;
			_constructor = arrayConstructor;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(38, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["at"] = new PropertyDescriptor(new ClrFunction(base.Engine, "at", At, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["concat"] = new PropertyDescriptor(new ClrFunction(base.Engine, "concat", Concat, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["copyWithin"] = new PropertyDescriptor(new ClrFunction(base.Engine, "copyWithin", CopyWithin, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["entries"] = new PropertyDescriptor(new ClrFunction(base.Engine, "entries", Entries, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["every"] = new PropertyDescriptor(new ClrFunction(base.Engine, "every", Every, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["fill"] = new PropertyDescriptor(new ClrFunction(base.Engine, "fill", Fill, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["filter"] = new PropertyDescriptor(new ClrFunction(base.Engine, "filter", Filter, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["find"] = new PropertyDescriptor(new ClrFunction(base.Engine, "find", Find, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["findIndex"] = new PropertyDescriptor(new ClrFunction(base.Engine, "findIndex", FindIndex, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["findLast"] = new PropertyDescriptor(new ClrFunction(base.Engine, "findLast", FindLast, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["findLastIndex"] = new PropertyDescriptor(new ClrFunction(base.Engine, "findLastIndex", FindLastIndex, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["flat"] = new PropertyDescriptor(new ClrFunction(base.Engine, "flat", Flat, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["flatMap"] = new PropertyDescriptor(new ClrFunction(base.Engine, "flatMap", FlatMap, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["forEach"] = new PropertyDescriptor(new ClrFunction(base.Engine, "forEach", ForEach, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["includes"] = new PropertyDescriptor(new ClrFunction(base.Engine, "includes", Includes, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["indexOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "indexOf", IndexOf, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["join"] = new PropertyDescriptor(new ClrFunction(base.Engine, "join", Join, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["keys"] = new PropertyDescriptor(new ClrFunction(base.Engine, "keys", Keys, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["lastIndexOf"] = new PropertyDescriptor(new ClrFunction(base.Engine, "lastIndexOf", LastIndexOf, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["map"] = new PropertyDescriptor(new ClrFunction(base.Engine, "map", Map, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["pop"] = new PropertyDescriptor(new ClrFunction(base.Engine, "pop", Pop, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["push"] = new PropertyDescriptor(new ClrFunction(base.Engine, "push", Push, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["reduce"] = new PropertyDescriptor(new ClrFunction(base.Engine, "reduce", Reduce, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["reduceRight"] = new PropertyDescriptor(new ClrFunction(base.Engine, "reduceRight", ReduceRight, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["reverse"] = new PropertyDescriptor(new ClrFunction(base.Engine, "reverse", Reverse, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["shift"] = new PropertyDescriptor(new ClrFunction(base.Engine, "shift", Shift, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["slice"] = new PropertyDescriptor(new ClrFunction(base.Engine, "slice", Slice, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["some"] = new PropertyDescriptor(new ClrFunction(base.Engine, "some", Some, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["sort"] = new PropertyDescriptor(new ClrFunction(base.Engine, "sort", Sort, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["splice"] = new PropertyDescriptor(new ClrFunction(base.Engine, "splice", Splice, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toLocaleString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toLocaleString", ToLocaleString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toReversed"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toReversed", ToReversed, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toSorted"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toSorted", ToSorted, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toSpliced"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toSpliced", ToSpliced, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["toString"] = new PropertyDescriptor(new ClrFunction(base.Engine, "toString", ToString, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["unshift"] = new PropertyDescriptor(new ClrFunction(base.Engine, "unshift", Unshift, 1, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["values"] = new PropertyDescriptor(new ClrFunction(base.Engine, "values", Values, 0, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable),
				["with"] = new PropertyDescriptor(new ClrFunction(base.Engine, "with", With, 2, PropertyFlag.Configurable), PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
			_originalIteratorFunction = new ClrFunction(base.Engine, "iterator", Values, 1);
			SymbolDictionary symbolDictionary = new SymbolDictionary(2);
			JsSymbol iterator = GlobalSymbolRegistry.Iterator;
			symbolDictionary[iterator] = new PropertyDescriptor(_originalIteratorFunction, PropertyFlag.Writable | PropertyFlag.Configurable);
			JsSymbol unscopables = GlobalSymbolRegistry.Unscopables;
			symbolDictionary[unscopables] = new LazyPropertyDescriptor(_engine, delegate(object? state)
			{
				JsObject jsObject = new JsObject((Engine)state);
				jsObject._prototype = null;
				jsObject.FastSetDataProperty("at", JsBoolean.True);
				jsObject.FastSetDataProperty("copyWithin", JsBoolean.True);
				jsObject.FastSetDataProperty("entries", JsBoolean.True);
				jsObject.FastSetDataProperty("fill", JsBoolean.True);
				jsObject.FastSetDataProperty("find", JsBoolean.True);
				jsObject.FastSetDataProperty("findIndex", JsBoolean.True);
				jsObject.FastSetDataProperty("findLast", JsBoolean.True);
				jsObject.FastSetDataProperty("findLastIndex", JsBoolean.True);
				jsObject.FastSetDataProperty("flat", JsBoolean.True);
				jsObject.FastSetDataProperty("flatMap", JsBoolean.True);
				jsObject.FastSetDataProperty("includes", JsBoolean.True);
				jsObject.FastSetDataProperty("keys", JsBoolean.True);
				jsObject.FastSetDataProperty("toReversed", JsBoolean.True);
				jsObject.FastSetDataProperty("toSorted", JsBoolean.True);
				jsObject.FastSetDataProperty("toSpliced", JsBoolean.True);
				jsObject.FastSetDataProperty("values", JsBoolean.True);
				return jsObject;
			}, PropertyFlag.Configurable);
			SymbolDictionary symbols = symbolDictionary;
			SetSymbols(symbols);
		}

		private ObjectInstance Keys(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is ObjectInstance { IsArrayLike: not false } objectInstance)
			{
				return _realm.Intrinsics.ArrayIteratorPrototype.Construct(objectInstance, ArrayIteratorType.Key);
			}
			ExceptionHelper.ThrowTypeError(_realm, "cannot construct iterator");
			return null;
		}

		internal ObjectInstance Values(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is ObjectInstance { IsArrayLike: not false } objectInstance)
			{
				return _realm.Intrinsics.ArrayIteratorPrototype.Construct(objectInstance, ArrayIteratorType.Value);
			}
			ExceptionHelper.ThrowTypeError(_realm, "cannot construct iterator");
			return null;
		}

		private ObjectInstance With(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(TypeConverter.ToObject(_realm, thisObject), forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			double num = TypeConverter.ToIntegerOrInfinity(arguments.At(0));
			JsValue jsValue = arguments.At(1);
			long num2 = ((!(num >= 0.0)) ? ((long)((double)longLength + num)) : ((long)num));
			if (num2 >= (long)longLength || num2 < 0)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid start index");
			}
			JsValue[] array = CreateBackingArray(longLength);
			for (ulong num3 = 0uL; num3 < longLength; num3++)
			{
				array[num3] = ((num3 == (ulong)num2) ? jsValue : arrayOperations.Get(num3));
			}
			return new JsArray(_engine, array);
		}

		private ObjectInstance Entries(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is ObjectInstance { IsArrayLike: not false } objectInstance)
			{
				return _realm.Intrinsics.ArrayIteratorPrototype.Construct(objectInstance, ArrayIteratorType.KeyAndValue);
			}
			ExceptionHelper.ThrowTypeError(_realm, "cannot construct iterator");
			return null;
		}

		private JsValue Fill(JsValue thisObject, JsValue[] arguments)
		{
			JsValue value = arguments.At(0);
			JsValue argument = arguments.At(1);
			JsValue jsValue = arguments.At(2);
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			ArrayOperations arrayOperations = ArrayOperations.For(objectInstance, forWrite: true);
			ulong longLength = arrayOperations.GetLongLength();
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			ulong num2 = (double.IsNegativeInfinity(num) ? 0 : ((!(num < 0.0)) ? ((ulong)System.Math.Min(num, longLength)) : ((ulong)System.Math.Max((double)longLength + num, 0.0))));
			double num3 = (jsValue.IsUndefined() ? ((double)longLength) : TypeConverter.ToIntegerOrInfinity(jsValue));
			ulong num4 = (double.IsNegativeInfinity(num3) ? 0 : ((!(num3 < 0.0)) ? ((ulong)System.Math.Min(num3, longLength)) : ((ulong)System.Math.Max((double)longLength + num3, 0.0))));
			for (ulong num5 = num2; num5 < num4; num5++)
			{
				arrayOperations.Set(num5, value, updateLength: false, throwOnError: false);
			}
			return objectInstance;
		}

		private JsValue CopyWithin(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			JsValue argument = arguments.At(0);
			JsValue argument2 = arguments.At(1);
			JsValue jsValue = arguments.At(2);
			ArrayOperations arrayOperations = ArrayOperations.For(objectInstance, forWrite: true);
			ulong longLength = arrayOperations.GetLongLength();
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			double num2 = ((num < 0.0) ? System.Math.Max((double)longLength + num, 0.0) : System.Math.Min(num, longLength));
			double num3 = TypeConverter.ToIntegerOrInfinity(argument2);
			long num4 = (double.IsNegativeInfinity(num3) ? 0 : ((!(num3 < 0.0)) ? ((long)System.Math.Min(num3, longLength)) : ((long)System.Math.Max((double)longLength + num3, 0.0))));
			double num5 = (jsValue.IsUndefined() ? ((double)longLength) : TypeConverter.ToIntegerOrInfinity(jsValue));
			long num6 = (double.IsNegativeInfinity(num5) ? 0 : ((!(num5 < 0.0)) ? ((long)System.Math.Min(num5, longLength)) : ((long)System.Math.Max((double)longLength + num5, 0.0))));
			long num7 = (long)System.Math.Min(num6 - num4, (double)longLength - num2);
			long num8 = 1L;
			if ((double)num4 < num2 && num2 < (double)(num4 + num7))
			{
				num8 = -1L;
				num4 += num7 - 1;
				num2 += (double)(num7 - 1);
			}
			while (num7 > 0)
			{
				if (arrayOperations.HasProperty((ulong)num4))
				{
					JsValue value = arrayOperations.Get((ulong)num4);
					arrayOperations.Set((ulong)num2, value, updateLength: true);
				}
				else
				{
					arrayOperations.DeletePropertyOrThrow((ulong)num2);
				}
				num4 += num8;
				num2 += (double)num8;
				num7--;
			}
			return objectInstance;
		}

		private JsValue LastIndexOf(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			if (longLength == 0L)
			{
				return JsNumber.IntegerNegativeOne;
			}
			double num = ((arguments.Length > 1) ? TypeConverter.ToInteger(arguments[1]) : ((double)(longLength - 1)));
			double num2 = ((!(num >= 0.0)) ? ((double)longLength - System.Math.Abs(num)) : System.Math.Min(num, longLength - 1));
			if (num2 < 0.0 || num2 > 9007199254740991.0)
			{
				return JsNumber.IntegerNegativeOne;
			}
			JsValue jsValue = arguments.At(0);
			ulong num3 = (ulong)num2;
			while (true)
			{
				if (arrayOperations.HasProperty(num3) && arrayOperations.Get(num3) == jsValue)
				{
					return num3;
				}
				if (num3 == 0L)
				{
					break;
				}
				num3--;
			}
			return JsNumber.IntegerNegativeOne;
		}

		private JsValue Reduce(JsValue thisObject, JsValue[] arguments)
		{
			JsValue source = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			uint length = arrayOperations.GetLength();
			ICallable callable = GetCallable(source);
			if (length == 0 && arguments.Length < 2)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			int i = 0;
			JsValue jsValue2 = JsValue.Undefined;
			if (arguments.Length > 1)
			{
				jsValue2 = jsValue;
			}
			else
			{
				bool flag = false;
				while (!flag && i < length)
				{
					if (flag = arrayOperations.TryGetValue((uint)i, out JsValue value))
					{
						jsValue2 = value;
					}
					i++;
				}
				if (!flag)
				{
					ExceptionHelper.ThrowTypeError(_realm);
				}
			}
			JsValue[] array = new JsValue[4] { null, null, null, arrayOperations.Target };
			for (; i < length; i++)
			{
				uint num = (uint)i;
				if (arrayOperations.TryGetValue(num, out JsValue value2))
				{
					array[0] = jsValue2;
					array[1] = value2;
					array[2] = num;
					jsValue2 = callable.Call(JsValue.Undefined, array);
				}
			}
			return jsValue2;
		}

		private JsValue Filter(JsValue thisObject, JsValue[] arguments)
		{
			JsValue source = arguments.At(0);
			JsValue thisObject2 = arguments.At(1);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			uint length = arrayOperations.GetLength();
			ICallable callable = GetCallable(source);
			ObjectInstance objectInstance = _realm.Intrinsics.Array.ArraySpeciesCreate(TypeConverter.ToObject(_realm, thisObject), 0uL);
			ArrayOperations arrayOperations2 = ArrayOperations.For(objectInstance, forWrite: true);
			uint num = 0u;
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = arrayOperations.Target;
			for (uint num2 = 0u; num2 < length; num2++)
			{
				if (arrayOperations.TryGetValue(num2, out JsValue value))
				{
					array[0] = value;
					array[1] = num2;
					if (TypeConverter.ToBoolean(callable.Call(thisObject2, array)))
					{
						arrayOperations2.CreateDataPropertyOrThrow(num, value);
						num++;
					}
				}
			}
			arrayOperations2.SetLength(num);
			_engine._jsValueArrayPool.ReturnArray(array);
			return objectInstance;
		}

		private JsValue Map(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is JsArray { CanUseFastAccess: not false } jsArray && !jsArray.HasOwnProperty(CommonProperties.Constructor))
			{
				return jsArray.Map(arguments);
			}
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			if (longLength > uint.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid array length");
			}
			JsValue source = arguments.At(0);
			JsValue thisObject2 = arguments.At(1);
			ICallable callable = GetCallable(source);
			ArrayOperations arrayOperations2 = ArrayOperations.For(_realm.Intrinsics.Array.ArraySpeciesCreate(TypeConverter.ToObject(_realm, thisObject), (uint)longLength), forWrite: true);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = arrayOperations.Target;
			for (uint num = 0u; num < longLength; num++)
			{
				if (arrayOperations.TryGetValue(num, out JsValue value))
				{
					array[0] = value;
					array[1] = num;
					JsValue value2 = callable.Call(thisObject2, array);
					arrayOperations2.CreateDataPropertyOrThrow(num, value2);
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return arrayOperations2.Target;
		}

		private JsValue Flat(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			uint length = arrayOperations.GetLength();
			double num = 1.0;
			JsValue jsValue = arguments.At(0);
			if (!jsValue.IsUndefined())
			{
				num = TypeConverter.ToIntegerOrInfinity(jsValue);
			}
			if (num < 0.0)
			{
				num = 0.0;
			}
			ObjectInstance objectInstance = _realm.Intrinsics.Array.ArraySpeciesCreate(arrayOperations.Target, 0uL);
			FlattenIntoArray(objectInstance, arrayOperations, length, 0uL, num);
			return objectInstance;
		}

		private JsValue FlatMap(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			JsValue jsValue = arguments.At(0);
			JsValue thisArg = arguments.At(1);
			uint length = arrayOperations.GetLength();
			if (!jsValue.IsCallable)
			{
				ExceptionHelper.ThrowTypeError(_realm, "flatMap mapper function is not callable");
			}
			ObjectInstance objectInstance = _realm.Intrinsics.Array.ArraySpeciesCreate(arrayOperations.Target, 0uL);
			FlattenIntoArray(objectInstance, arrayOperations, length, 0uL, 1.0, (ICallable)jsValue, thisArg);
			return objectInstance;
		}

		private ulong FlattenIntoArray(ObjectInstance target, ArrayOperations source, uint sourceLen, ulong start, double depth, ICallable? mapperFunction = null, JsValue? thisArg = null)
		{
			ulong num = start;
			ulong num2 = 0uL;
			JsValue[] array = System.Array.Empty<JsValue>();
			if (mapperFunction != null)
			{
				array = _engine._jsValueArrayPool.RentArray(3);
				array[2] = source.Target;
			}
			for (; num2 < sourceLen; num2++)
			{
				if (!source.HasProperty(num2))
				{
					continue;
				}
				JsValue jsValue = source.Get(num2);
				if (mapperFunction != null)
				{
					array[0] = jsValue;
					array[1] = JsNumber.Create(num2);
					jsValue = mapperFunction.Call(thisArg ?? JsValue.Undefined, array);
				}
				bool flag = false;
				if (depth > 0.0)
				{
					flag = jsValue.IsArray();
				}
				if (flag)
				{
					double depth2 = (double.IsPositiveInfinity(depth) ? depth : (depth - 1.0));
					ObjectInstance objectInstance = (ObjectInstance)jsValue;
					uint length = objectInstance.GetLength();
					num = FlattenIntoArray(target, ArrayOperations.For(objectInstance, forWrite: false), length, num, depth2);
					continue;
				}
				if (num >= 9007199254740991L)
				{
					ExceptionHelper.ThrowTypeError(_realm);
				}
				target.CreateDataPropertyOrThrow(num, jsValue);
				num++;
			}
			if (mapperFunction != null)
			{
				_engine._jsValueArrayPool.ReturnArray(array);
			}
			return num;
		}

		private JsValue ForEach(JsValue thisObject, JsValue[] arguments)
		{
			JsValue source = arguments.At(0);
			JsValue thisObject2 = arguments.At(1);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			uint length = arrayOperations.GetLength();
			ICallable callable = GetCallable(source);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = arrayOperations.Target;
			for (uint num = 0u; num < length; num++)
			{
				if (arrayOperations.TryGetValue(num, out JsValue value))
				{
					array[0] = value;
					array[1] = num;
					callable.Call(thisObject2, array);
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return JsValue.Undefined;
		}

		private JsValue Includes(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			long longLength = (long)arrayOperations.GetLongLength();
			if (longLength == 0L)
			{
				return JsBoolean.False;
			}
			JsValue y = arguments.At(0);
			JsValue argument = arguments.At(1);
			long num = 0L;
			double num2 = TypeConverter.ToIntegerOrInfinity(argument);
			if (double.IsPositiveInfinity(num2))
			{
				return JsBoolean.False;
			}
			if (double.IsNegativeInfinity(num2))
			{
				num2 = 0.0;
			}
			else if (num2 >= 0.0)
			{
				num = (long)num2;
			}
			else
			{
				num = longLength + (long)num2;
				if (num < 0)
				{
					num = 0L;
				}
			}
			for (; num < longLength; num++)
			{
				if (SameValueZeroComparer.Equals(arrayOperations.Get((ulong)num), y))
				{
					return true;
				}
			}
			return false;
		}

		private JsValue Some(JsValue thisObject, JsValue[] arguments)
		{
			ulong index;
			JsValue value;
			return TypeConverter.ToObject(_realm, thisObject).FindWithCallback(arguments, out index, out value, visitUnassigned: false);
		}

		private JsValue Every(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			if (longLength == 0L)
			{
				return JsBoolean.True;
			}
			JsValue source = arguments.At(0);
			JsValue thisObject2 = arguments.At(1);
			ICallable callable = GetCallable(source);
			JsValue[] array = _engine._jsValueArrayPool.RentArray(3);
			array[2] = arrayOperations.Target;
			for (uint num = 0u; num < longLength; num++)
			{
				if (arrayOperations.TryGetValue(num, out JsValue value))
				{
					array[0] = value;
					array[1] = num;
					if (!TypeConverter.ToBoolean(callable.Call(thisObject2, array)))
					{
						return JsBoolean.False;
					}
				}
			}
			_engine._jsValueArrayPool.ReturnArray(array);
			return JsBoolean.True;
		}

		private JsValue IndexOf(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			if (longLength == 0L)
			{
				return -1;
			}
			double num = ((arguments.Length > 1) ? TypeConverter.ToIntegerOrInfinity(arguments.At(1)) : 0.0);
			if (num > 9007199254740991.0)
			{
				return JsNumber.IntegerNegativeOne;
			}
			ulong num4;
			if (num < 0.0)
			{
				double num2 = System.Math.Abs(num);
				ulong num3 = longLength - (uint)num2;
				if (num2 > (double)longLength || num3 < 0)
				{
					num3 = 0uL;
				}
				num4 = num3;
			}
			else
			{
				num4 = (ulong)num;
			}
			if (num4 >= longLength)
			{
				return -1;
			}
			ulong smallestIndex = arrayOperations.GetSmallestIndex(longLength);
			if (smallestIndex > num4)
			{
				num4 = smallestIndex;
			}
			JsValue jsValue = arguments.At(0);
			for (; num4 < longLength; num4++)
			{
				if (arrayOperations.HasProperty(num4) && arrayOperations.Get(num4) == jsValue)
				{
					return num4;
				}
			}
			return -1;
		}

		private JsValue Find(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.ToObject(_realm, thisObject).FindWithCallback(arguments, out ulong _, out JsValue value, visitUnassigned: true);
			return value;
		}

		private JsValue FindIndex(JsValue thisObject, JsValue[] arguments)
		{
			if (TypeConverter.ToObject(_realm, thisObject).FindWithCallback(arguments, out ulong index, out JsValue _, visitUnassigned: true))
			{
				return index;
			}
			return -1;
		}

		private JsValue FindLast(JsValue thisObject, JsValue[] arguments)
		{
			TypeConverter.ToObject(_realm, thisObject).FindWithCallback(arguments, out ulong _, out JsValue value, visitUnassigned: true, fromEnd: true);
			return value;
		}

		private JsValue FindLastIndex(JsValue thisObject, JsValue[] arguments)
		{
			if (TypeConverter.ToObject(_realm, thisObject).FindWithCallback(arguments, out ulong index, out JsValue _, visitUnassigned: true, fromEnd: true))
			{
				return index;
			}
			return -1;
		}

		private JsValue At(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			uint length = objectInstance.GetLength();
			double num = TypeConverter.ToInteger(arguments.At(0));
			ulong num2 = ((!(num < 0.0)) ? ((ulong)num) : ((ulong)((double)length + num)));
			if (num2 < 0 || num2 >= length)
			{
				return JsValue.Undefined;
			}
			return objectInstance.Get(num2);
		}

		private JsValue Splice(JsValue thisObject, JsValue[] arguments)
		{
			JsValue o = arguments.At(0);
			JsValue o2 = arguments.At(1);
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, objectInstance, forWrite: true);
			ulong longLength = arrayOperations.GetLongLength();
			double num = TypeConverter.ToInteger(o);
			ulong num2 = ((!(num < 0.0)) ? ((ulong)System.Math.Min(num, longLength)) : ((ulong)System.Math.Max((double)longLength + num, 0.0)));
			JsValue[] array = System.Array.Empty<JsValue>();
			ulong num3;
			ulong num4;
			if (arguments.Length == 0)
			{
				num3 = 0uL;
				num4 = 0uL;
			}
			else if (arguments.Length == 1)
			{
				num3 = 0uL;
				num4 = longLength - num2;
			}
			else
			{
				num3 = (ulong)(arguments.Length - 2);
				num4 = (ulong)System.Math.Min(System.Math.Max(TypeConverter.ToInteger(o2), 0.0), longLength - num2);
				array = System.Array.Empty<JsValue>();
				if (arguments.Length > 2)
				{
					array = new JsValue[arguments.Length - 2];
					System.Array.Copy(arguments, 2, array, 0, array.Length);
				}
			}
			if (longLength + num3 - num4 > 9007199254740991L)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Invalid array length");
			}
			ArrayOperations arrayOperations2 = ArrayOperations.For(_realm.Intrinsics.Array.ArraySpeciesCreate(objectInstance, num4), forWrite: true);
			for (uint num5 = 0u; num5 < num4; num5++)
			{
				ulong index = num2 + num5;
				if (arrayOperations.HasProperty(index))
				{
					JsValue value = arrayOperations.Get(index);
					arrayOperations2.CreateDataPropertyOrThrow(num5, value);
				}
			}
			arrayOperations2.SetLength((uint)num4);
			ulong num6 = longLength - num4 + (uint)array.Length;
			arrayOperations.EnsureCapacity(num6);
			if ((ulong)array.Length < num4)
			{
				for (ulong num7 = num2; num7 < longLength - num4; num7++)
				{
					ulong index2 = num7 + num4;
					ulong index3 = num7 + (ulong)array.Length;
					if (arrayOperations.HasProperty(index2))
					{
						JsValue value2 = arrayOperations.Get(index2);
						arrayOperations.Set(index3, value2, updateLength: false, throwOnError: false);
					}
					else
					{
						arrayOperations.DeletePropertyOrThrow(index3);
					}
				}
				for (ulong num8 = longLength; num8 > (ulong)((long)(longLength - num4) + (long)array.Length); num8--)
				{
					arrayOperations.DeletePropertyOrThrow(num8 - 1);
				}
			}
			else if ((ulong)array.Length > num4)
			{
				for (ulong num9 = longLength - num4; num9 > num2; num9--)
				{
					ulong index4 = num9 + num4 - 1;
					ulong index5 = (ulong)((long)num9 + (long)array.Length - 1);
					if (arrayOperations.HasProperty(index4))
					{
						JsValue value3 = arrayOperations.Get(index4);
						arrayOperations.Set(index5, value3);
					}
					else
					{
						arrayOperations.DeletePropertyOrThrow(index5);
					}
				}
			}
			for (uint num10 = 0u; num10 < array.Length; num10++)
			{
				JsValue value4 = array[num10];
				arrayOperations.Set(num10 + num2, value4);
			}
			arrayOperations.SetLength(num6);
			return arrayOperations2.Target;
		}

		private JsValue Unshift(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			ulong longLength = arrayOperations.GetLongLength();
			uint num = (uint)arguments.Length;
			if (longLength + num > 9007199254740991L)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Invalid array length");
			}
			arrayOperations.EnsureCapacity(longLength + num);
			ulong smallestIndex = arrayOperations.GetSmallestIndex(longLength);
			for (ulong num2 = longLength; num2 > smallestIndex; num2--)
			{
				ulong index = num2 - 1;
				ulong index2 = num2 + num - 1;
				if (arrayOperations.TryGetValue(index, out JsValue value))
				{
					arrayOperations.Set(index2, value);
				}
				else
				{
					arrayOperations.DeletePropertyOrThrow(index2);
				}
			}
			for (uint num3 = 0u; num3 < num; num3++)
			{
				arrayOperations.Set(num3, arguments[num3]);
			}
			arrayOperations.SetLength(longLength + num);
			return longLength + num;
		}

		private JsValue Sort(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			ICallable compareFunction = GetCompareFunction(arguments.At(0));
			uint length = arrayOperations.GetLength();
			if (length <= 1)
			{
				return arrayOperations.Target;
			}
			List<JsValue> list = new List<JsValue>((int)System.Math.Min(10000u, arrayOperations.GetLength()));
			for (ulong num = 0uL; num < length; num++)
			{
				if (arrayOperations.TryGetValue(num, out JsValue value))
				{
					list.Add(value);
				}
			}
			_ = list.Count;
			try
			{
				ArrayComparer comparer = ArrayComparer.WithFunction(_engine, compareFunction);
				IOrderedEnumerable<JsValue> orderedEnumerable = list.OrderBy((JsValue x) => x, comparer);
				uint num2 = 0u;
				foreach (JsValue item in orderedEnumerable)
				{
					arrayOperations.Set(num2, item);
					num2++;
				}
				for (; num2 < length; num2++)
				{
					arrayOperations.DeletePropertyOrThrow(num2);
				}
			}
			catch (InvalidOperationException ex)
			{
				throw ex.InnerException ?? ex;
			}
			return arrayOperations.Target;
		}

		private JsValue Slice(JsValue thisObject, JsValue[] arguments)
		{
			JsValue o = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			double num = TypeConverter.ToInteger(o);
			ulong num2 = ((!(num < 0.0)) ? ((ulong)System.Math.Min(TypeConverter.ToInteger(o), longLength)) : ((ulong)System.Math.Max((double)longLength + num, 0.0)));
			ulong num3;
			if (jsValue.IsUndefined())
			{
				num3 = (ulong)TypeConverter.ToNumber(longLength);
			}
			else
			{
				double num4 = TypeConverter.ToInteger(jsValue);
				num3 = ((!(num4 < 0.0)) ? ((ulong)System.Math.Min(num4, longLength)) : ((ulong)System.Math.Max((double)longLength + num4, 0.0)));
			}
			if (num2 < num3 && num3 - num2 > uint.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(_realm, "Invalid array length");
			}
			uint num5 = (uint)System.Math.Max(0L, (long)(num3 - num2));
			ObjectInstance objectInstance = _realm.Intrinsics.Array.ArraySpeciesCreate(TypeConverter.ToObject(_realm, thisObject), num5);
			if (thisObject is JsArray source && objectInstance is JsArray jsArray)
			{
				jsArray.CopyValues(source, (uint)num2, 0u, num5);
			}
			else
			{
				ArrayOperations arrayOperations2 = ArrayOperations.For(objectInstance, forWrite: true);
				uint num6 = 0u;
				while (num2 < num3)
				{
					if (arrayOperations.TryGetValue(num2, out JsValue value))
					{
						arrayOperations2.CreateDataPropertyOrThrow(num6, value);
					}
					num2++;
					num6++;
				}
			}
			return objectInstance;
		}

		private JsValue Shift(JsValue thisObject, JsValue[] arg2)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			uint length = arrayOperations.GetLength();
			if (length == 0)
			{
				arrayOperations.SetLength(0uL);
				return JsValue.Undefined;
			}
			JsValue result = arrayOperations.Get(0uL);
			for (uint num = 1u; num < length; num++)
			{
				uint num2 = num - 1;
				if (arrayOperations.TryGetValue(num, out JsValue value))
				{
					arrayOperations.Set(num2, value, updateLength: false, throwOnError: false);
				}
				else
				{
					arrayOperations.DeletePropertyOrThrow(num2);
				}
			}
			arrayOperations.DeletePropertyOrThrow(length - 1);
			arrayOperations.SetLength(length - 1);
			return result;
		}

		private JsValue Reverse(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			ulong longLength = arrayOperations.GetLongLength();
			ulong num = (ulong)System.Math.Floor((double)longLength / 2.0);
			for (uint num2 = 0u; num2 != num; num2++)
			{
				ulong index = longLength - num2 - 1;
				bool num3 = arrayOperations.HasProperty(num2);
				JsValue value = (num3 ? arrayOperations.Get(num2) : null);
				bool flag = arrayOperations.HasProperty(index);
				JsValue value2 = (flag ? arrayOperations.Get(index) : null);
				if (num3 && flag)
				{
					arrayOperations.Set(num2, value2);
					arrayOperations.Set(index, value);
				}
				if (!num3 && flag)
				{
					arrayOperations.Set(num2, value2);
					arrayOperations.DeletePropertyOrThrow(index);
				}
				if (num3 && !flag)
				{
					arrayOperations.DeletePropertyOrThrow(num2);
					arrayOperations.Set(index, value);
				}
			}
			return arrayOperations.Target;
		}

		private JsValue Join(JsValue thisObject, JsValue[] arguments)
		{
			JsValue jsValue = arguments.At(0);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			uint length = arrayOperations.GetLength();
			string text = TypeConverter.ToString(jsValue.IsUndefined() ? JsString.CommaString : jsValue);
			if (length == 0)
			{
				return JsString.Empty;
			}
			string text2 = StringFromJsValue(arrayOperations.Get(0uL));
			if (length == 1)
			{
				return text2;
			}
			Span<char> initialBuffer = stackalloc char[256];
			using (System.Text.ValueStringBuilder valueStringBuilder = new System.Text.ValueStringBuilder(initialBuffer))
			{
				valueStringBuilder.Append(text2);
				for (uint num = 1u; num < length; num++)
				{
					if (text != "")
					{
						valueStringBuilder.Append(text);
					}
					valueStringBuilder.Append(StringFromJsValue(arrayOperations.Get(num)));
				}
				return valueStringBuilder.ToString();
			}
			static string StringFromJsValue(JsValue value)
			{
				if (!value.IsNullOrUndefined())
				{
					return TypeConverter.ToString(value);
				}
				return "";
			}
		}

		private JsValue ToLocaleString(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			uint length = arrayOperations.GetLength();
			if (length == 0)
			{
				return JsString.Empty;
			}
			JsValue value;
			JsValue jsValue = ((arrayOperations.TryGetValue(0uL, out value) && !value.IsNull() && !value.IsUndefined()) ? Invoke(value, "toLocaleString", System.Array.Empty<JsValue>()) : JsString.Empty);
			for (uint num = 1u; num < length; num++)
			{
				jsValue = string.Concat(jsValue?.ToString() + ",", ((arrayOperations.TryGetValue(num, out JsValue value2) && !value2.IsNull()) ? Invoke(value2, "toLocaleString", System.Array.Empty<JsValue>()) : JsString.Empty)?.ToString());
			}
			return jsValue;
		}

		private JsValue Concat(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance item = TypeConverter.ToObject(_realm, thisObject);
			List<JsValue> list = new List<JsValue>(arguments.Length + 1) { item };
			list.AddRange(arguments);
			uint num = 0u;
			ObjectInstance objectInstance = _realm.Intrinsics.Array.ArraySpeciesCreate(TypeConverter.ToObject(_realm, thisObject), 0uL);
			ArrayOperations arrayOperations = ArrayOperations.For(objectInstance, forWrite: true);
			for (int i = 0; i < list.Count; i++)
			{
				JsValue jsValue = list[i];
				if (jsValue is ObjectInstance { IsConcatSpreadable: not false } objectInstance2)
				{
					if (jsValue is JsArray jsArray && objectInstance is JsArray jsArray2)
					{
						jsArray2.CopyValues(jsArray, 0u, num, jsArray.GetLength());
						num += jsArray.GetLength();
						continue;
					}
					ArrayOperations arrayOperations2 = ArrayOperations.For(objectInstance2, forWrite: false);
					ulong longLength = arrayOperations2.GetLongLength();
					if (num + longLength > 9007199254740991L)
					{
						ExceptionHelper.ThrowTypeError(_realm, "Invalid array length");
					}
					for (uint num2 = 0u; num2 < longLength; num2++)
					{
						arrayOperations2.TryGetValue(num2, out JsValue value);
						arrayOperations.CreateDataPropertyOrThrow(num, value);
						num++;
					}
				}
				else
				{
					arrayOperations.CreateDataPropertyOrThrow(num, jsValue);
					num++;
				}
			}
			objectInstance.DefineOwnProperty(CommonProperties.Length, new PropertyDescriptor(num, PropertyFlag.OnlyWritable));
			return objectInstance;
		}

		internal JsValue ToString(JsValue thisObject, JsValue[] arguments)
		{
			ObjectInstance objectInstance = TypeConverter.ToObject(_realm, thisObject);
			Func<JsValue, JsValue[], JsValue> func = ((!(objectInstance.Get("join") is ICallable callable)) ? new Func<JsValue, JsValue[], JsValue>(_realm.Intrinsics.Object.PrototypeObject.ToObjectString) : new Func<JsValue, JsValue[], JsValue>(callable.Call));
			return func(objectInstance, Arguments.Empty);
		}

		private JsValue ToReversed(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			if (longLength == 0L)
			{
				return new JsArray(_engine);
			}
			JsValue[] array = CreateBackingArray(longLength);
			ulong num = 0uL;
			while (num < longLength)
			{
				ulong index = longLength - num - 1;
				array[num++] = arrayOperations.Get(index);
			}
			return new JsArray(_engine, array);
		}

		private JsValue ToSorted(JsValue thisObject, JsValue[] arguments)
		{
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: false);
			ICallable compareFunction = GetCompareFunction(arguments.At(0));
			ulong longLength = arrayOperations.GetLongLength();
			ValidateArrayLength(longLength);
			if (longLength == 0L)
			{
				return new JsArray(_engine);
			}
			JsValue[] all = arrayOperations.GetAll(Types.Undefined | Types.Null | Types.Boolean | Types.String | Types.Number | Types.Symbol | Types.Object, skipHoles: true);
			all = SortArray(all, compareFunction);
			return new JsArray(_engine, all);
		}

		private JsValue ToSpliced(JsValue thisObject, JsValue[] arguments)
		{
			JsValue argument = arguments.At(0);
			JsValue argument2 = arguments.At(1);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, TypeConverter.ToObject(_realm, thisObject), forWrite: false);
			ulong longLength = arrayOperations.GetLongLength();
			double num = TypeConverter.ToIntegerOrInfinity(argument);
			ulong num2 = (double.IsNegativeInfinity(num) ? 0 : ((!(num < 0.0)) ? ((ulong)System.Math.Min(num, longLength)) : ((ulong)System.Math.Max((double)longLength + num, 0.0))));
			JsValue[] array = System.Array.Empty<JsValue>();
			ulong num3;
			ulong num4;
			if (arguments.Length == 0)
			{
				num3 = 0uL;
				num4 = 0uL;
			}
			else if (arguments.Length == 1)
			{
				num3 = 0uL;
				num4 = longLength - num2;
			}
			else
			{
				num3 = (ulong)(arguments.Length - 2);
				num4 = (ulong)System.Math.Min(System.Math.Max(TypeConverter.ToIntegerOrInfinity(argument2), 0.0), longLength - num2);
				array = System.Array.Empty<JsValue>();
				if (arguments.Length > 2)
				{
					array = new JsValue[arguments.Length - 2];
					System.Array.Copy(arguments, 2, array, 0, array.Length);
				}
			}
			ulong num5 = longLength + num3 - num4;
			if (num5 > 9007199254740991L)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Invalid input length");
			}
			ValidateArrayLength(num5);
			ulong num6 = num2 + num4;
			JsArray jsArray = new JsArray(_engine, (uint)num5);
			uint num7;
			for (num7 = 0u; num7 < num2; num7++)
			{
				jsArray.SetIndexValue(num7, arrayOperations.Get(num7), updateLength: false);
			}
			jsArray.SetLength((uint)num2);
			JsValue[] array2 = array;
			foreach (JsValue value in array2)
			{
				jsArray.SetIndexValue(num7++, value, updateLength: false);
			}
			while (num7 < num5)
			{
				JsValue value2 = arrayOperations.Get(num6);
				jsArray.SetIndexValue(num7, value2, updateLength: false);
				num7++;
				num6++;
			}
			jsArray.SetLength(num7);
			return jsArray;
		}

		private JsValue[] SortArray(IEnumerable<JsValue> array, ICallable? compareFn)
		{
			ArrayComparer comparer = ArrayComparer.WithFunction(_engine, compareFn);
			try
			{
				return array.OrderBy((JsValue x) => x, comparer).ToArray();
			}
			catch (InvalidOperationException ex)
			{
				throw ex.InnerException ?? ex;
			}
		}

		private ICallable? GetCompareFunction(JsValue compareArg)
		{
			ICallable result = null;
			if (!compareArg.IsUndefined())
			{
				if (!(compareArg is ICallable callable))
				{
					ExceptionHelper.ThrowTypeError(_realm, "The comparison function must be either a function or undefined");
					return null;
				}
				result = callable;
			}
			return result;
		}

		private JsValue ReduceRight(JsValue thisObject, JsValue[] arguments)
		{
			JsValue source = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			ulong longLength = arrayOperations.GetLongLength();
			ICallable callable = GetCallable(source);
			if (longLength == 0L && arguments.Length < 2)
			{
				ExceptionHelper.ThrowTypeError(_realm);
			}
			long num = (long)(longLength - 1);
			JsValue jsValue2 = JsValue.Undefined;
			if (arguments.Length > 1)
			{
				jsValue2 = jsValue;
			}
			else
			{
				bool flag = false;
				while (!flag && num >= 0)
				{
					if (flag = arrayOperations.TryGetValue((ulong)num, out JsValue value))
					{
						jsValue2 = value;
					}
					num--;
				}
				if (!flag)
				{
					ExceptionHelper.ThrowTypeError(_realm);
				}
			}
			JsValue[] array = new JsValue[4] { null, null, null, arrayOperations.Target };
			while (num >= 0)
			{
				if (arrayOperations.TryGetValue((ulong)num, out JsValue value2))
				{
					array[0] = jsValue2;
					array[1] = value2;
					array[2] = num;
					jsValue2 = callable.Call(JsValue.Undefined, array);
				}
				num--;
			}
			return jsValue2;
		}

		public JsValue Push(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is JsArray { CanUseFastAccess: not false } jsArray)
			{
				return jsArray.Push(arguments);
			}
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			ulong num = arrayOperations.GetLongLength();
			if ((ulong)((long)num + (long)arguments.Length) > 9007199254740991uL)
			{
				ExceptionHelper.ThrowTypeError(_realm, "Invalid array length");
			}
			foreach (JsValue value in arguments)
			{
				arrayOperations.Set(num, value, updateLength: true);
				num++;
			}
			arrayOperations.SetLength(num);
			return num;
		}

		public JsValue Pop(JsValue thisObject, JsValue[] arguments)
		{
			if (thisObject is JsArray { CanUseFastAccess: not false } jsArray)
			{
				return jsArray.Pop();
			}
			ArrayOperations arrayOperations = ArrayOperations.For(_realm, thisObject, forWrite: true);
			ulong longLength = arrayOperations.GetLongLength();
			if (longLength == 0L)
			{
				arrayOperations.SetLength(0uL);
				return JsValue.Undefined;
			}
			longLength--;
			JsValue result = arrayOperations.Get(longLength);
			arrayOperations.DeletePropertyOrThrow(longLength);
			arrayOperations.SetLength(longLength);
			return result;
		}

		private JsValue[] CreateBackingArray(ulong length)
		{
			ValidateArrayLength(length);
			return new JsValue[length];
		}

		private void ValidateArrayLength(ulong length)
		{
			if (length > uint.MaxValue)
			{
				ExceptionHelper.ThrowRangeError(_engine.Realm, "Invalid array length " + length);
			}
		}
	}
}
namespace Jint.Native.AggregateError
{
	internal sealed class AggregateErrorConstructor : Constructor
	{
		private static readonly JsString _name = new JsString("AggregateError");

		private AggregateErrorPrototype PrototypeObject { get; }

		internal AggregateErrorConstructor(Engine engine, Realm realm, ErrorConstructor errorConstructor)
			: base(engine, realm, _name)
		{
			_prototype = errorConstructor;
			PrototypeObject = new AggregateErrorPrototype(engine, realm, this, errorConstructor.PrototypeObject);
			_length = new PropertyDescriptor(JsNumber.PositiveTwo, PropertyFlag.Configurable);
			_prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
		}

		protected internal override JsValue Call(JsValue thisObject, JsValue[] arguments)
		{
			return Construct(arguments, this);
		}

		public override ObjectInstance Construct(JsValue[] arguments, JsValue newTarget)
		{
			JsValue items = arguments.At(0);
			JsValue jsValue = arguments.At(1);
			JsValue options = arguments.At(2);
			JsError jsError = OrdinaryCreateFromConstructor(newTarget, (Intrinsics intrinsics) => intrinsics.AggregateError.PrototypeObject, (Engine engine, Realm _, object? _) => new JsError(engine));
			if (!jsValue.IsUndefined())
			{
				string text = TypeConverter.ToString(jsValue);
				jsError.CreateNonEnumerableDataPropertyOrThrow(CommonProperties.Message, text);
			}
			jsError.InstallErrorCause(options);
			List<JsValue> values = TypedArrayConstructor.IterableToList(_realm, items);
			jsError.DefinePropertyOrThrow("errors", new PropertyDescriptor(_realm.Intrinsics.Array.CreateArrayFromList(values), configurable: true, enumerable: false, writable: true));
			return jsError;
		}
	}
	internal sealed class AggregateErrorPrototype : Prototype
	{
		private readonly AggregateErrorConstructor _constructor;

		internal AggregateErrorPrototype(Engine engine, Realm realm, AggregateErrorConstructor constructor, ObjectInstance prototype)
			: base(engine, realm)
		{
			_constructor = constructor;
			_prototype = prototype;
		}

		protected override void Initialize()
		{
			PropertyDictionary properties = new PropertyDictionary(3, checkExistingKeys: false)
			{
				["constructor"] = new PropertyDescriptor(_constructor, PropertyFlag.NonEnumerable),
				["message"] = new PropertyDescriptor(JsString.Empty, PropertyFlag.Writable | PropertyFlag.Configurable),
				["name"] = new PropertyDescriptor("AggregateError", PropertyFlag.Writable | PropertyFlag.Configurable)
			};
			SetProperties(properties);
		}
	}
}
namespace Jint.Extensions
{
	internal static class Hash
	{
		private const int FnvOffsetBias = -2128831035;

		private const int FnvPrime = 16777619;

		internal static int GetFNVHashCode(ReadOnlySpan<char> data)
		{
			return CombineFNVHash(-2128831035, data);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetFNVHashCode(string text)
		{
			return CombineFNVHash(-2128831035, text);
		}

		internal static int GetFNVHashCode(StringBuilder text)
		{
			int num = -2128831035;
			StringBuilder.ChunkEnumerator enumerator = text.GetChunks().GetEnumerator();
			while (enumerator.MoveNext())
			{
				num = CombineFNVHash(num, enumerator.Current.Span);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
		private static int CombineFNVHash(int hashCode, string text)
		{
			foreach (char c in text)
			{
				hashCode = (hashCode ^ c) * 16777619;
			}
			return hashCode;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
		private static int CombineFNVHash(int hashCode, ReadOnlySpan<char> data)
		{
			for (int i = 0; i < data.Length; i++)
			{
				hashCode = (hashCode ^ data[i]) * 16777619;
			}
			return hashCode;
		}
	}
	internal static class JavascriptExtensions
	{
		internal static string UpperToLowerCamelCase(this string str)
		{
			if (char.IsLower(str[0]))
			{
				return str;
			}
			char[] array = str.ToCharArray();
			array[0] = char.ToLowerInvariant(array[0]);
			return new string(array);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly Type nullableType = typeof(Nullable<>);

		internal static void SetValue(this MemberInfo memberInfo, object forObject, object? value)
		{
			if (memberInfo.MemberType == MemberTypes.Field)
			{
				FieldInfo fieldInfo = (FieldInfo)memberInfo;
				if (value != null && fieldInfo.FieldType.IsInstanceOfType(value))
				{
					fieldInfo.SetValue(forObject, value);
				}
			}
			else if (memberInfo.MemberType == MemberTypes.Property)
			{
				PropertyInfo propertyInfo = (PropertyInfo)memberInfo;
				if (value != null && propertyInfo.PropertyType.IsInstanceOfType(value))
				{
					propertyInfo.SetValue(forObject, value);
				}
			}
		}

		internal static Type GetDefinedType(this MemberInfo memberInfo)
		{
			if (!(memberInfo is PropertyInfo propertyInfo))
			{
				if (memberInfo is FieldInfo fieldInfo)
				{
					return fieldInfo.FieldType;
				}
				return null;
			}
			return propertyInfo.PropertyType;
		}

		internal static IEnumerable<MethodInfo> GetExtensionMethods([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] this Type type)
		{
			return from m in type.GetMethods(BindingFlags.Static | BindingFlags.Public)
				where m.IsExtensionMethod()
				select m;
		}

		internal static IEnumerable<MethodInfo> GetOperatorOverloadMethods([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods)] this Type type)
		{
			return from m in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)
				where m.IsSpecialName
				select m;
		}

		private static bool IsExtensionMethod(this MethodBase methodInfo)
		{
			return methodInfo.IsDefined(typeof(ExtensionAttribute), inherit: true);
		}

		public static bool IsNullable(this Type type)
		{
			if ((object)type != null && type.IsGenericType)
			{
				return type.GetGenericTypeDefinition() == nullableType;
			}
			return false;
		}

		public static bool IsNumeric(this Type type)
		{
			if (type == null || type.IsEnum)
			{
				return false;
			}
			TypeCode typeCode = Type.GetTypeCode(type);
			if ((uint)(typeCode - 5) <= 10u)
			{
				return true;
			}
			return false;
		}

		public static bool IsClrNumericCoercible(this Type type)
		{
			if (type == null || type.IsEnum)
			{
				return false;
			}
			switch (Type.GetTypeCode(type))
			{
			case TypeCode.Int32:
			case TypeCode.Int64:
			case TypeCode.Double:
			case TypeCode.Decimal:
				return true;
			default:
				return false;
			}
		}

		public static object AsNumberOfType(this double d, TypeCode type)
		{
			switch (type)
			{
			case TypeCode.Decimal:
				return (decimal)d;
			case TypeCode.Double:
				return d;
			case TypeCode.Int32:
				return (int)d;
			case TypeCode.Int64:
				return (long)d;
			default:
				ExceptionHelper.ThrowArgumentException("Cannot convert " + type);
				return null;
			}
		}

		public static bool TryConvertViaTypeCoercion(Type? memberType, ValueCoercionType valueCoercionType, JsValue value, [NotNullWhen(true)] out object? converted)
		{
			if (value.IsInteger() && (memberType == typeof(int) || memberType == typeof(long)))
			{
				converted = value.AsInteger();
				return true;
			}
			if (memberType == typeof(bool) && (valueCoercionType & ValueCoercionType.Boolean) != ValueCoercionType.None)
			{
				converted = TypeConverter.ToBoolean(value);
				return true;
			}
			if (memberType == typeof(string) && !value.IsNullOrUndefined() && (valueCoercionType & ValueCoercionType.String) != ValueCoercionType.None)
			{
				converted = TypeConverter.ToString(value);
				return true;
			}
			if ((object)memberType != null && memberType.IsClrNumericCoercible() && (valueCoercionType & ValueCoercionType.Number) != ValueCoercionType.None)
			{
				double d = TypeConverter.ToNumber(value);
				converted = d.AsNumberOfType(Type.GetTypeCode(memberType));
				return true;
			}
			converted = null;
			return false;
		}
	}
}
namespace Jint.Constraints
{
	public sealed class CancellationConstraint : Constraint
	{
		private CancellationToken _cancellationToken;

		internal CancellationConstraint(CancellationToken cancellationToken)
		{
			_cancellationToken = cancellationToken;
		}

		public override void Check()
		{
			if (_cancellationToken.IsCancellationRequested)
			{
				ExceptionHelper.ThrowExecutionCanceledException();
			}
		}

		public void Reset(CancellationToken cancellationToken)
		{
			_cancellationToken = cancellationToken;
		}

		public override void Reset()
		{
		}
	}
	public sealed class MaxStatementsConstraint : Constraint
	{
		private int _statementsCount;

		public int MaxStatements { get; set; }

		internal MaxStatementsConstraint(int maxStatements)
		{
			MaxStatements = maxStatements;
		}

		public override void Check()
		{
			if (MaxStatements > 0 && _statementsCount++ > MaxStatements)
			{
				ExceptionHelper.ThrowStatementsCountOverflowException();
			}
		}

		public override void Reset()
		{
			_statementsCount = 0;
		}
	}
	public sealed class MemoryLimitConstraint : Constraint
	{
		private static readonly Func<long>? GetAllocatedBytesForCurrentThread;

		private readonly long _memoryLimit;

		private long _initialMemoryUsage;

		static MemoryLimitConstraint()
		{
			MethodInfo method = typeof(GC).GetMethod("GetAllocatedBytesForCurrentThread");
			if (method != null)
			{
				GetAllocatedBytesForCurrentThread = (Func<long>)Delegate.CreateDelegate(typeof(Func<long>), null, method);
			}
		}

		internal MemoryLimitConstraint(long memoryLimit)
		{
			_memoryLimit = memoryLimit;
		}

		public override void Check()
		{
			if (_memoryLimit <= 0)
			{
				return;
			}
			if (GetAllocatedBytesForCurrentThread != null)
			{
				long num = GetAllocatedBytesForCurrentThread() - _initialMemoryUsage;
				if (num > _memoryLimit)
				{
					ExceptionHelper.ThrowMemoryLimitExceededException($"Script has allocated {num} but is limited to {_memoryLimit}");
				}
			}
			else
			{
				ExceptionHelper.ThrowPlatformNotSupportedException("The current platform doesn't support MemoryLimit.");
			}
		}

		public override void Reset()
		{
			if (GetAllocatedBytesForCurrentThread != null)
			{
				_initialMemoryUsage = GetAllocatedBytesForCurrentThread();
			}
		}
	}
	internal sealed class TimeConstraint : Constraint
	{
		private readonly TimeSpan _timeout;

		private CancellationTokenSource? _cts;

		internal TimeConstraint(TimeSpan timeout)
		{
			_timeout = timeout;
		}

		public override void Check()
		{
			CancellationTokenSource? cts = _cts;
			if (cts != null && cts.IsCancellationRequested)
			{
				ExceptionHelper.ThrowTimeoutException();
			}
		}

		public override void Reset()
		{
			_cts?.Dispose();
			_cts = new CancellationTokenSource(_timeout);
		}
	}
}
namespace Jint.Collections
{
	[DebuggerDisplay("Count = {Count}")]
	internal class DictionarySlim<TKey, TValue> : IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : IEquatable<TKey>
	{
		[StructLayout(LayoutKind.Auto)]
		[DebuggerDisplay("({key}, {value})->{next}")]
		private struct Entry
		{
			public TKey key;

			public TValue value;

			public int next;
		}

		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable
		{
			private readonly DictionarySlim<TKey, TValue> _dictionary;

			private int _index;

			private int _count;

			private KeyValuePair<TKey, TValue> _current;

			public KeyValuePair<TKey, TValue> Current => _current;

			object IEnumerator.Current => _current;

			internal Enumerator(DictionarySlim<TKey, TValue> dictionary)
			{
				_dictionary = dictionary;
				_index = 0;
				_count = _dictionary._count;
				_current = default(KeyValuePair<TKey, TValue>);
			}

			public bool MoveNext()
			{
				if (_count == 0)
				{
					_current = default(KeyValuePair<TKey, TValue>);
					return false;
				}
				_count--;
				while (_dictionary._entries[_index].next < -1)
				{
					_index++;
				}
				_current = new KeyValuePair<TKey, TValue>(_dictionary._entries[_index].key, _dictionary._entries[_index++].value);
				return true;
			}

			void IEnumerator.Reset()
			{
				_index = 0;
				_count = _dictionary._count;
				_current = default(KeyValuePair<TKey, TValue>);
			}

			public void Dispose()
			{
			}
		}

		internal static class HashHelpers
		{
			internal static readonly int[] SizeOneIntArray = new int[1];

			internal static int PowerOf2(int v)
			{
				if ((v & (v - 1)) == 0)
				{
					return v;
				}
				int num;
				for (num = 2; num < v; num <<= 1)
				{
				}
				return num;
			}
		}

		private static readonly Entry[] InitialEntries = new Entry[1];

		private int _count;

		private int _freeList = -1;

		private int[] _buckets;

		private Entry[] _entries;

		public int Count => _count;

		public ref TValue this[TKey key]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref GetOrAddValueRef(key);
			}
		}

		public DictionarySlim()
		{
			_buckets = HashHelpers.SizeOneIntArray;
			_entries = InitialEntries;
		}

		public DictionarySlim(int capacity)
		{
			if (capacity < 2)
			{
				capacity = 2;
			}
			capacity = HashHelpers.PowerOf2(capacity);
			_buckets = new int[capacity];
			_entries = new Entry[capacity];
		}

		public void Clear()
		{
			_count = 0;
			_freeList = -1;
			_buckets = HashHelpers.SizeOneIntArray;
			_entries = InitialEntries;
		}

		public bool ContainsKey(TKey key)
		{
			Entry[] entries = _entries;
			int num = _buckets[key.GetHashCode() & (_buckets.Length - 1)] - 1;
			while ((uint)num < (uint)entries.Length)
			{
				if (key.Equals(entries[num].key))
				{
					return true;
				}
				num = entries[num].next;
			}
			return false;
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			Entry[] entries = _entries;
			int num = _buckets[key.GetHashCode() & (_buckets.Length - 1)] - 1;
			while ((uint)num < (uint)entries.Length)
			{
				if (key.Equals(entries[num].key))
				{
					value = entries[num].value;
					return true;
				}
				num = entries[num].next;
			}
			value = default(TValue);
			return false;
		}

		public bool Remove(TKey key)
		{
			Entry[] entries = _entries;
			int num = key.GetHashCode() & (_buckets.Length - 1);
			int num2 = _buckets[num] - 1;
			int num3 = -1;
			while (num2 != -1)
			{
				Entry entry = entries[num2];
				ref TKey key2 = ref entry.key;
				TKey other = key;
				if (key2.Equals(other))
				{
					if (num3 != -1)
					{
						entries[num3].next = entry.next;
					}
					else
					{
						_buckets[num] = entry.next + 1;
					}
					entries[num2] = default(Entry);
					entries[num2].next = -3 - _freeList;
					_freeList = num2;
					_count--;
					return true;
				}
				num3 = num2;
				num2 = entry.next;
			}
			return false;
		}

		public ref TValue GetOrAddValueRef(TKey key)
		{
			Entry[] entries = _entries;
			int num = key.GetHashCode() & (_buckets.Length - 1);
			int num2 = _buckets[num] - 1;
			while ((uint)num2 < (uint)entries.Length)
			{
				if (key.Equals(entries[num2].key))
				{
					return ref entries[num2].value;
				}
				num2 = entries[num2].next;
			}
			return ref AddKey(key, num);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private ref TValue AddKey(TKey key, int bucketIndex)
		{
			Entry[] array = _entries;
			int num;
			if (_freeList != -1)
			{
				num = _freeList;
				_freeList = -3 - array[_freeList].next;
			}
			else
			{
				if (_count == array.Length || array.Length == 1)
				{
					array = Resize();
					bucketIndex = key.GetHashCode() & (_buckets.Length - 1);
				}
				num = _count;
			}
			array[num].key = key;
			array[num].next = _buckets[bucketIndex] - 1;
			_buckets[bucketIndex] = num + 1;
			_count++;
			return ref array[num].value;
		}

		private Entry[] Resize()
		{
			int count = _count;
			int num = _entries.Length * 2;
			if ((uint)num > 2147483647u)
			{
				throw new InvalidOperationException("Capacity Overflow");
			}
			Entry[] array = new Entry[num];
			Array.Copy(_entries, 0, array, 0, count);
			int[] array2 = new int[array.Length];
			while (count-- > 0)
			{
				int num2 = array[count].key.GetHashCode() & (array2.Length - 1);
				array[count].next = array2[num2] - 1;
				array2[num2] = count + 1;
			}
			_buckets = array2;
			_entries = array;
			return array;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this);
		}
	}
	internal class HybridDictionary<TValue> : IEnumerable<KeyValuePair<Key, TValue>>, IEnumerable
	{
		private const int CutoverPoint = 9;

		private const int InitialDictionarySize = 13;

		private const int FixedSizeCutoverPoint = 6;

		private readonly bool _checkExistingKeys;

		private ListDictionary<TValue> _list;

		internal StringDictionarySlim<TValue> _dictionary;

		public TValue this[Key key]
		{
			get
			{
				TryGetValue(key, out var value);
				return value;
			}
			set
			{
				if (_dictionary != null)
				{
					_dictionary[key] = value;
				}
				else if (_list != null)
				{
					if (_list.Count >= 8)
					{
						SwitchToDictionary(key, value, tryAdd: false);
					}
					else
					{
						_list[key] = value;
					}
				}
				else
				{
					_list = new ListDictionary<TValue>(key, value, _checkExistingKeys);
				}
			}
		}

		public int Count
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _dictionary?.Count ?? _list?.Count ?? 0;
			}
		}

		public bool CheckExistingKeys
		{
			set
			{
				if (_list != null)
				{
					_list.CheckExistingKeys = value;
				}
			}
		}

		public HybridDictionary()
			: this(0, checkExistingKeys: true)
		{
		}

		public HybridDictionary(int initialSize, bool checkExistingKeys)
		{
			_checkExistingKeys = checkExistingKeys;
			if (initialSize >= 6)
			{
				_dictionary = new StringDictionarySlim<TValue>(initialSize);
			}
		}

		protected HybridDictionary(StringDictionarySlim<TValue> dictionary)
		{
			_checkExistingKeys = true;
			_dictionary = dictionary;
		}

		public bool TryGetValue(Key key, out TValue value)
		{
			if (_dictionary != null)
			{
				return _dictionary.TryGetValue(key, out value);
			}
			if (_list != null)
			{
				return _list.TryGetValue(key, out value);
			}
			value = default(TValue);
			return false;
		}

		public void SetOrUpdateValue<TState>(Key key, Func<TValue, TState, TValue> updater, TState state)
		{
			if (_dictionary != null)
			{
				_dictionary.SetOrUpdateValue(key, updater, state);
			}
			else if (_list != null)
			{
				_list.SetOrUpdateValue(key, updater, state);
			}
			else
			{
				_list = new ListDictionary<TValue>(key, updater(default(TValue), state), _checkExistingKeys);
			}
		}

		private bool SwitchToDictionary(Key key, TValue value, bool tryAdd)
		{
			StringDictionarySlim<TValue> stringDictionarySlim = new StringDictionarySlim<TValue>(13);
			foreach (KeyValuePair<Key, TValue> item in _list)
			{
				stringDictionarySlim[item.Key] = item.Value;
			}
			bool result;
			if (tryAdd)
			{
				result = stringDictionarySlim.TryAdd(key, value);
			}
			else
			{
				stringDictionarySlim[key] = value;
				result = true;
			}
			_dictionary = stringDictionarySlim;
			_list = null;
			return result;
		}

		public bool TryAdd(Key key, TValue value)
		{
			if (_dictionary != null)
			{
				return _dictionary.TryAdd(key, value);
			}
			if (_list == null)
			{
				_list = new ListDictionary<TValue>(key, value, _checkExistingKeys);
			}
			if (_list.Count + 1 >= 9)
			{
				return SwitchToDictionary(key, value, tryAdd: true);
			}
			return _list.Add(key, value, tryAdd: true);
		}

		public void Add(Key key, TValue value)
		{
			if (_dictionary != null)
			{
				_dictionary.GetOrAddValueRef(key) = value;
			}
			else if (_list == null)
			{
				_list = new ListDictionary<TValue>(key, value, _checkExistingKeys);
			}
			else if (_list.Count + 1 >= 9)
			{
				SwitchToDictionary(key, value, tryAdd: false);
			}
			else
			{
				_list.Add(key, value);
			}
		}

		public void Clear()
		{
			_dictionary?.Clear();
			_list?.Clear();
		}

		public bool ContainsKey(Key key)
		{
			if (_dictionary != null)
			{
				return _dictionary.ContainsKey(key);
			}
			if (_list != null)
			{
				return _list.ContainsKey(key);
			}
			return false;
		}

		IEnumerator<KeyValuePair<Key, TValue>> IEnumerable<KeyValuePair<Key, TValue>>.GetEnumerator()
		{
			if (_dictionary != null)
			{
				return _dictionary.GetEnumerator();
			}
			if (_list != null)
			{
				return _list.GetEnumerator();
			}
			return Enumerable.Empty<KeyValuePair<Key, TValue>>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			if (_dictionary != null)
			{
				return _dictionary.GetEnumerator();
			}
			if (_list != null)
			{
				return _list.GetEnumerator();
			}
			return Enumerable.Empty<KeyValuePair<Key, TValue>>().GetEnumerator();
		}

		public bool Remove(Key key)
		{
			if (_dictionary != null)
			{
				return _dictionary.Remove(key);
			}
			if (_list != null)
			{
				return _list.Remove(key);
			}
			return false;
		}
	}
	internal sealed class ListDictionary<TValue> : IEnumerable<KeyValuePair<Key, TValue>>, IEnumerable
	{
		internal struct NodeEnumerator : IEnumerator<KeyValuePair<Key, TValue>>, IEnumerator, IDisposable
		{
			private readonly ListDictionary<TValue> _list;

			private DictionaryNode _current;

			private bool _start;

			public KeyValuePair<Key, TValue> Current => new KeyValuePair<Key, TValue>(_current.Key, _current.Value);

			object IEnumerator.Current => _current;

			public NodeEnumerator(ListDictionary<TValue> list)
			{
				_list = list;
				_start = true;
				_current = null;
			}

			public bool MoveNext()
			{
				if (_start)
				{
					_current = _list._head;
					_start = false;
				}
				else if (_current != null)
				{
					_current = _current.Next;
				}
				return _current != null;
			}

			void IEnumerator.Reset()
			{
				_start = true;
				_current = null;
			}

			public void Dispose()
			{
			}
		}

		internal sealed class DictionaryNode
		{
			public Key Key;

			public TValue Value;

			public DictionaryNode Next;
		}

		private DictionaryNode _head;

		private int _count;

		private bool _checkExistingKeys;

		public TValue this[Key key]
		{
			get
			{
				TryGetValue(key, out var value);
				return value;
			}
			set
			{
				DictionaryNode last = null;
				bool checkExistingKeys = _checkExistingKeys;
				DictionaryNode dictionaryNode;
				for (dictionaryNode = _head; dictionaryNode != null; dictionaryNode = dictionaryNode.Next)
				{
					Key a = dictionaryNode.Key;
					if (checkExistingKeys && a == key)
					{
						break;
					}
					last = dictionaryNode;
				}
				if (dictionaryNode != null)
				{
					dictionaryNode.Value = value;
				}
				else
				{
					AddNode(key, value, last);
				}
			}
		}

		public int Count
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _count;
			}
		}

		internal bool CheckExistingKeys
		{
			set
			{
				_checkExistingKeys = value;
			}
		}

		public ListDictionary(Key key, TValue value, bool checkExistingKeys)
		{
			_checkExistingKeys = checkExistingKeys;
			_head = new DictionaryNode
			{
				Key = key,
				Value = value
			};
			_count = 1;
		}

		public bool TryGetValue(Key key, out TValue value)
		{
			for (DictionaryNode dictionaryNode = _head; dictionaryNode != null; dictionaryNode = dictionaryNode.Next)
			{
				if (dictionaryNode.Key == key)
				{
					value = dictionaryNode.Value;
					return true;
				}
			}
			value = default(TValue);
			return false;
		}

		public void SetOrUpdateValue<TState>(Key key, Func<TValue, TState, TValue> updater, TState state)
		{
			DictionaryNode last = null;
			for (DictionaryNode dictionaryNode = _head; dictionaryNode != null; dictionaryNode = dictionaryNode.Next)
			{
				if (dictionaryNode.Key == key)
				{
					dictionaryNode.Value = updater(dictionaryNode.Value, state);
					return;
				}
				last = dictionaryNode;
			}
			AddNode(key, updater(default(TValue), state), last);
		}

		public bool Add(Key key, TValue value, bool tryAdd = false)
		{
			DictionaryNode last = null;
			bool checkExistingKeys = _checkExistingKeys;
			for (DictionaryNode dictionaryNode = _head; dictionaryNode != null; dictionaryNode = dictionaryNode.Next)
			{
				Key a = dictionaryNode.Key;
				if (checkExistingKeys && a == key)
				{
					if (tryAdd)
					{
						return false;
					}
					ExceptionHelper.ThrowArgumentException();
				}
				last = dictionaryNode;
			}
			AddNode(key, value, last);
			return true;
		}

		private void AddNode(Key key, TValue value, DictionaryNode last)
		{
			DictionaryNode dictionaryNode = new DictionaryNode
			{
				Key = key,
				Value = value
			};
			if (_head == null)
			{
				_head = dictionaryNode;
			}
			else
			{
				last.Next = dictionaryNode;
			}
			_count++;
		}

		public void Clear()
		{
			_count = 0;
			_head = null;
		}

		public bool ContainsKey(Key key)
		{
			for (DictionaryNode dictionaryNode = _head; dictionaryNode != null; dictionaryNode = dictionaryNode.Next)
			{
				Key a = dictionaryNode.Key;
				if (a == key)
				{
					return true;
				}
			}
			return false;
		}

		public NodeEnumerator GetEnumerator()
		{
			return new NodeEnumerator(this);
		}

		IEnumerator<KeyValuePair<Key, TValue>> IEnumerable<KeyValuePair<Key, TValue>>.GetEnumerator()
		{
			return new NodeEnumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new NodeEnumerator(this);
		}

		public bool Remove(Key key)
		{
			DictionaryNode dictionaryNode = null;
			DictionaryNode dictionaryNode2;
			for (dictionaryNode2 = _head; dictionaryNode2 != null; dictionaryNode2 = dictionaryNode2.Next)
			{
				Key a = dictionaryNode2.Key;
				if (a == key)
				{
					break;
				}
				dictionaryNode = dictionaryNode2;
			}
			if (dictionaryNode2 == null)
			{
				return false;
			}
			if (dictionaryNode2 == _head)
			{
				_head = dictionaryNode2.Next;
			}
			else
			{
				dictionaryNode.Next = dictionaryNode2.Next;
			}
			_count--;
			return true;
		}
	}
	internal sealed class ObjectTraverseStack
	{
		private readonly Engine _engine;

		private readonly Stack<object> _stack = new Stack<object>();

		public ObjectTraverseStack(Engine engine)
		{
			_engine = engine;
		}

		public void Enter(JsValue value)
		{
			if ((object)value == null)
			{
				ExceptionHelper.ThrowArgumentNullException("value");
			}
			if (_stack.Contains(value))
			{
				ExceptionHelper.ThrowTypeError(_engine.Realm, "Cyclic reference detected.");
			}
			_stack.Push(value);
		}

		public void Exit()
		{
			_stack.Pop();
		}
	}
	internal sealed class PropertyDictionary : HybridDictionary<PropertyDescriptor>
	{
		public PropertyDictionary()
		{
		}

		public PropertyDictionary(int capacity, bool checkExistingKeys)
			: base(capacity, checkExistingKeys)
		{
		}

		public PropertyDictionary(StringDictionarySlim<PropertyDescriptor> properties)
			: base(properties)
		{
		}
	}
	internal sealed class RefStack<T> : IEnumerable<T>, IEnumerable where T : struct
	{
		internal struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable
		{
			private readonly RefStack<T> _stack;

			private int _index;

			private T? _currentElement;

			public T Current => _currentElement.Value;

			object? IEnumerator.Current => Current;

			internal Enumerator(RefStack<T> stack)
			{
				_stack = stack;
				_index = -2;
				_currentElement = null;
			}

			public void Dispose()
			{
				_index = -1;
			}

			public bool MoveNext()
			{
				if (_index == -2)
				{
					_index = _stack._size - 1;
					bool num = _index >= 0;
					if (num)
					{
						_currentElement = _stack._array[_index];
					}
					return num;
				}
				if (_index == -1)
				{
					return false;
				}
				bool num2 = --_index >= 0;
				if (num2)
				{
					_currentElement = _stack._array[_index];
					return num2;
				}
				_currentElement = null;
				return num2;
			}

			void IEnumerator.Reset()
			{
				_index = -2;
				_currentElement = null;
			}
		}

		internal T[] _array;

		internal int _size;

		private const int DefaultCapacity = 2;

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

		public RefStack(int capacity = 2)
		{
			_array = new T[capacity];
			_size = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref readonly T Peek()
		{
			return ref _array[_size - 1];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref readonly T Peek(int fromTop)
		{
			int num = _size - 1 - fromTop;
			return ref _array[num];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryPeek([NotNullWhen(true)] out T item)
		{
			if (_size > 0)
			{
				item = _array[_size - 1];
				return true;
			}
			item = default(T);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref readonly T Pop()
		{
			if (_size == 0)
			{
				ExceptionHelper.ThrowInvalidOperationException("stack is empty");
			}
			_size--;
			return ref _array[_size];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Push(in T item)
		{
			if (_size == _array.Length)
			{
				EnsureCapacity(_size + 1);
			}
			_array[_size++] = item;
		}

		private void EnsureCapacity(int min)
		{
			T[] array = _array;
			if (array.Length < min)
			{
				int num = ((array.Length == 0) ? 2 : (array.Length * 2));
				if (num < min)
				{
					num = min;
				}
				Resize(num);
			}
		}

		private void Resize(int value)
		{
			if (value == _array.Length)
			{
				return;
			}
			if (value > 0)
			{
				T[] array = new T[value];
				if (_size > 0)
				{
					Array.Copy(_array, 0, array, 0, _size);
				}
				_array = array;
			}
			else
			{
				_array = Array.Empty<T>();
			}
		}

		public void Clear()
		{
			_size = 0;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[DebuggerTypeProxy(typeof(DictionarySlimDebugView<>))]
	[DebuggerDisplay("Count = {Count}")]
	internal sealed class StringDictionarySlim<TValue> : IReadOnlyCollection<KeyValuePair<Key, TValue>>, IEnumerable<KeyValuePair<Key, TValue>>, IEnumerable
	{
		[DebuggerDisplay("({key}, {value})->{next}")]
		private struct Entry
		{
			public Key key;

			public TValue value;

			public int next;
		}

		public struct Enumerator : IEnumerator<KeyValuePair<Key, TValue>>, IEnumerator, IDisposable
		{
			private readonly StringDictionarySlim<TValue> _dictionary;

			private int _index;

			private int _count;

			private KeyValuePair<Key, TValue> _current;

			public KeyValuePair<Key, TValue> Current => _current;

			object IEnumerator.Current => _current;

			internal Enumerator(StringDictionarySlim<TValue> dictionary)
			{
				_dictionary = dictionary;
				_index = 0;
				_count = _dictionary._count;
				_current = default(KeyValuePair<Key, TValue>);
			}

			public bool MoveNext()
			{
				if (_count == 0)
				{
					_current = default(KeyValuePair<Key, TValue>);
					return false;
				}
				_count--;
				while (_dictionary._entries[_index].next < -1)
				{
					_index++;
				}
				_current = new KeyValuePair<Key, TValue>(_dictionary._entries[_index].key, _dictionary._entries[_index++].value);
				return true;
			}

			void IEnumerator.Reset()
			{
				_index = 0;
				_count = _dictionary._count;
				_current = default(KeyValuePair<Key, TValue>);
			}

			public void Dispose()
			{
			}
		}

		internal static class HashHelpers
		{
			internal static readonly int[] SizeOneIntArray = new int[1];

			internal static int PowerOf2(int v)
			{
				if ((v & (v - 1)) == 0)
				{
					return v;
				}
				int num;
				for (num = 2; num < v; num <<= 1)
				{
				}
				return num;
			}
		}

		internal sealed class DictionarySlimDebugView<V>
		{
			private readonly StringDictionarySlim<V> _dictionary;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public KeyValuePair<Key, V>[] Items => _dictionary.ToArray();

			public DictionarySlimDebugView(StringDictionarySlim<V> dictionary)
			{
				_dictionary = dictionary ?? throw new ArgumentNullException("dictionary");
			}
		}

		private static readonly Entry[] InitialEntries = new Entry[1];

		private int _count;

		private int _freeList = -1;

		private int[] _buckets;

		private Entry[] _entries;

		public int Count
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _count;
			}
		}

		public ref TValue this[Key key]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return ref GetOrAddValueRef(key);
			}
		}

		public StringDictionarySlim()
		{
			_buckets = HashHelpers.SizeOneIntArray;
			_entries = InitialEntries;
		}

		public StringDictionarySlim(int capacity)
		{
			if (capacity < 2)
			{
				capacity = 2;
			}
			capacity = HashHelpers.PowerOf2(capacity);
			_buckets = new int[capacity];
			_entries = new Entry[capacity];
		}

		public void Clear()
		{
			_count = 0;
			_freeList = -1;
			_buckets = HashHelpers.SizeOneIntArray;
			_entries = InitialEntries;
		}

		public bool ContainsKey(Key key)
		{
			Entry[] entries = _entries;
			int num = _buckets[key.HashCode & (_buckets.Length - 1)] - 1;
			while ((uint)num < (uint)entries.Length)
			{
				if (key.Name == entries[num].key.Name)
				{
					return true;
				}
				num = entries[num].next;
			}
			return false;
		}

		public bool TryGetValue(Key key, out TValue value)
		{
			Entry[] entries = _entries;
			int num = _buckets[key.HashCode & (_buckets.Length - 1)] - 1;
			while ((uint)num < (uint)entries.Length)
			{
				if (key.Name == entries[num].key.Name)
				{
					value = entries[num].value;
					return true;
				}
				num = entries[num].next;
			}
			value = default(TValue);
			return false;
		}

		public bool Remove(Key key)
		{
			Entry[] entries = _entries;
			int num = key.HashCode & (_buckets.Length - 1);
			int num2 = _buckets[num] - 1;
			int num3 = -1;
			while (num2 != -1)
			{
				Entry entry = entries[num2];
				if (entry.key == key)
				{
					if (num3 != -1)
					{
						entries[num3].next = entry.next;
					}
					else
					{
						_buckets[num] = entry.next + 1;
					}
					entries[num2] = default(Entry);
					entries[num2].next = -3 - _freeList;
					_freeList = num2;
					_count--;
					return true;
				}
				num3 = num2;
				num2 = entry.next;
			}
			return false;
		}

		public void SetOrUpdateValue<TState>(Key key, Func<TValue, TState, TValue> updater, TState state)
		{
			ref TValue orAddValueRef = ref GetOrAddValueRef(key);
			orAddValueRef = updater(orAddValueRef, state);
		}

		public ref TValue GetOrAddValueRef(Key key)
		{
			Entry[] entries = _entries;
			int num = key.HashCode & (_buckets.Length - 1);
			int num2 = _buckets[num] - 1;
			while ((uint)num2 < (uint)entries.Length)
			{
				if (key.Name == entries[num2].key.Name)
				{
					return ref entries[num2].value;
				}
				num2 = entries[num2].next;
			}
			return ref AddKey(key, num);
		}

		public bool TryAdd(Key key, TValue value)
		{
			Entry[] entries = _entries;
			int num = key.HashCode & (_buckets.Length - 1);
			int num2 = _buckets[num] - 1;
			while ((uint)num2 < (uint)entries.Length)
			{
				if (key.Name == entries[num2].key.Name)
				{
					return false;
				}
				num2 = entries[num2].next;
			}
			AddKey(key, num) = value;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AddDangerous(in Key key, TValue value)
		{
			AddKey(key, key.HashCode & (_buckets.Length - 1)) = value;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private ref TValue AddKey(Key key, int bucketIndex)
		{
			Entry[] array = _entries;
			int num;
			if (_freeList != -1)
			{
				num = _freeList;
				_freeList = -3 - array[_freeList].next;
			}
			else
			{
				if (_count == array.Length || array.Length == 1)
				{
					array = Resize();
					bucketIndex = key.HashCode & (_buckets.Length - 1);
				}
				num = _count;
			}
			array[num].key = key;
			array[num].next = _buckets[bucketIndex] - 1;
			_buckets[bucketIndex] = num + 1;
			_count++;
			return ref array[num].value;
		}

		private Entry[] Resize()
		{
			int count = _count;
			int num = _entries.Length * 2;
			if ((uint)num > 2147483647u)
			{
				throw new InvalidOperationException("Capacity Overflow");
			}
			Entry[] array = new Entry[num];
			Array.Copy(_entries, 0, array, 0, count);
			int[] array2 = new int[array.Length];
			while (count-- > 0)
			{
				int num2 = array[count].key.HashCode & (array2.Length - 1);
				array[count].next = array2[num2] - 1;
				array2[num2] = count + 1;
			}
			_buckets = array2;
			_entries = array;
			return array;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<KeyValuePair<Key, TValue>> IEnumerable<KeyValuePair<Key, TValue>>.GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new Enumerator(this);
		}
	}
	internal sealed class SymbolDictionary : DictionarySlim<JsSymbol, PropertyDescriptor>
	{
		public SymbolDictionary()
		{
		}

		public SymbolDictionary(int capacity)
			: base(capacity)
		{
		}
	}
}