using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Scriban.Functions;
using Scriban.Helpers;
using Scriban.Parsing;
using Scriban.Runtime;
using Scriban.Runtime.Accessors;
using Scriban.Syntax;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("Scriban.Tests")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Alexandre Mutel")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Alexandre Mutel")]
[assembly: AssemblyDescription("Scriban is a fast, powerful, safe and lightweight scripting language and engine for .NET, which was primarily developed for text templating with a compatibility mode for parsing liquid templates.")]
[assembly: AssemblyFileVersion("0.0.0.0")]
[assembly: AssemblyInformationalVersion("0.0.0-alpha.0.856+b79ba35830fb5260f45b6c06620726ddddc7863a")]
[assembly: AssemblyProduct("Scriban")]
[assembly: AssemblyTitle("Scriban")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/HAHOOS/scriban.git")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace System
{
	[ExcludeFromCodeCoverage]
	internal readonly struct Index : IEquatable<Index>
	{
		private static class ThrowHelper
		{
			[DoesNotReturn]
			public static void ThrowValueArgumentOutOfRange_NeedNonNegNumException()
			{
				throw new ArgumentOutOfRangeException("value", "Non-negative number required.");
			}
		}

		private readonly int _value;

		public static Index Start => new Index(0);

		public static Index End => new Index(-1);

		public int Value
		{
			get
			{
				if (_value < 0)
				{
					return ~_value;
				}
				return _value;
			}
		}

		public bool IsFromEnd => _value < 0;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Index(int value, bool fromEnd = false)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			if (fromEnd)
			{
				_value = ~value;
			}
			else
			{
				_value = value;
			}
		}

		private Index(int value)
		{
			_value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Index FromStart(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Index FromEnd(int value)
		{
			if (value < 0)
			{
				ThrowHelper.ThrowValueArgumentOutOfRange_NeedNonNegNumException();
			}
			return new Index(~value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int GetOffset(int length)
		{
			int num = _value;
			if (IsFromEnd)
			{
				num += length + 1;
			}
			return num;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Index)
			{
				return _value == ((Index)value)._value;
			}
			return false;
		}

		public bool Equals(Index other)
		{
			return _value == other._value;
		}

		public override int GetHashCode()
		{
			return _value;
		}

		public static implicit operator Index(int value)
		{
			return FromStart(value);
		}

		public override string ToString()
		{
			if (IsFromEnd)
			{
				return ToStringFromEnd();
			}
			return ((uint)Value).ToString();
		}

		private string ToStringFromEnd()
		{
			return "^" + Value;
		}
	}
	[ExcludeFromCodeCoverage]
	internal readonly struct Range : IEquatable<Range>
	{
		private static class HashHelpers
		{
			public static int Combine(int h1, int h2)
			{
				return (((h1 << 5) | (h1 >>> 27)) + h1) ^ h2;
			}
		}

		private static class ThrowHelper
		{
			[DoesNotReturn]
			public static void ThrowArgumentOutOfRangeException()
			{
				throw new ArgumentOutOfRangeException("length");
			}
		}

		public Index Start { get; }

		public Index End { get; }

		public static Range All => Index.Start..Index.End;

		public Range(Index start, Index end)
		{
			Start = start;
			End = end;
		}

		public override bool Equals([NotNullWhen(true)] object? value)
		{
			if (value is Range { Start: var start } range && start.Equals(Start))
			{
				return range.End.Equals(End);
			}
			return false;
		}

		public bool Equals(Range other)
		{
			if (other.Start.Equals(Start))
			{
				return other.End.Equals(End);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashHelpers.Combine(Start.GetHashCode(), End.GetHashCode());
		}

		public override string ToString()
		{
			return Start.ToString() + ".." + End;
		}

		public static Range StartAt(Index start)
		{
			return start..Index.End;
		}

		public static Range EndAt(Index end)
		{
			return Index.Start..end;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public (int Offset, int Length) GetOffsetAndLength(int length)
		{
			Index start = Start;
			int num = ((!start.IsFromEnd) ? start.Value : (length - start.Value));
			Index end = End;
			int num2 = ((!end.IsFromEnd) ? end.Value : (length - end.Value));
			if ((uint)num2 > (uint)length || (uint)num > (uint)num2)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return (Offset: num, Length: num2 - num);
		}
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class SuppressGCTransitionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnmanagedCallersOnlyAttribute : Attribute
	{
		public Type[]? CallConvs;

		public string? EntryPoint;
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class WasmImportLinkageAttribute : Attribute
	{
	}
}
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.Versioning
{
	[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 RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
	[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;
		}
	}
	[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 SupportedOSPlatformAttribute : Attribute
	{
		public SupportedOSPlatformAttribute(string platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class SupportedOSPlatformGuardAttribute : Attribute
	{
		public SupportedOSPlatformGuardAttribute(string platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class TargetPlatformAttribute : Attribute
	{
		public TargetPlatformAttribute(string platformName)
		{
		}
	}
	[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 UnsupportedOSPlatformAttribute : Attribute
	{
		public string? Message { get; }

		public UnsupportedOSPlatformAttribute(string platformName)
		{
		}

		public UnsupportedOSPlatformAttribute(string platformName, string? message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnsupportedOSPlatformGuardAttribute : Attribute
	{
		public UnsupportedOSPlatformGuardAttribute(string platformName)
		{
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[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.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
	[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
{
	[AttributeUsage(AttributeTargets.Method)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class DebuggerDisableUserUnhandledExceptionsAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class StackTraceHiddenAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[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.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[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.Struct | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class DynamicallyAccessedMembersAttribute : Attribute
	{
		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes = memberTypes;
		}
	}
	[Flags]
	internal enum DynamicallyAccessedMemberTypes
	{
		None = 0,
		PublicParameterlessConstructor = 1,
		PublicConstructors = 3,
		NonPublicConstructors = 4,
		PublicMethods = 8,
		NonPublicMethods = 0x10,
		PublicFields = 0x20,
		NonPublicFields = 0x40,
		PublicNestedTypes = 0x80,
		NonPublicNestedTypes = 0x100,
		PublicProperties = 0x200,
		NonPublicProperties = 0x400,
		PublicEvents = 0x800,
		NonPublicEvents = 0x1000,
		Interfaces = 0x2000,
		All = -1
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class DynamicDependencyAttribute : Attribute
	{
		public string? MemberSignature { get; }

		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public Type? Type { get; }

		public string? TypeName { get; }

		public string? AssemblyName { get; }

		public string? Condition { get; set; }

		public DynamicDependencyAttribute(string memberSignature)
		{
			MemberSignature = memberSignature;
		}

		public DynamicDependencyAttribute(string memberSignature, Type type)
		{
			MemberSignature = memberSignature;
			Type = type;
		}

		public DynamicDependencyAttribute(string memberSignature, string typeName, string assemblyName)
		{
			MemberSignature = memberSignature;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}

		public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, Type type)
		{
			MemberTypes = memberTypes;
			Type = type;
		}

		public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, string typeName, string assemblyName)
		{
			MemberTypes = memberTypes;
			TypeName = typeName;
			AssemblyName = assemblyName;
		}
	}
	[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class FeatureGuardAttribute : Attribute
	{
		public Type FeatureType { get; }

		public FeatureGuardAttribute(Type featureType)
		{
			FeatureType = featureType;
		}
	}
	[AttributeUsage(AttributeTargets.Property, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class FeatureSwitchDefinitionAttribute : Attribute
	{
		public string SwitchName { get; }

		public FeatureSwitchDefinitionAttribute(string switchName)
		{
			SwitchName = switchName;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event, Inherited = false, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class RequiresAssemblyFilesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresAssemblyFilesAttribute()
		{
		}

		public RequiresAssemblyFilesAttribute(string message)
		{
			Message = message;
		}
	}
	[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;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class RequiresUnreferencedCodeAttribute : Attribute
	{
		public string Message { get; }

		public string? Url { get; set; }

		public RequiresUnreferencedCodeAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[Conditional("MULTI_TARGETING_SUPPORT_ATTRIBUTES")]
	internal sealed class UnconditionalSuppressMessageAttribute : Attribute
	{
		public string Category { get; }

		public string CheckId { get; }

		public string? Scope { get; set; }

		public string? Target { get; set; }

		public string? MessageId { get; set; }

		public string? Justification { get; set; }

		public UnconditionalSuppressMessageAttribute(string category, string checkId)
		{
			Category = category;
			CheckId = checkId;
		}
	}
}
namespace Scriban
{
	[DebuggerDisplay("Count: {Count}")]
	public class LogMessageBag : IReadOnlyList<LogMessage>, IEnumerable<LogMessage>, IEnumerable, IReadOnlyCollection<LogMessage>
	{
		private readonly List<LogMessage> _messages;

		public int Count => _messages.Count;

		public LogMessage this[int index] => _messages[index];

		public bool HasErrors { get; private set; }

		public LogMessageBag()
		{
			_messages = new List<LogMessage>();
		}

		public void Add(LogMessage message)
		{
			if (message == null)
			{
				throw new ArgumentNullException("message");
			}
			if (message.Type == ParserMessageType.Error)
			{
				HasErrors = true;
			}
			_messages.Add(message);
		}

		public void AddRange(IEnumerable<LogMessage> messages)
		{
			if (messages == null)
			{
				throw new ArgumentNullException("messages");
			}
			foreach (LogMessage message in messages)
			{
				Add(message);
			}
		}

		public IEnumerator<LogMessage> GetEnumerator()
		{
			return _messages.GetEnumerator();
		}

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

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (LogMessage message in _messages)
			{
				stringBuilder.AppendLine(message.ToString());
			}
			return stringBuilder.ToString();
		}
	}
	public class Template
	{
		public string? SourceFilePath { get; }

		public ScriptPage? Page { get; private set; }

		public bool HasErrors { get; private set; }

		public LogMessageBag Messages { get; }

		public ParserOptions ParserOptions { get; }

		public LexerOptions LexerOptions { get; }

		private async ValueTask<object?> EvaluateAndRenderAsync(TemplateContext context, bool render)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			CheckErrors();
			if (SourceFilePath != null)
			{
				context.PushSourceFile(SourceFilePath);
			}
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				if (Page == null)
				{
					return null;
				}
				object result = await context.EvaluateAsync(Page).ConfigureAwait(continueOnCapturedContext: false);
				if (render && context.EnableOutput && result != null)
				{
					await context.WriteAsync(Page.Span, result).ConfigureAwait(continueOnCapturedContext: false);
				}
				return result;
			}
			finally
			{
				if (SourceFilePath != null)
				{
					context.PopSourceFile();
				}
			}
		}

		public async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			bool previousOutput = context.EnableOutput;
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				context.EnableOutput = false;
				return await EvaluateAndRenderAsync(context, render: false).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				context.EnableOutput = previousOutput;
			}
		}

		public static async ValueTask<object?> EvaluateAsync(string expression, TemplateContext context)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = new LexerOptions
			{
				Mode = ScriptMode.ScriptOnly
			};
			return await Parse(expression, null, null, lexerOptions).EvaluateAsync(context).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async ValueTask<object?> EvaluateAsync(object? model = null, MemberRenamerDelegate? memberRenamer = null, MemberFilterDelegate? memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext context = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			context.EnableOutput = false;
			context.MemberRenamer = memberRenamer ?? StandardMemberRenamer.Default;
			context.MemberFilter = memberFilter;
			context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
			context.PushGlobal(scriptObject);
			object result = await EvaluateAsync(context).ConfigureAwait(continueOnCapturedContext: false);
			context.PopGlobal();
			return result;
		}

		public static async ValueTask<object?> EvaluateAsync(string expression, object model, MemberRenamerDelegate? memberRenamer = null, MemberFilterDelegate? memberFilter = null)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = new LexerOptions
			{
				Mode = ScriptMode.ScriptOnly
			};
			return await Parse(expression, null, null, lexerOptions).EvaluateAsync(model, memberRenamer, memberFilter).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async ValueTask<string> RenderAsync(TemplateContext context)
		{
			await EvaluateAndRenderAsync(context, render: true).ConfigureAwait(continueOnCapturedContext: false);
			string text = context.Output.ToString();
			if (context.Output is StringBuilderOutput stringBuilderOutput)
			{
				stringBuilderOutput.Builder.Length = 0;
			}
			if (text == null)
			{
				text = string.Empty;
			}
			return text;
		}

		public async ValueTask<string> RenderAsync(object? model = null, MemberRenamerDelegate? memberRenamer = null, MemberFilterDelegate? memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext templateContext = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			templateContext.MemberRenamer = memberRenamer ?? StandardMemberRenamer.Default;
			templateContext.MemberFilter = memberFilter;
			templateContext.PushGlobal(scriptObject);
			return await RenderAsync(templateContext).ConfigureAwait(continueOnCapturedContext: false);
		}

		private Template(ParserOptions? parserOptions, LexerOptions? lexerOptions, string? sourceFilePath)
		{
			ParserOptions = parserOptions ?? Scriban.Parsing.ParserOptions.Default;
			LexerOptions = lexerOptions ?? Scriban.Parsing.LexerOptions.Default;
			Messages = new LogMessageBag();
			SourceFilePath = sourceFilePath;
		}

		public static Template Parse(string text, string? sourceFilePath = null, ParserOptions? parserOptions = null, LexerOptions? lexerOptions = null)
		{
			Template template = new Template(parserOptions, lexerOptions, sourceFilePath);
			template.ParseInternal(text, sourceFilePath);
			return template;
		}

		public static Template ParseLiquid(string text, string? sourceFilePath = null, ParserOptions? parserOptions = null, LexerOptions? lexerOptions = null)
		{
			LexerOptions lexerOptions2 = lexerOptions ?? Scriban.Parsing.LexerOptions.Default;
			lexerOptions2 = lexerOptions2 with
			{
				Lang = ScriptLang.Liquid
			};
			return Parse(text, sourceFilePath, parserOptions, lexerOptions2);
		}

		public static object? Evaluate(string expression, TemplateContext context)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = new LexerOptions
			{
				Mode = ScriptMode.ScriptOnly
			};
			return Parse(expression, null, null, lexerOptions).Evaluate(context);
		}

		public static object? Evaluate(string expression, object model, MemberRenamerDelegate? memberRenamer = null, MemberFilterDelegate? memberFilter = null)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			LexerOptions lexerOptions = new LexerOptions
			{
				Mode = ScriptMode.ScriptOnly
			};
			return Parse(expression, null, null, lexerOptions).Evaluate(model, memberRenamer, memberFilter);
		}

		public object? Evaluate(TemplateContext context)
		{
			bool enableOutput = context.EnableOutput;
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				context.EnableOutput = false;
				return EvaluateAndRender(context, render: false);
			}
			finally
			{
				context.EnableOutput = enableOutput;
			}
		}

		public object? Evaluate(object? model = null, MemberRenamerDelegate? memberRenamer = null, MemberFilterDelegate? memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext templateContext = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			templateContext.EnableOutput = false;
			templateContext.MemberRenamer = memberRenamer ?? StandardMemberRenamer.Default;
			templateContext.MemberFilter = memberFilter;
			templateContext.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
			templateContext.PushGlobal(scriptObject);
			object? result = Evaluate(templateContext);
			templateContext.PopGlobal();
			return result;
		}

		public string Render(TemplateContext context)
		{
			EvaluateAndRender(context, render: true);
			string text = context.Output.ToString();
			if (context.Output is StringBuilderOutput stringBuilderOutput)
			{
				stringBuilderOutput.Builder.Length = 0;
			}
			if (text == null)
			{
				text = string.Empty;
			}
			return text;
		}

		public string Render(object? model = null, MemberRenamerDelegate? memberRenamer = null, MemberFilterDelegate? memberFilter = null)
		{
			ScriptObject scriptObject = new ScriptObject();
			if (model != null)
			{
				scriptObject.Import(model, memberFilter, memberRenamer);
			}
			TemplateContext templateContext = ((LexerOptions.Lang == ScriptLang.Liquid) ? new LiquidTemplateContext() : new TemplateContext());
			templateContext.MemberRenamer = memberRenamer ?? StandardMemberRenamer.Default;
			templateContext.MemberFilter = memberFilter;
			templateContext.PushGlobal(scriptObject);
			return Render(templateContext);
		}

		public string ToText(ScriptPrinterOptions options = default(ScriptPrinterOptions))
		{
			CheckErrors();
			TextWriterOutput textWriterOutput = new TextWriterOutput();
			ScriptPrinter scriptPrinter = new ScriptPrinter(textWriterOutput, options);
			if (Page != null)
			{
				scriptPrinter.Write(Page);
			}
			return textWriterOutput.ToString();
		}

		private object? EvaluateAndRender(TemplateContext context, bool render)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			CheckErrors();
			if (SourceFilePath != null)
			{
				context.PushSourceFile(SourceFilePath);
			}
			try
			{
				context.UseScientific = LexerOptions.Lang == ScriptLang.Scientific;
				if (Page == null)
				{
					return null;
				}
				object obj = context.Evaluate(Page);
				if (render && context.EnableOutput && obj != null)
				{
					context.Write(Page.Span, obj);
				}
				return obj;
			}
			finally
			{
				if (SourceFilePath != null)
				{
					context.PopSourceFile();
				}
			}
		}

		private void CheckErrors()
		{
			if (HasErrors)
			{
				throw new InvalidOperationException("This template has errors. Check the <Template.HasError> and <Template.Messages> before evaluating a template. Messages:\n" + string.Join("\n", Messages));
			}
		}

		private void ParseInternal(string text, string? sourceFilePath)
		{
			if (string.IsNullOrEmpty(text))
			{
				HasErrors = false;
				Page = new ScriptPage
				{
					Span = new SourceSpan(sourceFilePath ?? string.Empty, default(TextPosition), TextPosition.Eof)
				};
			}
			else
			{
				Parser parser = new Parser(new Lexer(text, sourceFilePath, LexerOptions), ParserOptions);
				Page = parser.Run();
				HasErrors = parser.HasErrors;
				Messages.AddRange(parser.Messages);
			}
		}
	}
	public class TemplateContext : IFormatProvider
	{
		public delegate bool TryGetMemberDelegate(TemplateContext context, SourceSpan span, object target, string member, out object? value);

		public delegate bool TryGetVariableDelegate(TemplateContext context, SourceSpan span, ScriptVariable variable, out object? value);

		public delegate string RenderRuntimeExceptionDelegate(ScriptRuntimeException exception);

		internal enum LoopType
		{
			Default,
			Queryable
		}

		private class VariableContext
		{
			public IScriptObject? LocalObject;

			public FastStack<ScriptObject> Loops;

			public bool HideParentFunctionScopes;

			public VariableContext(IScriptObject? localObject)
			{
				LocalObject = localObject;
				Loops = new FastStack<ScriptObject>(4);
			}
		}

		private enum VariableScope
		{
			Local,
			Loop
		}

		private FastStack<ScriptObject> _availableStores;

		internal FastStack<ScriptBlockStatement> BlockDelegates;

		private FastStack<VariableContext> _globalContexts;

		private FastStack<VariableContext> _functionContexts;

		private FastStack<CultureInfo> _cultures;

		private readonly Dictionary<Type, IListAccessor> _listAccessors;

		private FastStack<ScriptLoopStatementBase> _loops;

		private readonly Dictionary<Type, IObjectAccessor> _memberAccessors;

		private FastStack<IScriptOutput> _outputs;

		private FastStack<VariableContext> _localContexts;

		private VariableContext? _currentLocalContext;

		private IScriptOutput _output;

		private FastStack<string> _sourceFiles;

		private FastStack<object?> _caseValues;

		private int _callDepth;

		private bool _isFunctionCallDisabled;

		private int _loopStep;

		private int _getOrSetValueLevel;

		private FastStack<VariableContext> _availableGlobalContexts;

		private FastStack<VariableContext> _availableFunctionContexts;

		private FastStack<VariableContext> _availableLocalContexts;

		private FastStack<ScriptPipeArguments> _availablePipeArguments;

		private FastStack<ScriptPipeArguments> _pipeArguments;

		private FastStack<List<ScriptExpression>> _availableScriptExpressionLists;

		private object?[]?[] _availableReflectionArguments;

		private ScriptPipeArguments? _currentPipeArguments;

		private bool _previousTextWasNewLine;

		private readonly IEqualityComparer<string>? _keyComparer;

		public static RenderRuntimeExceptionDelegate RenderRuntimeExceptionDefault = (ScriptRuntimeException ex) => $"[{ex.OriginalMessage}]";

		private static readonly object TrueObject = true;

		private static readonly object FalseObject = false;

		private int _objectToStringLevel;

		private int _currentToStringLength;

		private int _currentOutputLength;

		private bool _hasOutputLimitEllipsis;

		internal bool AllowPipeArguments => _getOrSetValueLevel <= 1;

		public CultureInfo CurrentCulture
		{
			get
			{
				if (_cultures.Count != 0)
				{
					return _cultures.Peek();
				}
				return CultureInfo.InvariantCulture;
			}
		}

		public ITemplateLoader? TemplateLoader { get; set; }

		public bool IsLiquid { get; protected set; }

		public bool AutoIndent { get; set; }

		public bool IndentOnEmptyLines { get; set; }

		[Obsolete("Use AutoIndent instead. Note that AutoIndent is true by default.")]
		public bool IndentWithInclude
		{
			get
			{
				return AutoIndent;
			}
			set
			{
				AutoIndent = value;
			}
		}

		public int LimitToString { get; set; }

		public int ObjectRecursionLimit { get; set; }

		public string NewLine { get; set; }

		public ScriptLang Language { get; set; }

		public CancellationToken CancellationToken { get; set; }

		public ParserOptions TemplateLoaderParserOptions { get; set; }

		public LexerOptions TemplateLoaderLexerOptions { get; set; }

		public MemberRenamerDelegate MemberRenamer { get; set; }

		public MemberFilterDelegate? MemberFilter { get; set; }

		public int LoopLimit { get; set; }

		public int? LoopLimitQueryable { get; set; }

		public int RecursiveLimit { get; set; }

		public bool EnableOutput { get; set; }

		public IScriptOutput Output => _output;

		public bool UseScientific { get; set; }

		public bool ErrorForStatementFunctionAsExpression { get; set; }

		public ScriptObject BuiltinObject { get; }

		public IScriptObject? CurrentGlobal => _globalContexts.Peek()?.LocalObject;

		public Dictionary<string, Template> CachedTemplates { get; }

		public string? CurrentSourceFile => _sourceFiles.Peek();

		public TryGetVariableDelegate? TryGetVariable { get; set; }

		public RenderRuntimeExceptionDelegate? RenderRuntimeException { get; set; }

		public TryGetMemberDelegate? TryGetMember { get; set; }

		public Dictionary<object, object> Tags { get; }

		internal ScriptPipeArguments? CurrentPipeArguments => _currentPipeArguments;

		public int GlobalCount => _globalContexts.Count;

		public int OutputCount => _outputs.Count;

		public int CultureCount => _cultures.Count;

		public int SourceFileCount => _sourceFiles.Count;

		internal ScriptFlowState FlowState { get; set; }

		public TimeSpan RegexTimeOut { get; set; }

		public bool StrictVariables { get; set; }

		public bool EnableBreakAndContinueAsReturnOutsideLoop { get; set; }

		public bool EnableRelaxedTargetAccess { get; set; }

		public bool EnableRelaxedMemberAccess { get; set; }

		public bool EnableRelaxedFunctionAccess { get; set; }

		public bool EnableRelaxedIndexerAccess { get; set; }

		public bool EnableNullIndexer { get; set; }

		public ScriptNode? CurrentNode { get; private set; }

		public SourceSpan CurrentSpan => CurrentNode?.Span ?? default(SourceSpan);

		public string? CurrentIndent { get; set; }

		internal bool IsInLoop => _loops.Count > 0;

		internal bool IgnoreExceptionsWhileRewritingScientific { get; set; }

		protected virtual async ValueTask<Template> CreateTemplateAsync(string templatePath, ScriptNode? callerContext)
		{
			SourceSpan callerSpan = callerContext?.Span ?? CurrentSpan;
			ITemplateLoader templateLoader = TemplateLoader ?? throw new ScriptRuntimeException(callerSpan, "No TemplateLoader registered in TemplateContext.TemplateLoader");
			string text;
			try
			{
				text = await templateLoader.LoadAsync(this, callerSpan, templatePath).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(callerSpan, "Unexpected exception while creating template from path `" + templatePath + "`", ex);
			}
			if (text == null)
			{
				throw new ScriptRuntimeException(callerSpan, "The result of including `" + templatePath + "` cannot be null");
			}
			Template template = Template.Parse(text, templatePath, TemplateLoaderParserOptions, TemplateLoaderLexerOptions);
			if (template.HasErrors)
			{
				throw new ScriptParserRuntimeException(callerSpan, "Error while parsing template `" + templatePath + "`", template.Messages);
			}
			CachedTemplates.Add(templatePath, template);
			return template;
		}

		public virtual async ValueTask<object?> EvaluateAsync(ScriptNode? scriptNode, bool aliasReturnedFunction)
		{
			if (scriptNode == null)
			{
				return null;
			}
			bool previousFunctionCallState = _isFunctionCallDisabled;
			int previousLevel = _getOrSetValueLevel;
			ScriptNode previousNode = CurrentNode;
			try
			{
				CurrentNode = scriptNode;
				_getOrSetValueLevel = 0;
				_isFunctionCallDisabled = aliasReturnedFunction;
				return await scriptNode.EvaluateAsync(this).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (ScriptRuntimeException exception) when (RenderRuntimeException != null)
			{
				return RenderRuntimeException(exception);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				ScriptRuntimeException ex2 = new ScriptRuntimeException(scriptNode.Span, ex.Message, ex);
				if (RenderRuntimeException != null)
				{
					return RenderRuntimeException(ex2);
				}
				throw ex2;
			}
			finally
			{
				CurrentNode = previousNode;
				_getOrSetValueLevel = previousLevel;
				_isFunctionCallDisabled = previousFunctionCallState;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public async ValueTask<object?> EvaluateAsync(ScriptNode scriptNode)
		{
			return await EvaluateAsync(scriptNode, aliasReturnedFunction: false).ConfigureAwait(continueOnCapturedContext: false);
		}

		private async ValueTask<Dictionary<string, object?>?> FetchNamedArgumentsAsync(ScriptNode? callerContext)
		{
			if (!(callerContext is ScriptFunctionCall scriptFunctionCall) || scriptFunctionCall.Arguments.Count == 0)
			{
				return null;
			}
			Dictionary<string, object?> namedArgumentsValues = new Dictionary<string, object>();
			foreach (ScriptExpression argument in scriptFunctionCall.Arguments)
			{
				if (argument is ScriptNamedArgument scriptNamedArgument)
				{
					string name = scriptNamedArgument.Name?.Name;
					if (name != null && scriptNamedArgument.Value != null)
					{
						namedArgumentsValues[name] = await scriptNamedArgument.Value.EvaluateAsync(this).ConfigureAwait(continueOnCapturedContext: false);
					}
				}
			}
			return namedArgumentsValues;
		}

		public async ValueTask<Template> GetOrCreateTemplateAsync(string templatePath, ScriptNode? callerContext)
		{
			if (!CachedTemplates.TryGetValue(templatePath, out Template value))
			{
				value = await CreateTemplateAsync(templatePath, callerContext).ConfigureAwait(continueOnCapturedContext: false);
				CachedTemplates[templatePath] = value;
			}
			return value;
		}

		private async ValueTask<object?> GetOrSetValueAsync(ScriptExpression targetExpression, object? valueToSet, bool setter)
		{
			object value = null;
			try
			{
				if (targetExpression is IScriptVariablePath scriptVariablePath)
				{
					if (setter)
					{
						await scriptVariablePath.SetValueAsync(this, valueToSet).ConfigureAwait(continueOnCapturedContext: false);
					}
					else
					{
						value = await scriptVariablePath.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
					}
				}
				else
				{
					if (setter)
					{
						throw new ScriptRuntimeException(targetExpression.Span, "Unsupported target expression for assignment.");
					}
					value = await EvaluateAsync(targetExpression).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			catch (Exception ex) when (_getOrSetValueLevel == 1 && !(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(targetExpression.Span, "Unexpected exception while accessing target expression: " + ex.Message, ex);
			}
			value = await AwaitIfNeededAsync(value).ConfigureAwait(continueOnCapturedContext: false);
			if (((_isFunctionCallDisabled && _getOrSetValueLevel > 1) || !_isFunctionCallDisabled) && ScriptFunctionCall.IsFunction(value))
			{
				value = await ScriptFunctionCall.CallAsync(this, targetExpression, value, _getOrSetValueLevel == 1, null).ConfigureAwait(continueOnCapturedContext: false);
			}
			return value;
		}

		public async ValueTask<object?> GetValueAsync(ScriptExpression? target)
		{
			if (target == null)
			{
				return null;
			}
			ScriptNode previousNode = CurrentNode;
			_getOrSetValueLevel++;
			try
			{
				CurrentNode = target;
				return await GetOrSetValueAsync(target, null, setter: false).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				CurrentNode = previousNode;
				_getOrSetValueLevel--;
			}
		}

		public async ValueTask<string> RenderTemplateAsync(Template template, ScriptArray arguments, ScriptNode? callerContext)
		{
			_ = string.Empty;
			EnterRecursive(callerContext);
			string previousIndent = CurrentIndent;
			bool previousTextWasNewLine = _previousTextWasNewLine;
			CurrentIndent = null;
			PushOutput();
			Dictionary<string, object> dictionary = await FetchNamedArgumentsAsync(callerContext).ConfigureAwait(continueOnCapturedContext: false);
			PushLocal();
			try
			{
				SetValue(ScriptVariable.Arguments, arguments, asReadOnly: true, force: true);
				if (dictionary != null)
				{
					foreach (KeyValuePair<string, object> item in dictionary)
					{
						ScriptVariable variable = ScriptVariable.Create(item.Key, ScriptVariableScope.Local);
						SetValue(variable, item.Value, asReadOnly: false, force: true);
					}
				}
				if (previousIndent != null)
				{
					ResetPreviousNewLine();
				}
				return await template.RenderAsync(this).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				PopLocal();
				PopOutput();
				CurrentIndent = previousIndent;
				_previousTextWasNewLine = previousTextWasNewLine;
				ExitRecursive(callerContext);
			}
		}

		public async ValueTask SetValueAsync(ScriptExpression? target, object? value)
		{
			if (target == null)
			{
				return;
			}
			_getOrSetValueLevel++;
			try
			{
				await GetOrSetValueAsync(target, value, setter: true).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				_getOrSetValueLevel--;
			}
		}

		public async ValueTask<TemplateContext> WriteAsync(string? text, int startIndex, int count)
		{
			if (text != null)
			{
				if (CurrentIndent != null)
				{
					int index = startIndex;
					int indexEnd = startIndex + count;
					while (index < indexEnd)
					{
						int newLineIndex = text.IndexOf('\n', index);
						if (newLineIndex < 0 || newLineIndex >= indexEnd)
						{
							if (_previousTextWasNewLine)
							{
								if (!(await WriteOutputChunkAsync(CurrentIndent, 0, CurrentIndent.Length).ConfigureAwait(continueOnCapturedContext: false)))
								{
									return this;
								}
								_previousTextWasNewLine = false;
							}
							await WriteOutputChunkAsync(text, index, indexEnd - index).ConfigureAwait(continueOnCapturedContext: false);
							return this;
						}
						int length = newLineIndex - index;
						if (_previousTextWasNewLine && (IndentOnEmptyLines || (length != 0 && (length != 1 || text[index] != '\r'))))
						{
							if (!(await WriteOutputChunkAsync(CurrentIndent, 0, CurrentIndent.Length).ConfigureAwait(continueOnCapturedContext: false)))
							{
								return this;
							}
							_previousTextWasNewLine = false;
						}
						if (!(await WriteOutputChunkAsync(text, index, length + 1).ConfigureAwait(continueOnCapturedContext: false)))
						{
							return this;
						}
						index = newLineIndex + 1;
						_previousTextWasNewLine = true;
					}
				}
				else
				{
					if (count > 0)
					{
						_previousTextWasNewLine = text[startIndex + count - 1] == '\n';
					}
					await WriteOutputChunkAsync(text, startIndex, count).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			return this;
		}

		public async ValueTask<TemplateContext> WriteAsync(string? text)
		{
			if (text != null)
			{
				await WriteAsync(text, 0, text.Length).ConfigureAwait(continueOnCapturedContext: false);
			}
			return this;
		}

		public async ValueTask<TemplateContext> WriteAsync(ScriptStringSlice slice)
		{
			await WriteAsync(slice.FullText ?? string.Empty, slice.Index, slice.Length).ConfigureAwait(continueOnCapturedContext: false);
			return this;
		}

		public virtual async ValueTask<TemplateContext> WriteAsync(SourceSpan span, object? textAsObject)
		{
			if (textAsObject != null)
			{
				textAsObject = await AwaitIfNeededAsync(textAsObject).ConfigureAwait(continueOnCapturedContext: false);
				string text = ObjectToString(textAsObject);
				if (text != null)
				{
					await WriteAsync(text).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			return this;
		}

		public async ValueTask<TemplateContext> WriteLineAsync()
		{
			await WriteAsync(NewLine).ConfigureAwait(continueOnCapturedContext: false);
			return this;
		}

		private async ValueTask<bool> WriteOutputChunkAsync(string text, int startIndex, int count)
		{
			if (count <= 0)
			{
				return true;
			}
			int allowedCount = GetAllowedOutputCount(count);
			if (allowedCount > 0)
			{
				await Output.WriteAsync(text, startIndex, allowedCount, CancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				_currentOutputLength += allowedCount;
			}
			if (allowedCount < count)
			{
				await WriteOutputLimitEllipsisAsync().ConfigureAwait(continueOnCapturedContext: false);
				return false;
			}
			return true;
		}

		private async ValueTask WriteOutputLimitEllipsisAsync()
		{
			if (!_hasOutputLimitEllipsis)
			{
				await Output.WriteAsync("...", 0, 3, CancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				_hasOutputLimitEllipsis = true;
			}
		}

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

		public TemplateContext(ScriptObject? builtin)
			: this(builtin, null)
		{
		}

		public TemplateContext(IEqualityComparer<string>? keyComparer)
			: this(null, keyComparer)
		{
		}

		public TemplateContext(ScriptObject? builtin, IEqualityComparer<string>? keyComparer)
		{
			BuiltinObject = builtin ?? GetDefaultBuiltinObject();
			EnableOutput = true;
			EnableBreakAndContinueAsReturnOutsideLoop = false;
			EnableRelaxedTargetAccess = false;
			EnableRelaxedMemberAccess = true;
			EnableRelaxedFunctionAccess = false;
			EnableRelaxedIndexerAccess = true;
			AutoIndent = true;
			IndentOnEmptyLines = true;
			LoopLimit = 1000;
			RecursiveLimit = 100;
			LimitToString = 1048576;
			ObjectRecursionLimit = 20;
			MemberRenamer = StandardMemberRenamer.Default;
			RegexTimeOut = TimeSpan.FromSeconds(10.0);
			TemplateLoaderParserOptions = new ParserOptions();
			TemplateLoaderLexerOptions = LexerOptions.Default;
			NewLine = Environment.NewLine;
			Language = ScriptLang.Default;
			_outputs = new FastStack<IScriptOutput>(4);
			_output = new StringBuilderOutput();
			_outputs.Push(_output);
			_globalContexts = new FastStack<VariableContext>(4);
			_functionContexts = new FastStack<VariableContext>(4);
			_availableGlobalContexts = new FastStack<VariableContext>(4);
			_availableFunctionContexts = new FastStack<VariableContext>(4);
			_availableLocalContexts = new FastStack<VariableContext>(4);
			_localContexts = new FastStack<VariableContext>(4);
			_availableStores = new FastStack<ScriptObject>(4);
			_cultures = new FastStack<CultureInfo>(4);
			_caseValues = new FastStack<object>(4);
			_sourceFiles = new FastStack<string>(4);
			_memberAccessors = new Dictionary<Type, IObjectAccessor>();
			_listAccessors = new Dictionary<Type, IListAccessor>();
			_loops = new FastStack<ScriptLoopStatementBase>(4);
			BlockDelegates = new FastStack<ScriptBlockStatement>(4);
			_availablePipeArguments = new FastStack<ScriptPipeArguments>(4);
			_pipeArguments = new FastStack<ScriptPipeArguments>(4);
			_availableScriptExpressionLists = new FastStack<List<ScriptExpression>>(4);
			_availableReflectionArguments = new object[65][];
			_keyComparer = keyComparer;
			for (int i = 0; i < _availableReflectionArguments.Length; i++)
			{
				_availableReflectionArguments[i] = new object[i];
			}
			_isFunctionCallDisabled = false;
			CachedTemplates = new Dictionary<string, Template>();
			Tags = new Dictionary<object, object>();
			PushGlobal(BuiltinObject);
		}

		public void CheckAbort()
		{
			RuntimeHelpers.EnsureSufficientExecutionStack();
			CancellationToken cancellationToken = CancellationToken;
			if (cancellationToken.IsCancellationRequested)
			{
				throw new ScriptAbortException(CurrentNode?.Span ?? default(SourceSpan), cancellationToken);
			}
		}

		public void PushCulture(CultureInfo culture)
		{
			if (culture == null)
			{
				throw new ArgumentNullException("culture");
			}
			_cultures.Push(culture);
		}

		public CultureInfo PopCulture()
		{
			if (_cultures.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopCulture more than PushCulture");
			}
			return _cultures.Pop();
		}

		internal void PushPipeArguments()
		{
			ScriptPipeArguments scriptPipeArguments = ((_availablePipeArguments.Count > 0) ? _availablePipeArguments.Pop() : new ScriptPipeArguments(1));
			_pipeArguments.Push(scriptPipeArguments);
			_currentPipeArguments = scriptPipeArguments;
		}

		internal void ClearPipeArguments()
		{
			while (_pipeArguments.Count > 0)
			{
				PopPipeArguments();
			}
		}

		internal List<ScriptExpression> GetOrCreateListOfScriptExpressions(int capacity)
		{
			List<ScriptExpression> list = ((_availableScriptExpressionLists.Count > 0) ? _availableScriptExpressionLists.Pop() : new List<ScriptExpression>());
			if (capacity > list.Capacity)
			{
				list.Capacity = capacity;
			}
			return list;
		}

		internal void ReleaseListOfScriptExpressions(List<ScriptExpression> list)
		{
			_availableScriptExpressionLists.Push(list);
			list.Clear();
		}

		internal object?[] GetOrCreateReflectionArguments(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			if (length >= _availableReflectionArguments.Length)
			{
				return new object[length];
			}
			object[] array = _availableReflectionArguments[length] ?? new object[length];
			if (length > 0)
			{
				_availableReflectionArguments[length] = array[0] as object[];
				array[0] = null;
			}
			return array;
		}

		internal void ReleaseReflectionArguments(object?[] reflectionArguments)
		{
			if (reflectionArguments != null && reflectionArguments.Length < _availableReflectionArguments.Length)
			{
				Array.Clear(reflectionArguments, 0, reflectionArguments.Length);
				object[] array = _availableReflectionArguments[reflectionArguments.Length];
				_availableReflectionArguments[reflectionArguments.Length] = reflectionArguments;
				if (reflectionArguments.Length != 0)
				{
					reflectionArguments[0] = array;
				}
			}
		}

		internal void PopPipeArguments()
		{
			if (_pipeArguments.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopPipeArguments more than PushPipeArguments");
			}
			ScriptPipeArguments scriptPipeArguments = _pipeArguments.Pop();
			scriptPipeArguments.Clear();
			_currentPipeArguments = ((_pipeArguments.Count > 0) ? _pipeArguments.Peek() : null);
			_availablePipeArguments.Push(scriptPipeArguments);
		}

		public void PushSourceFile(string sourceFile)
		{
			if (sourceFile == null)
			{
				throw new ArgumentNullException("sourceFile");
			}
			_sourceFiles.Push(sourceFile);
		}

		public string PopSourceFile()
		{
			if (_sourceFiles.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopSourceFile more than PushSourceFile");
			}
			return _sourceFiles.Pop();
		}

		public object? GetValue(ScriptExpression? target)
		{
			if (target == null)
			{
				return null;
			}
			ScriptNode currentNode = CurrentNode;
			_getOrSetValueLevel++;
			try
			{
				CurrentNode = target;
				return GetOrSetValue(target, null, setter: false);
			}
			finally
			{
				CurrentNode = currentNode;
				_getOrSetValueLevel--;
			}
		}

		public void SetValue(ScriptVariable variable, bool value)
		{
			SetValue(variable, value ? TrueObject : FalseObject);
		}

		public virtual void Import(SourceSpan span, object objectToImport)
		{
			if (!(objectToImport is ScriptObject))
			{
				throw new ScriptRuntimeException(span, "Unexpected value `" + GetTypeName(objectToImport) + "` for import. Expecting an plain script object.");
			}
			(CurrentGlobal ?? throw new ScriptRuntimeException(span, "No current global object is available.")).Import(objectToImport);
		}

		public void SetValue(ScriptExpression? target, object? value)
		{
			if (target == null)
			{
				return;
			}
			_getOrSetValueLevel++;
			try
			{
				GetOrSetValue(target, value, setter: true);
			}
			finally
			{
				_getOrSetValueLevel--;
			}
		}

		public void PushOutput()
		{
			PushOutput(new StringBuilderOutput());
		}

		public void PushOutput(IScriptOutput output)
		{
			_output = output ?? throw new ArgumentNullException("output");
			_outputs.Push(_output);
		}

		public IScriptOutput PopOutput()
		{
			if (_outputs.Count == 1)
			{
				throw new InvalidOperationException("Unexpected PopOutput for top level writer");
			}
			IScriptOutput result = _outputs.Pop();
			_output = _outputs.Peek();
			return result;
		}

		public virtual TemplateContext Write(SourceSpan span, object? textAsObject)
		{
			if (textAsObject != null)
			{
				textAsObject = AwaitIfNeeded(textAsObject);
				string text = ObjectToString(textAsObject);
				if (text != null)
				{
					Write(text);
				}
			}
			return this;
		}

		private void ResetOutputLimitTracking()
		{
			_currentOutputLength = 0;
			_hasOutputLimitEllipsis = false;
		}

		private bool WriteOutputChunk(string text, int startIndex, int count)
		{
			if (count <= 0)
			{
				return true;
			}
			int allowedOutputCount = GetAllowedOutputCount(count);
			if (allowedOutputCount > 0)
			{
				Output.Write(text, startIndex, allowedOutputCount);
				_currentOutputLength += allowedOutputCount;
			}
			if (allowedOutputCount < count)
			{
				WriteOutputLimitEllipsis();
				return false;
			}
			return true;
		}

		private int GetAllowedOutputCount(int requestedCount)
		{
			if (LimitToString <= 0)
			{
				return requestedCount;
			}
			int num = LimitToString - _currentOutputLength;
			if (num <= 0)
			{
				return 0;
			}
			return Math.Min(requestedCount, num);
		}

		private void WriteOutputLimitEllipsis()
		{
			if (!_hasOutputLimitEllipsis)
			{
				Output.Write("...", 0, 3);
				_hasOutputLimitEllipsis = true;
			}
		}

		public TemplateContext Write(string? text)
		{
			if (text != null)
			{
				Write(text, 0, text.Length);
			}
			return this;
		}

		public TemplateContext WriteLine()
		{
			Write(NewLine);
			return this;
		}

		public TemplateContext Write(ScriptStringSlice slice)
		{
			Write(slice.FullText ?? string.Empty, slice.Index, slice.Length);
			return this;
		}

		public TemplateContext Write(string? text, int startIndex, int count)
		{
			if (text != null)
			{
				if (CurrentIndent != null)
				{
					int num = startIndex;
					int num2 = startIndex + count;
					while (num < num2)
					{
						int num3 = text.IndexOf('\n', num);
						if (num3 < 0 || num3 >= num2)
						{
							if (_previousTextWasNewLine)
							{
								if (!WriteOutputChunk(CurrentIndent, 0, CurrentIndent.Length))
								{
									return this;
								}
								_previousTextWasNewLine = false;
							}
							WriteOutputChunk(text, num, num2 - num);
							return this;
						}
						int num4 = num3 - num;
						if (_previousTextWasNewLine && (IndentOnEmptyLines || (num4 != 0 && (num4 != 1 || text[num] != '\r'))))
						{
							if (!WriteOutputChunk(CurrentIndent, 0, CurrentIndent.Length))
							{
								return this;
							}
							_previousTextWasNewLine = false;
						}
						if (!WriteOutputChunk(text, num, num4 + 1))
						{
							return this;
						}
						num = num3 + 1;
						_previousTextWasNewLine = true;
					}
				}
				else
				{
					if (count > 0)
					{
						_previousTextWasNewLine = text[startIndex + count - 1] == '\n';
					}
					WriteOutputChunk(text, startIndex, count);
				}
			}
			return this;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public object? Evaluate(ScriptNode scriptNode)
		{
			return Evaluate(scriptNode, aliasReturnedFunction: false);
		}

		public virtual object? Evaluate(ScriptNode? scriptNode, bool aliasReturnedFunction)
		{
			if (scriptNode == null)
			{
				return null;
			}
			bool isFunctionCallDisabled = _isFunctionCallDisabled;
			int getOrSetValueLevel = _getOrSetValueLevel;
			ScriptNode currentNode = CurrentNode;
			try
			{
				CurrentNode = scriptNode;
				_getOrSetValueLevel = 0;
				_isFunctionCallDisabled = aliasReturnedFunction;
				return scriptNode.Evaluate(this);
			}
			catch (ScriptRuntimeException exception) when (RenderRuntimeException != null)
			{
				return RenderRuntimeException(exception);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				ScriptRuntimeException ex2 = new ScriptRuntimeException(scriptNode.Span, ex.Message, ex);
				if (RenderRuntimeException != null)
				{
					return RenderRuntimeException(ex2);
				}
				throw ex2;
			}
			finally
			{
				CurrentNode = currentNode;
				_getOrSetValueLevel = getOrSetValueLevel;
				_isFunctionCallDisabled = isFunctionCallDisabled;
			}
		}

		public IObjectAccessor GetMemberAccessor(object target)
		{
			if (target == null)
			{
				return NullAccessor.Default;
			}
			Type type = target.GetType();
			if (!_memberAccessors.TryGetValue(type, out IObjectAccessor value))
			{
				value = GetMemberAccessorImpl(target) ?? NullAccessor.Default;
				_memberAccessors.Add(type, value);
			}
			return value;
		}

		public virtual void Reset()
		{
			while (OutputCount > 1)
			{
				PopOutput();
			}
			((StringBuilderOutput)Output).Builder.Length = 0;
			while (GlobalCount > 1)
			{
				PopGlobal();
			}
			while (CultureCount > 0)
			{
				PopCulture();
			}
			while (SourceFileCount > 0)
			{
				PopSourceFile();
			}
			CachedTemplates.Clear();
			_memberAccessors.Clear();
			ResetOutputLimitTracking();
		}

		protected virtual IObjectAccessor? GetMemberAccessorImpl(object target)
		{
			Type type = target.GetType();
			if (target is IScriptObject)
			{
				return ScriptObjectAccessor.Default;
			}
			if (target is string)
			{
				return StringAccessor.Default;
			}
			if (type.IsPrimitiveOrDecimal())
			{
				return PrimitiveAccessor.Default;
			}
			if (DictionaryAccessor.TryGet(target, out IObjectAccessor accessor) && accessor != null)
			{
				return accessor;
			}
			if (type.IsArray)
			{
				return ArrayAccessor.Default;
			}
			if (target is IList)
			{
				return ListAccessor.Default;
			}
			return new TypedObjectAccessor(type, _keyComparer, MemberFilter, MemberRenamer);
		}

		public static ScriptObject GetDefaultBuiltinObject()
		{
			return new BuiltinFunctions();
		}

		public void EnterRecursive(ScriptNode? node)
		{
			SourceSpan span = node?.Span ?? CurrentSpan;
			try
			{
				RuntimeHelpers.EnsureSufficientExecutionStack();
			}
			catch (InsufficientExecutionStackException)
			{
				throw new ScriptRuntimeException(span, "Exceeding recursive depth limit, near to stack overflow");
			}
			_callDepth++;
			if (RecursiveLimit != 0 && _callDepth > RecursiveLimit)
			{
				throw new ScriptRuntimeException(span, $"Exceeding number of recursive depth limit `{RecursiveLimit}` for node: `{node}`");
			}
		}

		public void ExitRecursive(ScriptNode? node)
		{
			_callDepth--;
			if (_callDepth < 0)
			{
				throw new ScriptRuntimeException(node?.Span ?? CurrentSpan, $"unexpected ExitRecursive not matching EnterRecursive for `{node}`");
			}
		}

		internal void EnterFunction(ScriptNode? caller)
		{
			EnterRecursive(caller);
		}

		internal void ExitFunction(ScriptNode? caller)
		{
			ExitRecursive(caller);
		}

		internal void EnterLoop(ScriptLoopStatementBase loop)
		{
			if (loop == null)
			{
				throw new ArgumentNullException("loop");
			}
			_loops.Push(loop);
			PushVariableScope(VariableScope.Loop);
			OnEnterLoop(loop);
		}

		protected virtual void OnEnterLoop(ScriptLoopStatementBase loop)
		{
		}

		internal void ExitLoop(ScriptLoopStatementBase loop)
		{
			try
			{
				OnExitLoop(loop);
			}
			finally
			{
				PopVariableScope(VariableScope.Loop);
				_loops.Pop();
				if (!IsInLoop)
				{
					_loopStep = 0;
				}
			}
		}

		protected virtual void OnExitLoop(ScriptLoopStatementBase loop)
		{
		}

		internal void StepLoop(SourceSpan span, ref int loopStep, LoopType loopType = LoopType.Default)
		{
			CheckAbort();
			loopStep++;
			int num = ((loopType == LoopType.Queryable) ? LoopLimitQueryable.GetValueOrDefault(LoopLimit) : LoopLimit);
			if (num != 0 && loopStep > num)
			{
				throw new ScriptRuntimeException(span, $"Exceeding number of iteration limit `{num}` for internal iteration.");
			}
		}

		internal bool StepLoop(ScriptLoopStatementBase loop, LoopType loopType = LoopType.Default)
		{
			_loopStep++;
			int num = ((loopType != LoopType.Queryable) ? LoopLimit : LoopLimitQueryable.GetValueOrDefault(LoopLimit));
			if (num != 0 && _loopStep > num)
			{
				throw new ScriptRuntimeException(_loops.Peek().Span, $"Exceeding number of iteration limit `{num}` for loop statement.");
			}
			return OnStepLoop(loop);
		}

		protected virtual bool OnStepLoop(ScriptLoopStatementBase loop)
		{
			return true;
		}

		internal void PushCase(object? caseValue)
		{
			_caseValues.Push(caseValue);
		}

		internal object? PeekCase()
		{
			return _caseValues.Peek();
		}

		internal object? PopCase()
		{
			if (_caseValues.Count == 0)
			{
				throw new InvalidOperationException("Cannot PopCase more than PushCase");
			}
			return _caseValues.Pop();
		}

		private object? GetOrSetValue(ScriptExpression targetExpression, object? valueToSet, bool setter)
		{
			object value = null;
			try
			{
				if (targetExpression is IScriptVariablePath scriptVariablePath)
				{
					if (setter)
					{
						scriptVariablePath.SetValue(this, valueToSet);
					}
					else
					{
						value = scriptVariablePath.GetValue(this);
					}
				}
				else
				{
					if (setter)
					{
						throw new ScriptRuntimeException(targetExpression.Span, "Unsupported target expression for assignment.");
					}
					value = Evaluate(targetExpression);
				}
			}
			catch (Exception ex) when (_getOrSetValueLevel == 1 && !(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(targetExpression.Span, "Unexpected exception while accessing target expression: " + ex.Message, ex);
			}
			value = AwaitIfNeeded(value);
			if (((_isFunctionCallDisabled && _getOrSetValueLevel > 1) || !_isFunctionCallDisabled) && ScriptFunctionCall.IsFunction(value))
			{
				value = ScriptFunctionCall.Call(this, targetExpression, value, _getOrSetValueLevel == 1, null);
			}
			return value;
		}

		public IListAccessor GetListAccessor(object target)
		{
			return TryGetListAccessor(target) ?? throw new ScriptRuntimeException(CurrentSpan, "Unable to find a list accessor for `" + GetTypeName(target) + "`.");
		}

		internal IListAccessor? TryGetListAccessor(object target)
		{
			Type type = target.GetType();
			if (!_listAccessors.TryGetValue(type, out IListAccessor value))
			{
				value = GetListAccessorImpl(target, type);
				if (value != null)
				{
					_listAccessors.Add(type, value);
				}
			}
			return value;
		}

		protected virtual IListAccessor? GetListAccessorImpl(object target, Type type)
		{
			if (type.IsArray)
			{
				return ArrayAccessor.Default;
			}
			if (type == typeof(string))
			{
				return StringAccessor.Default;
			}
			if (type.IsPrimitiveOrDecimal())
			{
				return PrimitiveAccessor.Default;
			}
			if (target is IList)
			{
				return ListAccessor.Default;
			}
			return null;
		}

		public void ResetPreviousNewLine()
		{
			_previousTextWasNewLine = false;
		}

		public virtual string? GetTemplatePathFromName(string? templateName, ScriptNode? callerContext)
		{
			SourceSpan span = callerContext?.Span ?? CurrentSpan;
			if (string.IsNullOrEmpty(templateName))
			{
				throw new ScriptRuntimeException(span, "Include template name cannot be null or empty");
			}
			string templateName2 = templateName ?? throw new ScriptRuntimeException(span, "Include template name cannot be null or empty");
			return ConvertTemplateNameToPath(templateName2, callerContext);
		}

		protected string ConvertTemplateNameToPath(string templateName, ScriptNode? callerContext)
		{
			SourceSpan sourceSpan = callerContext?.Span ?? CurrentSpan;
			if (TemplateLoader == null)
			{
				throw new ScriptRuntimeException(sourceSpan, "Unable to include <" + templateName + ">. No TemplateLoader registered in TemplateContext.TemplateLoader");
			}
			ITemplateLoader templateLoader = TemplateLoader;
			string path;
			try
			{
				path = templateLoader.GetPath(this, sourceSpan, templateName);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(sourceSpan, "Unexpected exception while getting the path for the include name `" + templateName + "`", ex);
			}
			if (path == null)
			{
				throw new ScriptRuntimeException(sourceSpan, "Include template path is null for `" + templateName);
			}
			return path;
		}

		public Template GetOrCreateTemplate(string templatePath, ScriptNode? callerContext)
		{
			if (!CachedTemplates.TryGetValue(templatePath, out Template value))
			{
				value = CreateTemplate(templatePath, callerContext);
				CachedTemplates[templatePath] = value;
			}
			return value;
		}

		protected virtual Template CreateTemplate(string templatePath, ScriptNode? callerContext)
		{
			SourceSpan sourceSpan = callerContext?.Span ?? CurrentSpan;
			ITemplateLoader templateLoader = TemplateLoader ?? throw new ScriptRuntimeException(sourceSpan, "No TemplateLoader registered in TemplateContext.TemplateLoader");
			string text;
			try
			{
				text = templateLoader.Load(this, sourceSpan, templatePath);
			}
			catch (Exception ex) when (!(ex is ScriptRuntimeException))
			{
				throw new ScriptRuntimeException(sourceSpan, "Unexpected exception while creating template from path `" + templatePath + "`", ex);
			}
			if (text == null)
			{
				throw new ScriptRuntimeException(sourceSpan, "The result of including `" + templatePath + "` cannot be null");
			}
			Template template = Template.Parse(text, templatePath, TemplateLoaderParserOptions, TemplateLoaderLexerOptions);
			if (template.HasErrors)
			{
				throw new ScriptParserRuntimeException(sourceSpan, "Error while parsing template `" + templatePath + "`", template.Messages);
			}
			CachedTemplates.Add(templatePath, template);
			return template;
		}

		private Dictionary<string, object?>? FetchNamedArguments(ScriptNode? callerContext)
		{
			if (!(callerContext is ScriptFunctionCall scriptFunctionCall) || scriptFunctionCall.Arguments.Count == 0)
			{
				return null;
			}
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			foreach (ScriptExpression argument in scriptFunctionCall.Arguments)
			{
				if (argument is ScriptNamedArgument scriptNamedArgument)
				{
					string text = scriptNamedArgument.Name?.Name;
					if (text != null && scriptNamedArgument.Value != null)
					{
						object value = scriptNamedArgument.Value.Evaluate(this);
						dictionary[text] = value;
					}
				}
			}
			return dictionary;
		}

		public string RenderTemplate(Template template, ScriptArray arguments, ScriptNode? callerContext)
		{
			string empty = string.Empty;
			EnterRecursive(callerContext);
			string currentIndent = CurrentIndent;
			bool previousTextWasNewLine = _previousTextWasNewLine;
			CurrentIndent = null;
			PushOutput();
			Dictionary<string, object> dictionary = FetchNamedArguments(callerContext);
			PushLocal();
			try
			{
				SetValue(ScriptVariable.Arguments, arguments, asReadOnly: true, force: true);
				if (dictionary != null)
				{
					foreach (KeyValuePair<string, object> item in dictionary)
					{
						ScriptVariable variable = ScriptVariable.Create(item.Key, ScriptVariableScope.Local);
						SetValue(variable, item.Value, asReadOnly: false, force: true);
					}
				}
				if (currentIndent != null)
				{
					ResetPreviousNewLine();
				}
				return template.Render(this);
			}
			finally
			{
				PopLocal();
				PopOutput();
				CurrentIndent = currentIndent;
				_previousTextWasNewLine = previousTextWasNewLine;
				ExitRecursive(callerContext);
			}
		}

		public object? GetFormat(Type? formatType)
		{
			return CurrentCulture.GetFormat(formatType);
		}

		public virtual object? IsEmpty(SourceSpan span, object? against)
		{
			if (against == null)
			{
				return null;
			}
			if (against is IList)
			{
				return ((IList)against).Count == 0;
			}
			if (against is IEnumerable)
			{
				return !((IEnumerable)against).GetEnumerator().MoveNext();
			}
			if (against.GetType().IsPrimitiveOrDecimal())
			{
				return false;
			}
			return GetMemberAccessor(against).GetMemberCount(this, span, against) > 0;
		}

		public virtual IList? ToList(SourceSpan span, object? value)
		{
			if (value == null)
			{
				return null;
			}
			if (value is IList)
			{
				return (IList)value;
			}
			return new ScriptArray((value as IEnumerable) ?? throw new ScriptRuntimeException(span, "Unexpected list value. Expecting an array, list or iterator. Unable to convert to a list."));
		}

		public virtual string? ObjectToString(object? value, bool nested = false)
		{
			if (_objectToStringLevel == 0)
			{
				_currentToStringLength = 0;
			}
			try
			{
				_objectToStringLevel++;
				if (ObjectRecursionLimit != 0 && _objectToStringLevel > ObjectRecursionLimit)
				{
					throw new InvalidOperationException("Structure is too deeply nested or contains reference loops.");
				}
				string text = ObjectToStringImpl(value, nested);
				if (LimitToString > 0 && _objectToStringLevel == 1 && text != null && text.Length >= LimitToString)
				{
					return text + "...";
				}
				return text;
			}
			finally
			{
				_objectToStringLevel--;
			}
		}

		private string? ObjectToStringImpl(object? value, bool nested)
		{
			if (LimitToString > 0 && _currentToStringLength >= LimitToString)
			{
				return string.Empty;
			}
			if (value is string text)
			{
				if (LimitToString > 0 && _currentToStringLength + text.Length >= LimitToString)
				{
					int num = LimitToString - _currentToStringLength;
					if (num <= 0)
					{
						return string.Empty;
					}
					string text2 = text.Substring(0, num);
					if (!nested)
					{
						return text2;
					}
					return "\"" + StringFunctions.Escape(text2);
				}
				if (!nested)
				{
					return text;
				}
				return "\"" + StringFunctions.Escape(text) + "\"";
			}
			if (value == null || value == EmptyScriptObject.Default)
			{
				if (!nested)
				{
					return null;
				}
				return "null";
			}
			if (value is bool)
			{
				if (!(bool)value)
				{
					return "false";
				}
				return "true";
			}
			if (value is DateTime value2)
			{
				bool strictVariables = StrictVariables;
				try
				{
					StrictVariables = false;
					if (GetValue(DateTimeFunctions.DateVariable) is DateTimeFunctions dateTimeFunctions)
					{
						return dateTimeFunctions.ToString(value2, dateTimeFunctions.Format, CurrentCulture);
					}
				}
				finally
				{
					StrictVariables = strictVariables;
				}
			}
			if (value is IFormattable formattable)
			{
				return formattable.ToString(null, this);
			}
			if (value is IConvertible convertible)
			{
				return convertible.ToString(this);
			}
			if (value is IEnumerable enumerable)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("[");
				_currentToStringLength++;
				bool flag = true;
				foreach (object item in enumerable)
				{
					if (!flag)
					{
						stringBuilder.Append(", ");
						_currentToStringLength += 2;
					}
					string text3 = ObjectToString(item, nested: true);
					stringBuilder.Append(text3);
					if (text3 != null)
					{
						_currentToStringLength += text3.Length;
					}
					if (LimitToString > 0 && _currentToStringLength >= LimitToString)
					{
						return stringBuilder.ToString();
					}
					flag = false;
				}
				stringBuilder.Append("]");
				_currentToStringLength++;
				return stringBuilder.ToString();
			}
			string fullName = value.GetType().FullName;
			if (fullName != null && fullName.StartsWith("System.Collections.Generic.KeyValuePair"))
			{
				ScriptObject scriptObject = new ScriptObject(2);
				scriptObject.Import(value, null, MemberRenamer);
				return ObjectToString(scriptObject, nested: true);
			}
			if (value is IScriptCustomFunction && !(value is ScriptFunction))
			{
				return "<function>";
			}
			return value.ToString();
		}

		public virtual bool ToBool(SourceSpan span, object? value)
		{
			if (value == null || value == EmptyScriptObject.Default)
			{
				return false;
			}
			if (value is bool)
			{
				return (bool)value;
			}
			if (UseScientific)
			{
				Type type = value.GetType();
				if (type.IsPrimitive || type == typeof(decimal))
				{
					return Convert.ToBoolean(value);
				}
				if (value is BigInteger bigInteger)
				{
					return bigInteger != BigInteger.Zero;
				}
			}
			return true;
		}

		public virtual int ToInt(SourceSpan span, object? value)
		{
			if (value == null)
			{
				return 0;
			}
			if (value is int)
			{
				return (int)value;
			}
			checked
			{
				try
				{
					if (value is BigInteger bigInteger)
					{
						return (int)bigInteger;
					}
					if (value is IScriptConvertibleTo scriptConvertibleTo && scriptConvertibleTo.TryConvertTo(this, span, typeof(int), out object value2))
					{
						return (int)value2;
					}
					if (value is uint num)
					{
						return (int)num;
					}
					if (value is ulong num2)
					{
						return (int)num2;
					}
					return Convert.ToInt32(value, CurrentCulture);
				}
				catch (Exception innerException)
				{
					throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to int", innerException);
				}
			}
		}

		public virtual string GetTypeName(object? value)
		{
			if (value == null)
			{
				return "null";
			}
			if (value is Type type)
			{
				return type.ScriptPrettyName();
			}
			if (value is IScriptCustomTypeInfo scriptCustomTypeInfo)
			{
				return scriptCustomTypeInfo.TypeName;
			}
			return value.GetType().ScriptPrettyName();
		}

		[return: MaybeNull]
		public T ToObject<T>(SourceSpan span, object? value)
		{
			object obj = ToObject(span, value, typeof(T));
			if (obj is T)
			{
				return (T)obj;
			}
			if (obj == null && default(T) == null)
			{
				return default(T);
			}
			throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to `" + GetTypeName(typeof(T)) + "`");
		}

		public virtual object? ToObject(SourceSpan span, object? value, Type destinationType)
		{
			if ((object)destinationType == null)
			{
				throw new ArgumentNullException("destinationType");
			}
			bool flag;
			(flag, destinationType) = GetNullableInfo(destinationType);
			if (flag && value == null)
			{
				return null;
			}
			Type type = value?.GetType();
			if (destinationType == type)
			{
				return value;
			}
			if (destinationType == typeof(string))
			{
				return ObjectToString(value);
			}
			if (destinationType == typeof(int))
			{
				return ToInt(span, value);
			}
			if (destinationType == typeof(bool))
			{
				return ToBool(span, value);
			}
			if (value == null)
			{
				if (destinationType == typeof(double))
				{
					return 0.0;
				}
				if (destinationType == typeof(float))
				{
					return 0f;
				}
				if (destinationType == typeof(long))
				{
					return 0L;
				}
				if (destinationType == typeof(decimal))
				{
					return 0m;
				}
				if (destinationType == typeof(BigInteger))
				{
					return new BigInteger(0);
				}
				return null;
			}
			if (destinationType.IsEnum)
			{
				try
				{
					if (value is string value2)
					{
						return Enum.Parse(destinationType, value2);
					}
					return Enum.ToObject(destinationType, value);
				}
				catch (Exception innerException)
				{
					throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to `" + GetTypeName(destinationType) + "`", innerException);
				}
			}
			if (value is IScriptConvertibleTo scriptConvertibleTo && scriptConvertibleTo.TryConvertTo(this, span, destinationType, out object value3))
			{
				return value3;
			}
			if (typeof(IScriptConvertibleFrom).IsAssignableFrom(destinationType))
			{
				if (!(Activator.CreateInstance(destinationType) is IScriptConvertibleFrom scriptConvertibleFrom))
				{
					throw new ScriptRuntimeException(span, "Unable to create an instance of `" + GetTypeName(destinationType) + "`");
				}
				if (scriptConvertibleFrom.TryConvertFrom(this, span, value))
				{
					return scriptConvertibleFrom;
				}
			}
			Type c = type;
			if ((object)type != null && type.IsPrimitiveOrDecimal() && destinationType.IsPrimitiveOrDecimal())
			{
				try
				{
					if (destinationType == typeof(BigInteger))
					{
						if (type == typeof(char))
						{
							return new BigInteger((char)value);
						}
						if (type == typeof(bool))
						{
							return new BigInteger(((bool)value) ? 1 : 0);
						}
						if (type == typeof(float))
						{
							return new BigInteger((float)value);
						}
						if (type == typeof(double))
						{
							return new BigInteger((double)value);
						}
						if (type == typeof(int))
						{
							return new BigInteger((int)value);
						}
						if (type == typeof(uint))
						{
							return new BigInteger((uint)value);
						}
						if (type == typeof(long))
						{
							return new BigInteger((long)value);
						}
						if (type == typeof(ulong))
						{
							return new BigInteger((ulong)value);
						}
					}
					else if (type == typeof(BigInteger))
					{
						if (destinationType == typeof(char))
						{
							return (char)(int)(BigInteger)value;
						}
						if (destinationType == typeof(float))
						{
							return (float)(BigInteger)value;
						}
						if (destinationType == typeof(double))
						{
							return (double)(BigInteger)value;
						}
						if (destinationType == typeof(uint))
						{
							return (uint)(BigInteger)value;
						}
						if (destinationType == typeof(long))
						{
							return (long)(BigInteger)value;
						}
						if (destinationType == typeof(ulong))
						{
							return (ulong)(BigInteger)value;
						}
					}
					return Convert.ChangeType(value, destinationType, CurrentCulture);
				}
				catch (Exception innerException2)
				{
					throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to `" + GetTypeName(destinationType) + "`", innerException2);
				}
			}
			if (destinationType == typeof(IList))
			{
				return ToList(span, value);
			}
			if (destinationType.IsAssignableFrom(c))
			{
				return value;
			}
			throw new ScriptRuntimeException(span, "Unable to convert type `" + GetTypeName(value) + "` to `" + GetTypeName(destinationType) + "`");
			static (bool isNullable, Type DestinationType) GetNullableInfo(Type type2)
			{
				type2 = type2 ?? throw new ArgumentNullException("destinationType");
				Type underlyingType = Nullable.GetUnderlyingType(type2);
				if ((object)underlyingType != null)
				{
					return (isNullable: true, DestinationType: underlyingType);
				}
				return (isNullable: false, DestinationType: type2);
			}
		}

		public void PushGlobal(IScriptObject scriptObject)
		{
			PushGlobalOnly(scriptObject);
			PushLocal();
		}

		internal void PushGlobalOnly(IScriptObject scriptObject)
		{
			if (scriptObject == null)
			{
				throw new ArgumentNullException("scriptObject");
			}
			_globalContexts.Push(GetOrCreateGlobalContext(scriptObject));
		}

		private VariableContext GetOrCreateGlobalContext(IScriptObject globalObject)
		{
			if (_availableGlobalContexts.Count == 0)
			{
				return new VariableContext(globalObject);
			}
			VariableContext variableContext = _availableGlobalContexts.Pop();
			variableContext.LocalObject = globalObject;
			return variableContext;
		}

		internal IScriptObject PopGlobalOnly()
		{
			if (_globalContexts.Count == 1)
			{
				throw new InvalidOperationException("Unexpected PopGlobal() not matching a PushGlobal");
			}
			VariableContext variableContext = _globalContexts.Pop();
			IScriptObject? localObject = variableContext.LocalObject;
			variableContext.LocalObject = null;
			_availableGlobalContexts.Push(variableContext);
			if (localObject == null)
			{
				throw new InvalidOperationException("Unexpected null global store.");
			}
			return localObject;
		}

		public IScriptObject PopGlobal()
		{
			IScriptObject result = PopGlobalOnly();
			PopLocal();
			return result;
		}

		public void PushLocal()
		{
			PushVariableScope(VariableScope.Local);
		}

		public void PopLocal()
		{
			PopVariableScope(VariableScope.Local);
		}

		internal void PushFunction(ScriptObject? functionVariables, bool hideParentFunctionScopes)
		{
			VariableContext variableContext = ((_availableFunctionContexts.Count > 0) ? _availableFunctionContexts.Pop() : new VariableContext(null));
			variableContext.LocalObject = functionVariables;
			variableContext.HideParentFunctionScopes = hideParentFunctionScopes;
			_functionContexts.Push(variableContext);
			PushLocal();
		}

		internal void PopFunction()
		{
			VariableContext variableContext = _functionContexts.Pop();
			PopLocal();
			if (variableContext.LocalObject is ScriptObject scriptObject)
			{
				scriptObject.Clear();
			}
			variableContext.LocalObject = null;
			variableContext.HideParentFunctionScopes = false;
			_availableFunctionContexts.Push(variableContext);
		}

		public void SetValue(ScriptVariable variable, object? value, bool asReadOnly = false)
		{
			if ((object)variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			if (!GetStoreForWrite(variable).TrySetValue(this, variable.Span, variable.Name, value, asReadOnly))
			{
				throw new ScriptRuntimeException(variable.Span, $"Cannot set value on the readonly variable `{variable}`");
			}
		}

		public void SetValue(ScriptVariable variable, object? value, bool asReadOnly, bool force)
		{
			if ((object)variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			IScriptObject storeForWrite = GetStoreForWrite(variable);
			if (force)
			{
				storeForWrite.Remove(variable.Name);
				storeForWrite.TrySetValue(this, variable.Span, variable.Name, value, asReadOnly);
			}
			else if (!storeForWrite.TrySetValue(this, variable.Span, variable.Name, value, asReadOnly))
			{
				throw new ScriptRuntimeException(variable.Span, $"Cannot set value on the readonly variable `{variable}`");
			}
		}

		public void DeleteValue(ScriptVariable variable)
		{
			if ((object)variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			GetStoreForWrite(variable).Remove(variable.Name);
		}

		public void SetReadOnly(ScriptVariable variable, bool isReadOnly = true)
		{
			if ((object)variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			GetStoreForWrite(variable).SetReadOnly(variable.Name, isReadOnly);
		}

		public virtual void SetLoopVariable(ScriptVariable variable, object? value)
		{
			if ((object)variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			VariableContext obj = ((variable.Scope == ScriptVariableScope.Global) ? GetCurrentGlobalVariableContext() : (_currentLocalContext ?? throw new InvalidOperationException("No current local context is available.")));
			if (obj.Loops.Count == 0)
			{
				throw new InvalidOperationException("Cannot set a loop global variable without a loop variable store.");
			}
			if (!obj.Loops.Peek().TrySetValue(this, variable.Span, variable.Name, value, readOnly: false))
			{
				throw new ScriptRuntimeException(variable.Span, $"Cannot set value on the variable `{variable}`");
			}
		}

		private void PushLocalContext(ScriptObject? locals = null)
		{
			VariableContext variableContext = ((_availableLocalContexts.Count > 0) ? _availableLocalContexts.Pop() : new VariableContext(null));
			variableContext.LocalObject = locals;
			_localContexts.Push(variableContext);
			_currentLocalContext = variableContext;
		}

		private ScriptObject? PopLocalContext()
		{
			VariableContext variableContext = _localContexts.Pop();
			ScriptObject result = variableContext.LocalObject as ScriptObject;
			variableContext.LocalObject = null;
			_availableLocalContexts.Push(variableContext);
			_currentLocalContext = _localContexts.Peek();
			return result;
		}

		public object? GetValue(ScriptVariable variable)
		{
			if ((object)variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			IEnumerable<IScriptObject> storeForRead = GetStoreForRead(variable);
			object value = null;
			foreach (IScriptObject item in storeForRead)
			{
				if (item.TryGetValue(this, variable.Span, variable.Name, out value))
				{
					return value;
				}
			}
			bool found = false;
			if (TryGetVariable != null && TryGetVariable(this, variable.Span, variable, out value))
			{
				found = true;
			}
			CheckVariableFound(variable, found);
			return value;
		}

		public object? GetValue(ScriptVariableGlobal variable)
		{
			if ((object)variable == null)
			{
				throw new ArgumentNullException("variable");
			}
			object value = null;
			foreach (VariableContext visibleFunctionContext in GetVisibleFunctionContexts())
			{
				if (TryGetValue(visibleFunctionContext, variable, out value))
				{
					return value;
				}
			}
			int count = _globalContexts.Count;
			VariableContext[] items = _globalContexts.Items;
			for (int num = count - 1; num >= 0; num--)
			{
				VariableContext context = items[num];
				if (TryGetValue(context, variable, out value))
				{
					return value;
				}
			}
			bool found = false;
			if (TryGetVariable != null && TryGetVariable(this, variable.Span, variable, out value))
			{
				found = true;
			}
			CheckVariableFound(variable, found);
			return value;
		}

		internal object? AwaitIfNeeded(object? value)
		{
			return value;
		}

		internal async ValueTask<object?> AwaitIfNeededAsync(object? value)
		{
			if (value == null)
			{
				return null;
			}
			if (value is Task task)
			{
				await task.ConfigureAwait(continueOnCapturedContext: false);
				return task.GetType().GetProperty("Result")?.GetValue(task);
			}
			if (value is ValueTask valueTask)
			{
				await valueTask.ConfigureAwait(continueOnCapturedContext: false);
				return null;
			}
			Type type = value.GetType();
			if (type.IsValueType && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>))
			{
				MethodInfo method = type.GetMethod("AsTask", Type.EmptyTypes);
				if ((object)method == null)
				{
					return value;
				}
				if (!(method.Invoke(value, null) is Task awaitedTask))
				{
					return value;
				}
				await awaitedTask.ConfigureAwait(continueOnCapturedContext: false);
				return awaitedTask.GetType().GetProperty("Result")?.GetValue(awaitedTask);
			}
			return value;
		}

		public ValueTask<object?> GetValueAsync(ScriptVariableGlobal variable)
		{
			return new ValueTask<object>(GetValue(variable));
		}

		public ValueTask<object?> GetValueAsync(ScriptVariable variable)
		{
			return new ValueTask<object>(GetValue(variable));
		}

		public ValueTask SetValueAsync(ScriptVariable variable, object? value, bool asReadOnly = false)
		{
			SetValue(variable, value, asReadOnly);
			return default(ValueTask);
		}

		private IScriptObject GetStoreForWrite(ScriptVariable variable)
		{
			ScriptVariableScope scope = variable.Scope;
			IScriptObject scriptObject = null;
			switch (scope)
			{
			case ScriptVariableScope.Global:
				scriptObject = GetGlobalStoreForWrite(variable);
				break;
			case ScriptVariableScope.Local:
			{
				VariableContext variableContext = _currentLocalContext ?? throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the local variable `{variable}` in the current context");
				if (variableContext.LocalObject != null)
				{
					scriptObject = variableContext.LocalObject;
					break;
				}
				if (_globalContexts.Count > 0)
				{
					scriptObject = _globalContexts.Peek().LocalObject;
					break;
				}
				throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the local variable `{variable}` in the current context");
			}
			}
			if (scriptObject == null)
			{
				throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the variable `{variable}` in the current context");
			}
			return scriptObject;
		}

		private IEnumerable<IScriptObject> GetStoreForRead(ScriptVariable variable)
		{
			ScriptVariableScope scope = variable.Scope;
			switch (scope)
			{
			case ScriptVariableScope.Global:
			{
				foreach (VariableContext visibleFunctionContext in GetVisibleFunctionContexts())
				{
					foreach (IScriptObject item in GetStoresForRead(visibleFunctionContext))
					{
						yield return item;
					}
				}
				for (int i = _globalContexts.Count - 1; i >= 0; i--)
				{
					VariableContext context = _globalContexts.Items[i];
					foreach (IScriptObject item2 in GetStoresForRead(context))
					{
						yield return item2;
					}
				}
				break;
			}
			case ScriptVariableScope.Local:
			{
				VariableContext currentLocalContext = _currentLocalContext ?? throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the local variable `{variable}` in the current context");
				ScriptObject[] loopItems = currentLocalContext.Loops.Items;
				for (int i = currentLocalContext.Loops.Count - 1; i >= 0; i--)
				{
					yield return loopItems[i];
				}
				if (currentLocalContext.LocalObject != null)
				{
					yield return currentLocalContext.LocalObject;
					break;
				}
				if (_globalContexts.Count > 0)
				{
					IScriptObject localObject = _globalContexts.Peek().LocalObject;
					if (localObject == null)
					{
						throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the local variable `{variable}` in the current context");
					}
					yield return localObject;
					break;
				}
				throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the local variable `{variable}` in the current context");
			}
			default:
				throw new NotImplementedException($"Variable scope `{scope}` is not implemented");
			}
		}

		private IEnumerable<VariableContext> GetVisibleFunctionContexts()
		{
			for (int i = _functionContexts.Count - 1; i >= 0; i--)
			{
				VariableContext functionContext = _functionContexts.Items[i];
				yield return functionContext;
				if (functionContext.HideParentFunctionScopes)
				{
					break;
				}
			}
		}

		private VariableContext GetCurrentGlobalVariableContext()
		{
			foreach (VariableContext visibleFunctionContext in GetVisibleFunctionContexts())
			{
				if (visibleFunctionContext.LocalObject != null)
				{
					return visibleFunctionContext;
				}
			}
			return _globalContexts.Peek();
		}

		private IScriptObject GetGlobalStoreForWrite(ScriptVariable variable)
		{
			string name = variable.Name;
			IScriptObject localObject = _globalContexts.Peek().LocalObject;
			if (localObject == null)
			{
				throw new ScriptRuntimeException(variable.Span, $"Invalid usage of the global variable `{variable}` in the current context");
			}
			IScriptObject scriptObject = null;
			foreach (VariableContext visibleFunctionContext in GetVisibleFunctionContexts())
			{
				IScriptObject localObject2 = visibleFunctionContext.LocalObject;
				if (localObject2 != null)
				{
					if (scriptObject == null)
					{
						scriptObject = localObject2;
					}
					if (localObject2.Contains(name))
					{
						CheckStoreCanWrite(variable, localObject2);
						return localObject2;
					}
				}
			}
			if (scriptObject == null)
			{
				CheckStoreCanWrite(variable, localObject);
				return localObject;
			}
			if (ContainsInGlobalContexts(name))
			{
				CheckStoreCanWrite(variable, localObject);
				return localObject;
			}
			CheckStoreCanWrite(variable, scriptObject);
			return scriptObject;
		}

		private bool ContainsInGlobalContexts(string name)
		{
			for (int num = _globalContexts.Count - 1; num >= 0; num--)
			{
				IScriptObject? localObject = _globalContexts.Items[num].LocalObject;
				if (localObject != null && localObject.Contains(name))
				{
					return true;
				}
			}
			return false;
		}

		private static IEnumerable<IScriptObject> GetStoresForRead(VariableContext context)
		{
			ScriptObject[] loopItems = context.Loops.Items;
			for (int i = context.Loops.Count - 1; i >= 0; i--)
			{
				yield return loopItems[i];
			}
			if (context.LocalObject != null)
			{
				yield return context.LocalObject;
			}
		}

		private bool TryGetValue(VariableContext context, ScriptVariable variable, out object? value)
		{
			foreach (IScriptObject item in GetStoresForRead(context))
			{
				if (item.TryGetValue(this, variable.Span, variable.Name, out value))
				{
					return true;
				}
			}
			value = null;
			return false;
		}

		private void CheckStoreCanWrite(ScriptVariable variable, IScriptObject store)
		{
			if (!store.CanWrite(variable.Name))
			{
				string arg = ((store == BuiltinObject) ? "builtin " : string.Empty);
				throw new ScriptRuntimeException(variable.Span, $"Cannot set the {arg}readonly variable `{variable}`");
			}
		}

		private void CheckVariableFound(ScriptVariable variable, bool found)
		{
			if (StrictVariables && !found)
			{
				throw new ScriptRuntimeException(variable.Span, $"The variable or function `{variable}` was not found");
			}
		}

		private void PushVariableScope(VariableScope scope)
		{
			if (scope == VariableScope.Local)
			{
				ScriptObject locals = ((_availableStores.Count > 0) ? _availableStores.Pop() : new ScriptObject());
				PushLocalContext(locals);
				return;
			}
			ScriptObject item = ((_availableStores.Count > 0) ? _availableStores.Pop() : new ScriptObject());
			ScriptObject item2 = ((_availableStores.Count > 0) ? _availableStores.Pop() : new ScriptObject());
			GetCurrentGlobalVariableContext().Loops.Push(item2);
			(_currentLocalContext ?? throw new InvalidOperationException("No current local context is available.")).Loops.Push(item);
		}

		private void PopVariableScope(VariableScope scope)
		{
			if (scope == VariableScope.Local)
			{
				ScriptObject scriptObject = PopLocalContext();
				if (scriptObject == null)
				{
					throw new InvalidOperationException("Invalid number of matching push/pop VariableScope.");
				}
				scriptObject.Clear();
				_availableStores.Push(scriptObject);
				return;
			}
			VariableContext? obj = _currentLocalContext ?? throw new InvalidOperationException("No current local context is available.");
			if (obj.Loops.Count == 0)
			{
				throw new InvalidOperationException("Invalid number of matching push/pop VariableScope.");
			}
			ScriptObject scriptObject2 = GetCurrentGlobalVariableContext().Loops.Pop();
			scriptObject2.Clear();
			_availableStores.Push(scriptObject2);
			ScriptObject scriptObject3 = obj.Loops.Pop();
			scriptObject3.Clear();
			_availableStores.Push(scriptObject3);
		}
	}
	public class ScriptPrinter
	{
		private readonly IScriptOutput _output;

		private readonly bool _isScriptOnly;

		private bool _isInCode;

		private bool _expectSpace;

		private bool _expectEndOfStatement;

		private bool _previousHasSpace;

		private bool _hasEndOfStatement;

		private bool _hasComma;

		private FastStack<bool> _isWhileLoop;

		public readonly ScriptPrinterOptions Options;

		public bool PreviousHasSpace => _previousHasSpace;

		public bool IsInWhileLoop
		{
			get
			{
				if (_isWhileLoop.Count > 0)
				{
					return _isWhileLoop.Peek();
				}
				return false;
			}
		}

		public ScriptPrinter(IScriptOutput output, ScriptPrinterOptions options = default(ScriptPrinterOptions))
		{
			_isWhileLoop = new FastStack<bool>(4);
			Options = options;
			if (options.Mode != ScriptMode.Default && options.Mode != ScriptMode.ScriptOnly)
			{
				throw new ArgumentException($"The rendering mode `{options.Mode}` is not supported. Only `ScriptMode.Default` or `ScriptMode.ScriptOnly` are currently supported");
			}
			_isScriptOnly = options.Mode == ScriptMode.ScriptOnly;
			_isInCode = _isScriptOnly || options.Mode == ScriptMode.FrontMatterOnly || options.Mode == ScriptMode.FrontMatterAndContent;
			_output = output;
			_hasEndOfStatement = true;
		}

		public ScriptPrinter Write(ScriptNode? node)
		{
			if (node != null)
			{
				bool flag = false;
				if (node is ScriptLoopStatementBase)
				{
					_isWhileLoop.Push(node is ScriptWhileStatement);
					flag = true;
				}
				try
				{
					WriteBegin(node);
					if (node is IScriptTerminal)
					{
						_hasComma = false;
					}
					node.PrintTo(this);
					WriteEnd(node);
				}
				finally
				{
					if (flag)
					{
						_isWhileLoop.Pop();
					}
				}
			}
			return this;
		}

		public ScriptPrinter Write(string text)
		{
			_previousHasSpace = text.Length > 0 && char.IsWhiteSpace(text[text.Length - 1]);
			_output.Write(text);
			return this;
		}

		public ScriptPrinter Write(ScriptStringSlice slice)
		{
			_previousHasSpace = slice.Length > 0 && char.IsWhiteSpace(slice[slice.Length - 1]);
			_output.Write(slice);
			return this;
		}

		public ScriptPrinter ExpectEos()
		{
			if (!_hasEndOfStatement)
			{
				_expectEndOfStatement = true;
			}
			return this;
		}

		public ScriptPrinter ExpectSpace()
		{
			_expectSpace = true;
			return this;
		}

		public ScriptPrinter WriteListWithCommas<T>(IList<T>? list) where T : ScriptNode
		{
			if (list == null)
			{
				return this;
			}
			for (int i = 0; i < list.Count; i++)
			{
				T node = list[i];
				if (i > 0 && !_hasComma)
				{
					Write(",");
					_hasComma = true;
				}
				Write(node);
			}
			return this;
		}

		public ScriptPrinter WriteEnterCode(int escape = 0)
		{
			Write("{");
			for (int i = 0; i < escape; i++)
			{
				Write("%");
			}
			Write("{");
			_expectEndOfStatement = false;
			_expectSpace = false;
			_hasEndOfStatement = true;
			_isInCode = true;
			return this;
		}

		public ScriptPrinter WriteExitCode(int escape = 0)
		{
			Write("}");
			for (int i = 0; i < escape; i++)
			{
				Write("%");
			}
			Write("}");
			_expectEndOfStatement = false;
			_expectSpace = false;
			_hasEndOfStatement = false;
			_isInCode = false;
			return this;
		}

		private void WriteBegin(ScriptNode node)
		{
			WriteTrivias(node, before: true);
			HandleEos(node);
			if (_hasEndOfStatement)
			{
				_hasEndOfStatement = false;
				_expectEndOfStatement = false;
			}
			if (node.CanHaveLeadingTrivia())
			{
				if (_expectSpace && !_previousHasSpace)
				{
					Write(" ");
				}
				_expectSpace = false;
			}
		}

		private void WriteEnd(ScriptNode node)
		{
			WriteTrivias(node, before: false);
			if (node is ScriptPage && _isInCode && !_isScriptOnly)
			{
				WriteExitCode();
			}
		}

		private static bool IsFrontMarker(ScriptNode node)
		{
			if (node is ScriptToken scriptToken)
			{
				return scriptToken.TokenType == TokenType.FrontMatterMarker;
			}
			return false;
		}

		private void HandleEos(ScriptNode node)
		{
			bool flag = IsFrontMarker(node);
			if ((node is ScriptStatement || flag) && !IsBlockOrPage(node) && _isInCode && _expectEndOfStatement)
			{
				if (!_hasEndOfStatement && !(node is ScriptEscapeStatement))
				{
					Write(flag ? "\n" : "; ");
				}
				_expectEndOfStatement = false;
				_hasEndOfStatement = false;
				_hasComma = false;
			}
		}

		private static bool IsBlockOrPage(ScriptNode node)
		{
			if (!(node is ScriptBlockStatement))
			{
				return node is ScriptPage;
			}
			return true;
		}

		private void WriteTrivias(ScriptNode node, bool before)
		{
			if (!(node is IScriptTerminal scriptTerminal))
			{
				return;
			}
			ScriptTrivias trivias = scriptTerminal.Trivias;
			if (trivias == null)
			{
				return;
			}
			foreach (ScriptTrivia item in before ? trivias.Before : trivias.After)
			{
				item.Write(this);
				if (item.Type == ScriptTriviaType.NewLine || item.Type == ScriptTriviaType.SemiColon)
				{
					_hasEndOfStatement = true;
					if (item.Type == ScriptTriviaType.SemiColon)
					{
						_hasComma = false;
					}
					if (_expectSpace)
					{
						_expectSpace = false;
					}
				}
				if (item.Type == ScriptTriviaType.Comma)
				{
					_hasComma = true;
				}
			}
		}
	}
	public struct ScriptPrinterOptions
	{
		public ScriptMode Mode;
	}
	public class LiquidTemplateContext : TemplateContext
	{
		public LiquidTemplateContext()
			: base(new LiquidBuiltinsFunctions())
		{
			base.Language = ScriptLang.Liquid;
			base.EnableBreakAndContinueAsReturnOutsideLoop = true;
			base.EnableRelaxedTargetAccess = true;
			base.TemplateLoaderLexerOptions = new LexerOptions
			{
				Lang = ScriptLang.Liquid
			};
			base.TemplateLoaderParserOptions = new ParserOptions
			{
				LiquidFunctionsToScriban = true
			};
			base.IsLiquid = true;
		}

		public override string? GetTemplatePathFromName(string? templateName, ScriptNode? callerContext)
		{
			if (string.IsNullOrEmpty(templateName))
			{
				return null;
			}
			string templateName2 = templateName ?? throw new ScriptRuntimeException(base.CurrentSpan, "Include template name cannot be null or empty");
			return ConvertTemplateNameToPath(templateName2, callerContext);
		}
	}
}
namespace Scriban.Syntax
{
	internal class ScientificFunctionCallRewriter
	{
		[DebuggerDisplay("Count = {Count}, Current = {Index} : {Current}")]
		private class BinaryExpressionIterator : List<BinaryExpressionOrOperator>
		{
			public int Index { get; set; }

			public BinaryExpressionOrOperator Current
			{
				get
				{
					if (Index >= base.Count)
					{
						return default(BinaryExpressionOrOperator);
					}
					return base[Index];
				}
			}

			public bool HasCurrent => Index < base.Count;

			public bool HasNext => Index + 1 < base.Count;

			public bool MoveNext()
			{
				Index++;
				return HasCurrent;
			}

			public BinaryExpressionOrOperator PeekNext()
			{
				return base[Index + 1];
			}
		}

		[DebuggerDisplay("{ToDebuggerDisplay(),nq}")]
		private readonly struct BinaryExpressionOrOperator
		{
			public readonly ScriptExpression? Expression;

			public readonly ScriptBinaryOperator Operator;

			public readonly ScriptToken? OperatorToken;

			public readonly FunctionCallKind CallKind;

			public BinaryExpressionOrOperator(ScriptExpression expression, FunctionCallKind kind)
			{
				Expression = expression;
				Operator = ScriptBinaryOperator.None;
				OperatorToken = null;
				CallKind = kind;
			}

			public BinaryExpressionOrOperator(ScriptBinaryOperator @operator, ScriptToken? operatorToken)
			{
				Expression = null;
				Operator = @operator;
				OperatorToken = operatorToken;
				CallKind = FunctionCallKind.None;
			}

			private string ToDebuggerDisplay()
			{
				object obj;
				if (Expression == null)
				{
					obj = OperatorToken?.ToString();
					if (obj == null)
					{
						return $"`{Operator.ToText()}` - CallKind = {CallKind}";
					}
				}
				else
				{
					obj = Expression.ToString();
				}
				return (string)obj;
			}
		}

		private enum FunctionCallKind
		{
			None,
			Regular,
			Expression
		}

		private const int ImplicitFunctionCallPrecedence = 101;

		private static async ValueTask FlattenBinaryExpressionsAsync(TemplateContext context, ScriptExpression expression, List<BinaryExpressionOrOperator> expressions)
		{
			ScriptBinaryExpression binaryExpression;
			while (true)
			{
				binaryExpression = expression as ScriptBinaryExpression;
				if (binaryExpression == null)
				{
					ScriptExpression expression2 = expression;
					expressions.Add(new BinaryExpressionOrOperator(expression2, await GetFunctionCallKindAsync(context, expression).ConfigureAwait(continueOnCapturedContext: false)));
					return;
				}
				if (binaryExpression.Left == null || binaryExpression.Right == null)
				{
					break;
				}
				ScriptExpression expression3 = (ScriptExpression)binaryExpression.Left.Clone();
				ScriptExpression right = (ScriptExpression)binaryExpression.Right.Clone();
				ScriptToken token = ((binaryExpression.OperatorToken != null) ? ((ScriptToken)binaryExpression.OperatorToken.Clone()) : null);
				await FlattenBinaryExpressionsAsync(context, expression3, expressions).ConfigureAwait(continueOnCapturedContext: false);
				expressions.Add(new BinaryExpressionOrOperator(binaryExpression.Operator, token));
				expression = right;
			}
			throw new ScriptRuntimeException(binaryExpression.Span, "Invalid binary expression while rewriting a scientific expression.");
		}

		private static async ValueTask<FunctionCallKind> GetFunctionCallKindAsync(TemplateContext context, ScriptExpression expression)
		{
			bool restoreStrictVariables = context.StrictVariables;
			context.StrictVariables = false;
			object result = null;
			try
			{
				result = await context.EvaluateAsync(expression, aliasReturnedFunction: true).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (ScriptRuntimeException) when (context.IgnoreExceptionsWhileRewritingScientific)
			{
			}
			finally
			{
				context.StrictVariables = restoreStrictVariables;
			}
			if (result is IScriptCustomFunction scriptCustomFunction && ((scriptCustomFunction.RequiredParameterCount != 0) ? scriptCustomFunction.RequiredParameterCount : ((scriptCustomFunction.ParameterCount > 0) ? 1 : 0)) > 0)
			{
				return (!scriptCustomFunction.IsParameterType<ScriptExpression>(0)) ? FunctionCallKind.Regular : FunctionCallKind.Expression;
			}
			return FunctionCallKind.None;
		}

		public static async ValueTask<ScriptExpression> RewriteAsync(TemplateContext context, ScriptBinaryExpression binaryExpression)
		{
			if (!HasImplicitBinaryExpression(binaryExpression))
			{
				return binaryExpression;
			}
			BinaryExpressionIterator iterator = new BinaryExpressionIterator();
			await FlattenBinaryExpressionsAsync(context, binaryExpression, iterator).ConfigureAwait(continueOnCapturedContext: false);
			return ParseBinaryExpressionTree(iterator, 0, isExpectingExpression: false);
		}

		public static ScriptExpression Rewrite(TemplateContext context, ScriptBinaryExpression binaryExpression)
		{
			if (!HasImplicitBinaryExpression(binaryExpression))
			{
				return binaryExpression;
			}
			BinaryExpressionIterator binaryExpressionIterator = new BinaryExpressionIterator();
			FlattenBinaryExpressions(context, binaryExpression, binaryExpressionIterator);
			return ParseBinaryExpressionTree(binaryExpressionIterator, 0, isExpectingExpression: false);
		}

		private static bool HasImplicitBinaryExpression(ScriptExpression? expression)
		{
			if (expression is ScriptBinaryExpression scriptBinaryExpression)
			{
				if (scriptBinaryExpression.OperatorToken == null && scriptBinaryExpression.Operator == ScriptBinaryOperator.Multiply)
				{
					return true;
				}
				if (!HasImplicitBinaryExpression(scriptBinaryExpression.Left))
				{
					return HasImplicitBinaryExpression(scriptBinaryExpression.Right);
				}
				return true;
			}
			return false;
		}

		private static void FlattenBinaryExpressions(TemplateContext context, ScriptExpression expression, List<BinaryExpressionOrOperator> expressions)
		{
			ScriptBinaryExpression scriptBinaryExpression;
			while (true)
			{
				scriptBinaryExpression = expression as ScriptBinaryExpression;
				if (scriptBinaryExpression == null)
				{
					expressions.Add(new BinaryExpressionOrOperator(expression, GetFunctionCallKind(context, expression)));
					return;
				}
				if (scriptBinaryExpression.Left == null || scriptBinaryExpression.Right == null)
				{
					break;
				}
				ScriptExpression expression2 = (ScriptExpression)scriptBinaryExpression.Left.Clone();
				ScriptExpression obj = (ScriptExpression)scriptBinaryExpression.Right.Clone();
				ScriptToken operatorToken = ((scriptBinaryExpression.OperatorToken != null) ? ((ScriptToken)scriptBinaryExpression.OperatorToken.Clone()) : null);
				FlattenBinaryExpressions(context, expression2, expressions);
				expressions.Add(new BinaryExpressionOrOperator(scriptBinaryExpression.Operator, operatorToken));
				expression = obj;
			}
			throw new ScriptRuntimeException(scriptBinaryExpression.Span, "Invalid binary expression while rewriting a scientific expression.");
		}

		private static ScriptExpression ParseBinaryExpressionTree(BinaryExpressionIterator it, int precedence, bool isExpectingExpression)
		{
			ScriptExpression scriptExpression = null;
			while (it.HasCurrent)
			{
				BinaryExpressionOrOperator current = it.Current;
				ScriptExpression expression = current.Expression;
				if (expression == null)
				{
					int num = Parser.GetDefaultBinaryOperatorPrecedence(current.Operator);
					if (!isExpectingExpression && it.HasNext && it.PeekNext().CallKind != FunctionCallKind.None)
					{
						num = ((num < 101) ? num : 101);
					}
					if (num <= precedence)
					{
						break;
					}
					it.MoveNext();
					if (scriptExpression == null)
					{
						throw new ScriptRuntimeException(default(SourceSpan), "Unexpected missing left operand while rewriting a scientific expression.");
					}
					ScriptBinaryExpression scriptBinaryExpression = new ScriptBinaryExpression
					{
						Left = scriptExpression,
						Operator = current.Operator,
						OperatorToken = (current.OperatorToken ?? ScriptToken.Star()),
						Span = 
						{
							Start = scriptExpression.Span.Start
						}
					};
					scriptBinaryExpression.Right = ParseBinaryExpressionTree(it, num, isExpectingExpression);
					scriptBinaryExpression.Span.End = scriptBinaryExpression.Right.Span.End;
					scriptExpression = scriptBinaryExpression;
				}
				else if (!isExpectingExpression && current.CallKind != FunctionCallKind.None)
				{
					ScriptFunctionCall obj = new ScriptFunctionCall
					{
						Target = expression,
						ExplicitCall = true,
						Span = 
						{
							Start = expression.Span.Start
						}
					};
					if (!it.MoveNext())
					{
						throw new ScriptRuntimeException(expression.Span, "The function is expecting at least one argument");
					}
					if (it.Current.Expression == null && (it.Current.Operator != ScriptBinaryOperator.Multiply || it.Current.OperatorToken != null))
					{
						throw new ScriptRuntimeException(expression.Span, "The function expecting one argument cannot be followed by the operator " + (it.Current.OperatorToken?.ToString() ?? it.Current.Operator.ToText()));
					}
					if (!it.MoveNext())
					{
						throw new ScriptRuntimeException(expression.Span, "The function is expecting at least one argument");
					}
					ScriptExpression scriptExpression2 = ParseBinaryExpressionTree(it, 101, current.CallKind == FunctionCallKind.Expression);
					obj.Arguments.Add(scriptExpression2);
					obj.Span.End = scriptExpression2.Span.End;
					scriptExpression = obj;
				}
				else
				{
					scriptExpression = expression;
					it.MoveNext();
				}
			}
			return scriptExpression ?? throw new ScriptRuntimeException(default(SourceSpan), "Unexpected empty scientific expression.");
		}

		private static FunctionCallKind GetFunctionCallKind(TemplateContext context, ScriptExpression expression)
		{
			bool strictVariables = context.StrictVariables;
			context.StrictVariables = false;
			object obj = null;
			try
			{
				obj = context.Evaluate(expression, aliasReturnedFunction: true);
			}
			catch (ScriptRuntimeException) when (context.IgnoreExceptionsWhileRewritingScientific)
			{
			}
			finally
			{
				context.StrictVariables = strictVariables;
			}
			if (obj is IScriptCustomFunction scriptCustomFunction && ((scriptCustomFunction.RequiredParameterCount != 0) ? scriptCustomFunction.RequiredParameterCount : ((scriptCustomFunction.ParameterCount > 0) ? 1 : 0)) > 0)
			{
				if (!scriptCustomFunction.IsParameterType<ScriptExpression>(0))
				{
					return FunctionCallKind.Regular;
				}
				return FunctionCallKind.Expression;
			}
			return FunctionCallKind.None;
		}
	}
	[ScriptSyntax("array initializer", "[item1, item2,...]")]
	public class ScriptArrayInitializerExpression : ScriptExpression
	{
		private ScriptList<ScriptExpression> _values = new ScriptList<ScriptExpression>();

		private ScriptToken _openBracketToken = ScriptToken.OpenBracket();

		private ScriptToken _closeBracketToken = ScriptToken.CloseBracket();

		public override int ChildrenCount => 3;

		public ScriptToken OpenBracketToken
		{
			get
			{
				return _openBracketToken;
			}
			set
			{
				ParentToThis(ref _openBracketToken, value);
			}
		}

		public ScriptList<ScriptExpression> Values
		{
			get
			{
				return _values;
			}
			set
			{
				ParentToThis(ref _values, value);
			}
		}

		public ScriptToken CloseBracketToken
		{
			get
			{
				return _closeBracketToken;
			}
			set
			{
				ParentToThis(ref _closeBracketToken, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			ScriptArray scriptArray = new ScriptArray();
			foreach (ScriptExpression value in Values)
			{
				scriptArray.Add(await context.EvaluateAsync(value).ConfigureAwait(continueOnCapturedContext: false));
			}
			return scriptArray;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => OpenBracketToken, 
				1 => Values, 
				2 => CloseBracketToken, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptArrayInitializerExpression()
		{
			_openBracketToken.Parent = this;
			_values.Parent = this;
			_closeBracketToken.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			ScriptArray scriptArray = new ScriptArray();
			foreach (ScriptExpression value in Values)
			{
				object item = context.Evaluate(value);
				scriptArray.Add(item);
			}
			return scriptArray;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(OpenBracketToken);
			printer.WriteListWithCommas(Values);
			printer.Write(CloseBracketToken);
		}
	}
	[ScriptSyntax("assign expression", "<target_expression> = <value_expression>")]
	public class ScriptAssignExpression : ScriptExpression
	{
		private ScriptExpression? _target;

		private ScriptToken _equalToken = ScriptToken.Equal();

		private ScriptExpression? _value;

		public override int ChildrenCount => 3;

		public ScriptExpression? Target
		{
			get
			{
				return _target;
			}
			set
			{
				ParentToThisNullable(ref _target, value);
			}
		}

		public ScriptToken EqualToken
		{
			get
			{
				return _equalToken;
			}
			set
			{
				ParentToThis(ref _equalToken, value);
			}
		}

		public ScriptExpression? Value
		{
			get
			{
				return _value;
			}
			set
			{
				ParentToThisNullable(ref _value, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Target == null || Value == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid assignment expression. Target and value are required.");
			}
			object obj = ((EqualToken.TokenType != TokenType.Equal) ? (await GetValueToSetAsync(context).ConfigureAwait(continueOnCapturedContext: false)) : (await context.EvaluateAsync(Value).ConfigureAwait(continueOnCapturedContext: false)));
			object value = obj;
			await context.SetValueAsync(Target, value).ConfigureAwait(continueOnCapturedContext: false);
			return null;
		}

		private async ValueTask<object?> GetValueToSetAsync(TemplateContext context)
		{
			if (Target == null || Value == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid assignment expression. Target and value are required.");
			}
			object right = await context.EvaluateAsync(Value).ConfigureAwait(continueOnCapturedContext: false);
			object leftValue = await context.EvaluateAsync(Target).ConfigureAwait(continueOnCapturedContext: false);
			ScriptBinaryOperator op = EqualToken.TokenType switch
			{
				TokenType.PlusEqual => ScriptBinaryOperator.Add, 
				TokenType.MinusEqual => ScriptBinaryOperator.Subtract, 
				TokenType.AsteriskEqual => ScriptBinaryOperator.Multiply, 
				TokenType.DivideEqual => ScriptBinaryOperator.Divide, 
				TokenType.DoubleDivideEqual => ScriptBinaryOperator.DivideRound, 
				TokenType.PercentEqual => ScriptBinaryOperator.Modulus, 
				_ => throw new ScriptRuntimeException(context.CurrentSpan, $"Operator {EqualToken} is not a valid compound assignment operator"), 
			};
			return ScriptBinaryExpression.Evaluate(context, Span, op, leftValue, right);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Target, 
				1 => EqualToken, 
				2 => Value, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptAssignExpression()
		{
			_equalToken.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Target == null || Value == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid assignment expression. Target and value are required.");
			}
			object value = ((EqualToken.TokenType == TokenType.Equal) ? context.Evaluate(Value) : GetValueToSet(context));
			context.SetValue(Target, value);
			return null;
		}

		private object? GetValueToSet(TemplateContext context)
		{
			if (Target == null || Value == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid assignment expression. Target and value are required.");
			}
			object rightValue = context.Evaluate(Value);
			object leftValue = context.Evaluate(Target);
			ScriptBinaryOperator op = EqualToken.TokenType switch
			{
				TokenType.PlusEqual => ScriptBinaryOperator.Add, 
				TokenType.MinusEqual => ScriptBinaryOperator.Subtract, 
				TokenType.AsteriskEqual => ScriptBinaryOperator.Multiply, 
				TokenType.DivideEqual => ScriptBinaryOperator.Divide, 
				TokenType.DoubleDivideEqual => ScriptBinaryOperator.DivideRound, 
				TokenType.PercentEqual => ScriptBinaryOperator.Modulus, 
				_ => throw new ScriptRuntimeException(context.CurrentSpan, $"Operator {EqualToken} is not a valid compound assignment operator"), 
			};
			return ScriptBinaryExpression.Evaluate(context, Span, op, leftValue, rightValue);
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Target != null)
			{
				printer.Write(Target);
			}
			printer.Write(EqualToken);
			if (Value != null)
			{
				printer.Write(Value);
			}
		}
	}
	[ScriptSyntax("binary expression", "<expression> operator <expression>")]
	public class ScriptBinaryExpression : ScriptExpression
	{
		private ScriptExpression? _left;

		private ScriptToken? _operatorToken;

		private ScriptExpression? _right;

		private static readonly BigInteger MaxBigInteger = BigInteger.One << 1048576;

		private const int MaxBigIntegerShift = 1048576;

		public override int ChildrenCount => 3;

		public ScriptExpression? Left
		{
			get
			{
				return _left;
			}
			set
			{
				ParentToThisNullable(ref _left, value);
			}
		}

		public ScriptBinaryOperator Operator { get; set; }

		public ScriptToken? OperatorToken
		{
			get
			{
				return _operatorToken;
			}
			set
			{
				ParentToThisNullable(ref _operatorToken, value);
			}
		}

		public string OperatorAsText => OperatorToken?.Value ?? Operator.ToText();

		public ScriptExpression? Right
		{
			get
			{
				return _right;
			}
			set
			{
				ParentToThisNullable(ref _right, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			ScriptExpression leftExpression = Left;
			ScriptExpression rightExpression = Right;
			if (leftExpression == null || rightExpression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid binary expression. Left and right expressions are required.");
			}
			if (context.UseScientific)
			{
				ScriptExpression scriptExpression = await ScientificFunctionCallRewriter.RewriteAsync(context, this).ConfigureAwait(continueOnCapturedContext: false);
				if (scriptExpression != this)
				{
					return await context.EvaluateAsync(scriptExpression).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			object leftValue = await context.EvaluateAsync(leftExpression).ConfigureAwait(continueOnCapturedContext: false);
			switch (Operator)
			{
			case ScriptBinaryOperator.And:
			{
				bool leftBoolValue = context.ToBool(leftExpression.Span, leftValue);
				if (!leftBoolValue)
				{
					return false;
				}
				object value2 = await context.EvaluateAsync(rightExpression).ConfigureAwait(continueOnCapturedContext: false);
				bool flag = context.ToBool(rightExpression.Span, value2);
				return leftBoolValue && flag;
			}
			case ScriptBinaryOperator.Or:
			{
				if (context.ToBool(leftExpression.Span, leftValue))
				{
					return true;
				}
				object value = await context.EvaluateAsync(rightExpression).ConfigureAwait(continueOnCapturedContext: false);
				return context.ToBool(rightExpression.Span, value);
			}
			default:
			{
				object rightValue = await context.EvaluateAsync(rightExpression).ConfigureAwait(continueOnCapturedContext: false);
				return Evaluate(context, OperatorToken?.Span ?? Span, Operator, leftExpression.Span, leftValue, rightExpression.Span, rightValue);
			}
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Left, 
				1 => OperatorToken, 
				2 => Right, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			ScriptExpression left = Left;
			ScriptExpression right = Right;
			if (left == null || right == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid binary expression. Left and right expressions are required.");
			}
			if (context.UseScientific)
			{
				ScriptExpression scriptExpression = ScientificFunctionCallRewriter.Rewrite(context, this);
				if (scriptExpression != this)
				{
					return context.Evaluate(scriptExpression);
				}
			}
			object obj = context.Evaluate(left);
			switch (Operator)
			{
			case ScriptBinaryOperator.And:
			{
				bool flag = context.ToBool(left.Span, obj);
				if (!flag)
				{
					return false;
				}
				object value2 = context.Evaluate(right);
				bool flag2 = context.ToBool(right.Span, value2);
				return flag && flag2;
			}
			case ScriptBinaryOperator.Or:
			{
				if (context.ToBool(left.Span, obj))
				{
					return true;
				}
				object value = context.Evaluate(right);
				return context.ToBool(right.Span, value);
			}
			default:
			{
				object rightValue = context.Evaluate(right);
				return Evaluate(context, OperatorToken?.Span ?? Span, Operator, left.Span, obj, right.Span, rightValue);
			}
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Left != null)
			{
				printer.Write(Left);
			}
			if (Operator == ScriptBinaryOperator.Subtract && !printer.PreviousHasSpace)
			{
				printer.ExpectSpace();
			}
			if (OperatorToken != null)
			{
				printer.Write(OperatorToken);
			}
			else
			{
				printer.ExpectSpace();
			}
			if (Operator == ScriptBinaryOperator.Subtract)
			{
				printer.ExpectSpace();
			}
			if (Right != null)
			{
				printer.Write(Right);
			}
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public static object? Evaluate(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, object? leftValue, object? rightValue)
		{
			return Evaluate(context, span, op, span, leftValue, span, rightValue);
		}

		public static object? Evaluate(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, SourceSpan leftSpan, object? leftValue, SourceSpan rightSpan, object? rightValue)
		{
			switch (op)
			{
			case ScriptBinaryOperator.EmptyCoalescing:
				return leftValue ?? rightValue;
			case ScriptBinaryOperator.NotEmptyCoalescing:
				if (leftValue == null)
				{
					return leftValue;
				}
				return rightValue;
			case ScriptBinaryOperator.LiquidHasKey:
				if (leftValue is IDictionary<string, object> value2)
				{
					return ObjectFunctions.HasKey(value2, context.ObjectToString(rightValue) ?? string.Empty);
				}
				break;
			case ScriptBinaryOperator.LiquidHasValue:
				if (leftValue is IDictionary<string, object> value)
				{
					return ObjectFunctions.HasValue(value, context.ObjectToString(rightValue) ?? string.Empty);
				}
				break;
			case ScriptBinaryOperator.BinaryOr:
			case ScriptBinaryOperator.BinaryAnd:
			case ScriptBinaryOperator.CompareEqual:
			case ScriptBinaryOperator.CompareNotEqual:
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareLess:
			case ScriptBinaryOperator.CompareGreater:
			case ScriptBinaryOperator.LiquidContains:
			case ScriptBinaryOperator.LiquidStartsWith:
			case ScriptBinaryOperator.LiquidEndsWith:
			case ScriptBinaryOperator.Add:
			case ScriptBinaryOperator.Subtract:
			case ScriptBinaryOperator.Multiply:
			case ScriptBinaryOperator.Divide:
			case ScriptBinaryOperator.DivideRound:
			case ScriptBinaryOperator.Modulus:
			case ScriptBinaryOperator.ShiftLeft:
			case ScriptBinaryOperator.ShiftRight:
			case ScriptBinaryOperator.Power:
			case ScriptBinaryOperator.RangeInclude:
			case ScriptBinaryOperator.RangeExclude:
				try
				{
					if (leftValue is string || rightValue is string || leftValue is char || rightValue is char)
					{
						if (leftValue is char c)
						{
							leftValue = c.ToString(context.CurrentCulture);
						}
						if (rightValue is char c2)
						{
							rightValue = c2.ToString(CultureInfo.InvariantCulture);
						}
						return CalculateToString(context, span, op, leftSpan, leftValue, rightSpan, rightValue);
					}
					if (leftValue == null || rightValue == null)
					{
						return CalculateOthers(context, span, op, leftSpan, leftValue, rightSpan, rightValue);
					}
					if (leftValue == EmptyScriptObject.Default || rightValue == EmptyScriptObject.Default)
					{
						return CalculateEmpty(context, span, op, leftSpan, leftValue, rightSpan, rightValue);
					}
					if (leftValue is IScriptCustomBinaryOperation scriptCustomBinaryOperation)
					{
						if (scriptCustomBinaryOperation.TryEvaluate(context, span, op, leftSpan, leftValue, rightSpan, rightValue, out object result))
						{
							return result;
						}
						break;
					}
					if (rightValue is IScriptCustomBinaryOperation scriptCustomBinaryOperation2)
					{
						if (scriptCustomBinaryOperation2.TryEvaluate(context, span, op, leftSpan, leftValue, rightSpan, rightValue, out object result2))
						{
							return result2;
						}
						break;
					}
					return CalculateOthers(context, span, op, leftSpan, leftValue, rightSpan, rightValue);
				}
				catch (Exception ex) when (!(ex is ScriptRuntimeException))
				{
					throw new ScriptRuntimeException(span, ex.Message);
				}
			}
			throw new ScriptRuntimeException(span, $"The operator `{op.ToText()}` is not supported between `{leftValue}` and `{rightValue}`");
		}

		private static object? CalculateEmpty(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, SourceSpan leftSpan, object? leftValue, SourceSpan rightSpan, object? rightValue)
		{
			bool flag = leftValue == EmptyScriptObject.Default;
			bool flag2 = rightValue == EmptyScriptObject.Default;
			if (flag && flag2)
			{
				switch (op)
				{
				case ScriptBinaryOperator.CompareEqual:
				case ScriptBinaryOperator.CompareLessOrEqual:
				case ScriptBinaryOperator.CompareGreaterOrEqual:
					return true;
				case ScriptBinaryOperator.CompareNotEqual:
				case ScriptBinaryOperator.CompareLess:
				case ScriptBinaryOperator.CompareGreater:
				case ScriptBinaryOperator.LiquidContains:
				case ScriptBinaryOperator.LiquidStartsWith:
				case ScriptBinaryOperator.LiquidEndsWith:
					return false;
				default:
					return EmptyScriptObject.Default;
				}
			}
			object against = (flag ? rightValue : leftValue);
			object obj = context.IsEmpty(span, against);
			switch (op)
			{
			case ScriptBinaryOperator.CompareEqual:
				return obj;
			case ScriptBinaryOperator.CompareNotEqual:
				if (!(obj is bool))
				{
					return obj;
				}
				return !(bool)obj;
			case ScriptBinaryOperator.CompareLess:
			case ScriptBinaryOperator.CompareGreater:
				return false;
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareGreaterOrEqual:
				return obj;
			case ScriptBinaryOperator.BinaryOr:
			case ScriptBinaryOperator.BinaryAnd:
			case ScriptBinaryOperator.Add:
			case ScriptBinaryOperator.Subtract:
			case ScriptBinaryOperator.Multiply:
			case ScriptBinaryOperator.Divide:
			case ScriptBinaryOperator.DivideRound:
			case ScriptBinaryOperator.Modulus:
			case ScriptBinaryOperator.Power:
			case ScriptBinaryOperator.RangeInclude:
			case ScriptBinaryOperator.RangeExclude:
				return EmptyScriptObject.Default;
			case ScriptBinaryOperator.LiquidContains:
			case ScriptBinaryOperator.LiquidStartsWith:
			case ScriptBinaryOperator.LiquidEndsWith:
				return false;
			default:
				throw new ScriptRuntimeException(span, string.Format("Operator `{0}` is not implemented for `{1}` / `{2}`", op.ToText(), flag ? "empty" : leftValue, flag2 ? "empty" : rightValue));
			}
		}

		private static object? CalculateToString(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, SourceSpan leftSpan, object? left, SourceSpan rightSpan, object? right)
		{
			switch (op)
			{
			case ScriptBinaryOperator.Add:
				return (context.ObjectToString(left) ?? string.Empty) + (context.ObjectToString(right) ?? string.Empty);
			case ScriptBinaryOperator.Multiply:
			{
				SourceSpan span2 = rightSpan;
				if (right is string)
				{
					object? obj = left;
					left = right;
					right = obj;
					span2 = leftSpan;
				}
				int num;
				try
				{
					num = context.ToInt(span, right);
				}
				catch
				{
					throw new ScriptRuntimeException(span2, "Expecting an integer. The operator `" + op.ToText() + "` is not supported for the expression. Only working on string x int or int x string");
				}
				string text = context.ObjectToString(left) ?? string.Empty;
				if (context.LimitToString > 0 && num > 0 && text.Length > 0 && (long)text.Length * (long)num > context.LimitToString)
				{
					throw new ScriptRuntimeException(span2, $"String multiplication exceeds LimitToString `{context.LimitToString}`.");
				}
				StringBuilder stringBuilder = new StringBuilder();
				for (int i = 0; i < num; i++)
				{
					stringBuilder.Append(text);
				}
				return stringBuilder.ToString();
			}
			case ScriptBinaryOperator.CompareEqual:
				return context.ObjectToString(left) == context.ObjectToString(right);
			case ScriptBinaryOperator.CompareNotEqual:
				return context.ObjectToString(left) != context.ObjectToString(right);
			case ScriptBinaryOperator.CompareGreater:
				return string.Compare(context.ObjectToString(left), context.ObjectToString(right), StringComparison.Ordinal) > 0;
			case ScriptBinaryOperator.CompareLess:
				return string.Compare(context.ObjectToString(left), context.ObjectToString(right), StringComparison.Ordinal) < 0;
			case ScriptBinaryOperator.CompareGreaterOrEqual:
				return string.Compare(context.ObjectToString(left), context.ObjectToString(right), StringComparison.Ordinal) >= 0;
			case ScriptBinaryOperator.CompareLessOrEqual:
				return string.Compare(context.ObjectToString(left), context.ObjectToString(right), StringComparison.Ordinal) <= 0;
			case ScriptBinaryOperator.LiquidContains:
				return (context.ObjectToString(left) ?? string.Empty).Contains(context.ObjectToString(right) ?? string.Empty);
			case ScriptBinaryOperator.LiquidStartsWith:
				return (context.ObjectToString(left) ?? string.Empty).StartsWith(context.ObjectToString(right) ?? string.Empty, StringComparison.Ordinal);
			case ScriptBinaryOperator.LiquidEndsWith:
				return (context.ObjectToString(left) ?? string.Empty).EndsWith(context.ObjectToString(right) ?? string.Empty, StringComparison.Ordinal);
			default:
				throw new ScriptRuntimeException(span, "Operator `" + op.ToText() + "` is not supported on string objects");
			}
		}

		private static IEnumerable<object> RangeInclude(TemplateContext context, SourceSpan span, long left, long right)
		{
			ValidateRangeSize(context, span, left, right, inclusive: true);
			return RangeIncludeImpl(left, right);
		}

		private static IEnumerable<object> RangeIncludeImpl(long left, long right)
		{
			if (left < right)
			{
				for (long i = left; i <= right; i++)
				{
					yield return FitToBestInteger(i);
				}
				yield break;
			}
			for (long i = left; i >= right; i--)
			{
				yield return FitToBestInteger(i);
			}
		}

		private static IEnumerable<object> RangeExclude(TemplateContext context, SourceSpan span, long left, long right)
		{
			ValidateRangeSize(context, span, left, right, inclusive: false);
			return RangeExcludeImpl(left, right);
		}

		private static IEnumerable<object> RangeExcludeImpl(long left, long right)
		{
			if (left < right)
			{
				for (long i = left; i < right; i++)
				{
					yield return FitToBestInteger(i);
				}
				yield break;
			}
			for (long i = left; i > right; i--)
			{
				yield return FitToBestInteger(i);
			}
		}

		private static IEnumerable<object> RangeInclude(TemplateContext context, SourceSpan span, BigInteger left, BigInteger right)
		{
			ValidateRangeSize(context, span, left, right, inclusive: true);
			return RangeIncludeImpl(left, right);
		}

		private static IEnumerable<object> RangeIncludeImpl(BigInteger left, BigInteger right)
		{
			if (left < right)
			{
				for (BigInteger i = left; i <= right; ++i)
				{
					yield return FitToBestInteger(i);
				}
			}
			else
			{
				for (BigInteger i = left; i >= right; --i)
				{
					yield return FitToBestInteger(i);
				}
			}
		}

		private static IEnumerable<object> RangeExclude(TemplateContext context, SourceSpan span, BigInteger left, BigInteger right)
		{
			ValidateRangeSize(context, span, left, right, inclusive: false);
			return RangeExcludeImpl(left, right);
		}

		private static IEnumerable<object> RangeExcludeImpl(BigInteger left, BigInteger right)
		{
			if (left < right)
			{
				for (BigInteger i = left; i < right; ++i)
				{
					yield return FitToBestInteger(i);
				}
			}
			else
			{
				for (BigInteger i = left; i > right; --i)
				{
					yield return FitToBestInteger(i);
				}
			}
		}

		private static object? CalculateOthers(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, SourceSpan leftSpan, object? leftValue, SourceSpan rightSpan, object? rightValue)
		{
			if (leftValue == null && rightValue == null)
			{
				switch (op)
				{
				case ScriptBinaryOperator.CompareEqual:
					return true;
				case ScriptBinaryOperator.CompareNotEqual:
					return false;
				case ScriptBinaryOperator.CompareLessOrEqual:
				case ScriptBinaryOperator.CompareGreaterOrEqual:
				case ScriptBinaryOperator.CompareLess:
				case ScriptBinaryOperator.CompareGreater:
					if (context.UseScientific)
					{
						throw new ScriptRuntimeException(span, "Both left and right expressions are null. Cannot perform this operation on null values.");
					}
					return false;
				case ScriptBinaryOperator.BinaryOr:
				case ScriptBinaryOperator.BinaryAnd:
				case ScriptBinaryOperator.Add:
				case ScriptBinaryOperator.Subtract:
				case ScriptBinaryOperator.Multiply:
				case ScriptBinaryOperator.Divide:
				case ScriptBinaryOperator.DivideRound:
				case ScriptBinaryOperator.Modulus:
				case ScriptBinaryOperator.ShiftLeft:
				case ScriptBinaryOperator.ShiftRight:
				case ScriptBinaryOperator.Power:
				case ScriptBinaryOperator.RangeInclude:
				case ScriptBinaryOperator.RangeExclude:
					if (context.UseScientific)
					{
						throw new ScriptRuntimeException(span, "Both left and right expressions are null. Cannot perform this operation on null values.");
					}
					return null;
				case ScriptBinaryOperator.LiquidContains:
				case ScriptBinaryOperator.LiquidStartsWith:
				case ScriptBinaryOperator.LiquidEndsWith:
					return false;
				default:
					return null;
				}
			}
			if (leftValue == null || rightValue == null)
			{
				switch (op)
				{
				case ScriptBinaryOperator.CompareEqual:
					return false;
				case ScriptBinaryOperator.CompareNotEqual:
					return true;
				case ScriptBinaryOperator.CompareLessOrEqual:
				case ScriptBinaryOperator.CompareGreaterOrEqual:
				case ScriptBinaryOperator.CompareLess:
				case ScriptBinaryOperator.CompareGreater:
				case ScriptBinaryOperator.LiquidContains:
				case ScriptBinaryOperator.LiquidStartsWith:
				case ScriptBinaryOperator.LiquidEndsWith:
					if (context.UseScientific)
					{
						throw new ScriptRuntimeException(span, "The " + ((leftValue == null) ? "left" : "right") + " expression is null. Cannot perform this operation on a null value.");
					}
					return false;
				case ScriptBinaryOperator.BinaryOr:
				case ScriptBinaryOperator.BinaryAnd:
				case ScriptBinaryOperator.Add:
				case ScriptBinaryOperator.Subtract:
				case ScriptBinaryOperator.Multiply:
				case ScriptBinaryOperator.Divide:
				case ScriptBinaryOperator.DivideRound:
				case ScriptBinaryOperator.Modulus:
				case ScriptBinaryOperator.ShiftLeft:
				case ScriptBinaryOperator.ShiftRight:
				case ScriptBinaryOperator.Power:
				case ScriptBinaryOperator.RangeInclude:
				case ScriptBinaryOperator.RangeExclude:
					if (context.UseScientific)
					{
						throw new ScriptRuntimeException(span, "The " + ((leftValue == null) ? "left" : "right") + " expression is null. Cannot perform this operation on a null value.");
					}
					return null;
				default:
					return null;
				}
			}
			Type type = leftValue.GetType();
			Type type2 = rightValue.GetType();
			if (type == typeof(decimal))
			{
				decimal right = context.ToObject<decimal>(span, rightValue);
				return CalculateDecimal(op, span, (decimal)leftValue, right);
			}
			if (type2 == typeof(decimal))
			{
				decimal left = context.ToObject<decimal>(span, leftValue);
				return CalculateDecimal(op, span, left, (decimal)rightValue);
			}
			if (type == typeof(double))
			{
				double right2 = context.ToObject<double>(span, rightValue);
				return CalculateDouble(op, span, (double)leftValue, right2);
			}
			if (type2 == typeof(double))
			{
				double left2 = context.ToObject<double>(span, leftValue);
				return CalculateDouble(op, span, left2, (double)rightValue);
			}
			if (type == typeof(float))
			{
				float right3 = context.ToObject<float>(span, rightValue);
				return CalculateFloat(op, span, (float)leftValue, right3);
			}
			if (type2 == typeof(float))
			{
				float left3 = context.ToObject<float>(span, leftValue);
				return CalculateFloat(op, span, left3, (float)rightValue);
			}
			if (type == typeof(BigInteger))
			{
				BigInteger right4 = context.ToObject<BigInteger>(span, rightValue);
				return CalculateBigInteger(context, op, span, (BigInteger)leftValue, right4);
			}
			if (type2 == typeof(BigInteger))
			{
				BigInteger left4 = context.ToObject<BigInteger>(span, leftValue);
				return CalculateBigInteger(context, op, span, left4, (BigInteger)rightValue);
			}
			if (type == typeof(long))
			{
				long right5 = context.ToObject<long>(span, rightValue);
				return CalculateLong(context, op, span, (long)leftValue, right5);
			}
			if (type2 == typeof(long))
			{
				long left5 = context.ToObject<long>(span, leftValue);
				return CalculateLong(context, op, span, left5, (long)rightValue);
			}
			if (type == typeof(ulong))
			{
				ulong right6 = context.ToObject<ulong>(span, rightValue);
				return CalculateLong(context, op, span, (ulong)leftValue, right6);
			}
			if (type2 == typeof(ulong))
			{
				ulong left6 = context.ToObject<ulong>(span, leftValue);
				return CalculateLong(context, op, span, left6, (ulong)rightValue);
			}
			if (type == typeof(uint))
			{
				uint num = context.ToObject<uint>(span, rightValue);
				return CalculateLong(context, op, span, (uint)leftValue, num);
			}
			if (type2 == typeof(uint))
			{
				uint num2 = context.ToObject<uint>(span, leftValue);
				return CalculateLong(context, op, span, num2, (uint)rightValue);
			}
			if (type == typeof(int) || ((object)type != null && type.IsEnum))
			{
				int right7 = context.ToObject<int>(span, rightValue);
				return CalculateInt(context, op, span, (int)leftValue, right7);
			}
			if (type2 == typeof(int) || ((object)type2 != null && type2.IsEnum))
			{
				int left7 = context.ToObject<int>(span, leftValue);
				return CalculateInt(context, op, span, left7, (int)rightValue);
			}
			if (type == typeof(bool))
			{
				bool right8 = context.ToObject<bool>(span, rightValue);
				return CalculateBool(op, span, (bool)leftValue, right8);
			}
			if (type2 == typeof(bool))
			{
				bool left8 = context.ToObject<bool>(span, leftValue);
				return CalculateBool(op, span, left8, (bool)rightValue);
			}
			if (type == typeof(DateTime) && type2 == typeof(DateTime))
			{
				return CalculateDateTime(op, span, (DateTime)leftValue, (DateTime)rightValue);
			}
			if (type == typeof(DateTime) && type2 == typeof(TimeSpan))
			{
				return CalculateDateTime(op, span, (DateTime)leftValue, (TimeSpan)rightValue);
			}
			return op switch
			{
				ScriptBinaryOperator.CompareEqual => leftValue.Equals(rightValue), 
				ScriptBinaryOperator.CompareNotEqual => !leftValue.Equals(rightValue), 
				_ => throw new ScriptRuntimeException(span, $"Unsupported types `{leftValue}/{context.GetTypeName(leftValue)}` {op.ToText()} `{rightValue}/{context.GetTypeName(rightValue)}` for binary operation"), 
			};
		}

		private static object CalculateInt(TemplateContext context, ScriptBinaryOperator op, SourceSpan span, int left, int right)
		{
			return FitToBestInteger(CalculateLongWithInt(context, op, span, left, right));
		}

		private static object FitToBestInteger(object value)
		{
			if (value is int)
			{
				return value;
			}
			if (value is long longValue)
			{
				return FitToBestInteger(longValue);
			}
			if (value is BigInteger bigInt)
			{
				return FitToBestInteger(bigInt);
			}
			return value;
		}

		private static object FitToBestInteger(long longValue)
		{
			if (longValue >= int.MinValue && longValue <= int.MaxValue)
			{
				return (int)longValue;
			}
			return longValue;
		}

		private static object FitToBestInteger(BigInteger bigInt)
		{
			if (bigInt >= -2147483648L && bigInt <= 2147483647L)
			{
				return (int)bigInt;
			}
			if (bigInt >= long.MinValue && bigInt <= long.MaxValue)
			{
				return (long)bigInt;
			}
			return bigInt;
		}

		private static object CalculateLongWithInt(TemplateContext context, ScriptBinaryOperator op, SourceSpan span, int leftInt, int rightInt)
		{
			long num = leftInt;
			long num2 = rightInt;
			switch (op)
			{
			case ScriptBinaryOperator.Add:
				return num + num2;
			case ScriptBinaryOperator.Subtract:
				return num - num2;
			case ScriptBinaryOperator.Multiply:
				return num * num2;
			case ScriptBinaryOperator.Divide:
				return (double)num / (double)num2;
			case ScriptBinaryOperator.DivideRound:
				return num / num2;
			case ScriptBinaryOperator.ShiftLeft:
				return (BigInteger)num << ValidateShiftAmount(span, num2);
			case ScriptBinaryOperator.ShiftRight:
				return (BigInteger)num >> ValidateShiftAmount(span, num2);
			case ScriptBinaryOperator.Power:
				if (num2 < 0)
				{
					return Math.Pow(num, num2);
				}
				return BigInteger.ModPow(num, num2, MaxBigInteger);
			case ScriptBinaryOperator.BinaryOr:
				return num | num2;
			case ScriptBinaryOperator.BinaryAnd:
				return num & num2;
			case ScriptBinaryOperator.Modulus:
				return num % num2;
			case ScriptBinaryOperator.CompareEqual:
				return num == num2;
			case ScriptBinaryOperator.CompareNotEqual:
				return num != num2;
			case ScriptBinaryOperator.CompareGreater:
				return num > num2;
			case ScriptBinaryOperator.CompareLess:
				return num < num2;
			case ScriptBinaryOperator.CompareGreaterOrEqual:
				return num >= num2;
			case ScriptBinaryOperator.CompareLessOrEqual:
				return num <= num2;
			case ScriptBinaryOperator.RangeInclude:
				return new ScriptRange(RangeInclude(context, span, num, num2));
			case ScriptBinaryOperator.RangeExclude:
				return new ScriptRange(RangeExclude(context, span, num, num2));
			default:
				throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not implemented for long<->long");
			}
		}

		private static object CalculateLong(TemplateContext context, ScriptBinaryOperator op, SourceSpan span, long left, long right)
		{
			return CalculateBigInteger(context, op, span, new BigInteger(left), new BigInteger(right));
		}

		private static object CalculateLong(TemplateContext context, ScriptBinaryOperator op, SourceSpan span, ulong left, ulong right)
		{
			return CalculateBigInteger(context, op, span, new BigInteger(left), new BigInteger(right));
		}

		private static object CalculateBigInteger(TemplateContext context, ScriptBinaryOperator op, SourceSpan span, BigInteger left, BigInteger right)
		{
			return FitToBestInteger(CalculateBigIntegerNoFit(context, op, span, left, right));
		}

		private static object CalculateBigIntegerNoFit(TemplateContext context, ScriptBinaryOperator op, SourceSpan span, BigInteger left, BigInteger right)
		{
			switch (op)
			{
			case ScriptBinaryOperator.Add:
				return left + right;
			case ScriptBinaryOperator.Subtract:
				return left - right;
			case ScriptBinaryOperator.Multiply:
				return left * right;
			case ScriptBinaryOperator.Divide:
				return (double)left / (double)right;
			case ScriptBinaryOperator.DivideRound:
				return left / right;
			case ScriptBinaryOperator.ShiftLeft:
				return left << ValidateShiftAmount(span, right);
			case ScriptBinaryOperator.ShiftRight:
				return left >> ValidateShiftAmount(span, right);
			case ScriptBinaryOperator.Power:
				if (right < 0L)
				{
					return Math.Pow((double)left, (double)right);
				}
				return BigInteger.ModPow(left, right, MaxBigInteger);
			case ScriptBinaryOperator.BinaryOr:
				return left | right;
			case ScriptBinaryOperator.BinaryAnd:
				return left & right;
			case ScriptBinaryOperator.Modulus:
				return left % right;
			case ScriptBinaryOperator.CompareEqual:
				return left == right;
			case ScriptBinaryOperator.CompareNotEqual:
				return left != right;
			case ScriptBinaryOperator.CompareGreater:
				return left > right;
			case ScriptBinaryOperator.CompareLess:
				return left < right;
			case ScriptBinaryOperator.CompareGreaterOrEqual:
				return left >= right;
			case ScriptBinaryOperator.CompareLessOrEqual:
				return left <= right;
			case ScriptBinaryOperator.RangeInclude:
				return new ScriptRange(RangeInclude(context, span, left, right));
			case ScriptBinaryOperator.RangeExclude:
				return new ScriptRange(RangeExclude(context, span, left, right));
			default:
				throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not implemented for long<->long");
			}
		}

		private static void ValidateRangeSize(TemplateContext context, SourceSpan span, BigInteger left, BigInteger right, bool inclusive)
		{
			if (context.LoopLimit > 0)
			{
				BigInteger bigInteger = BigInteger.Abs(right - left);
				if (inclusive)
				{
					bigInteger += BigInteger.One;
				}
				if (bigInteger > context.LoopLimit)
				{
					throw new ScriptRuntimeException(span, $"Range expression exceeds LoopLimit `{context.LoopLimit}`.");
				}
			}
		}

		private static int ValidateShiftAmount(SourceSpan span, BigInteger shift)
		{
			if (shift > 2147483647L || shift < -2147483648L)
			{
				throw new ScriptRuntimeException(span, $"Shift amount `{shift}` exceeds maximum supported magnitude `{1048576}`.");
			}
			int num = (int)shift;
			if (Math.Abs((long)num) > 1048576)
			{
				throw new ScriptRuntimeException(span, $"Shift amount `{shift}` exceeds maximum supported magnitude `{1048576}`.");
			}
			return num;
		}

		private static object CalculateDouble(ScriptBinaryOperator op, SourceSpan span, double left, double right)
		{
			return op switch
			{
				ScriptBinaryOperator.Add => left + right, 
				ScriptBinaryOperator.Subtract => left - right, 
				ScriptBinaryOperator.Multiply => left * right, 
				ScriptBinaryOperator.Divide => left / right, 
				ScriptBinaryOperator.DivideRound => Math.Round(left / right), 
				ScriptBinaryOperator.ShiftLeft => left * Math.Pow(2.0, right), 
				ScriptBinaryOperator.ShiftRight => left / Math.Pow(2.0, right), 
				ScriptBinaryOperator.Power => Math.Pow(left, right), 
				ScriptBinaryOperator.Modulus => left % right, 
				ScriptBinaryOperator.CompareEqual => left == right, 
				ScriptBinaryOperator.CompareNotEqual => left != right, 
				ScriptBinaryOperator.CompareGreater => left > right, 
				ScriptBinaryOperator.CompareLess => left < right, 
				ScriptBinaryOperator.CompareGreaterOrEqual => left >= right, 
				ScriptBinaryOperator.CompareLessOrEqual => left <= right, 
				_ => throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not implemented for double<->double"), 
			};
		}

		private static object CalculateDecimal(ScriptBinaryOperator op, SourceSpan span, decimal left, decimal right)
		{
			return op switch
			{
				ScriptBinaryOperator.Add => left + right, 
				ScriptBinaryOperator.Subtract => left - right, 
				ScriptBinaryOperator.Multiply => left * right, 
				ScriptBinaryOperator.Divide => left / right, 
				ScriptBinaryOperator.DivideRound => Math.Round(left / right), 
				ScriptBinaryOperator.ShiftLeft => left * (decimal)Math.Pow(2.0, (double)right), 
				ScriptBinaryOperator.ShiftRight => left / (decimal)Math.Pow(2.0, (double)right), 
				ScriptBinaryOperator.Power => (decimal)Math.Pow((double)left, (double)right), 
				ScriptBinaryOperator.Modulus => left % right, 
				ScriptBinaryOperator.CompareEqual => left == right, 
				ScriptBinaryOperator.CompareNotEqual => left != right, 
				ScriptBinaryOperator.CompareGreater => left > right, 
				ScriptBinaryOperator.CompareLess => left < right, 
				ScriptBinaryOperator.CompareGreaterOrEqual => left >= right, 
				ScriptBinaryOperator.CompareLessOrEqual => left <= right, 
				_ => throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not implemented for decimal<->decimal"), 
			};
		}

		private static object CalculateFloat(ScriptBinaryOperator op, SourceSpan span, float left, float right)
		{
			return op switch
			{
				ScriptBinaryOperator.Add => left + right, 
				ScriptBinaryOperator.Subtract => left - right, 
				ScriptBinaryOperator.Multiply => left * right, 
				ScriptBinaryOperator.Divide => left / right, 
				ScriptBinaryOperator.DivideRound => (float)(int)(left / right), 
				ScriptBinaryOperator.Power => (float)Math.Pow(left, right), 
				ScriptBinaryOperator.ShiftLeft => left * (float)Math.Pow(2.0, right), 
				ScriptBinaryOperator.ShiftRight => left / (float)Math.Pow(2.0, right), 
				ScriptBinaryOperator.Modulus => left % right, 
				ScriptBinaryOperator.CompareEqual => left == right, 
				ScriptBinaryOperator.CompareNotEqual => left != right, 
				ScriptBinaryOperator.CompareGreater => left > right, 
				ScriptBinaryOperator.CompareLess => left < right, 
				ScriptBinaryOperator.CompareGreaterOrEqual => left >= right, 
				ScriptBinaryOperator.CompareLessOrEqual => left <= right, 
				_ => throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not implemented for float<->float"), 
			};
		}

		private static object CalculateDateTime(ScriptBinaryOperator op, SourceSpan span, DateTime left, DateTime right)
		{
			return op switch
			{
				ScriptBinaryOperator.Subtract => left - right, 
				ScriptBinaryOperator.CompareEqual => left == right, 
				ScriptBinaryOperator.CompareNotEqual => left != right, 
				ScriptBinaryOperator.CompareLess => left < right, 
				ScriptBinaryOperator.CompareLessOrEqual => left <= right, 
				ScriptBinaryOperator.CompareGreater => left > right, 
				ScriptBinaryOperator.CompareGreaterOrEqual => left >= right, 
				_ => throw new ScriptRuntimeException(span, $"The operator `{op}` is not supported for DateTime"), 
			};
		}

		private static object CalculateDateTime(ScriptBinaryOperator op, SourceSpan span, DateTime left, TimeSpan right)
		{
			if (op == ScriptBinaryOperator.Add)
			{
				return left + right;
			}
			throw new ScriptRuntimeException(span, $"The operator `{op}` is not supported for between <DateTime> and <TimeSpan>");
		}

		private static object CalculateBool(ScriptBinaryOperator op, SourceSpan span, bool left, bool right)
		{
			return op switch
			{
				ScriptBinaryOperator.CompareEqual => left == right, 
				ScriptBinaryOperator.CompareNotEqual => left != right, 
				_ => throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not valid for bool<->bool"), 
			};
		}
	}
	[ScriptSyntax("block statement", "<statement>...end")]
	public sealed class ScriptBlockStatement : ScriptStatement
	{
		private ScriptList<ScriptStatement> _statements = new ScriptList<ScriptStatement>();

		public override int ChildrenCount => 1;

		public ScriptList<ScriptStatement> Statements
		{
			get
			{
				return _statements;
			}
			set
			{
				ParentToThis(ref _statements, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			bool autoIndent = context.AutoIndent;
			object obj = null;
			ScriptList<ScriptStatement> statements = Statements;
			string previousIndent = context.CurrentIndent;
			string currentIndent = previousIndent;
			try
			{
				for (int i = 0; i < statements.Count; i++)
				{
					ScriptStatement statement = statements[i];
					context.CheckAbort();
					if (autoIndent && statement is ScriptEscapeStatement scriptEscapeStatement)
					{
						if (scriptEscapeStatement.IsEntering)
						{
							currentIndent = scriptEscapeStatement.Indent;
						}
						else if (scriptEscapeStatement.IsClosing)
						{
							currentIndent = previousIndent;
						}
					}
					context.CurrentIndent = currentIndent;
					if (!statement.CanSkipEvaluation)
					{
						obj = await context.EvaluateAsync(statement).ConfigureAwait(continueOnCapturedContext: false);
						if (!statement.CanOutput)
						{
							obj = null;
						}
						else if (obj != null && context.FlowState != ScriptFlowState.Return && context.EnableOutput)
						{
							await context.WriteAsync(Span, obj).ConfigureAwait(continueOnCapturedContext: false);
							obj = null;
						}
						if (context.FlowState != ScriptFlowState.None)
						{
							break;
						}
					}
				}
			}
			finally
			{
				context.CurrentIndent = previousIndent;
			}
			return obj;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return Statements;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptBlockStatement()
		{
			_statements.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			bool autoIndent = context.AutoIndent;
			object obj = null;
			ScriptList<ScriptStatement> statements = Statements;
			string currentIndent = context.CurrentIndent;
			string currentIndent2 = currentIndent;
			try
			{
				for (int i = 0; i < statements.Count; i++)
				{
					ScriptStatement scriptStatement = statements[i];
					context.CheckAbort();
					if (autoIndent && scriptStatement is ScriptEscapeStatement scriptEscapeStatement)
					{
						if (scriptEscapeStatement.IsEntering)
						{
							currentIndent2 = scriptEscapeStatement.Indent;
						}
						else if (scriptEscapeStatement.IsClosing)
						{
							currentIndent2 = currentIndent;
						}
					}
					context.CurrentIndent = currentIndent2;
					if (!scriptStatement.CanSkipEvaluation)
					{
						obj = context.Evaluate(scriptStatement);
						if (!scriptStatement.CanOutput)
						{
							obj = null;
						}
						else if (obj != null && context.FlowState != ScriptFlowState.Return && context.EnableOutput)
						{
							context.Write(Span, obj);
							obj = null;
						}
						if (context.FlowState != ScriptFlowState.None)
						{
							break;
						}
					}
				}
			}
			finally
			{
				context.CurrentIndent = currentIndent;
			}
			return obj;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			foreach (ScriptStatement statement in Statements)
			{
				printer.Write(statement);
			}
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}
	}
	[ScriptSyntax("capture statement", "capture <variable> ... end")]
	public class ScriptCaptureStatement : ScriptStatement
	{
		private ScriptExpression? _target;

		private ScriptBlockStatement? _body;

		private ScriptKeyword _captureKeyword = ScriptKeyword.Capture();

		public override int ChildrenCount => 3;

		public ScriptKeyword CaptureKeyword
		{
			get
			{
				return _captureKeyword;
			}
			set
			{
				ParentToThis(ref _captureKeyword, value);
			}
		}

		public ScriptExpression? Target
		{
			get
			{
				return _target;
			}
			set
			{
				ParentToThisNullable(ref _target, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			ScriptBlockStatement body = Body;
			ScriptExpression target = Target;
			if (body == null || target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid capture statement. Target and body are required.");
			}
			context.PushOutput();
			try
			{
				await context.EvaluateAsync(body).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				IScriptOutput value = context.PopOutput();
				await context.SetValueAsync(target, value).ConfigureAwait(continueOnCapturedContext: false);
			}
			return null;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => CaptureKeyword, 
				1 => Target, 
				2 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptCaptureStatement()
		{
			_captureKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			ScriptBlockStatement body = Body;
			ScriptExpression target = Target;
			if (body == null || target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid capture statement. Target and body are required.");
			}
			context.PushOutput();
			try
			{
				context.Evaluate(body);
			}
			finally
			{
				IScriptOutput value = context.PopOutput();
				context.SetValue(target, value);
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(CaptureKeyword).ExpectSpace();
			if (Target != null)
			{
				printer.Write(Target).ExpectEos();
			}
			if (Body != null)
			{
				printer.Write(Body).ExpectEos();
			}
		}
	}
	[ScriptSyntax("case statement", "case <expression> ... end|when|else")]
	public class ScriptCaseStatement : ScriptConditionStatement
	{
		private ScriptKeyword _caseKeyword;

		private ScriptExpression? _value;

		private ScriptBlockStatement? _body;

		public override int ChildrenCount => 3;

		public ScriptKeyword CaseKeyword
		{
			get
			{
				return _caseKeyword;
			}
			set
			{
				ParentToThis(ref _caseKeyword, value);
			}
		}

		public ScriptExpression? Value
		{
			get
			{
				return _value;
			}
			set
			{
				ParentToThisNullable(ref _value, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Value == null || Body == null)
			{
				return null;
			}
			context.PushCase(await context.EvaluateAsync(Value).ConfigureAwait(continueOnCapturedContext: false));
			try
			{
				return await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				context.PopCase();
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => CaseKeyword, 
				1 => Value, 
				2 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptCaseStatement()
		{
			_caseKeyword = ScriptKeyword.Case();
			_caseKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Value == null || Body == null)
			{
				return null;
			}
			object caseValue = context.Evaluate(Value);
			context.PushCase(caseValue);
			try
			{
				return context.Evaluate(Body);
			}
			finally
			{
				context.PopCase();
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(CaseKeyword).ExpectSpace();
			printer.Write(Value).ExpectEos();
			printer.Write(Body).ExpectEos();
		}
	}
	[ScriptSyntax("conditional expression", "<condition> ? <then_value> : <else_value>")]
	public class ScriptConditionalExpression : ScriptExpression
	{
		private ScriptExpression? _condition;

		private ScriptToken _questionToken;

		private ScriptExpression? _thenValue;

		private ScriptToken _colonToken;

		private ScriptExpression? _elseValue;

		public override int ChildrenCount => 5;

		public ScriptExpression? Condition
		{
			get
			{
				return _condition;
			}
			set
			{
				ParentToThisNullable(ref _condition, value);
			}
		}

		public ScriptToken QuestionToken
		{
			get
			{
				return _questionToken;
			}
			set
			{
				ParentToThis(ref _questionToken, value);
			}
		}

		public ScriptExpression? ThenValue
		{
			get
			{
				return _thenValue;
			}
			set
			{
				ParentToThisNullable(ref _thenValue, value);
			}
		}

		public ScriptToken ColonToken
		{
			get
			{
				return _colonToken;
			}
			set
			{
				ParentToThis(ref _colonToken, value);
			}
		}

		public ScriptExpression? ElseValue
		{
			get
			{
				return _elseValue;
			}
			set
			{
				ParentToThisNullable(ref _elseValue, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Condition == null || ThenValue == null || ElseValue == null)
			{
				return null;
			}
			object value = await context.EvaluateAsync(Condition).ConfigureAwait(continueOnCapturedContext: false);
			bool flag = context.ToBool(Condition.Span, value);
			return await context.EvaluateAsync(flag ? ThenValue : ElseValue).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Condition, 
				1 => QuestionToken, 
				2 => ThenValue, 
				3 => ColonToken, 
				4 => ElseValue, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptConditionalExpression()
		{
			_questionToken = ScriptToken.Question();
			_questionToken.Parent = this;
			_colonToken = ScriptToken.Colon();
			_colonToken.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Condition == null || ThenValue == null || ElseValue == null)
			{
				return null;
			}
			object value = context.Evaluate(Condition);
			bool flag = context.ToBool(Condition.Span, value);
			return context.Evaluate(flag ? ThenValue : ElseValue);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(Condition);
			printer.Write(QuestionToken);
			printer.Write(ThenValue);
			printer.Write(ColonToken);
			printer.Write(ElseValue);
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}
	}
	[ScriptSyntax("else statement", "else | else if <expression> ... end|else|else if")]
	public class ScriptElseStatement : ScriptConditionStatement
	{
		private ScriptKeyword _elseKeyword;

		private ScriptBlockStatement? _body;

		public override int ChildrenCount => 2;

		public ScriptKeyword ElseKeyword
		{
			get
			{
				return _elseKeyword;
			}
			set
			{
				ParentToThis(ref _elseKeyword, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return (Body != null) ? (await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false)) : null;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => ElseKeyword, 
				1 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptElseStatement()
		{
			_elseKeyword = ScriptKeyword.Else();
			_elseKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Body != null)
			{
				return context.Evaluate(Body);
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(ElseKeyword).ExpectEos();
			printer.Write(Body).ExpectEos();
		}
	}
	[ScriptSyntax("expression statement", "<expression>")]
	public class ScriptExpressionStatement : ScriptStatement
	{
		private ScriptExpression? _expression;

		public override int ChildrenCount => 1;

		public ScriptExpression? Expression
		{
			get
			{
				return _expression;
			}
			set
			{
				ParentToThisNullable(ref _expression, value);
				base.CanOutput = !(value is ScriptAssignExpression);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Expression == null)
			{
				return null;
			}
			object obj = await context.EvaluateAsync(Expression).ConfigureAwait(continueOnCapturedContext: false);
			if (obj is ScriptNode scriptNode)
			{
				return await context.EvaluateAsync(scriptNode).ConfigureAwait(continueOnCapturedContext: false);
			}
			return obj;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return Expression;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Expression == null)
			{
				return null;
			}
			object obj = context.Evaluate(Expression);
			if (obj is ScriptNode scriptNode)
			{
				return context.Evaluate(scriptNode);
			}
			return obj;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(Expression).ExpectEos();
		}
	}
	[ScriptSyntax("for statement", "for <variable> in <expression> ... end")]
	public class ScriptForStatement : ScriptLoopStatementBase, IScriptNamedArgumentContainer
	{
		private ScriptKeyword _forOrTableRowKeyword;

		private ScriptExpression? _variable;

		private ScriptKeyword _inKeyword;

		private ScriptExpression? _iterator;

		private ScriptList<ScriptNamedArgument> _namedArguments = new ScriptList<ScriptNamedArgument>();

		private ScriptBlockStatement? _body;

		private ScriptElseStatement? _else;

		public override int ChildrenCount => 7;

		public ScriptKeyword ForOrTableRowKeyword
		{
			get
			{
				return _forOrTableRowKeyword;
			}
			set
			{
				ParentToThis(ref _forOrTableRowKeyword, value);
			}
		}

		public ScriptExpression? Variable
		{
			get
			{
				return _variable;
			}
			set
			{
				ParentToThisNullable(ref _variable, value);
			}
		}

		public ScriptKeyword InKeyword
		{
			get
			{
				return _inKeyword;
			}
			set
			{
				ParentToThis(ref _inKeyword, value);
			}
		}

		public ScriptExpression? Iterator
		{
			get
			{
				return _iterator;
			}
			set
			{
				ParentToThisNullable(ref _iterator, value);
			}
		}

		public ScriptList<ScriptNamedArgument> NamedArguments
		{
			get
			{
				return _namedArguments;
			}
			set
			{
				ParentToThis(ref _namedArguments, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public ScriptElseStatement? Else
		{
			get
			{
				return _else;
			}
			set
			{
				ParentToThisNullable(ref _else, value);
			}
		}

		public bool SetContinue { get; set; }

		internal ScriptNode? IteratorOrLastParameter
		{
			get
			{
				if (NamedArguments == null || NamedArguments.Count <= 0)
				{
					return Iterator;
				}
				return NamedArguments[NamedArguments.Count - 1];
			}
		}

		protected override async ValueTask<object?> EvaluateImplAsync(TemplateContext context)
		{
			ScriptExpression iterator = Iterator;
			ScriptExpression variable = Variable;
			if (iterator == null || variable == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid for statement. Variable and iterator are required.");
			}
			object obj = await context.EvaluateAsync(iterator).ConfigureAwait(continueOnCapturedContext: false);
			IEnumerable list = obj as IEnumerable;
			if (list != null)
			{
				object loopResult = null;
				object previousValue = null;
				TemplateContext.LoopType loopType = ((obj is IQueryable) ? TemplateContext.LoopType.Queryable : TemplateContext.LoopType.Default);
				int limit = -1;
				int continueIndex = 0;
				if (NamedArguments != null)
				{
					bool reversed = false;
					int offset = 0;
					IEnumerable<object> listTyped = list.Cast<object>();
					foreach (ScriptNamedArgument namedArgument in NamedArguments)
					{
						switch (namedArgument.Name?.Name)
						{
						case "offset":
						{
							if (namedArgument.Value == null)
							{
								throw new ScriptRuntimeException(namedArgument.Span, "Invalid `offset` argument. Value is required.");
							}
							TemplateContext templateContext = context;
							SourceSpan span = namedArgument.Value.Span;
							offset = templateContext.ToInt(span, await context.EvaluateAsync(namedArgument.Value).ConfigureAwait(continueOnCapturedContext: false));
							continueIndex = offset;
							break;
						}
						case "reversed":
							reversed = true;
							break;
						case "limit":
						{
							if (namedArgument.Value == null)
							{
								throw new ScriptRuntimeException(namedArgument.Span, "Invalid `limit` argument. Value is required.");
							}
							TemplateContext templateContext = context;
							SourceSpan span = namedArgument.Value.Span;
							limit = templateContext.ToInt(span, await context.EvaluateAsync(namedArgument.Value).ConfigureAwait(continueOnCapturedContext: false));
							break;
						}
						default:
							await ProcessArgumentAsync(context, namedArgument).ConfigureAwait(continueOnCapturedContext: false);
							break;
						}
					}
					if (offset > 0)
					{
						listTyped = listTyped.Skip(offset);
					}
					if (reversed)
					{
						listTyped = listTyped.Reverse();
					}
					if (limit > 0)
					{
						listTyped = listTyped.Take(limit);
					}
					list = listTyped;
				}
				bool isFirst = true;
				int index = 0;
				await BeforeLoopAsync(context).ConfigureAwait(continueOnCapturedContext: false);
				LoopState loopState = CreateLoopState();
				context.SetLoopVariable(GetLoopVariable(context), loopState);
				IEnumerator it = list.GetEnumerator();
				loopState.SetEnumerable(list, it);
				bool enteredLoop = false;
				if (it.MoveNext())
				{
					enteredLoop = true;
					while (true)
					{
						if (!context.StepLoop(this, loopType))
						{
							return null;
						}
						loopState.ResetLast();
						object value = it.Current;
						loopState.Index = index;
						loopState.ValueChanged = isFirst || !object.Equals(previousValue, value);
						if (variable is ScriptVariable variable2)
						{
							context.SetLoopVariable(variable2, value);
						}
						else
						{
							await context.SetValueAsync(variable, value).ConfigureAwait(continueOnCapturedContext: false);
						}
						loopResult = await LoopItemAsync(context, loopState).ConfigureAwait(continueOnCapturedContext: false);
						bool flag = loopState.MoveNextAndIsLast();
						if (!ContinueLoop(context) || flag)
						{
							break;
						}
						previousValue = value;
						isFirst = false;
						index++;
						continueIndex++;
					}
				}
				await AfterLoopAsync(context).ConfigureAwait(continueOnCapturedContext: false);
				if (SetContinue)
				{
					context.SetValue(ScriptVariable.Continue, continueIndex + 1);
				}
				if (!enteredLoop && Else != null)
				{
					loopResult = await context.EvaluateAsync(Else).ConfigureAwait(continueOnCapturedContext: false);
				}
				return loopResult;
			}
			if (obj != null)
			{
				throw new ScriptRuntimeException(iterator.Span, $"Unexpected type `{obj.GetType()}` for iterator");
			}
			return null;
		}

		protected override async ValueTask<object?> LoopItemAsync(TemplateContext context, LoopState state)
		{
			if (Body == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid for statement. Body is required.");
			}
			return await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => ForOrTableRowKeyword, 
				1 => Variable, 
				2 => InKeyword, 
				3 => Iterator, 
				4 => NamedArguments, 
				5 => Body, 
				6 => Else, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptForStatement()
		{
			_forOrTableRowKeyword = ((this is ScriptTableRowStatement) ? ScriptKeyword.TableRow() : ScriptKeyword.For());
			_forOrTableRowKeyword.Parent = this;
			_inKeyword = ScriptKeyword.In();
			_inKeyword.Parent = this;
			_namedArguments.Parent = this;
		}

		protected override object? LoopItem(TemplateContext context, LoopState state)
		{
			if (Body == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid for statement. Body is required.");
			}
			return context.Evaluate(Body);
		}

		protected virtual ScriptVariable GetLoopVariable(TemplateContext context)
		{
			return ScriptVariable.ForObject;
		}

		protected override object? EvaluateImpl(TemplateContext context)
		{
			ScriptExpression iterator = Iterator;
			ScriptExpression variable = Variable;
			if (iterator == null || variable == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid for statement. Variable and iterator are required.");
			}
			object obj = context.Evaluate(iterator);
			IEnumerable enumerable = obj as IEnumerable;
			if (enumerable != null)
			{
				object result = null;
				object objA = null;
				TemplateContext.LoopType loopType = ((obj is IQueryable) ? TemplateContext.LoopType.Queryable : TemplateContext.LoopType.Default);
				int num = -1;
				int num2 = 0;
				if (NamedArguments != null)
				{
					bool flag = false;
					int num3 = 0;
					IEnumerable<object> enumerable2 = enumerable.Cast<object>();
					foreach (ScriptNamedArgument namedArgument in NamedArguments)
					{
						switch (namedArgument.Name?.Name)
						{
						case "offset":
							if (namedArgument.Value == null)
							{
								throw new ScriptRuntimeException(namedArgument.Span, "Invalid `offset` argument. Value is required.");
							}
							num3 = context.ToInt(namedArgument.Value.Span, context.Evaluate(namedArgument.Value));
							num2 = num3;
							break;
						case "reversed":
							flag = true;
							break;
						case "limit":
							if (namedArgument.Value == null)
							{
								throw new ScriptRuntimeException(namedArgument.Span, "Invalid `limit` argument. Value is required.");
							}
							num = context.ToInt(namedArgument.Value.Span, context.Evaluate(namedArgument.Value));
							break;
						default:
							ProcessArgument(context, namedArgument);
							break;
						}
					}
					if (num3 > 0)
					{
						enumerable2 = enumerable2.Skip(num3);
					}
					if (flag)
					{
						enumerable2 = enumerable2.Reverse();
					}
					if (num > 0)
					{
						enumerable2 = enumerable2.Take(num);
					}
					enumerable = enumerable2;
				}
				bool flag2 = true;
				int num4 = 0;
				BeforeLoop(context);
				LoopState loopState = CreateLoopState();
				context.SetLoopVariable(GetLoopVariable(context), loopState);
				IEnumerator enumerator2 = enumerable.GetEnumerator();
				loopState.SetEnumerable(enumerable, enumerator2);
				bool flag3 = false;
				if (enumerator2.MoveNext())
				{
					flag3 = true;
					while (true)
					{
						if (!context.StepLoop(this, loopType))
						{
							return null;
						}
						loopState.ResetLast();
						object current2 = enumerator2.Current;
						loopState.Index = num4;
						loopState.ValueChanged = flag2 || !object.Equals(objA, current2);
						if (variable is ScriptVariable variable2)
						{
							context.SetLoopVariable(variable2, current2);
						}
						else
						{
							context.SetValue(variable, current2);
						}
						result = LoopItem(context, loopState);
						bool flag4 = loopState.MoveNextAndIsLast();
						if (!ContinueLoop(context) || flag4)
						{
							break;
						}
						objA = current2;
						flag2 = false;
						num4++;
						num2++;
					}
				}
				AfterLoop(context);
				if (SetContinue)
				{
					context.SetValue(ScriptVariable.Continue, num2 + 1);
				}
				if (!flag3 && Else != null)
				{
					result = context.Evaluate(Else);
				}
				return result;
			}
			if (obj != null)
			{
				throw new ScriptRuntimeException(iterator.Span, $"Unexpected type `{obj.GetType()}` for iterator");
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(ForOrTableRowKeyword).ExpectSpace();
			if (Variable != null)
			{
				printer.Write(Variable).ExpectSpace();
			}
			if (!printer.PreviousHasSpace)
			{
				printer.Write(" ");
			}
			printer.Write(InKeyword).ExpectSpace();
			if (Iterator != null)
			{
				printer.Write(Iterator);
			}
			if (NamedArguments != null)
			{
				foreach (ScriptNamedArgument namedArgument in NamedArguments)
				{
					printer.ExpectSpace();
					printer.Write(namedArgument);
				}
			}
			printer.ExpectEos();
			if (Body != null)
			{
				printer.Write(Body).ExpectEos();
			}
			if (Else != null)
			{
				printer.Write(Else);
			}
		}

		protected virtual void ProcessArgument(TemplateContext context, ScriptNamedArgument argument)
		{
			throw new ScriptRuntimeException(argument.Span, $"Unsupported argument `{argument.Name}` for statement: `{this}`");
		}

		protected virtual ValueTask ProcessArgumentAsync(TemplateContext context, ScriptNamedArgument argument)
		{
			throw new ScriptRuntimeException(argument.Span, $"Unsupported argument `{argument.Name}` for statement: `{this}`");
		}
	}
	public class ScriptFrontMatter : ScriptStatement
	{
		private ScriptToken _startMarker = new ScriptToken(TokenType.FrontMatterMarker);

		private ScriptToken _endMarker = new ScriptToken(TokenType.FrontMatterMarker);

		private ScriptBlockStatement _statements = new ScriptBlockStatement();

		public TextPosition TextPositionAfterEndMarker;

		public override int ChildrenCount => 3;

		public ScriptToken StartMarker
		{
			get
			{
				return _startMarker;
			}
			set
			{
				ParentToThis(ref _startMarker, value);
			}
		}

		public ScriptBlockStatement Statements
		{
			get
			{
				return _statements;
			}
			set
			{
				ParentToThis(ref _statements, value);
			}
		}

		public ScriptToken EndMarker
		{
			get
			{
				return _endMarker;
			}
			set
			{
				ParentToThis(ref _endMarker, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return await context.EvaluateAsync(Statements).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => StartMarker, 
				1 => Statements, 
				2 => EndMarker, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptFrontMatter()
		{
			_startMarker.Parent = this;
			_endMarker.Parent = this;
			_statements.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return context.Evaluate(Statements);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.ExpectEos();
			printer.Write(StartMarker);
			printer.ExpectEos();
			printer.Write(Statements);
			printer.ExpectEos();
			printer.Write(EndMarker);
			printer.ExpectEos();
		}
	}
	[ScriptSyntax("function statement", "func <variable> ... end")]
	public class ScriptFunction : ScriptStatement, IScriptCustomFunction, IScriptFunctionInfo
	{
		private class FindRetVisitor : ScriptVisitor
		{
			[ThreadStatic]
			private static FindRetVisitor? _instance;

			public bool Found { get; private set; }

			private FindRetVisitor()
			{
			}

			public static bool HasRet(ScriptNode node)
			{
				if (node == null)
				{
					return false;
				}
				FindRetVisitor? obj = _instance ?? (_instance = new FindRetVisitor());
				obj.Found = false;
				obj.Visit(node);
				return obj.Found;
			}

			public override void Visit(ScriptReturnStatement? node)
			{
				if (node != null)
				{
					Found = true;
				}
			}

			protected override void DefaultVisit(ScriptNode? node)
			{
				if (Found || node == null)
				{
					return;
				}
				int childrenCount = node.ChildrenCount;
				for (int i = 0; i < childrenCount; i++)
				{
					ScriptNode children = node.GetChildren(i);
					Visit(children);
					if (Found)
					{
						break;
					}
				}
			}
		}

		private ScriptKeyword _funcToken;

		private ScriptNode? _nameOrDoToken;

		private ScriptToken? _openParen;

		private ScriptList<ScriptParameter>? _parameters;

		private ScriptToken? _closeParen;

		private ScriptToken? _equalToken;

		private ScriptStatement? _body;

		private bool _hasReturnType;

		private ScriptVarParamKind _varParamKind = ScriptVarParamKind.Direct;

		private int _requiredParameterCount;

		public override int ChildrenCount => 7;

		public ScriptKeyword FuncToken
		{
			get
			{
				return _funcToken;
			}
			set
			{
				ParentToThis(ref _funcToken, value);
			}
		}

		public ScriptNode? NameOrDoToken
		{
			get
			{
				return _nameOrDoToken;
			}
			set
			{
				if (value != null && !(value is ScriptVariable) && !(value is ScriptKeyword { Value: "do" }))
				{
					throw new ArgumentException("Must be a ScriptVariable or `do` ScriptKeyword");
				}
				ParentToThisNullable(ref _nameOrDoToken, value);
			}
		}

		public ScriptToken? OpenParen
		{
			get
			{
				return _openParen;
			}
			set
			{
				ParentToThisNullable(ref _openParen, value);
			}
		}

		public ScriptList<ScriptParameter>? Parameters
		{
			get
			{
				return _parameters;
			}
			set
			{
				ParentToThisNullable(ref _parameters, value);
				_requiredParameterCount = _parameters?.Count ?? 0;
				_varParamKind = ((_parameters == null) ? ScriptVarParamKind.Direct : ScriptVarParamKind.None);
				if (_parameters == null)
				{
					return;
				}
				for (int i = 0; i < _parameters.Count; i++)
				{
					ScriptToken equalOrTripleDotToken = _parameters[i].EqualOrTripleDotToken;
					if (equalOrTripleDotToken != null)
					{
						if (equalOrTripleDotToken.TokenType == TokenType.TripleDot)
						{
							_requiredParameterCount--;
							_varParamKind = ScriptVarParamKind.LastParameter;
						}
						if (equalOrTripleDotToken.TokenType == TokenType.Equal)
						{
							_requiredParameterCount--;
						}
					}
				}
			}
		}

		public ScriptToken? CloseParen
		{
			get
			{
				return _closeParen;
			}
			set
			{
				ParentToThisNullable(ref _closeParen, value);
			}
		}

		public ScriptToken? EqualToken
		{
			get
			{
				return _equalToken;
			}
			set
			{
				ParentToThisNullable(ref _equalToken, value);
			}
		}

		public ScriptStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
				UpdateReturnType();
			}
		}

		public bool IsAnonymous => !(NameOrDoToken is ScriptVariable);

		public bool HasParameters => Parameters != null;

		public int RequiredParameterCount => _requiredParameterCount;

		public int ParameterCount => Parameters?.Count ?? 0;

		public ScriptVarParamKind VarParamKind => _varParamKind;

		public Type ReturnType
		{
			get
			{
				if (!_hasReturnType)
				{
					return typeof(void);
				}
				return typeof(object);
			}
		}

		public async ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			bool hasParameters = HasParameters;
			ScriptObject scriptObject = (hasParameters ? new ScriptObject() : null);
			context.PushFunction(scriptObject, !IsAnonymous);
			try
			{
				if (NameOrDoToken is ScriptVariableLocal variable)
				{
					context.SetValue(variable, this);
				}
				context.SetValue(ScriptVariable.Arguments, arguments, asReadOnly: true);
				if (hasParameters)
				{
					if (scriptObject == null)
					{
						throw new ScriptRuntimeException(Span, "Missing global scope for function invocation.");
					}
					ScriptList<ScriptParameter> parameters = Parameters;
					if (parameters == null)
					{
						throw new ScriptRuntimeException(Span, "Missing function parameters.");
					}
					for (int i = 0; i < parameters.Count; i++)
					{
						ScriptParameter scriptParameter = parameters[i];
						string text = scriptParameter.Name?.Name;
						if (text == null)
						{
							throw new ScriptRuntimeException(scriptParameter.Span, "Missing function parameter name.");
						}
						scriptObject.SetValue(text, arguments[i], readOnly: false);
					}
				}
				if (blockStatement != null)
				{
					context.SetValue(ScriptVariable.BlockDelegate, blockStatement, asReadOnly: true);
				}
				return (Body != null) ? (await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false)) : null;
			}
			finally
			{
				context.PopFunction();
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => FuncToken, 
				1 => NameOrDoToken, 
				2 => OpenParen, 
				3 => Parameters, 
				4 => CloseParen, 
				5 => EqualToken, 
				6 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptFunction()
		{
			_funcToken = ScriptKeyword.Func();
			_funcToken.Parent = this;
			_varParamKind = ScriptVarParamKind.Direct;
		}

		public void UpdateReturnType()
		{
			_hasReturnType = Body is ScriptExpressionStatement || (Body != null && FindRetVisitor.HasRet(Body));
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (NameOrDoToken is ScriptVariable variable)
			{
				context.SetValue(variable, this);
				return null;
			}
			return this;
		}

		public override bool CanHaveLeadingTrivia()
		{
			return NameOrDoToken != null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (!IsAnonymous && Body is ScriptBlockStatement)
			{
				printer.Write(FuncToken).ExpectSpace();
			}
			printer.Write(NameOrDoToken);
			if (OpenParen != null)
			{
				printer.Write(OpenParen);
			}
			if (HasParameters)
			{
				if (OpenParen != null && Parameters != null)
				{
					printer.WriteListWithCommas(Parameters);
				}
				else if (Parameters != null)
				{
					for (int i = 0; i < Parameters.Count; i++)
					{
						ScriptParameter node = Parameters[i];
						if (i > 0)
						{
							printer.ExpectSpace();
						}
						printer.Write(node);
					}
				}
			}
			if (CloseParen != null)
			{
				printer.Write(CloseParen);
			}
			if (Body is ScriptBlockStatement)
			{
				printer.ExpectEos();
				printer.Write(Body);
			}
			else if (Body != null)
			{
				printer.Write(EqualToken);
				printer.Write(Body);
			}
			if (!IsAnonymous)
			{
				printer.ExpectEos();
			}
		}

		public object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			bool hasParameters = HasParameters;
			ScriptObject scriptObject = (hasParameters ? new ScriptObject() : null);
			context.PushFunction(scriptObject, !IsAnonymous);
			try
			{
				if (NameOrDoToken is ScriptVariableLocal variable)
				{
					context.SetValue(variable, this);
				}
				context.SetValue(ScriptVariable.Arguments, arguments, asReadOnly: true);
				if (hasParameters)
				{
					if (scriptObject == null)
					{
						throw new ScriptRuntimeException(Span, "Missing global scope for function invocation.");
					}
					ScriptList<ScriptParameter> parameters = Parameters;
					if (parameters == null)
					{
						throw new ScriptRuntimeException(Span, "Missing function parameters.");
					}
					for (int i = 0; i < parameters.Count; i++)
					{
						ScriptParameter scriptParameter = parameters[i];
						string text = scriptParameter.Name?.Name;
						if (text == null)
						{
							throw new ScriptRuntimeException(scriptParameter.Span, "Missing function parameter name.");
						}
						scriptObject.SetValue(text, arguments[i], readOnly: false);
					}
				}
				if (blockStatement != null)
				{
					context.SetValue(ScriptVariable.BlockDelegate, blockStatement, asReadOnly: true);
				}
				return (Body == null) ? null : context.Evaluate(Body);
			}
			finally
			{
				context.PopFunction();
			}
		}

		public ScriptParameterInfo GetParameterInfo(int index)
		{
			ScriptList<ScriptParameter> parameters = Parameters;
			if (parameters == null || parameters.Count == 0)
			{
				return new ScriptParameterInfo(typeof(object), string.Empty);
			}
			int count = parameters.Count;
			if (index > count - 1)
			{
				index = count - 1;
			}
			ScriptParameter scriptParameter = parameters[index];
			string name = scriptParameter.Name?.Name ?? string.Empty;
			object obj = scriptParameter.DefaultValue?.Value;
			if (obj == null)
			{
				return new ScriptParameterInfo(typeof(object), name);
			}
			return new ScriptParameterInfo(typeof(object), name, obj);
		}
	}
	[ScriptSyntax("function call expression", "<target_expression> <arguemnt[0]> ... <arguement[n]>")]
	public class ScriptFunctionCall : ScriptExpression
	{
		private ScriptExpression? _target;

		private ScriptToken? _openParent;

		private ScriptList<ScriptExpression> _arguments;

		private ScriptToken? _closeParen;

		public const int MaximumParameterCount = 64;

		public override int ChildrenCount => 4;

		public ScriptExpression? Target
		{
			get
			{
				return _target;
			}
			set
			{
				ParentToThisNullable(ref _target, value);
			}
		}

		public ScriptToken? OpenParent
		{
			get
			{
				return _openParent;
			}
			set
			{
				ParentToThisNullable(ref _openParent, value);
			}
		}

		public ScriptList<ScriptExpression> Arguments
		{
			get
			{
				return _arguments;
			}
			set
			{
				ParentToThis(ref _arguments, value);
			}
		}

		public ScriptToken? CloseParen
		{
			get
			{
				return _closeParen;
			}
			set
			{
				ParentToThisNullable(ref _closeParen, value);
			}
		}

		public bool ExplicitCall { get; set; }

		public static async ValueTask<object?> CallAsync(TemplateContext context, ScriptNode? callerContext, object? functionObject, bool processPipeArguments, IReadOnlyList<ScriptExpression>? arguments)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			ScriptBlockStatement blockDelegate = null;
			if (context.BlockDelegates.Count > 0)
			{
				blockDelegate = context.BlockDelegates.Pop();
			}
			SourceSpan callerSpan = callerContext?.Span ?? context.CurrentSpan;
			if (functionObject == null)
			{
				throw new ScriptRuntimeException(callerSpan, $"The target function `{callerContext}` is null");
			}
			ScriptFunction scriptFunction = functionObject as ScriptFunction;
			IScriptCustomFunction function = functionObject as IScriptCustomFunction;
			bool flag = processPipeArguments && context.CurrentPipeArguments != null && context.CurrentPipeArguments.Count > 0;
			if (function == null)
			{
				if (flag && callerContext is ScriptFunctionCall scriptFunctionCall)
				{
					throw new ScriptRuntimeException(callerSpan, $"Pipe expression destination `{scriptFunctionCall.Target}` is not a valid function ");
				}
				throw new ScriptRuntimeException(callerSpan, $"Invalid target function `{functionObject}` ({context.GetTypeName(functionObject)})");
			}
			if (function.ParameterCount >= 64)
			{
				throw new ScriptRuntimeException(callerSpan, $"Out of range number of parameters {function.ParameterCount} for target function `{functionObject}`. The maximum number of parameters for a function is: {64}.");
			}
			if (context.ErrorForStatementFunctionAsExpression && function.ReturnType == typeof(void) && callerContext?.Parent is ScriptExpression)
			{
				ScriptNode arg = callerContext.FindFirstTerminal();
				throw new ScriptRuntimeException(callerContext.Span, $"The function `{arg}` is a statement and cannot be used within an expression.");
			}
			List<ScriptExpression> allArgumentsWithPipe = null;
			ScriptArray argumentValues;
			if (flag)
			{
				int capacity = Math.Max(function.RequiredParameterCount, 1 + (arguments?.Count ?? 0));
				allArgumentsWithPipe = context.GetOrCreateListOfScriptExpressions(capacity);
				ScriptExpression item = (context.CurrentPipeArguments ?? throw new ScriptRuntimeException(callerSpan, "Invalid pipe state. Missing pipe arguments.")).Pop();
				argumentValues = new ScriptArray(capacity);
				allArgumentsWithPipe.Add(item);
				if (arguments != null)
				{
					allArgumentsWithPipe.AddRange(arguments);
				}
				arguments = allArgumentsWithPipe;
			}
			else
			{
				argumentValues = new ScriptArray(arguments?.Count ?? 0);
			}
			object result = null;
			try
			{
				ulong argMask = 0uL;
				if (arguments != null)
				{
					argMask = await ProcessArgumentsAsync(context, callerContext, arguments, function, scriptFunction, argumentValues).ConfigureAwait(continueOnCapturedContext: false);
				}
				bool flag2 = function.VarParamKind != ScriptVarParamKind.None;
				int requiredParameterCount = function.RequiredParameterCount;
				int parameterCount = function.ParameterCount;
				if (function.VarParamKind != ScriptVarParamKind.Direct)
				{
					FillRemainingOptionalArguments(ref argMask, argumentValues.Count, parameterCount - 1, function, argumentValues);
				}
				uint num = (uint)((1 << requiredParameterCount) - 1);
				argMask &= num;
				SourceSpan span = callerSpan;
				span.Start = span.End.NextColumn();
				span.End = span.End.NextColumn();
				if (argMask != num)
				{
					int num2 = 0;
					while (argMask != 0L)
					{
						if ((argMask & 1) != 0L)
						{
							num2++;
						}
						argMask >>= 1;
					}
					throw new ScriptRuntimeException(span, $"Invalid number of arguments `{num2}` passed to `{callerContext}` while expecting `{requiredParameterCount}` arguments");
				}
				if (!flag2 && argumentValues.Count > parameterCount)
				{
					if (argumentValues.Count > 0 && arguments != null && argumentValues.Count <= arguments.Count)
					{
						throw new ScriptRuntimeException(arguments[argumentValues.Count - 1].Span, $"Invalid number of arguments `{argumentValues.Count}` passed to `{callerContext}` while expecting `{parameterCount}` arguments");
					}
					throw new ScriptRuntimeException(span, $"Invalid number of arguments `{argumentValues.Count}` passed to `{callerContext}` while expecting `{parameterCount}` arguments");
				}
				if (callerContext != null)
				{
					context.EnterFunction(callerContext);
				}
				try
				{
					result = await function.InvokeAsync(context, callerContext, argumentValues, blockDelegate).ConfigureAwait(continueOnCapturedContext: false);
				}
				catch (ArgumentException ex)
				{
					int parameterIndexByName = GetParameterIndexByName(function, ex.ParamName);
					if (parameterIndexByName >= 0 && arguments != null && parameterIndexByName < arguments.Count)
					{
						throw new ScriptRuntimeException(arguments[parameterIndexByName].Span, ex.Message);
					}
					throw;
				}
				catch (ScriptArgumentException ex2)
				{
					int argumentIndex = ex2.ArgumentIndex;
					if (argumentIndex >= 0 && arguments != null && argumentIndex < arguments.Count)
					{
						throw new ScriptRuntimeException(arguments[argumentIndex].Span, ex2.Message);
					}
					throw;
				}
				finally
				{
					if (callerContext != null)
					{
						context.ExitFunction(callerContext);
					}
				}
			}
			finally
			{
				if (allArgumentsWithPipe != null)
				{
					context.ReleaseListOfScriptExpressions(allArgumentsWithPipe);
				}
			}
			context.FlowState = ScriptFlowState.None;
			return result;
		}

		public static async ValueTask<object?> CallAsync(TemplateContext context, ScriptNode? callerContext, IScriptCustomFunction function, ScriptArray arguments)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			if (function == null)
			{
				throw new ArgumentNullException("function");
			}
			if (arguments == null)
			{
				throw new ArgumentNullException("arguments");
			}
			int parameterCount = function.ParameterCount;
			ScriptArray scriptArray = new ScriptArray();
			SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
			if (function.VarParamKind == ScriptVarParamKind.None && parameterCount == arguments.Count)
			{
				for (int i = 0; i < parameterCount; i++)
				{
					object value = arguments[i];
					Type parameterType = function.GetParameterInfo(i).ParameterType;
					object item = context.ToObject(span, value, parameterType);
					scriptArray.Add(item);
				}
			}
			else
			{
				ulong argMask = 0uL;
				foreach (object argument in arguments)
				{
					int count = scriptArray.Count;
					Type parameterType2 = function.GetParameterInfo(count).ParameterType;
					object value2 = context.ToObject(span, argument, parameterType2);
					SetArgumentValue(count, value2, function, ref argMask, scriptArray, parameterCount);
				}
				FillRemainingOptionalArguments(ref argMask, scriptArray.Count, parameterCount - 1, function, scriptArray);
				int requiredParameterCount = function.RequiredParameterCount;
				uint num = (uint)((1 << requiredParameterCount) - 1);
				argMask &= num;
				SourceSpan span2 = callerContext?.Span ?? span;
				span2.Start = span2.End.NextColumn();
				span2.End = span2.End.NextColumn();
				if (argMask != num)
				{
					int num2 = 0;
					while (argMask != 0L)
					{
						if ((argMask & 1) != 0L)
						{
							num2++;
						}
						argMask >>= 1;
					}
					throw new ScriptRuntimeException(span2, $"Invalid number of arguments `{num2}` passed to `{callerContext}` while expecting `{requiredParameterCount}` arguments");
				}
			}
			object result = null;
			if (callerContext != null)
			{
				context.EnterFunction(callerContext);
			}
			try
			{
				result = await function.InvokeAsync(context, callerContext, scriptArray, null).ConfigureAwait(continueOnCapturedContext: false);
			}
			catch (ArgumentException ex)
			{
				int parameterIndexByName = GetParameterIndexByName(function, ex.ParamName);
				if (parameterIndexByName >= 0 && arguments != null && parameterIndexByName < arguments.Count)
				{
					throw new ScriptRuntimeException(span, ex.Message);
				}
				throw;
			}
			catch (ScriptArgumentException ex2)
			{
				int argumentIndex = ex2.ArgumentIndex;
				if (argumentIndex >= 0 && arguments != null && argumentIndex < arguments.Count)
				{
					throw new ScriptRuntimeException(span, ex2.Message);
				}
				throw;
			}
			finally
			{
				if (callerContext != null)
				{
					context.ExitFunction(callerContext);
				}
			}
			context.FlowState = ScriptFlowState.None;
			return result;
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			ScriptExpression target = Target;
			if (target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid function call. Target is required.");
			}
			object obj = await context.EvaluateAsync(target, aliasReturnedFunction: true).ConfigureAwait(continueOnCapturedContext: false);
			if (obj == null)
			{
				if (context.EnableRelaxedFunctionAccess)
				{
					return null;
				}
				throw new ScriptRuntimeException(target.Span, $"The function `{target}` was not found");
			}
			return await CallAsync(context, this, obj, context.AllowPipeArguments, Arguments).ConfigureAwait(continueOnCapturedContext: false);
		}

		private static async ValueTask<ulong> ProcessArgumentsAsync(TemplateContext context, ScriptNode? callerContext, IReadOnlyList<ScriptExpression> arguments, IScriptCustomFunction function, ScriptFunction? scriptFunction, ScriptArray argumentValues)
		{
			ulong argMask = 0uL;
			int parameterCount = function.ParameterCount;
			SourceSpan callerSpan = callerContext?.Span ?? context.CurrentSpan;
			for (int argIndex = 0; argIndex < arguments.Count; argIndex++)
			{
				ScriptExpression argument = arguments[argIndex];
				int index = argumentValues.Count;
				ScriptNamedArgument scriptNamedArgument = argument as ScriptNamedArgument;
				if (scriptNamedArgument != null)
				{
					string text = scriptNamedArgument.Name?.Name;
					if (text == null)
					{
						throw new ScriptRuntimeException(argument.Span, "Invalid null argument name");
					}
					index = GetParameterIndexByName(function, text);
					if (function.VarParamKind != ScriptVarParamKind.None && index < 0)
					{
						if (argumentValues.CanWrite(text))
						{
							SourceSpan span = callerSpan;
							string member = text;
							argumentValues.TrySetValue(context, span, member, await context.EvaluateAsync(scriptNamedArgument).ConfigureAwait(continueOnCapturedContext: false), readOnly: false);
							continue;
						}
						throw new ScriptRuntimeException(argument.Span, "Cannot pass argument " + text + " to function. This name is not supported by this function.");
					}
					if (index < 0)
					{
						index = argumentValues.Count;
					}
				}
				object obj = ((!function.IsParameterType<ScriptExpression>(index)) ? (await context.EvaluateAsync(argument).ConfigureAwait(continueOnCapturedContext: false)) : ((scriptNamedArgument != null) ? scriptNamedArgument.Value : argument));
				if (argument is ScriptUnaryExpression { Operator: ScriptUnaryOperator.FunctionParametersExpand } && !(obj is ScriptExpression) && obj is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						Type parameterType = function.GetParameterInfo(argumentValues.Count).ParameterType;
						object value = context.ToObject(callerSpan, item, parameterType);
						SetArgumentValue(index, value, function, ref argMask, argumentValues, parameterCount);
						index++;
					}
				}
				else
				{
					Type parameterType2 = function.GetParameterInfo(index).ParameterType;
					obj = context.ToObject(argument.Span, obj, parameterType2);
					SetArgumentValue(index, obj, function, ref argMask, argumentValues, parameterCount);
				}
			}
			return argMask;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Target, 
				1 => OpenParent, 
				2 => Arguments, 
				3 => CloseParen, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptFunctionCall()
		{
			_arguments = new ScriptList<ScriptExpression>();
			_arguments.Parent = this;
		}

		public bool TryGetFunctionDeclaration([NotNullWhen(true)] out ScriptFunction? function)
		{
			function = null;
			if (!ExplicitCall)
			{
				return false;
			}
			if (!(Target is ScriptVariableGlobal scriptVariableGlobal))
			{
				return false;
			}
			if (OpenParent == null || CloseParen == null)
			{
				return false;
			}
			foreach (ScriptExpression argument in Arguments)
			{
				if (!(argument is ScriptVariableGlobal))
				{
					return false;
				}
			}
			ScriptList<ScriptParameter> scriptList = new ScriptList<ScriptParameter>();
			function = new ScriptFunction
			{
				NameOrDoToken = (ScriptVariable)scriptVariableGlobal.Clone(),
				OpenParen = (ScriptToken)OpenParent.Clone(),
				CloseParen = (ScriptToken)CloseParen.Clone(),
				Span = Span
			};
			foreach (ScriptExpression argument2 in Arguments)
			{
				ScriptVariableGlobal name = (ScriptVariableGlobal)argument2.Clone();
				scriptList.Add(new ScriptParameter
				{
					Name = name
				});
			}
			function.Parameters = scriptList;
			return true;
		}

		public void AddArgument(ScriptExpression argument)
		{
			if (argument == null)
			{
				throw new ArgumentNullException("argument");
			}
			Arguments.Add(argument);
			if (CloseParen == null && !argument.Span.IsEmpty)
			{
				Span.End = argument.Span.End;
			}
		}

		[Obsolete("This method has no effect and will be deleted in a future version")]
		public ScriptExpression GetScientificExpression(TemplateContext context)
		{
			return this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			ScriptExpression target = Target;
			if (target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid function call. Target is required.");
			}
			object obj = context.Evaluate(target, aliasReturnedFunction: true);
			if (obj == null)
			{
				if (context.EnableRelaxedFunctionAccess)
				{
					return null;
				}
				throw new ScriptRuntimeException(target.Span, $"The function `{target}` was not found");
			}
			return Call(context, this, obj, context.AllowPipeArguments, Arguments);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Target != null)
			{
				printer.Write(Target);
			}
			if (OpenParent != null)
			{
				printer.Write(OpenParent);
				printer.WriteListWithCommas(Arguments);
			}
			else
			{
				for (int i = 0; i < Arguments.Count; i++)
				{
					ScriptExpression node = Arguments[i];
					printer.ExpectSpace();
					printer.Write(node);
				}
			}
			if (CloseParen != null)
			{
				printer.Write(CloseParen);
			}
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public static bool IsFunction(object? target)
		{
			return target is IScriptCustomFunction;
		}

		public static object? Call(TemplateContext context, ScriptNode? callerContext, object? functionObject, bool processPipeArguments, IReadOnlyList<ScriptExpression>? arguments)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			ScriptBlockStatement blockStatement = null;
			if (context.BlockDelegates.Count > 0)
			{
				blockStatement = context.BlockDelegates.Pop();
			}
			SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
			if (functionObject == null)
			{
				throw new ScriptRuntimeException(sourceSpan, $"The target function `{callerContext}` is null");
			}
			ScriptFunction scriptFunction = functionObject as ScriptFunction;
			IScriptCustomFunction scriptCustomFunction = functionObject as IScriptCustomFunction;
			bool flag = processPipeArguments && context.CurrentPipeArguments != null && context.CurrentPipeArguments.Count > 0;
			if (scriptCustomFunction == null)
			{
				if (flag && callerContext is ScriptFunctionCall scriptFunctionCall)
				{
					throw new ScriptRuntimeException(sourceSpan, $"Pipe expression destination `{scriptFunctionCall.Target}` is not a valid function ");
				}
				throw new ScriptRuntimeException(sourceSpan, $"Invalid target function `{functionObject}` ({context.GetTypeName(functionObject)})");
			}
			if (scriptCustomFunction.ParameterCount >= 64)
			{
				throw new ScriptRuntimeException(sourceSpan, $"Out of range number of parameters {scriptCustomFunction.ParameterCount} for target function `{functionObject}`. The maximum number of parameters for a function is: {64}.");
			}
			if (context.ErrorForStatementFunctionAsExpression && scriptCustomFunction.ReturnType == typeof(void) && callerContext?.Parent is ScriptExpression)
			{
				ScriptNode arg = callerContext.FindFirstTerminal();
				throw new ScriptRuntimeException(callerContext.Span, $"The function `{arg}` is a statement and cannot be used within an expression.");
			}
			List<ScriptExpression> list = null;
			ScriptArray scriptArray;
			if (flag)
			{
				int capacity = Math.Max(scriptCustomFunction.RequiredParameterCount, 1 + (arguments?.Count ?? 0));
				list = context.GetOrCreateListOfScriptExpressions(capacity);
				ScriptExpression item = (context.CurrentPipeArguments ?? throw new ScriptRuntimeException(sourceSpan, "Invalid pipe state. Missing pipe arguments.")).Pop();
				scriptArray = new ScriptArray(capacity);
				list.Add(item);
				if (arguments != null)
				{
					list.AddRange(arguments);
				}
				arguments = list;
			}
			else
			{
				scriptArray = new ScriptArray(arguments?.Count ?? 0);
			}
			object result = null;
			try
			{
				ulong argMask = 0uL;
				if (arguments != null)
				{
					argMask = ProcessArguments(context, callerContext, arguments, scriptCustomFunction, scriptFunction, scriptArray);
				}
				bool flag2 = scriptCustomFunction.VarParamKind != ScriptVarParamKind.None;
				int requiredParameterCount = scriptCustomFunction.RequiredParameterCount;
				int parameterCount = scriptCustomFunction.ParameterCount;
				if (scriptCustomFunction.VarParamKind != ScriptVarParamKind.Direct)
				{
					FillRemainingOptionalArguments(ref argMask, scriptArray.Count, parameterCount - 1, scriptCustomFunction, scriptArray);
				}
				uint num = (uint)((1 << requiredParameterCount) - 1);
				argMask &= num;
				SourceSpan span = sourceSpan;
				span.Start = span.End.NextColumn();
				span.End = span.End.NextColumn();
				if (argMask != num)
				{
					int num2 = 0;
					while (argMask != 0L)
					{
						if ((argMask & 1) != 0L)
						{
							num2++;
						}
						argMask >>= 1;
					}
					throw new ScriptRuntimeException(span, $"Invalid number of arguments `{num2}` passed to `{callerContext}` while expecting `{requiredParameterCount}` arguments");
				}
				if (!flag2 && scriptArray.Count > parameterCount)
				{
					if (scriptArray.Count > 0 && arguments != null && scriptArray.Count <= arguments.Count)
					{
						throw new ScriptRuntimeException(arguments[scriptArray.Count - 1].Span, $"Invalid number of arguments `{scriptArray.Count}` passed to `{callerContext}` while expecting `{parameterCount}` arguments");
					}
					throw new ScriptRuntimeException(span, $"Invalid number of arguments `{scriptArray.Count}` passed to `{callerContext}` while expecting `{parameterCount}` arguments");
				}
				if (callerContext != null)
				{
					context.EnterFunction(callerContext);
				}
				try
				{
					result = scriptCustomFunction.Invoke(context, callerContext, scriptArray, blockStatement);
				}
				catch (ArgumentException ex)
				{
					int parameterIndexByName = GetParameterIndexByName(scriptCustomFunction, ex.ParamName);
					if (parameterIndexByName >= 0 && arguments != null && parameterIndexByName < arguments.Count)
					{
						throw new ScriptRuntimeException(arguments[parameterIndexByName].Span, ex.Message);
					}
					throw;
				}
				catch (ScriptArgumentException ex2)
				{
					int argumentIndex = ex2.ArgumentIndex;
					if (argumentIndex >= 0 && arguments != null && argumentIndex < arguments.Count)
					{
						throw new ScriptRuntimeException(arguments[argumentIndex].Span, ex2.Message);
					}
					throw;
				}
				finally
				{
					if (callerContext != null)
					{
						context.ExitFunction(callerContext);
					}
				}
			}
			finally
			{
				if (list != null)
				{
					context.ReleaseListOfScriptExpressions(list);
				}
			}
			context.FlowState = ScriptFlowState.None;
			return result;
		}

		public static object? Call(TemplateContext context, ScriptNode? callerContext, IScriptCustomFunction function, ScriptArray arguments)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			if (function == null)
			{
				throw new ArgumentNullException("function");
			}
			if (arguments == null)
			{
				throw new ArgumentNullException("arguments");
			}
			int parameterCount = function.ParameterCount;
			ScriptArray scriptArray = new ScriptArray();
			SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
			if (function.VarParamKind == ScriptVarParamKind.None && parameterCount == arguments.Count)
			{
				for (int i = 0; i < parameterCount; i++)
				{
					object value = arguments[i];
					Type parameterType = function.GetParameterInfo(i).ParameterType;
					object item = context.ToObject(sourceSpan, value, parameterType);
					scriptArray.Add(item);
				}
			}
			else
			{
				ulong argMask = 0uL;
				foreach (object argument in arguments)
				{
					int count = scriptArray.Count;
					Type parameterType2 = function.GetParameterInfo(count).ParameterType;
					object value2 = context.ToObject(sourceSpan, argument, parameterType2);
					SetArgumentValue(count, value2, function, ref argMask, scriptArray, parameterCount);
				}
				FillRemainingOptionalArguments(ref argMask, scriptArray.Count, parameterCount - 1, function, scriptArray);
				int requiredParameterCount = function.RequiredParameterCount;
				uint num = (uint)((1 << requiredParameterCount) - 1);
				argMask &= num;
				SourceSpan span = callerContext?.Span ?? sourceSpan;
				span.Start = span.End.NextColumn();
				span.End = span.End.NextColumn();
				if (argMask != num)
				{
					int num2 = 0;
					while (argMask != 0L)
					{
						if ((argMask & 1) != 0L)
						{
							num2++;
						}
						argMask >>= 1;
					}
					throw new ScriptRuntimeException(span, $"Invalid number of arguments `{num2}` passed to `{callerContext}` while expecting `{requiredParameterCount}` arguments");
				}
			}
			object result = null;
			if (callerContext != null)
			{
				context.EnterFunction(callerContext);
			}
			try
			{
				result = function.Invoke(context, callerContext, scriptArray, null);
			}
			catch (ArgumentException ex)
			{
				int parameterIndexByName = GetParameterIndexByName(function, ex.ParamName);
				if (parameterIndexByName >= 0 && arguments != null && parameterIndexByName < arguments.Count)
				{
					throw new ScriptRuntimeException(sourceSpan, ex.Message);
				}
				throw;
			}
			catch (ScriptArgumentException ex2)
			{
				int argumentIndex = ex2.ArgumentIndex;
				if (argumentIndex >= 0 && arguments != null && argumentIndex < arguments.Count)
				{
					throw new ScriptRuntimeException(sourceSpan, ex2.Message);
				}
				throw;
			}
			finally
			{
				if (callerContext != null)
				{
					context.ExitFunction(callerContext);
				}
			}
			context.FlowState = ScriptFlowState.None;
			return result;
		}

		private static ulong ProcessArguments(TemplateContext context, ScriptNode? callerContext, IReadOnlyList<ScriptExpression> arguments, IScriptCustomFunction function, ScriptFunction? scriptFunction, ScriptArray argumentValues)
		{
			ulong argMask = 0uL;
			int parameterCount = function.ParameterCount;
			SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
			for (int i = 0; i < arguments.Count; i++)
			{
				ScriptExpression scriptExpression = arguments[i];
				int num = argumentValues.Count;
				ScriptNamedArgument scriptNamedArgument = scriptExpression as ScriptNamedArgument;
				if (scriptNamedArgument != null)
				{
					string text = scriptNamedArgument.Name?.Name;
					if (text == null)
					{
						throw new ScriptRuntimeException(scriptExpression.Span, "Invalid null argument name");
					}
					num = GetParameterIndexByName(function, text);
					if (function.VarParamKind != ScriptVarParamKind.None && num < 0)
					{
						if (argumentValues.CanWrite(text))
						{
							argumentValues.TrySetValue(context, span, text, context.Evaluate(scriptNamedArgument), readOnly: false);
							continue;
						}
						throw new ScriptRuntimeException(scriptExpression.Span, "Cannot pass argument " + text + " to function. This name is not supported by this function.");
					}
					if (num < 0)
					{
						num = argumentValues.Count;
					}
				}
				object obj = ((!function.IsParameterType<ScriptExpression>(num)) ? context.Evaluate(scriptExpression) : ((scriptNamedArgument != null) ? scriptNamedArgument.Value : scriptExpression));
				if (scriptExpression is ScriptUnaryExpression { Operator: ScriptUnaryOperator.FunctionParametersExpand } && !(obj is ScriptExpression) && obj is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						Type parameterType = function.GetParameterInfo(argumentValues.Count).ParameterType;
						object value = context.ToObject(span, item, parameterType);
						SetArgumentValue(num, value, function, ref argMask, argumentValues, parameterCount);
						num++;
					}
				}
				else
				{
					Type parameterType2 = function.GetParameterInfo(num).ParameterType;
					obj = context.ToObject(scriptExpression.Span, obj, parameterType2);
					SetArgumentValue(num, obj, function, ref argMask, argumentValues, parameterCount);
				}
			}
			return argMask;
		}

		private static void SetArgumentValue(int index, object? value, IScriptCustomFunction function, ref ulong argMask, ScriptArray argumentValues, int parameterCount)
		{
			if (index > argumentValues.Count)
			{
				FillRemainingOptionalArguments(ref argMask, argumentValues.Count, index, function, argumentValues);
			}
			if (index < parameterCount)
			{
				argMask |= (uint)(1 << index);
			}
			if (function.VarParamKind == ScriptVarParamKind.LastParameter && index >= parameterCount - 1)
			{
				ScriptArray scriptArray = argumentValues[parameterCount - 1] as ScriptArray;
				if (scriptArray == null)
				{
					scriptArray = (ScriptArray)(argumentValues[parameterCount - 1] = new ScriptArray());
				}
				scriptArray.Add(value);
			}
			else
			{
				argumentValues[index] = value;
			}
		}

		private static void FillRemainingOptionalArguments(ref ulong argMask, int startIndex, int endIndex, IScriptCustomFunction function, ScriptArray argumentValues)
		{
			int num = function.ParameterCount - 1;
			if (endIndex > num)
			{
				endIndex = num;
			}
			int num2 = ((function.VarParamKind == ScriptVarParamKind.LastParameter) ? num : (-1));
			for (int i = startIndex; i <= endIndex; i++)
			{
				ScriptParameterInfo parameterInfo = function.GetParameterInfo(i);
				if (parameterInfo.HasDefaultValue)
				{
					argumentValues[i] = parameterInfo.DefaultValue;
					argMask |= (uint)(1 << i);
				}
				else
				{
					argumentValues[i] = ((i == num2) ? new ScriptArray() : null);
				}
			}
		}

		private static int GetParameterIndexByName(IScriptFunctionInfo functionInfo, string? name)
		{
			if (name == null)
			{
				return -1;
			}
			int parameterCount = functionInfo.ParameterCount;
			for (int i = 0; i < parameterCount; i++)
			{
				if (functionInfo.GetParameterInfo(i).Name == name)
				{
					return i;
				}
			}
			return -1;
		}
	}
	[ScriptSyntax("if statement", "if <expression> ... end|else|else if")]
	public class ScriptIfStatement : ScriptConditionStatement
	{
		private ScriptExpression? _condition;

		private ScriptBlockStatement? _then;

		private ScriptConditionStatement? _else;

		private ScriptKeyword _ifKeyword;

		private ScriptKeyword? _elseKeyword;

		public override int ChildrenCount => 5;

		public ScriptKeyword? ElseKeyword
		{
			get
			{
				return _elseKeyword;
			}
			set
			{
				ParentToThisNullable(ref _elseKeyword, value);
			}
		}

		public ScriptKeyword IfKeyword
		{
			get
			{
				return _ifKeyword;
			}
			set
			{
				ParentToThis(ref _ifKeyword, value);
			}
		}

		public ScriptExpression? Condition
		{
			get
			{
				return _condition;
			}
			set
			{
				ParentToThisNullable(ref _condition, value);
			}
		}

		public ScriptBlockStatement? Then
		{
			get
			{
				return _then;
			}
			set
			{
				ParentToThisNullable(ref _then, value);
			}
		}

		public ScriptConditionStatement? Else
		{
			get
			{
				return _else;
			}
			set
			{
				ParentToThisNullable(ref _else, value);
			}
		}

		public bool IsElseIf => ElseKeyword != null;

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Condition == null)
			{
				return null;
			}
			SourceSpan span = Condition.Span;
			object result;
			if (context.ToBool(span, await context.EvaluateAsync(Condition).ConfigureAwait(continueOnCapturedContext: false)))
			{
				object obj = ((Then != null) ? (await context.EvaluateAsync(Then).ConfigureAwait(continueOnCapturedContext: false)) : null);
				result = obj;
			}
			else
			{
				object obj = ((Else != null) ? (await context.EvaluateAsync(Else).ConfigureAwait(continueOnCapturedContext: false)) : null);
				result = obj;
			}
			return result;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => ElseKeyword, 
				1 => IfKeyword, 
				2 => Condition, 
				3 => Then, 
				4 => Else, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptIfStatement()
		{
			_ifKeyword = ScriptKeyword.If();
			_ifKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Condition == null)
			{
				return null;
			}
			if (!context.ToBool(Condition.Span, context.Evaluate(Condition)))
			{
				if (Else != null)
				{
					return context.Evaluate(Else);
				}
				return null;
			}
			if (Then != null)
			{
				return context.Evaluate(Then);
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (IsElseIf)
			{
				printer.Write(ElseKeyword).ExpectSpace();
			}
			printer.Write(IfKeyword).ExpectSpace();
			printer.Write(Condition);
			printer.ExpectEos();
			printer.Write(Then);
			printer.Write(Else);
		}
	}
	[ScriptSyntax("import statement", "import <expression>")]
	public class ScriptImportStatement : ScriptStatement
	{
		private ScriptKeyword _importKeyword;

		private ScriptExpression? _expression;

		public override int ChildrenCount => 2;

		public ScriptKeyword ImportKeyword
		{
			get
			{
				return _importKeyword;
			}
			set
			{
				ParentToThis(ref _importKeyword, value);
			}
		}

		public ScriptExpression? Expression
		{
			get
			{
				return _expression;
			}
			set
			{
				ParentToThisNullable(ref _expression, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Expression == null)
			{
				return null;
			}
			object obj = await context.EvaluateAsync(Expression).ConfigureAwait(continueOnCapturedContext: false);
			if (obj == null)
			{
				return null;
			}
			context.Import(Expression.Span, obj);
			return null;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => ImportKeyword, 
				1 => Expression, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptImportStatement()
		{
			_importKeyword = ScriptKeyword.Import();
			_importKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Expression == null)
			{
				return null;
			}
			object obj = context.Evaluate(Expression);
			if (obj == null)
			{
				return null;
			}
			context.Import(Expression.Span, obj);
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(ImportKeyword).ExpectSpace();
			printer.Write(Expression);
			printer.ExpectEos();
		}
	}
	[ScriptSyntax("increment/decrement expression", "<operator> <expression> or <expression> <operator>")]
	public class ScriptIncrementDecrementExpression : ScriptUnaryExpression
	{
		public override int ChildrenCount => 2;

		public bool Post { get; set; }

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (base.Right == null)
			{
				return null;
			}
			int increment = ((base.Operator == ScriptUnaryOperator.Increment) ? 1 : (-1));
			SourceSpan span = base.Right.Span;
			object value = ScriptUnaryExpression.Evaluate(context, span, ScriptUnaryOperator.Plus, await context.EvaluateAsync(base.Right).ConfigureAwait(continueOnCapturedContext: false));
			object incrementedValue = ScriptBinaryExpression.Evaluate(context, base.Right.Span, ScriptBinaryOperator.Add, value, increment);
			await context.SetValueAsync(base.Right, incrementedValue).ConfigureAwait(continueOnCapturedContext: false);
			return Post ? value : incrementedValue;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => base.OperatorToken, 
				1 => base.Right, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (base.Right == null)
			{
				return null;
			}
			int num = ((base.Operator == ScriptUnaryOperator.Increment) ? 1 : (-1));
			object obj = ScriptUnaryExpression.Evaluate(context, base.Right.Span, ScriptUnaryOperator.Plus, context.Evaluate(base.Right));
			object obj2 = ScriptBinaryExpression.Evaluate(context, base.Right.Span, ScriptBinaryOperator.Add, obj, num);
			context.SetValue(base.Right, obj2);
			if (!Post)
			{
				return obj2;
			}
			return obj;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Post)
			{
				printer.Write(base.Right);
				PrintOperator(printer);
			}
			else
			{
				PrintOperator(printer);
				printer.Write(base.Right);
			}
		}

		private void PrintOperator(ScriptPrinter printer)
		{
			if (base.OperatorToken != null)
			{
				printer.Write(base.OperatorToken);
			}
			else
			{
				printer.Write(base.Operator.ToText());
			}
		}
	}
	[ScriptSyntax("indexer expression", "<expression>[<index_expression>]")]
	public class ScriptIndexerExpression : ScriptExpression, IScriptVariablePath
	{
		private ScriptExpression? _target;

		private ScriptToken _openBracket = ScriptToken.OpenBracket();

		private ScriptExpression? _index;

		private ScriptToken _closeBracket = ScriptToken.CloseBracket();

		public override int ChildrenCount => 4;

		public ScriptExpression? Target
		{
			get
			{
				return _target;
			}
			set
			{
				ParentToThisNullable(ref _target, value);
			}
		}

		public ScriptToken OpenBracket
		{
			get
			{
				return _openBracket;
			}
			set
			{
				ParentToThis(ref _openBracket, value);
			}
		}

		public ScriptExpression? Index
		{
			get
			{
				return _index;
			}
			set
			{
				ParentToThisNullable(ref _index, value);
			}
		}

		public ScriptToken CloseBracket
		{
			get
			{
				return _closeBracket;
			}
			set
			{
				ParentToThis(ref _closeBracket, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return await context.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
		}

		private async ValueTask<object?> GetOrSetValueAsync(TemplateContext context, object? valueToSet, bool setter)
		{
			object value = null;
			ScriptExpression target = Target;
			ScriptExpression indexExpression = Index;
			if (target == null || indexExpression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid indexer expression. Target and index are required.");
			}
			object targetObject = await context.GetValueAsync(target).ConfigureAwait(continueOnCapturedContext: false);
			if (targetObject == null)
			{
				if (!setter && (context.EnableRelaxedTargetAccess || HasNullConditionalTarget(target)))
				{
					return null;
				}
				throw new ScriptRuntimeException(target.Span, $"Object `{target}` is null. Cannot access indexer: {this}");
			}
			object obj = await context.EvaluateAsync(indexExpression).ConfigureAwait(continueOnCapturedContext: false);
			if (obj == null)
			{
				if (context.EnableNullIndexer)
				{
					return null;
				}
				throw new ScriptRuntimeException(indexExpression.Span, $"Cannot access target `{target}` with a null indexer: {this}");
			}
			IListAccessor listAccessor = context.TryGetListAccessor(targetObject);
			if (targetObject is IDictionary || (targetObject is IScriptObject && (listAccessor == null || obj is string)) || listAccessor == null)
			{
				IObjectAccessor memberAccessor = context.GetMemberAccessor(targetObject);
				if (memberAccessor.HasIndexer)
				{
					Type indexType = memberAccessor.IndexType;
					if ((object)indexType == null)
					{
						throw new ScriptRuntimeException(indexExpression.Span, $"Cannot access target `{target}` with an untyped indexer: {this}");
					}
					object obj2 = context.ToObject(indexExpression.Span, obj, indexType);
					if (obj2 == null)
					{
						if (context.EnableNullIndexer)
						{
							return null;
						}
						throw new ScriptRuntimeException(indexExpression.Span, $"Cannot access target `{target}` with a null indexer: {this}");
					}
					if (setter)
					{
						if (!memberAccessor.TrySetItem(context, indexExpression.Span, targetObject, obj2, valueToSet))
						{
							throw new ScriptRuntimeException(indexExpression.Span, $"Cannot set a value for the readonly member `{obj2}` in the indexer: {target}['{obj2}']");
						}
					}
					else
					{
						bool flag = memberAccessor.TryGetItem(context, indexExpression.Span, targetObject, obj2, out value);
						if (!context.EnableRelaxedMemberAccess && !flag)
						{
							throw new ScriptRuntimeException(indexExpression.Span, $"Cannot access target `{target}` with an indexer: {indexExpression}");
						}
					}
				}
				else
				{
					string text = context.ObjectToString(obj) ?? string.Empty;
					if (setter)
					{
						if (!memberAccessor.TrySetValue(context, indexExpression.Span, targetObject, text, valueToSet))
						{
							throw new ScriptRuntimeException(indexExpression.Span, $"Cannot set a value for the readonly member `{text}` in the indexer: {target}['{text}']");
						}
					}
					else if (!memberAccessor.TryGetValue(context, indexExpression.Span, targetObject, text, out value))
					{
						bool flag2 = context.TryGetMember?.Invoke(context, indexExpression.Span, targetObject, text, out value) ?? false;
						if (!context.EnableRelaxedMemberAccess && !flag2)
						{
							throw new ScriptRuntimeException(indexExpression.Span, $"Cannot access target `{target}` with an indexer: {indexExpression}");
						}
					}
				}
			}
			else
			{
				int num = context.ToInt(indexExpression.Span, obj);
				int length = listAccessor.GetLength(context, target.Span, targetObject);
				if (num < 0)
				{
					num = length + num;
				}
				if (!context.EnableRelaxedIndexerAccess && (num < 0 || num >= length))
				{
					throw new ScriptRuntimeException(indexExpression.Span, $"The index {num} is out of bounds [0, {length}] on the `{target}` with the indexer: {indexExpression}");
				}
				if (num >= 0)
				{
					if (setter)
					{
						listAccessor.SetValue(context, indexExpression.Span, targetObject, num, valueToSet);
					}
					else
					{
						value = listAccessor.GetValue(context, indexExpression.Span, targetObject, num);
					}
				}
			}
			return value;
		}

		public async ValueTask<object?> GetValueAsync(TemplateContext context)
		{
			return await GetOrSetValueAsync(context, null, setter: false).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async ValueTask SetValueAsync(TemplateContext context, object? valueToSet)
		{
			await GetOrSetValueAsync(context, valueToSet, setter: true).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Target, 
				1 => OpenBracket, 
				2 => Index, 
				3 => CloseBracket, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptIndexerExpression()
		{
			_openBracket.Parent = this;
			_closeBracket.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return context.GetValue(this);
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Target != null)
			{
				printer.Write(Target);
			}
			int num;
			if (object.Equals(Target, ScriptVariable.Arguments) && Index is ScriptLiteral)
			{
				num = (((ScriptLiteral)Index).IsPositiveInteger() ? 1 : 0);
				if (num != 0)
				{
					goto IL_0057;
				}
			}
			else
			{
				num = 0;
			}
			printer.Write(OpenBracket);
			goto IL_0057;
			IL_0057:
			if (Index != null)
			{
				printer.Write(Index);
			}
			if (num == 0)
			{
				printer.Write(CloseBracket);
			}
		}

		public object? GetValue(TemplateContext context)
		{
			return GetOrSetValue(context, null, setter: false);
		}

		public void SetValue(TemplateContext context, object? valueToSet)
		{
			GetOrSetValue(context, valueToSet, setter: true);
		}

		public string GetFirstPath()
		{
			return (Target as IScriptVariablePath)?.GetFirstPath() ?? string.Empty;
		}

		private object? GetOrSetValue(TemplateContext context, object? valueToSet, bool setter)
		{
			object value = null;
			ScriptExpression target = Target;
			ScriptExpression index = Index;
			if (target == null || index == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid indexer expression. Target and index are required.");
			}
			object value2 = context.GetValue(target);
			if (value2 == null)
			{
				if (!setter && (context.EnableRelaxedTargetAccess || HasNullConditionalTarget(target)))
				{
					return null;
				}
				throw new ScriptRuntimeException(target.Span, $"Object `{target}` is null. Cannot access indexer: {this}");
			}
			object obj = context.Evaluate(index);
			if (obj == null)
			{
				if (context.EnableNullIndexer)
				{
					return null;
				}
				throw new ScriptRuntimeException(index.Span, $"Cannot access target `{target}` with a null indexer: {this}");
			}
			IListAccessor listAccessor = context.TryGetListAccessor(value2);
			if (value2 is IDictionary || (value2 is IScriptObject && (listAccessor == null || obj is string)) || listAccessor == null)
			{
				IObjectAccessor memberAccessor = context.GetMemberAccessor(value2);
				if (memberAccessor.HasIndexer)
				{
					Type indexType = memberAccessor.IndexType;
					if ((object)indexType == null)
					{
						throw new ScriptRuntimeException(index.Span, $"Cannot access target `{target}` with an untyped indexer: {this}");
					}
					object obj2 = context.ToObject(index.Span, obj, indexType);
					if (obj2 == null)
					{
						if (context.EnableNullIndexer)
						{
							return null;
						}
						throw new ScriptRuntimeException(index.Span, $"Cannot access target `{target}` with a null indexer: {this}");
					}
					if (setter)
					{
						if (!memberAccessor.TrySetItem(context, index.Span, value2, obj2, valueToSet))
						{
							throw new ScriptRuntimeException(index.Span, $"Cannot set a value for the readonly member `{obj2}` in the indexer: {target}['{obj2}']");
						}
					}
					else
					{
						bool flag = memberAccessor.TryGetItem(context, index.Span, value2, obj2, out value);
						if (!context.EnableRelaxedMemberAccess && !flag)
						{
							throw new ScriptRuntimeException(index.Span, $"Cannot access target `{target}` with an indexer: {index}");
						}
					}
				}
				else
				{
					string text = context.ObjectToString(obj) ?? string.Empty;
					if (setter)
					{
						if (!memberAccessor.TrySetValue(context, index.Span, value2, text, valueToSet))
						{
							throw new ScriptRuntimeException(index.Span, $"Cannot set a value for the readonly member `{text}` in the indexer: {target}['{text}']");
						}
					}
					else if (!memberAccessor.TryGetValue(context, index.Span, value2, text, out value))
					{
						bool flag2 = context.TryGetMember?.Invoke(context, index.Span, value2, text, out value) ?? false;
						if (!context.EnableRelaxedMemberAccess && !flag2)
						{
							throw new ScriptRuntimeException(index.Span, $"Cannot access target `{target}` with an indexer: {index}");
						}
					}
				}
			}
			else
			{
				int num = context.ToInt(index.Span, obj);
				int length = listAccessor.GetLength(context, target.Span, value2);
				if (num < 0)
				{
					num = length + num;
				}
				if (!context.EnableRelaxedIndexerAccess && (num < 0 || num >= length))
				{
					throw new ScriptRuntimeException(index.Span, $"The index {num} is out of bounds [0, {length}] on the `{target}` with the indexer: {index}");
				}
				if (num >= 0)
				{
					if (setter)
					{
						listAccessor.SetValue(context, index.Span, value2, num, valueToSet);
					}
					else
					{
						value = listAccessor.GetValue(context, index.Span, value2, num);
					}
				}
			}
			return value;
		}

		private static bool HasNullConditionalTarget(ScriptExpression? expression)
		{
			if (!(expression is ScriptMemberExpression scriptMemberExpression))
			{
				if (!(expression is ScriptIndexerExpression scriptIndexerExpression))
				{
					if (expression is ScriptNestedExpression scriptNestedExpression)
					{
						return HasNullConditionalTarget(scriptNestedExpression.Expression);
					}
					return false;
				}
				return HasNullConditionalTarget(scriptIndexerExpression.Target);
			}
			if (scriptMemberExpression.DotToken.TokenType != TokenType.QuestionDot)
			{
				return HasNullConditionalTarget(scriptMemberExpression.Target);
			}
			return true;
		}
	}
	[ScriptSyntax("interpolated string expression", "$\"string{<expression>}string\"")]
	public class ScriptInterpolatedExpression : ScriptExpression
	{
		private ScriptExpression? _expression;

		private ScriptToken _openBrace;

		private ScriptToken _closeBrace;

		public override int ChildrenCount => 3;

		public ScriptToken OpenBrace
		{
			get
			{
				return _openBrace;
			}
			set
			{
				ParentToThis(ref _openBrace, value);
			}
		}

		public ScriptExpression? Expression
		{
			get
			{
				return _expression;
			}
			set
			{
				ParentToThisNullable(ref _expression, value);
			}
		}

		public ScriptToken CloseBrace
		{
			get
			{
				return _closeBrace;
			}
			set
			{
				ParentToThis(ref _closeBrace, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Expression == null)
			{
				return null;
			}
			context.PushPipeArguments();
			try
			{
				return await context.EvaluateAsync(Expression).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				if (context.CurrentPipeArguments != null)
				{
					context.PopPipeArguments();
				}
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => OpenBrace, 
				1 => Expression, 
				2 => CloseBrace, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptInterpolatedExpression()
		{
			_openBrace = ScriptToken.OpenInterpBrace();
			_openBrace.Parent = this;
			_closeBrace = ScriptToken.CloseInterpBrace();
			_closeBrace.Parent = this;
		}

		public ScriptInterpolatedExpression(ScriptExpression expression)
			: this()
		{
			Expression = expression;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Expression == null)
			{
				return null;
			}
			context.PushPipeArguments();
			try
			{
				return context.Evaluate(Expression);
			}
			finally
			{
				if (context.CurrentPipeArguments != null)
				{
					context.PopPipeArguments();
				}
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(OpenBrace);
			printer.Write(Expression);
			printer.Write(CloseBrace);
		}
	}
	[ScriptSyntax("interpolated expression", "{<expression>}")]
	public class ScriptInterpolatedStringExpression : ScriptExpression
	{
		private ScriptList<ScriptExpression> _stringParts;

		public override int ChildrenCount => 1;

		public ScriptList<ScriptExpression> Parts
		{
			get
			{
				return _stringParts;
			}
			set
			{
				ParentToThis(ref _stringParts, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			context.PushPipeArguments();
			try
			{
				StringBuilder builder = new StringBuilder();
				foreach (ScriptExpression part in Parts)
				{
					object obj = await context.EvaluateAsync(part).ConfigureAwait(continueOnCapturedContext: false);
					if (obj != null)
					{
						builder.Append(obj);
					}
				}
				return builder.ToString();
			}
			finally
			{
				if (context.CurrentPipeArguments != null)
				{
					context.PopPipeArguments();
				}
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return Parts;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptInterpolatedStringExpression()
		{
			_stringParts = new ScriptList<ScriptExpression>();
			_stringParts.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			context.PushPipeArguments();
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				foreach (ScriptExpression part in Parts)
				{
					object obj = context.Evaluate(part);
					if (obj != null)
					{
						stringBuilder.Append(obj);
					}
				}
				return stringBuilder.ToString();
			}
			finally
			{
				if (context.CurrentPipeArguments != null)
				{
					context.PopPipeArguments();
				}
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			foreach (ScriptExpression part in Parts)
			{
				printer.Write(part);
			}
		}
	}
	[ScriptSyntax("empty expression", "<expression>.empty?")]
	public class ScriptIsEmptyExpression : ScriptMemberExpression, IScriptVariablePath
	{
		private ScriptToken _questionToken = ScriptToken.Question();

		public override int ChildrenCount => 4;

		public ScriptToken QuestionToken
		{
			get
			{
				return _questionToken;
			}
			set
			{
				ParentToThis(ref _questionToken, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return await context.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
		}

		private async ValueTask<object?> GetTargetObjectAsync(TemplateContext context, bool isSet)
		{
			ScriptExpression target = base.Target;
			if (target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid `.empty?` expression. Target is required.");
			}
			object obj = await context.GetValueAsync(target).ConfigureAwait(continueOnCapturedContext: false);
			if (obj == null && (isSet || !context.EnableRelaxedMemberAccess))
			{
				throw new ScriptRuntimeException(Span, $"Object `{base.Target}` is null. Cannot access property `empty?`");
			}
			return obj;
		}

		public override async ValueTask<object?> GetValueAsync(TemplateContext context)
		{
			object against = await GetTargetObjectAsync(context, isSet: false).ConfigureAwait(continueOnCapturedContext: false);
			return context.IsEmpty(Span, against);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => base.Target, 
				1 => base.DotToken, 
				2 => base.Member, 
				3 => QuestionToken, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptIsEmptyExpression()
		{
			_questionToken.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return context.GetValue(this);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			base.PrintTo(printer);
			printer.Write(QuestionToken);
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public override object? GetValue(TemplateContext context)
		{
			object targetObject = GetTargetObject(context, isSet: false);
			return context.IsEmpty(Span, targetObject);
		}

		public override void SetValue(TemplateContext context, object? valueToSet)
		{
			throw new ScriptRuntimeException(Span, "The `.empty?` property cannot be set");
		}

		public override string GetFirstPath()
		{
			return (base.Target as IScriptVariablePath)?.GetFirstPath() ?? string.Empty;
		}

		private object? GetTargetObject(TemplateContext context, bool isSet)
		{
			ScriptExpression target = base.Target;
			if (target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid `.empty?` expression. Target is required.");
			}
			object? value = context.GetValue(target);
			if (value == null && (isSet || !context.EnableRelaxedMemberAccess))
			{
				throw new ScriptRuntimeException(Span, $"Object `{base.Target}` is null. Cannot access property `empty?`");
			}
			return value;
		}
	}
	public abstract class ScriptLoopStatementBase : ScriptStatement
	{
		protected class LoopState : IScriptObject
		{
			private int _length;

			private object? _lengthObject;

			private IEnumerable? _list;

			private IEnumerator? _it;

			private bool _isLast;

			private bool _isLastTaken;

			public int Index { get; set; }

			public bool IsFirst => Index == 0;

			public bool IsEven => (Index & 1) == 0;

			public bool IsOdd => !IsEven;

			public bool ValueChanged { get; set; }

			public int Length
			{
				get
				{
					if (_lengthObject == null)
					{
						_length = ((_list is IList list) ? list.Count : (_list?.Cast<object>().Count() ?? 0));
						_lengthObject = _length;
					}
					return _length;
				}
			}

			public int Count { get; set; }

			public bool IsReadOnly { get; set; }

			public void SetEnumerable(IEnumerable list, IEnumerator it)
			{
				_list = list;
				_it = it;
			}

			public void ResetLast()
			{
				_isLastTaken = false;
			}

			public bool MoveNextAndIsLast()
			{
				if (_it == null)
				{
					return false;
				}
				if (!_isLastTaken)
				{
					_isLast = !_it.MoveNext();
					_isLastTaken = true;
				}
				return _isLast;
			}

			public IEnumerable<string> GetMembers()
			{
				return Enumerable.Empty<string>();
			}

			public virtual bool Contains(string member)
			{
				switch (member)
				{
				case "first":
				case "index":
				case "index0":
				case "length":
				case "rindex":
				case "even":
				case "last":
				case "changed":
				case "rindex0":
				case "odd":
					return true;
				default:
					return false;
				}
			}

			public virtual bool TryGetValue(TemplateContext context, SourceSpan span, string member, out object? value)
			{
				value = null;
				bool isLiquid = context.IsLiquid;
				switch (member)
				{
				case "index":
					value = (isLiquid ? (Index + 1) : Index);
					return true;
				case "length":
					value = Length;
					return true;
				case "first":
					value = (IsFirst ? BoxHelper.TrueObject : BoxHelper.FalseObject);
					return true;
				case "even":
					value = (IsEven ? BoxHelper.TrueObject : BoxHelper.FalseObject);
					return true;
				case "odd":
					value = (IsOdd ? BoxHelper.TrueObject : BoxHelper.FalseObject);
					return true;
				case "last":
					value = (MoveNextAndIsLast() ? BoxHelper.TrueObject : BoxHelper.FalseObject);
					return true;
				case "changed":
					value = (ValueChanged ? BoxHelper.TrueObject : BoxHelper.FalseObject);
					return true;
				case "rindex":
					value = (isLiquid ? (Length - Index) : (Length - Index - 1));
					return true;
				default:
					if (isLiquid)
					{
						if (member == "index0")
						{
							value = Index;
							return true;
						}
						if (member == "rindex0")
						{
							value = Length - Index - 1;
							return true;
						}
					}
					return false;
				}
			}

			public bool CanWrite(string member)
			{
				throw new NotImplementedException();
			}

			public bool TrySetValue(TemplateContext context, SourceSpan span, string member, object? value, bool readOnly)
			{
				return false;
			}

			public bool Remove(string member)
			{
				return false;
			}

			public void SetReadOnly(string member, bool readOnly)
			{
			}

			public IScriptObject Clone(bool deep)
			{
				return (IScriptObject)MemberwiseClone();
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			context.EnterLoop(this);
			try
			{
				return await EvaluateImplAsync(context).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				context.ExitLoop(this);
				if (context.FlowState != ScriptFlowState.Return)
				{
					context.FlowState = ScriptFlowState.None;
				}
			}
		}

		protected virtual void BeforeLoop(TemplateContext context)
		{
		}

		protected abstract object? LoopItem(TemplateContext context, LoopState state);

		protected virtual LoopState CreateLoopState()
		{
			return new LoopState();
		}

		protected bool ContinueLoop(TemplateContext context)
		{
			if (context.FlowState == ScriptFlowState.Return)
			{
				return false;
			}
			bool result = context.FlowState != ScriptFlowState.Break;
			context.FlowState = ScriptFlowState.None;
			return result;
		}

		protected virtual void AfterLoop(TemplateContext context)
		{
		}

		public override object? Evaluate(TemplateContext context)
		{
			object obj = null;
			context.EnterLoop(this);
			try
			{
				return EvaluateImpl(context);
			}
			finally
			{
				context.ExitLoop(this);
				if (context.FlowState != ScriptFlowState.Return)
				{
					context.FlowState = ScriptFlowState.None;
				}
			}
		}

		protected abstract object? EvaluateImpl(TemplateContext context);

		protected abstract ValueTask<object?> EvaluateImplAsync(TemplateContext context);

		protected abstract ValueTask<object?> LoopItemAsync(TemplateContext context, LoopState state);

		protected virtual ValueTask BeforeLoopAsync(TemplateContext context)
		{
			return default(ValueTask);
		}

		protected virtual ValueTask AfterLoopAsync(TemplateContext context)
		{
			return default(ValueTask);
		}
	}
	[ScriptSyntax("member expression", "<expression>.<variable_name>")]
	public class ScriptMemberExpression : ScriptExpression, IScriptVariablePath
	{
		private ScriptExpression? _target;

		private ScriptToken _dotToken = ScriptToken.Dot();

		private ScriptVariable? _member;

		public override int ChildrenCount => 3;

		public ScriptExpression? Target
		{
			get
			{
				return _target;
			}
			set
			{
				ParentToThisNullable(ref _target, value);
			}
		}

		public ScriptToken DotToken
		{
			get
			{
				return _dotToken;
			}
			set
			{
				ParentToThis(ref _dotToken, value);
			}
		}

		public ScriptVariable? Member
		{
			get
			{
				return _member;
			}
			set
			{
				ParentToThisNullable(ref _member, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return await context.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
		}

		private async ValueTask<object?> GetTargetObjectAsync(TemplateContext context, bool isSet)
		{
			ScriptVariable member = Member;
			ScriptExpression target = Target;
			if ((object)member == null || target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid member expression. Target and member are required.");
			}
			object obj = await context.GetValueAsync(target).ConfigureAwait(continueOnCapturedContext: false);
			if (obj == null && (isSet || (!context.EnableRelaxedMemberAccess && DotToken.TokenType != TokenType.QuestionDot)))
			{
				throw new ScriptRuntimeException(member.Span, $"Object `{target}` is null. Cannot access member: {this}");
			}
			return obj;
		}

		public virtual async ValueTask<object?> GetValueAsync(TemplateContext context)
		{
			ScriptVariable member = Member;
			if ((object)member == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid member expression. Member is required.");
			}
			object obj = await GetTargetObjectAsync(context, isSet: false).ConfigureAwait(continueOnCapturedContext: false);
			if (obj == null)
			{
				if (context.EnableRelaxedTargetAccess || DotToken.TokenType == TokenType.QuestionDot)
				{
					return null;
				}
				throw new ScriptRuntimeException(member.Span, $"Cannot get the member {this} for a null object.");
			}
			IObjectAccessor memberAccessor = context.GetMemberAccessor(obj);
			string name = member.Name;
			if (!memberAccessor.TryGetValue(context, member.Span, obj, name, out object value))
			{
				bool? flag = context.TryGetMember?.Invoke(context, member.Span, obj, name, out value);
				if (!context.EnableRelaxedMemberAccess && (!flag.HasValue || !flag.Value))
				{
					throw new ScriptRuntimeException(member.Span, "Cannot get member with name " + name + ".");
				}
			}
			return value;
		}

		public virtual async ValueTask SetValueAsync(TemplateContext context, object? valueToSet)
		{
			ScriptVariable member = Member;
			if ((object)member == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid member expression. Member is required.");
			}
			object obj = await GetTargetObjectAsync(context, isSet: true).ConfigureAwait(continueOnCapturedContext: false);
			if (obj == null)
			{
				throw new ScriptRuntimeException(member.Span, $"Object `{Target}` is null. Cannot access member: {this}");
			}
			if (!context.GetMemberAccessor(obj).TrySetValue(member: member.Name, context: context, span: member.Span, target: obj, value: valueToSet))
			{
				throw new ScriptRuntimeException(member.Span, $"Cannot set a value for the readonly member: {this}");
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Target, 
				1 => DotToken, 
				2 => Member, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptMemberExpression()
		{
			_dotToken.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return context.GetValue(this);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Target != null)
			{
				printer.Write(Target);
			}
			printer.Write(DotToken);
			if ((object)Member != null)
			{
				printer.Write(Member);
			}
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public virtual object? GetValue(TemplateContext context)
		{
			ScriptVariable member = Member;
			if ((object)member == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid member expression. Member is required.");
			}
			object targetObject = GetTargetObject(context, isSet: false);
			if (targetObject == null)
			{
				if (context.EnableRelaxedTargetAccess || DotToken.TokenType == TokenType.QuestionDot)
				{
					return null;
				}
				throw new ScriptRuntimeException(member.Span, $"Cannot get the member {this} for a null object.");
			}
			IObjectAccessor memberAccessor = context.GetMemberAccessor(targetObject);
			string name = member.Name;
			if (!memberAccessor.TryGetValue(context, member.Span, targetObject, name, out object value))
			{
				bool? flag = context.TryGetMember?.Invoke(context, member.Span, targetObject, name, out value);
				if (!context.EnableRelaxedMemberAccess && (!flag.HasValue || !flag.Value))
				{
					throw new ScriptRuntimeException(member.Span, "Cannot get member with name " + name + ".");
				}
			}
			return value;
		}

		public virtual void SetValue(TemplateContext context, object? valueToSet)
		{
			ScriptVariable member = Member;
			if ((object)member == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid member expression. Member is required.");
			}
			object targetObject = GetTargetObject(context, isSet: true);
			if (targetObject == null)
			{
				throw new ScriptRuntimeException(member.Span, $"Object `{Target}` is null. Cannot access member: {this}");
			}
			if (!context.GetMemberAccessor(targetObject).TrySetValue(member: member.Name, context: context, span: member.Span, target: targetObject, value: valueToSet))
			{
				throw new ScriptRuntimeException(member.Span, $"Cannot set a value for the readonly member: {this}");
			}
		}

		public virtual string GetFirstPath()
		{
			return (Target as IScriptVariablePath)?.GetFirstPath() ?? string.Empty;
		}

		private object? GetTargetObject(TemplateContext context, bool isSet)
		{
			ScriptVariable member = Member;
			ScriptExpression target = Target;
			if ((object)member == null || target == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid member expression. Target and member are required.");
			}
			object? value = context.GetValue(target);
			if (value == null && (isSet || (!context.EnableRelaxedMemberAccess && DotToken.TokenType != TokenType.QuestionDot)))
			{
				throw new ScriptRuntimeException(member.Span, $"Object `{target}` is null. Cannot access member: {this}");
			}
			return value;
		}
	}
	public class ScriptNamedArgument : ScriptExpression
	{
		private ScriptVariable? _name;

		private ScriptToken? _colonToken;

		private ScriptExpression? _value;

		public override int ChildrenCount => 3;

		public ScriptVariable? Name
		{
			get
			{
				return _name;
			}
			set
			{
				ParentToThisNullable(ref _name, value);
			}
		}

		public ScriptToken? ColonToken
		{
			get
			{
				return _colonToken;
			}
			set
			{
				ParentToThisNullable(ref _colonToken, value);
			}
		}

		public ScriptExpression? Value
		{
			get
			{
				return _value;
			}
			set
			{
				ParentToThisNullable(ref _value, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Value != null)
			{
				return await context.EvaluateAsync(Value).ConfigureAwait(continueOnCapturedContext: false);
			}
			return true;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Name, 
				1 => ColonToken, 
				2 => Value, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Value != null)
			{
				return context.Evaluate(Value);
			}
			return true;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if ((object)Name == null)
			{
				return;
			}
			printer.Write(Name);
			if (Value != null)
			{
				if (ColonToken != null)
				{
					printer.Write(ColonToken);
				}
				printer.Write(Value);
			}
		}
	}
	[ScriptSyntax("nested expression", "(<expression>)")]
	public class ScriptNestedExpression : ScriptExpression, IScriptVariablePath
	{
		private ScriptExpression? _expression;

		private ScriptToken _openParen = ScriptToken.OpenParen();

		private ScriptToken _closeParen = ScriptToken.CloseParen();

		public override int ChildrenCount => 3;

		public ScriptToken OpenParen
		{
			get
			{
				return _openParen;
			}
			set
			{
				ParentToThis(ref _openParen, value);
			}
		}

		public ScriptExpression? Expression
		{
			get
			{
				return _expression;
			}
			set
			{
				ParentToThisNullable(ref _expression, value);
			}
		}

		public ScriptToken CloseParen
		{
			get
			{
				return _closeParen;
			}
			set
			{
				ParentToThis(ref _closeParen, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Expression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid nested expression. Inner expression is required.");
			}
			context.PushPipeArguments();
			try
			{
				return await context.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
			}
			finally
			{
				if (context.CurrentPipeArguments != null)
				{
					context.PopPipeArguments();
				}
			}
		}

		public async ValueTask<object?> GetValueAsync(TemplateContext context)
		{
			if (Expression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid nested expression. Inner expression is required.");
			}
			return await context.EvaluateAsync(Expression).ConfigureAwait(continueOnCapturedContext: false);
		}

		public async ValueTask SetValueAsync(TemplateContext context, object? valueToSet)
		{
			if (Expression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid nested expression. Inner expression is required.");
			}
			await context.SetValueAsync(Expression, valueToSet).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => OpenParen, 
				1 => Expression, 
				2 => CloseParen, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptNestedExpression()
		{
			_openParen.Parent = this;
			_closeParen.Parent = this;
		}

		public ScriptNestedExpression(ScriptExpression expression)
			: this()
		{
			Expression = expression;
		}

		public static ScriptNestedExpression Wrap(ScriptExpression expression, bool transferTrivia = false)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			ScriptNestedExpression scriptNestedExpression = new ScriptNestedExpression
			{
				Span = expression.Span,
				Expression = expression
			};
			if (!transferTrivia)
			{
				return scriptNestedExpression;
			}
			expression.FindFirstTerminal()?.MoveLeadingTriviasTo(scriptNestedExpression.OpenParen);
			expression.FindLastTerminal()?.MoveTrailingTriviasTo(scriptNestedExpression.CloseParen, before: true);
			return scriptNestedExpression;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Expression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid nested expression. Inner expression is required.");
			}
			context.PushPipeArguments();
			try
			{
				return context.GetValue(this);
			}
			finally
			{
				if (context.CurrentPipeArguments != null)
				{
					context.PopPipeArguments();
				}
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(OpenParen);
			if (Expression != null)
			{
				printer.Write(Expression);
			}
			printer.Write(CloseParen);
		}

		public object? GetValue(TemplateContext context)
		{
			if (Expression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid nested expression. Inner expression is required.");
			}
			return context.Evaluate(Expression);
		}

		public void SetValue(TemplateContext context, object? valueToSet)
		{
			if (Expression == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid nested expression. Inner expression is required.");
			}
			context.SetValue(Expression, valueToSet);
		}

		public string GetFirstPath()
		{
			return (Expression as IScriptVariablePath)?.GetFirstPath() ?? string.Empty;
		}
	}
	[ScriptSyntax("object initializer expression", "{ member1: <expression>, member2: ... }")]
	public class ScriptObjectInitializerExpression : ScriptExpression
	{
		private ScriptToken _openBrace;

		private ScriptList<ScriptObjectMember> _members;

		private ScriptToken _closeBrace;

		public override int ChildrenCount => 3;

		public ScriptToken OpenBrace
		{
			get
			{
				return _openBrace;
			}
			set
			{
				ParentToThis(ref _openBrace, value);
			}
		}

		public ScriptList<ScriptObjectMember> Members
		{
			get
			{
				return _members;
			}
			set
			{
				ParentToThis(ref _members, value);
			}
		}

		public ScriptToken CloseBrace
		{
			get
			{
				return _closeBrace;
			}
			set
			{
				ParentToThis(ref _closeBrace, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			ScriptObject obj = new ScriptObject();
			context.PushGlobalOnly(obj);
			try
			{
				foreach (ScriptObjectMember member in Members)
				{
					await member.EvaluateAsync(context).ConfigureAwait(continueOnCapturedContext: false);
				}
				return obj;
			}
			finally
			{
				context.PopGlobalOnly();
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => OpenBrace, 
				1 => Members, 
				2 => CloseBrace, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptObjectInitializerExpression()
		{
			_openBrace = ScriptToken.OpenBrace();
			_openBrace.Parent = this;
			_members = new ScriptList<ScriptObjectMember>();
			_members.Parent = this;
			_closeBrace = ScriptToken.CloseBrace();
			_closeBrace.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			ScriptObject scriptObject = new ScriptObject();
			context.PushGlobalOnly(scriptObject);
			try
			{
				foreach (ScriptObjectMember member in Members)
				{
					member.Evaluate(context);
				}
				return scriptObject;
			}
			finally
			{
				context.PopGlobalOnly();
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(OpenBrace);
			printer.WriteListWithCommas(Members);
			printer.Write(CloseBrace);
		}
	}
	public class ScriptObjectMember : ScriptNode
	{
		private ScriptExpression? _name;

		private ScriptExpression? _value;

		private ScriptToken _colonToken = ScriptToken.Colon();

		public override int ChildrenCount => 3;

		public ScriptExpression? Name
		{
			get
			{
				return _name;
			}
			set
			{
				ParentToThisNullable(ref _name, value);
			}
		}

		public ScriptToken ColonToken
		{
			get
			{
				return _colonToken;
			}
			set
			{
				ParentToThis(ref _colonToken, value);
			}
		}

		public ScriptExpression? Value
		{
			get
			{
				return _value;
			}
			set
			{
				ParentToThisNullable(ref _value, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Name == null || Value == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid object member. Name and value are required.");
			}
			ScriptVariable obj = Name as ScriptVariable;
			ScriptLiteral scriptLiteral = Name as ScriptLiteral;
			string obj2 = obj?.Name ?? scriptLiteral?.Value?.ToString();
			if (string.IsNullOrEmpty(obj2))
			{
				throw new ScriptRuntimeException(Span, "Object member name cannot be empty.");
			}
			IScriptObject scriptObject = context.CurrentGlobal ?? throw new ScriptRuntimeException(Span, "No current global object is available.");
			if (obj2 == null)
			{
				throw new ScriptRuntimeException(Span, "Object member name cannot be empty.");
			}
			string text = obj2;
			IScriptObject scriptObject2 = scriptObject;
			SourceSpan span = Span;
			string member = text;
			scriptObject2.TrySetValue(context, span, member, await context.EvaluateAsync(Value).ConfigureAwait(continueOnCapturedContext: false), readOnly: false);
			return null;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Name, 
				1 => ColonToken, 
				2 => Value, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptObjectMember()
		{
			_colonToken.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Name == null || Value == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid object member. Name and value are required.");
			}
			ScriptVariable obj = Name as ScriptVariable;
			ScriptLiteral scriptLiteral = Name as ScriptLiteral;
			string text = obj?.Name ?? scriptLiteral?.Value?.ToString();
			if (string.IsNullOrEmpty(text))
			{
				throw new ScriptRuntimeException(Span, "Object member name cannot be empty.");
			}
			(context.CurrentGlobal ?? throw new ScriptRuntimeException(Span, "No current global object is available.")).TrySetValue(member: text ?? throw new ScriptRuntimeException(Span, "Object member name cannot be empty."), context: context, span: Span, value: context.Evaluate(Value), readOnly: false);
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Name != null)
			{
				printer.Write(Name);
			}
			printer.Write(ColonToken);
			if (Value != null)
			{
				printer.Write(Value);
			}
		}
	}
	public class ScriptPage : ScriptNode
	{
		private ScriptFrontMatter? _frontMatter;

		private ScriptBlockStatement? _body;

		public override int ChildrenCount => 2;

		public ScriptFrontMatter? FrontMatter
		{
			get
			{
				return _frontMatter;
			}
			set
			{
				ParentToThisNullable(ref _frontMatter, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			context.FlowState = ScriptFlowState.None;
			try
			{
				return (Body != null) ? (await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false)) : null;
			}
			finally
			{
				context.FlowState = ScriptFlowState.None;
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => FrontMatter, 
				1 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			context.FlowState = ScriptFlowState.None;
			try
			{
				return (Body == null) ? null : context.Evaluate(Body);
			}
			finally
			{
				context.FlowState = ScriptFlowState.None;
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Body != null)
			{
				printer.Write(Body);
			}
		}
	}
	[ScriptSyntax("pipe expression", "<expression> | <expression>")]
	public class ScriptPipeCall : ScriptExpression
	{
		private ScriptExpression? _from;

		private ScriptToken? _pipeToken;

		private ScriptExpression? _to;

		public override int ChildrenCount => 3;

		public ScriptExpression? From
		{
			get
			{
				return _from;
			}
			set
			{
				ParentToThisNullable(ref _from, value);
			}
		}

		public ScriptToken? PipeToken
		{
			get
			{
				return _pipeToken;
			}
			set
			{
				ParentToThisNullable(ref _pipeToken, value);
			}
		}

		public ScriptExpression? To
		{
			get
			{
				return _to;
			}
			set
			{
				ParentToThisNullable(ref _to, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			ScriptExpression from = From;
			ScriptExpression to = To;
			if (from == null || to == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid pipe expression. Source and destination are required.");
			}
			bool newPipe = context.CurrentPipeArguments == null;
			try
			{
				if (newPipe)
				{
					context.PushPipeArguments();
				}
				ScriptPipeArguments pipeArguments = context.CurrentPipeArguments ?? throw new ScriptRuntimeException(Span, "Pipe arguments were not initialized.");
				pipeArguments.Push(from);
				object obj = await context.EvaluateAsync(to).ConfigureAwait(continueOnCapturedContext: false);
				if (obj is IScriptCustomFunction && pipeArguments.Count > 0 && pipeArguments.Peek() == from)
				{
					obj = await ScriptFunctionCall.CallAsync(context, to, obj, processPipeArguments: true, null).ConfigureAwait(continueOnCapturedContext: false);
				}
				if (pipeArguments.Count > 0 && pipeArguments.Peek() == from)
				{
					throw new ScriptRuntimeException(to.Span, $"Pipe expression destination `{to}` is not a valid function ");
				}
				return obj;
			}
			catch
			{
				newPipe = false;
				context.ClearPipeArguments();
				throw;
			}
			finally
			{
				if (newPipe)
				{
					context.PopPipeArguments();
				}
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => From, 
				1 => PipeToken, 
				2 => To, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			ScriptExpression scriptExpression = From;
			ScriptExpression to = To;
			if (scriptExpression == null || to == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid pipe expression. Source and destination are required.");
			}
			bool flag = context.CurrentPipeArguments == null;
			try
			{
				if (flag)
				{
					context.PushPipeArguments();
				}
				ScriptPipeArguments scriptPipeArguments = context.CurrentPipeArguments ?? throw new ScriptRuntimeException(Span, "Pipe arguments were not initialized.");
				scriptPipeArguments.Push(scriptExpression);
				object obj = context.Evaluate(to);
				if (obj is IScriptCustomFunction && scriptPipeArguments.Count > 0 && scriptPipeArguments.Peek() == scriptExpression)
				{
					obj = ScriptFunctionCall.Call(context, to, obj, processPipeArguments: true, null);
				}
				if (scriptPipeArguments.Count > 0 && scriptPipeArguments.Peek() == scriptExpression)
				{
					throw new ScriptRuntimeException(to.Span, $"Pipe expression destination `{to}` is not a valid function ");
				}
				return obj;
			}
			catch
			{
				flag = false;
				context.ClearPipeArguments();
				throw;
			}
			finally
			{
				if (flag)
				{
					context.PopPipeArguments();
				}
			}
		}

		public override bool CanHaveLeadingTrivia()
		{
			return false;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (From != null)
			{
				printer.Write(From);
			}
			if (PipeToken != null)
			{
				printer.Write(PipeToken);
			}
			if (To != null)
			{
				printer.Write(To);
			}
		}
	}
	[ScriptSyntax("raw statement", "<raw_text>")]
	public class ScriptRawStatement : ScriptStatement
	{
		public override int ChildrenCount => 0;

		public ScriptStringSlice Text { get; set; }

		public bool IsEscape { get; set; }

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Text.Length == 0 || string.IsNullOrEmpty(Text.FullText))
			{
				return null;
			}
			if (Text.Length > 0)
			{
				if (!context.EnableOutput)
				{
					return Text.ToString();
				}
				await context.WriteAsync(Text).ConfigureAwait(continueOnCapturedContext: false);
			}
			return null;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Text.Length == 0 || string.IsNullOrEmpty(Text.FullText))
			{
				return null;
			}
			if (Text.Length > 0)
			{
				if (!context.EnableOutput)
				{
					return Text.ToString();
				}
				context.Write(Text);
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Text.Length > 0 && !string.IsNullOrEmpty(Text.FullText))
			{
				printer.Write(Text);
			}
		}
	}
	[ScriptSyntax("return statement", "return <expression>?")]
	public class ScriptReturnStatement : ScriptStatement
	{
		private ScriptExpression? _expression;

		private ScriptKeyword _retKeyword;

		public override int ChildrenCount => 2;

		public ScriptKeyword RetKeyword
		{
			get
			{
				return _retKeyword;
			}
			set
			{
				ParentToThis(ref _retKeyword, value);
			}
		}

		public ScriptExpression? Expression
		{
			get
			{
				return _expression;
			}
			set
			{
				ParentToThisNullable(ref _expression, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			object obj = ((Expression != null) ? (await context.EvaluateAsync(Expression).ConfigureAwait(continueOnCapturedContext: false)) : null);
			object obj2 = obj;
			if (obj2 is ScriptRange values)
			{
				obj2 = new ScriptArray(values);
			}
			context.FlowState = ScriptFlowState.Return;
			return obj2;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => RetKeyword, 
				1 => Expression, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptReturnStatement()
		{
			_retKeyword = ScriptKeyword.Ret();
			_retKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			object obj = ((Expression == null) ? null : context.Evaluate(Expression));
			if (obj is ScriptRange values)
			{
				obj = new ScriptArray(values);
			}
			context.FlowState = ScriptFlowState.Return;
			return obj;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(RetKeyword).ExpectSpace();
			printer.Write(Expression).ExpectEos();
		}
	}
	public class ScriptTableRowStatement : ScriptForStatement
	{
		protected class TableRowLoopState : LoopState
		{
			public int Col { get; set; }

			public bool ColFirst { get; set; }

			public bool ColLast { get; set; }

			public override bool Contains(string member)
			{
				if (!base.Contains(member))
				{
					switch (member)
					{
					case "col":
					case "col0":
					case "col_first":
					case "col_last":
						return true;
					default:
						return false;
					}
				}
				return true;
			}

			public override bool TryGetValue(TemplateContext context, SourceSpan span, string member, out object? value)
			{
				if (!base.TryGetValue(context, span, member, out value))
				{
					switch (member)
					{
					case "col":
						value = (context.IsLiquid ? (Col + 1) : Col);
						return true;
					case "col0":
						value = Col;
						return true;
					case "col_first":
						value = (ColFirst ? BoxHelper.TrueObject : BoxHelper.FalseObject);
						return true;
					case "col_last":
						value = (ColLast ? BoxHelper.TrueObject : BoxHelper.FalseObject);
						return true;
					default:
						return false;
					}
				}
				return true;
			}
		}

		private int _columnsCount;

		public override int ChildrenCount => 7;

		protected override async ValueTask AfterLoopAsync(TemplateContext context)
		{
			await context.Write("</tr>").WriteLineAsync().ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override async ValueTask BeforeLoopAsync(TemplateContext context)
		{
			await context.WriteAsync("<tr class=\"row1\">").ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override async ValueTask<object?> LoopItemAsync(TemplateContext context, LoopState state)
		{
			int localIndex = state.Index;
			int columnIndex = localIndex % _columnsCount;
			TableRowLoopState obj = (TableRowLoopState)state;
			obj.Col = columnIndex;
			obj.ColFirst = columnIndex == 0;
			obj.ColLast = (localIndex + 1) % _columnsCount == 0;
			if (columnIndex == 0 && localIndex > 0)
			{
				await context.Write("</tr>").WriteAsync(context.NewLine).ConfigureAwait(continueOnCapturedContext: false);
				int num = localIndex / _columnsCount + 1;
				await context.Write("<tr class=\"row").Write(num.ToString(CultureInfo.InvariantCulture)).WriteAsync("\">")
					.ConfigureAwait(continueOnCapturedContext: false);
			}
			await context.Write("<td class=\"col").Write((columnIndex + 1).ToString(CultureInfo.InvariantCulture)).WriteAsync("\">")
				.ConfigureAwait(continueOnCapturedContext: false);
			object result = await base.LoopItemAsync(context, state).ConfigureAwait(continueOnCapturedContext: false);
			await context.WriteAsync("</td>").ConfigureAwait(continueOnCapturedContext: false);
			return result;
		}

		protected override async ValueTask ProcessArgumentAsync(TemplateContext context, ScriptNamedArgument argument)
		{
			_columnsCount = 1;
			if (argument.Name?.Name == "cols")
			{
				if (argument.Value == null)
				{
					throw new ScriptRuntimeException(argument.Span, "Invalid `cols` argument. Value is required.");
				}
				SourceSpan span = argument.Value.Span;
				_columnsCount = context.ToInt(span, await context.EvaluateAsync(argument.Value).ConfigureAwait(continueOnCapturedContext: false));
				if (_columnsCount <= 0)
				{
					_columnsCount = 1;
				}
			}
			else
			{
				await base.ProcessArgumentAsync(context, argument).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => base.ForOrTableRowKeyword, 
				1 => base.Variable, 
				2 => base.InKeyword, 
				3 => base.Iterator, 
				4 => base.NamedArguments, 
				5 => base.Body, 
				6 => base.Else, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptTableRowStatement()
		{
			_columnsCount = 1;
		}

		protected override ScriptVariable GetLoopVariable(TemplateContext context)
		{
			return ScriptVariable.TablerowObject;
		}

		protected override void ProcessArgument(TemplateContext context, ScriptNamedArgument argument)
		{
			_columnsCount = 1;
			if (argument.Name?.Name == "cols")
			{
				if (argument.Value == null)
				{
					throw new ScriptRuntimeException(argument.Span, "Invalid `cols` argument. Value is required.");
				}
				_columnsCount = context.ToInt(argument.Value.Span, context.Evaluate(argument.Value));
				if (_columnsCount <= 0)
				{
					_columnsCount = 1;
				}
			}
			else
			{
				base.ProcessArgument(context, argument);
			}
		}

		protected override void BeforeLoop(TemplateContext context)
		{
			context.Write("<tr class=\"row1\">");
		}

		protected override void AfterLoop(TemplateContext context)
		{
			context.Write("</tr>").WriteLine();
		}

		protected override object? LoopItem(TemplateContext context, LoopState state)
		{
			int index = state.Index;
			int num = index % _columnsCount;
			TableRowLoopState obj = (TableRowLoopState)state;
			obj.Col = num;
			obj.ColFirst = num == 0;
			obj.ColLast = (index + 1) % _columnsCount == 0;
			if (num == 0 && index > 0)
			{
				context.Write("</tr>").Write(context.NewLine);
				int num2 = index / _columnsCount + 1;
				context.Write("<tr class=\"row").Write(num2.ToString(CultureInfo.InvariantCulture)).Write("\">");
			}
			context.Write("<td class=\"col").Write((num + 1).ToString(CultureInfo.InvariantCulture)).Write("\">");
			object? result = base.LoopItem(context, state);
			context.Write("</td>");
			return result;
		}

		protected override LoopState CreateLoopState()
		{
			return new TableRowLoopState();
		}
	}
	[ScriptSyntax("this expression", "this")]
	public class ScriptThisExpression : ScriptExpression, IScriptVariablePath
	{
		private ScriptKeyword _thisKeyword;

		public override int ChildrenCount => 1;

		public ScriptKeyword ThisKeyword
		{
			get
			{
				return _thisKeyword;
			}
			set
			{
				ParentToThis(ref _thisKeyword, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return await context.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return ThisKeyword;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptThisExpression()
		{
			_thisKeyword = ScriptKeyword.This();
			_thisKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return context.GetValue(this);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(ThisKeyword);
		}

		public object? GetValue(TemplateContext context)
		{
			return context.CurrentGlobal;
		}

		public void SetValue(TemplateContext context, object? valueToSet)
		{
			throw new ScriptRuntimeException(Span, "Cannot set this variable");
		}

		public string GetFirstPath()
		{
			return "this";
		}

		public ValueTask<object?> GetValueAsync(TemplateContext context)
		{
			return new ValueTask<object>(context.CurrentGlobal);
		}

		public ValueTask SetValueAsync(TemplateContext context, object? valueToSet)
		{
			throw new ScriptRuntimeException(Span, "Cannot set this variable");
		}
	}
	[ScriptSyntax("unary expression", "<operator> <expression>")]
	public class ScriptUnaryExpression : ScriptExpression
	{
		private ScriptToken? _operatorToken;

		private ScriptExpression? _right;

		public override int ChildrenCount => 2;

		public ScriptUnaryOperator Operator { get; set; }

		public ScriptToken? OperatorToken
		{
			get
			{
				return _operatorToken;
			}
			set
			{
				ParentToThisNullable(ref _operatorToken, value);
			}
		}

		public string? OperatorAsText => OperatorToken?.Value ?? Operator.ToText();

		public ScriptExpression? Right
		{
			get
			{
				return _right;
			}
			set
			{
				ParentToThisNullable(ref _right, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Operator == ScriptUnaryOperator.FunctionAlias)
			{
				return await context.EvaluateAsync(Right, aliasReturnedFunction: true).ConfigureAwait(continueOnCapturedContext: false);
			}
			if (Right == null)
			{
				return Evaluate(context, Span, Operator, null);
			}
			object value = await context.EvaluateAsync(Right).ConfigureAwait(continueOnCapturedContext: false);
			return Evaluate(context, Right.Span, Operator, value);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => OperatorToken, 
				1 => Right, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Operator == ScriptUnaryOperator.FunctionAlias)
			{
				return context.Evaluate(Right, aliasReturnedFunction: true);
			}
			if (Right == null)
			{
				return Evaluate(context, Span, Operator, null);
			}
			object value = context.Evaluate(Right);
			return Evaluate(context, Right.Span, Operator, value);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (OperatorToken != null)
			{
				printer.Write(OperatorToken);
			}
			else
			{
				printer.Write(Operator.ToText());
			}
			printer.Write(Right);
		}

		public static object? Evaluate(TemplateContext context, SourceSpan span, ScriptUnaryOperator op, object? value)
		{
			if (value is IScriptCustomUnaryOperation scriptCustomUnaryOperation)
			{
				if (scriptCustomUnaryOperation.TryEvaluate(context, span, op, value, out object result))
				{
					return result;
				}
			}
			else
			{
				switch (op)
				{
				case ScriptUnaryOperator.Not:
					if (context.UseScientific)
					{
						if (!(value is bool))
						{
							throw new ScriptRuntimeException(span, $"Expecting a boolean instead of {context.GetTypeName(value)} value: {value}");
						}
						return !(bool)value;
					}
					return !context.ToBool(span, value);
				case ScriptUnaryOperator.Negate:
				case ScriptUnaryOperator.Plus:
				{
					bool flag = op == ScriptUnaryOperator.Negate;
					if (value == null)
					{
						break;
					}
					if (value is int)
					{
						if (!flag)
						{
							return value;
						}
						return -(int)value;
					}
					if (value is double)
					{
						if (!flag)
						{
							return value;
						}
						return 0.0 - (double)value;
					}
					if (value is float)
					{
						if (!flag)
						{
							return value;
						}
						return 0f - (float)value;
					}
					if (value is long)
					{
						if (!flag)
						{
							return value;
						}
						return -(long)value;
					}
					if (value is decimal)
					{
						if (!flag)
						{
							return value;
						}
						return -(decimal)value;
					}
					if (value is BigInteger)
					{
						if (!flag)
						{
							return value;
						}
						return -(BigInteger)value;
					}
					throw new ScriptRuntimeException(span, $"Unexpected value `{value} / Type: {context.GetTypeName(value)}`. Cannot negate(-)/positive(+) a non-numeric value");
				}
				case ScriptUnaryOperator.FunctionParametersExpand:
					return value;
				}
			}
			throw new ScriptRuntimeException(span, "Operator `" + op.ToText() + "` is not supported");
		}

		public static ScriptUnaryExpression Wrap(ScriptUnaryOperator unaryOperator, ScriptToken unaryToken, ScriptExpression expression, bool transferTrivia)
		{
			if (expression == null)
			{
				throw new ArgumentNullException("expression");
			}
			ScriptUnaryExpression scriptUnaryExpression = new ScriptUnaryExpression
			{
				Span = expression.Span,
				Operator = unaryOperator,
				OperatorToken = unaryToken,
				Right = expression
			};
			if (!transferTrivia)
			{
				return scriptUnaryExpression;
			}
			expression.FindFirstTerminal()?.MoveLeadingTriviasTo(scriptUnaryExpression.OperatorToken);
			return scriptUnaryExpression;
		}
	}
	[ScriptSyntax("variable", "<variable_name>")]
	public abstract class ScriptVariable : ScriptExpression, IScriptVariablePath, IEquatable<ScriptVariable>, IScriptTerminal
	{
		private int _hashCode;

		public static readonly ScriptVariableLocal Arguments = new ScriptVariableLocal(string.Empty);

		public static readonly ScriptVariableLocal BlockDelegate = new ScriptVariableLocal("$");

		public static readonly ScriptVariableLocal Continue = new ScriptVariableLocal("continue");

		public static readonly ScriptVariableGlobal ForObject = new ScriptVariableGlobal("for");

		public static readonly ScriptVariableGlobal TablerowObject = new ScriptVariableGlobal("tablerow");

		public static readonly ScriptVariableGlobal WhileObject = new ScriptVariableGlobal("while");

		public ScriptTrivias Trivias { get; set; }

		public string BaseName { get; }

		public string Name { get; }

		public ScriptVariableScope Scope { get; }

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return await context.GetValueAsync((ScriptExpression?)this).ConfigureAwait(continueOnCapturedContext: false);
		}

		public virtual async ValueTask<object?> GetValueAsync(TemplateContext context)
		{
			return await context.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected ScriptVariable(string name, ScriptVariableScope scope)
		{
			BaseName = name;
			Scope = scope;
			Trivias = new ScriptTrivias();
			switch (scope)
			{
			case ScriptVariableScope.Global:
				Name = name;
				break;
			case ScriptVariableScope.Local:
				Name = "$" + name;
				break;
			default:
				throw new InvalidOperationException($"Scope `{scope}` is not supported");
			}
			_hashCode = (BaseName.GetHashCode() * 397) ^ (int)Scope;
		}

		public static ScriptVariable Create(string name, ScriptVariableScope scope)
		{
			return scope switch
			{
				ScriptVariableScope.Global => new ScriptVariableGlobal(name), 
				ScriptVariableScope.Local => new ScriptVariableLocal(name), 
				_ => throw new InvalidOperationException($"Scope `{scope}` is not supported"), 
			};
		}

		public string GetFirstPath()
		{
			return Name;
		}

		public ValueTask SetValueAsync(TemplateContext context, object? valueToSet)
		{
			return context.SetValueAsync(this, valueToSet);
		}

		public virtual bool Equals(ScriptVariable? other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			if (string.Equals(Name, other.Name))
			{
				return Scope == other.Scope;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (this == obj)
			{
				return true;
			}
			if (obj is ScriptVariable)
			{
				return Equals((ScriptVariable)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _hashCode;
		}

		public static bool operator ==(ScriptVariable left, ScriptVariable right)
		{
			return object.Equals(left, right);
		}

		public static bool operator !=(ScriptVariable left, ScriptVariable right)
		{
			return !object.Equals(left, right);
		}

		public override object? Evaluate(TemplateContext context)
		{
			return context.GetValue((ScriptExpression?)this);
		}

		public virtual object? GetValue(TemplateContext context)
		{
			return context.GetValue(this);
		}

		public void SetValue(TemplateContext context, object? valueToSet)
		{
			context.SetValue(this, valueToSet);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(Name);
		}
	}
	public class ScriptVariableGlobal : ScriptVariable
	{
		public override int ChildrenCount => 0;

		public override async ValueTask<object?> GetValueAsync(TemplateContext context)
		{
			return await context.GetValueAsync(this).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptVariableGlobal(string name)
			: base(name, ScriptVariableScope.Global)
		{
		}

		public override object? GetValue(TemplateContext context)
		{
			return context.GetValue(this);
		}
	}
	[ScriptSyntax("when statement", "when <expression> ... end|when|else")]
	public class ScriptWhenStatement : ScriptConditionStatement
	{
		private ScriptKeyword _whenKeyword;

		private ScriptList<ScriptExpression> _values;

		private ScriptBlockStatement? _body;

		private ScriptConditionStatement? _next;

		public override int ChildrenCount => 4;

		public ScriptKeyword WhenKeyword
		{
			get
			{
				return _whenKeyword;
			}
			set
			{
				ParentToThis(ref _whenKeyword, value);
			}
		}

		public ScriptList<ScriptExpression> Values
		{
			get
			{
				return _values;
			}
			set
			{
				ParentToThis(ref _values, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public ScriptConditionStatement? Next
		{
			get
			{
				return _next;
			}
			set
			{
				ParentToThisNullable(ref _next, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			object caseValue = context.PeekCase();
			bool booleanResult = default(bool);
			foreach (ScriptExpression value in Values)
			{
				object rightValue = await context.EvaluateAsync(value).ConfigureAwait(continueOnCapturedContext: false);
				object obj = ScriptBinaryExpression.Evaluate(context, Span, ScriptBinaryOperator.CompareEqual, caseValue, rightValue);
				int num;
				if (obj is bool)
				{
					booleanResult = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (booleanResult ? 1u : 0u)) != 0)
				{
					return (Body != null) ? (await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false)) : null;
				}
			}
			return (Next != null) ? (await context.EvaluateAsync(Next).ConfigureAwait(continueOnCapturedContext: false)) : null;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => WhenKeyword, 
				1 => Values, 
				2 => Body, 
				3 => Next, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptWhenStatement()
		{
			_whenKeyword = ScriptKeyword.When();
			_whenKeyword.Parent = this;
			_values = new ScriptList<ScriptExpression>();
			_values.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			object leftValue = context.PeekCase();
			bool flag = default(bool);
			foreach (ScriptExpression value in Values)
			{
				object rightValue = context.Evaluate(value);
				object obj = ScriptBinaryExpression.Evaluate(context, Span, ScriptBinaryOperator.CompareEqual, leftValue, rightValue);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (flag ? 1u : 0u)) != 0)
				{
					return (Body == null) ? null : context.Evaluate(Body);
				}
			}
			if (Next != null)
			{
				return context.Evaluate(Next);
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(WhenKeyword).ExpectSpace();
			printer.WriteListWithCommas(Values);
			printer.ExpectEos();
			printer.Write(Body).ExpectEos();
			printer.Write(Next);
		}
	}
	[ScriptSyntax("while statement", "while <expression> ... end")]
	public class ScriptWhileStatement : ScriptLoopStatementBase
	{
		private ScriptKeyword _whileKeyword;

		private ScriptExpression? _condition;

		private ScriptBlockStatement? _body;

		public override int ChildrenCount => 3;

		public ScriptKeyword WhileKeyword
		{
			get
			{
				return _whileKeyword;
			}
			set
			{
				ParentToThis(ref _whileKeyword, value);
			}
		}

		public ScriptExpression? Condition
		{
			get
			{
				return _condition;
			}
			set
			{
				ParentToThisNullable(ref _condition, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		protected override async ValueTask<object?> EvaluateImplAsync(TemplateContext context)
		{
			int index = 0;
			object result = null;
			await BeforeLoopAsync(context).ConfigureAwait(continueOnCapturedContext: false);
			LoopState loopState = CreateLoopState();
			context.SetLoopVariable(ScriptVariable.WhileObject, loopState);
			while (context.StepLoop(this) && Condition != null)
			{
				SourceSpan span = Condition.Span;
				if (!context.ToBool(span, await context.EvaluateAsync(Condition).ConfigureAwait(continueOnCapturedContext: false)))
				{
					break;
				}
				loopState.Index = index++;
				result = await LoopItemAsync(context, loopState).ConfigureAwait(continueOnCapturedContext: false);
				if (!ContinueLoop(context))
				{
					break;
				}
			}
			await AfterLoopAsync(context).ConfigureAwait(continueOnCapturedContext: false);
			return result;
		}

		protected override async ValueTask<object?> LoopItemAsync(TemplateContext context, LoopState state)
		{
			return (Body != null) ? (await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false)) : null;
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => WhileKeyword, 
				1 => Condition, 
				2 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptWhileStatement()
		{
			_whileKeyword = ScriptKeyword.While();
			_whileKeyword.Parent = this;
		}

		protected override object? LoopItem(TemplateContext context, LoopState state)
		{
			if (Body != null)
			{
				return context.Evaluate(Body);
			}
			return null;
		}

		protected override object? EvaluateImpl(TemplateContext context)
		{
			int num = 0;
			object result = null;
			BeforeLoop(context);
			LoopState loopState = CreateLoopState();
			context.SetLoopVariable(ScriptVariable.WhileObject, loopState);
			while (context.StepLoop(this) && Condition != null && context.ToBool(Condition.Span, context.Evaluate(Condition)))
			{
				loopState.Index = num++;
				result = LoopItem(context, loopState);
				if (!ContinueLoop(context))
				{
					break;
				}
			}
			AfterLoop(context);
			return result;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(WhileKeyword).ExpectSpace();
			printer.Write(Condition);
			printer.ExpectEos();
			printer.Write(Body).ExpectEos();
		}
	}
	[ScriptSyntax("with statement", "with <variable> ... end")]
	public class ScriptWithStatement : ScriptStatement
	{
		private ScriptKeyword _withKeyword;

		private ScriptExpression? _name;

		private ScriptBlockStatement? _body;

		public override int ChildrenCount => 3;

		public ScriptKeyword WithKeyword
		{
			get
			{
				return _withKeyword;
			}
			set
			{
				ParentToThis(ref _withKeyword, value);
			}
		}

		public ScriptExpression? Name
		{
			get
			{
				return _name;
			}
			set
			{
				ParentToThisNullable(ref _name, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			if (Name == null)
			{
				return null;
			}
			object obj = await context.GetValueAsync(Name).ConfigureAwait(continueOnCapturedContext: false);
			if (!(obj is IScriptObject scriptObject))
			{
				string arg = obj?.GetType().Name ?? "null";
				throw new ScriptRuntimeException(Name.Span, $"Invalid target property `{Name}` used for [with] statement. Must be a ScriptObject instead of `{arg}`");
			}
			context.PushGlobal(scriptObject);
			try
			{
				return (Body != null) ? (await context.EvaluateAsync(Body).ConfigureAwait(continueOnCapturedContext: false)) : null;
			}
			finally
			{
				context.PopGlobal();
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => WithKeyword, 
				1 => Name, 
				2 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptWithStatement()
		{
			_withKeyword = ScriptKeyword.With();
			_withKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (Name == null)
			{
				return null;
			}
			object value = context.GetValue(Name);
			if (!(value is IScriptObject scriptObject))
			{
				string arg = value?.GetType().Name ?? "null";
				throw new ScriptRuntimeException(Name.Span, $"Invalid target property `{Name}` used for [with] statement. Must be a ScriptObject instead of `{arg}`");
			}
			context.PushGlobal(scriptObject);
			try
			{
				return (Body == null) ? null : context.Evaluate(Body);
			}
			finally
			{
				context.PopGlobal();
			}
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(WithKeyword).ExpectSpace();
			printer.Write(Name);
			printer.ExpectEos();
			printer.Write(Body).ExpectEos();
		}
	}
	[ScriptSyntax("wrap statement", "wrap <function_call> ... end")]
	public class ScriptWrapStatement : ScriptStatement
	{
		private ScriptKeyword _wrapKeyword = ScriptKeyword.Wrap();

		private ScriptExpression? _target;

		private ScriptBlockStatement? _body;

		public override int ChildrenCount => 3;

		public ScriptKeyword WrapKeyword
		{
			get
			{
				return _wrapKeyword;
			}
			set
			{
				ParentToThis(ref _wrapKeyword, value);
			}
		}

		public ScriptExpression? Target
		{
			get
			{
				return _target;
			}
			set
			{
				ParentToThisNullable(ref _target, value);
			}
		}

		public ScriptBlockStatement? Body
		{
			get
			{
				return _body;
			}
			set
			{
				ParentToThisNullable(ref _body, value);
			}
		}

		public override async ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			ScriptExpression target = Target;
			ScriptBlockStatement body = Body;
			if (target == null || body == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid wrap statement. Target and body are required.");
			}
			if (!(target is ScriptFunctionCall scriptNode))
			{
				object obj = await context.EvaluateAsync(target, aliasReturnedFunction: true).ConfigureAwait(continueOnCapturedContext: false);
				if (!(obj is IScriptCustomFunction))
				{
					ScriptSyntaxAttribute scriptSyntaxAttribute = ScriptSyntaxAttribute.Get(target);
					throw new ScriptRuntimeException(target.Span, string.Format("Expecting a direct function instead of the expression `{0}/{1}`", target, scriptSyntaxAttribute?.TypeName ?? "unknown"));
				}
				context.BlockDelegates.Push(body);
				return await ScriptFunctionCall.CallAsync(context, this, obj, processPipeArguments: false, null).ConfigureAwait(continueOnCapturedContext: false);
			}
			context.BlockDelegates.Push(body);
			return await context.EvaluateAsync(scriptNode).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => WrapKeyword, 
				1 => Target, 
				2 => Body, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptWrapStatement()
		{
			_wrapKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			ScriptExpression target = Target;
			ScriptBlockStatement body = Body;
			if (target == null || body == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid wrap statement. Target and body are required.");
			}
			if (!(target is ScriptFunctionCall scriptNode))
			{
				object obj = context.Evaluate(target, aliasReturnedFunction: true);
				if (!(obj is IScriptCustomFunction))
				{
					ScriptSyntaxAttribute scriptSyntaxAttribute = ScriptSyntaxAttribute.Get(target);
					throw new ScriptRuntimeException(target.Span, string.Format("Expecting a direct function instead of the expression `{0}/{1}`", target, scriptSyntaxAttribute?.TypeName ?? "unknown"));
				}
				context.BlockDelegates.Push(body);
				return ScriptFunctionCall.Call(context, this, obj, processPipeArguments: false, null);
			}
			context.BlockDelegates.Push(body);
			return context.Evaluate(scriptNode);
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(WrapKeyword).ExpectSpace();
			if (Target != null)
			{
				printer.Write(Target);
			}
			printer.ExpectEos();
			if (Body != null)
			{
				printer.Write(Body).ExpectEos();
			}
		}
	}
	public class ScriptAnonymousFunction : ScriptExpression
	{
		private ScriptFunction? _function;

		public override int ChildrenCount => 1;

		public ScriptFunction? Function
		{
			get
			{
				return _function;
			}
			set
			{
				ParentToThisNullable(ref _function, value);
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return Function;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			return Function;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Function != null)
			{
				printer.Write(Function);
			}
		}
	}
	public class ScriptArgumentBinary : ScriptExpression
	{
		private ScriptToken? _operatorToken;

		public override int ChildrenCount => 1;

		public ScriptBinaryOperator Operator { get; set; }

		public ScriptToken? OperatorToken
		{
			get
			{
				return _operatorToken;
			}
			set
			{
				ParentToThisNullable(ref _operatorToken, value);
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return OperatorToken;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			throw new InvalidOperationException("This node should not be evaluated");
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (OperatorToken != null)
			{
				printer.Write(OperatorToken);
			}
			else
			{
				printer.Write(Operator.ToText());
			}
		}
	}
	[ScriptSyntax("break statement", "break")]
	public class ScriptBreakStatement : ScriptStatement
	{
		private ScriptKeyword _breakKeyword = ScriptKeyword.Break();

		public override int ChildrenCount => 1;

		public ScriptKeyword BreakKeyword
		{
			get
			{
				return _breakKeyword;
			}
			set
			{
				ParentToThis(ref _breakKeyword, value);
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return BreakKeyword;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptBreakStatement()
		{
			_breakKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (context.IsInLoop)
			{
				context.FlowState = ScriptFlowState.Break;
			}
			else
			{
				if (!context.EnableBreakAndContinueAsReturnOutsideLoop)
				{
					throw new ScriptRuntimeException(Span, "The <break> statement can only be used inside for/while loops");
				}
				context.FlowState = ScriptFlowState.Return;
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(BreakKeyword).ExpectEos();
		}
	}
	[ScriptSyntax("continue statement", "continue")]
	public class ScriptContinueStatement : ScriptStatement
	{
		private ScriptKeyword _continueKeyword = ScriptKeyword.Continue();

		public override int ChildrenCount => 1;

		public ScriptKeyword ContinueKeyword
		{
			get
			{
				return _continueKeyword;
			}
			set
			{
				ParentToThis(ref _continueKeyword, value);
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return ContinueKeyword;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptContinueStatement()
		{
			_continueKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if (context.IsInLoop)
			{
				context.FlowState = ScriptFlowState.Continue;
			}
			else
			{
				if (!context.EnableBreakAndContinueAsReturnOutsideLoop)
				{
					throw new ScriptRuntimeException(Span, "The <continue> statement can only be used inside for/while loops");
				}
				context.FlowState = ScriptFlowState.Return;
			}
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(ContinueKeyword).ExpectEos();
		}
	}
	[ScriptSyntax("end statement", "end")]
	public class ScriptEndStatement : ScriptStatement
	{
		private ScriptKeyword _endKeyword = ScriptKeyword.End();

		public override int ChildrenCount => 1;

		public ScriptKeyword EndKeyword
		{
			get
			{
				return _endKeyword;
			}
			set
			{
				ParentToThis(ref _endKeyword, value);
			}
		}

		public bool ExpectEos { get; set; }

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return EndKeyword;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptEndStatement()
		{
			_endKeyword.Parent = this;
			base.CanSkipEvaluation = true;
			ExpectEos = true;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(EndKeyword);
			if (ExpectEos)
			{
				printer.ExpectEos();
			}
		}
	}
	[ScriptSyntax("{{ or }}", "{{ or }}")]
	public class ScriptEscapeStatement : ScriptStatement, IScriptTerminal
	{
		public override int ChildrenCount => 0;

		public ScriptTrivias Trivias { get; set; }

		public ScriptWhitespaceMode WhitespaceMode { get; set; }

		public string Indent { get; set; }

		public bool IsEntering { get; set; }

		public bool IsClosing => !IsEntering;

		public int EscapeCount { get; set; }

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptEscapeStatement()
		{
			Trivias = new ScriptTrivias();
			Indent = string.Empty;
			base.CanSkipEvaluation = true;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (IsEntering)
			{
				printer.WriteEnterCode(EscapeCount);
				WriteWhitespaceMode(printer);
			}
			else
			{
				WriteWhitespaceMode(printer);
				printer.WriteExitCode(EscapeCount);
			}
		}

		private void WriteWhitespaceMode(ScriptPrinter printer)
		{
			switch (WhitespaceMode)
			{
			case ScriptWhitespaceMode.Greedy:
				printer.Write("-");
				break;
			case ScriptWhitespaceMode.NonGreedy:
				printer.Write("~");
				break;
			default:
				throw new ArgumentOutOfRangeException();
			case ScriptWhitespaceMode.None:
				break;
			}
		}
	}
	public class ScriptIdentifier : ScriptVerbatim
	{
		public override int ChildrenCount => 0;

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptIdentifier()
		{
		}

		public ScriptIdentifier(string value)
			: base(value)
		{
		}
	}
	public class ScriptKeyword : ScriptVerbatim
	{
		public override int ChildrenCount => 0;

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public static ScriptKeyword This()
		{
			return new ScriptKeyword("this");
		}

		public static ScriptKeyword Func()
		{
			return new ScriptKeyword("func");
		}

		public static ScriptKeyword Do()
		{
			return new ScriptKeyword("do");
		}

		public static ScriptKeyword Break()
		{
			return new ScriptKeyword("break");
		}

		public static ScriptKeyword Capture()
		{
			return new ScriptKeyword("capture");
		}

		public static ScriptKeyword Case()
		{
			return new ScriptKeyword("case");
		}

		public static ScriptKeyword Continue()
		{
			return new ScriptKeyword("continue");
		}

		public static ScriptKeyword Else()
		{
			return new ScriptKeyword("else");
		}

		public static ScriptKeyword End()
		{
			return new ScriptKeyword("end");
		}

		public static ScriptKeyword If()
		{
			return new ScriptKeyword("if");
		}

		public static ScriptKeyword In()
		{
			return new ScriptKeyword("in");
		}

		public static ScriptKeyword For()
		{
			return new ScriptKeyword("for");
		}

		public static ScriptKeyword Import()
		{
			return new ScriptKeyword("import");
		}

		public static ScriptKeyword ReadOnly()
		{
			return new ScriptKeyword("readonly");
		}

		public static ScriptKeyword Ret()
		{
			return new ScriptKeyword("ret");
		}

		public static ScriptKeyword TableRow()
		{
			return new ScriptKeyword("tablerow");
		}

		public static ScriptKeyword When()
		{
			return new ScriptKeyword("when");
		}

		public static ScriptKeyword While()
		{
			return new ScriptKeyword("while");
		}

		public static ScriptKeyword With()
		{
			return new ScriptKeyword("with");
		}

		public static ScriptKeyword Wrap()
		{
			return new ScriptKeyword("wrap");
		}

		public ScriptKeyword()
		{
		}

		public ScriptKeyword(string value)
			: base(value)
		{
			base.Value = value;
		}
	}
	[ScriptSyntax("literal", "<value>")]
	public class ScriptLiteral : ScriptExpression, IScriptTerminal
	{
		public override int ChildrenCount => 0;

		public ScriptTrivias Trivias { get; set; }

		public object? Value { get; set; }

		public ScriptLiteralStringQuoteType StringQuoteType { get; set; }

		public TokenType StringTokenType { get; set; } = TokenType.String;

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptLiteral()
		{
			Trivias = new ScriptTrivias();
		}

		public ScriptLiteral(object? value)
		{
			Trivias = new ScriptTrivias();
			Value = value;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return Value;
		}

		public bool IsPositiveInteger()
		{
			if (Value == null)
			{
				return false;
			}
			Type type = Value.GetType();
			if (type == typeof(int))
			{
				return (int)Value >= 0;
			}
			if (type == typeof(byte))
			{
				return true;
			}
			if (type == typeof(sbyte))
			{
				return (sbyte)Value >= 0;
			}
			if (type == typeof(short))
			{
				return (short)Value >= 0;
			}
			if (type == typeof(ushort))
			{
				return true;
			}
			if (type == typeof(uint))
			{
				return true;
			}
			if (type == typeof(long))
			{
				return (long)Value > 0;
			}
			if (type == typeof(ulong))
			{
				return true;
			}
			return false;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			if (Value == null)
			{
				printer.Write("null");
				return;
			}
			Type type = Value.GetType();
			if (type == typeof(string))
			{
				printer.Write(ToLiteral(StringQuoteType, StringTokenType, (string)Value));
				return;
			}
			if (type == typeof(bool))
			{
				printer.Write(((bool)Value) ? "true" : "false");
				return;
			}
			if (type == typeof(int))
			{
				printer.Write(((int)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(double))
			{
				printer.Write(AppendDecimalPoint(((double)Value).ToString("R", CultureInfo.InvariantCulture), hasNaN: true));
				return;
			}
			if (type == typeof(float))
			{
				printer.Write(AppendDecimalPoint(((float)Value).ToString("R", CultureInfo.InvariantCulture), hasNaN: true));
				printer.Write("f");
				return;
			}
			if (type == typeof(decimal))
			{
				printer.Write(AppendDecimalPoint(((decimal)Value).ToString(CultureInfo.InvariantCulture), hasNaN: true));
				printer.Write("m");
				return;
			}
			if (type == typeof(byte))
			{
				printer.Write(((byte)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(sbyte))
			{
				printer.Write(((sbyte)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(short))
			{
				printer.Write(((short)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(ushort))
			{
				printer.Write(((ushort)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(uint))
			{
				printer.Write(((uint)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(long))
			{
				printer.Write(((long)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(ulong))
			{
				printer.Write(((uint)Value).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(char))
			{
				string text = Value.ToString();
				printer.Write(ToLiteral(ScriptLiteralStringQuoteType.SimpleQuote, StringTokenType, text ?? string.Empty));
				return;
			}
			string text2 = Value.ToString();
			if (text2 != null)
			{
				printer.Write(text2);
			}
		}

		private static string ToLiteral(ScriptLiteralStringQuoteType quoteType, TokenType stringTokenType, string input)
		{
			char c = quoteType switch
			{
				ScriptLiteralStringQuoteType.DoubleQuote => '"', 
				ScriptLiteralStringQuoteType.SimpleQuote => '\'', 
				ScriptLiteralStringQuoteType.Verbatim => '`', 
				_ => throw new ArgumentOutOfRangeException("quoteType"), 
			};
			StringBuilder stringBuilder = new StringBuilder(input.Length + 2);
			if (stringTokenType == TokenType.BeginInterpolatedString || stringTokenType == TokenType.InterpolatedString)
			{
				stringBuilder.Capacity = input.Length + 3;
				stringBuilder.Append('$');
			}
			if (stringTokenType == TokenType.BeginInterpolatedString || stringTokenType == TokenType.String || stringTokenType == TokenType.InterpolatedString)
			{
				stringBuilder.Append(c);
			}
			if (quoteType == ScriptLiteralStringQuoteType.Verbatim)
			{
				stringBuilder.Append(input.Replace("`", "``"));
			}
			else
			{
				foreach (char c2 in input)
				{
					switch (c2)
					{
					case '\\':
						stringBuilder.Append("\\\\");
						continue;
					case '\0':
						stringBuilder.Append("\\0");
						continue;
					case '\a':
						stringBuilder.Append("\\a");
						continue;
					case '\b':
						stringBuilder.Append("\\b");
						continue;
					case '\f':
						stringBuilder.Append("\\f");
						continue;
					case '\n':
						stringBuilder.Append("\\n");
						continue;
					case '\r':
						stringBuilder.Append("\\r");
						continue;
					case '\t':
						stringBuilder.Append("\\t");
						continue;
					case '\v':
						stringBuilder.Append("\\v");
						continue;
					case '{':
						if (stringTokenType.IsInterpolationStringToken())
						{
							stringBuilder.Append("\\{");
							continue;
						}
						break;
					}
					if (c2 == c)
					{
						stringBuilder.Append('\\').Append(c2);
					}
					else if (char.IsControl(c2))
					{
						stringBuilder.Append("\\u");
						ushort num = c2;
						stringBuilder.Append(num.ToString("x4"));
					}
					else
					{
						stringBuilder.Append(c2);
					}
				}
			}
			if (stringTokenType == TokenType.EndingInterpolatedString || stringTokenType == TokenType.String || stringTokenType == TokenType.InterpolatedString)
			{
				stringBuilder.Append(c);
			}
			return stringBuilder.ToString();
		}

		private static string AppendDecimalPoint(string text, bool hasNaN)
		{
			foreach (char c in text)
			{
				if (c == 'e' || c == 'E' || c == '.')
				{
					return text;
				}
			}
			if (hasNaN && (string.Equals(text, "NaN") || text.Contains("Infinity")))
			{
				return text;
			}
			return text + ".0";
		}
	}
	public class ScriptNopStatement : ScriptStatement
	{
		public override int ChildrenCount => 0;

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
		}
	}
	public class ScriptParameter : ScriptNode
	{
		private ScriptVariable? _name;

		private ScriptToken? _equalOrTripleDotToken;

		private ScriptLiteral? _defaultValue;

		public override int ChildrenCount => 3;

		public ScriptVariable? Name
		{
			get
			{
				return _name;
			}
			set
			{
				ParentToThisNullable(ref _name, value);
			}
		}

		public ScriptToken? EqualOrTripleDotToken
		{
			get
			{
				return _equalOrTripleDotToken;
			}
			set
			{
				ParentToThisNullable(ref _equalOrTripleDotToken, value);
			}
		}

		public ScriptLiteral? DefaultValue
		{
			get
			{
				return _defaultValue;
			}
			set
			{
				ParentToThisNullable(ref _defaultValue, value);
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => Name, 
				1 => EqualOrTripleDotToken, 
				2 => DefaultValue, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public override object? Evaluate(TemplateContext context)
		{
			throw new InvalidOperationException("A parameter should not be evaluated directly");
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(Name);
			if (EqualOrTripleDotToken != null)
			{
				printer.Write(EqualOrTripleDotToken);
				if (EqualOrTripleDotToken.TokenType == TokenType.Equal && DefaultValue != null)
				{
					printer.Write(DefaultValue);
				}
			}
		}
	}
	[ScriptSyntax("readonly statement", "readonly <variable>")]
	public class ScriptReadOnlyStatement : ScriptStatement
	{
		private ScriptVariable? _variable;

		private ScriptKeyword _readOnlyKeyword = ScriptKeyword.ReadOnly();

		public override int ChildrenCount => 2;

		public ScriptKeyword ReadOnlyKeyword
		{
			get
			{
				return _readOnlyKeyword;
			}
			set
			{
				ParentToThis(ref _readOnlyKeyword, value);
			}
		}

		public ScriptVariable? Variable
		{
			get
			{
				return _variable;
			}
			set
			{
				ParentToThisNullable(ref _variable, value);
			}
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return index switch
			{
				0 => ReadOnlyKeyword, 
				1 => Variable, 
				_ => null, 
			};
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptReadOnlyStatement()
		{
			_readOnlyKeyword.Parent = this;
		}

		public override object? Evaluate(TemplateContext context)
		{
			if ((object)Variable == null)
			{
				throw new ScriptRuntimeException(Span, "Invalid readonly statement. Variable is required.");
			}
			context.SetReadOnly(Variable);
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(ReadOnlyKeyword).ExpectSpace();
			if ((object)Variable != null)
			{
				printer.Write(Variable);
			}
			printer.ExpectEos();
		}
	}
	public class ScriptToken : ScriptVerbatim
	{
		public override int ChildrenCount => 0;

		public TokenType TokenType { get; set; }

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public static ScriptToken SemiColon()
		{
			return new ScriptToken(TokenType.SemiColon);
		}

		public static ScriptToken Arroba()
		{
			return new ScriptToken(TokenType.Arroba);
		}

		public static ScriptToken Caret()
		{
			return new ScriptToken(TokenType.Caret);
		}

		public static ScriptToken DoubleCaret()
		{
			return new ScriptToken(TokenType.DoubleCaret);
		}

		public static ScriptToken Colon()
		{
			return new ScriptToken(TokenType.Colon);
		}

		public static ScriptToken Equal()
		{
			return new ScriptToken(TokenType.Equal);
		}

		public static ScriptToken Pipe()
		{
			return new ScriptToken(TokenType.VerticalBar);
		}

		public static ScriptToken PipeGreater()
		{
			return new ScriptToken(TokenType.PipeGreater);
		}

		public static ScriptToken Exclamation()
		{
			return new ScriptToken(TokenType.Exclamation);
		}

		public static ScriptToken DoubleAmp()
		{
			return new ScriptToken(TokenType.DoubleAmp);
		}

		public static ScriptToken DoublePipe()
		{
			return new ScriptToken(TokenType.DoubleVerticalBar);
		}

		public static ScriptToken Amp()
		{
			return new ScriptToken(TokenType.Amp);
		}

		public static ScriptToken Question()
		{
			return new ScriptToken(TokenType.Question);
		}

		public static ScriptToken DoubleQuestion()
		{
			return new ScriptToken(TokenType.DoubleQuestion);
		}

		public static ScriptToken QuestionExclamation()
		{
			return new ScriptToken(TokenType.QuestionExclamation);
		}

		public static ScriptToken CompareEqual()
		{
			return new ScriptToken(TokenType.DoubleEqual);
		}

		public static ScriptToken CompareNotEqual()
		{
			return new ScriptToken(TokenType.ExclamationEqual);
		}

		public static ScriptToken CompareLess()
		{
			return new ScriptToken(TokenType.Less);
		}

		public static ScriptToken CompareGreater()
		{
			return new ScriptToken(TokenType.Greater);
		}

		public static ScriptToken CompareLessOrEqual()
		{
			return new ScriptToken(TokenType.LessEqual);
		}

		public static ScriptToken CompareGreaterOrEqual()
		{
			return new ScriptToken(TokenType.GreaterEqual);
		}

		public static ScriptToken Divide()
		{
			return new ScriptToken(TokenType.Divide);
		}

		public static ScriptToken DivideEqual()
		{
			return new ScriptToken(TokenType.DivideEqual);
		}

		public static ScriptToken DoubleDivide()
		{
			return new ScriptToken(TokenType.DoubleDivide);
		}

		public static ScriptToken DoubleDivideEqual()
		{
			return new ScriptToken(TokenType.DoubleDivideEqual);
		}

		public static ScriptToken Star()
		{
			return new ScriptToken(TokenType.Asterisk);
		}

		public static ScriptToken StarEqual()
		{
			return new ScriptToken(TokenType.AsteriskEqual);
		}

		public static ScriptToken Plus()
		{
			return new ScriptToken(TokenType.Plus);
		}

		public static ScriptToken PlusEqual()
		{
			return new ScriptToken(TokenType.PlusEqual);
		}

		public static ScriptToken Minus()
		{
			return new ScriptToken(TokenType.Minus);
		}

		public static ScriptToken MinusEqual()
		{
			return new ScriptToken(TokenType.MinusEqual);
		}

		public static ScriptToken Modulus()
		{
			return new ScriptToken(TokenType.Percent);
		}

		public static ScriptToken ModulusEqual()
		{
			return new ScriptToken(TokenType.PercentEqual);
		}

		public static ScriptToken DoubleLess()
		{
			return new ScriptToken(TokenType.DoubleLessThan);
		}

		public static ScriptToken DoubleGreater()
		{
			return new ScriptToken(TokenType.DoubleGreaterThan);
		}

		public static ScriptToken Comma()
		{
			return new ScriptToken(TokenType.Comma);
		}

		public static ScriptToken Dot()
		{
			return new ScriptToken(TokenType.Dot);
		}

		public static ScriptToken DoubleDot()
		{
			return new ScriptToken(TokenType.DoubleDot);
		}

		public static ScriptToken TripleDot()
		{
			return new ScriptToken(TokenType.TripleDot);
		}

		public static ScriptToken DoubleDotLess()
		{
			return new ScriptToken(TokenType.DoubleDotLess);
		}

		public static ScriptToken OpenParen()
		{
			return new ScriptToken(TokenType.OpenParen);
		}

		public static ScriptToken CloseParen()
		{
			return new ScriptToken(TokenType.CloseParen);
		}

		public static ScriptToken OpenBrace()
		{
			return new ScriptToken(TokenType.OpenBrace);
		}

		public static ScriptToken CloseBrace()
		{
			return new ScriptToken(TokenType.CloseBrace);
		}

		public static ScriptToken OpenBracket()
		{
			return new ScriptToken(TokenType.OpenBracket);
		}

		public static ScriptToken CloseBracket()
		{
			return new ScriptToken(TokenType.CloseBracket);
		}

		public static ScriptToken OpenInterpBrace()
		{
			return new ScriptToken(TokenType.OpenInterpolatedBrace);
		}

		public static ScriptToken CloseInterpBrace()
		{
			return new ScriptToken(TokenType.CloseInterpolatedBrace);
		}

		public ScriptToken()
		{
		}

		public ScriptToken(TokenType type)
		{
			TokenType = type;
			base.Value = type.ToText() ?? string.Empty;
		}
	}
	public class ScriptVariableLocal : ScriptVariable
	{
		public override int ChildrenCount => 0;

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return null;
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public ScriptVariableLocal(string name)
			: base(name, ScriptVariableScope.Local)
		{
		}
	}
	public abstract class ScriptRewriter : ScriptVisitor<ScriptNode?>
	{
		public bool CopyTrivias { get; set; }

		public override ScriptNode Visit(ScriptAnonymousFunction node)
		{
			ScriptFunction function = (ScriptFunction)Visit((ScriptNode?)node.Function);
			return new ScriptAnonymousFunction
			{
				Function = function
			};
		}

		public override ScriptNode Visit(ScriptArgumentBinary node)
		{
			ScriptToken operatorToken = (ScriptToken)Visit((ScriptNode?)node.OperatorToken);
			return new ScriptArgumentBinary
			{
				OperatorToken = operatorToken,
				Operator = node.Operator
			};
		}

		public override ScriptNode Visit(ScriptArrayInitializerExpression node)
		{
			ScriptToken openBracketToken = (ScriptToken)Visit((ScriptNode?)node.OpenBracketToken);
			ScriptList<ScriptExpression> values = VisitAll(node.Values);
			ScriptToken closeBracketToken = (ScriptToken)Visit((ScriptNode?)node.CloseBracketToken);
			return new ScriptArrayInitializerExpression
			{
				OpenBracketToken = openBracketToken,
				Values = values,
				CloseBracketToken = closeBracketToken
			};
		}

		public override ScriptNode Visit(ScriptAssignExpression node)
		{
			ScriptExpression target = (ScriptExpression)Visit(node.Target);
			ScriptToken equalToken = (ScriptToken)Visit((ScriptNode?)node.EqualToken);
			ScriptExpression value = (ScriptExpression)Visit(node.Value);
			return new ScriptAssignExpression
			{
				Target = target,
				EqualToken = equalToken,
				Value = value
			};
		}

		public override ScriptNode Visit(ScriptBinaryExpression node)
		{
			ScriptExpression left = (ScriptExpression)Visit(node.Left);
			ScriptToken operatorToken = (ScriptToken)Visit((ScriptNode?)node.OperatorToken);
			ScriptExpression right = (ScriptExpression)Visit(node.Right);
			return new ScriptBinaryExpression
			{
				Left = left,
				OperatorToken = operatorToken,
				Right = right,
				Operator = node.Operator
			};
		}

		public override ScriptNode Visit(ScriptBlockStatement node)
		{
			ScriptList<ScriptStatement> statements = VisitAll(node.Statements);
			return new ScriptBlockStatement
			{
				Statements = statements
			};
		}

		public override ScriptNode Visit(ScriptBreakStatement node)
		{
			ScriptKeyword breakKeyword = (ScriptKeyword)Visit((ScriptNode?)node.BreakKeyword);
			return new ScriptBreakStatement
			{
				BreakKeyword = breakKeyword
			};
		}

		public override ScriptNode Visit(ScriptCaptureStatement node)
		{
			ScriptKeyword captureKeyword = (ScriptKeyword)Visit((ScriptNode?)node.CaptureKeyword);
			ScriptExpression target = (ScriptExpression)Visit(node.Target);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			return new ScriptCaptureStatement
			{
				CaptureKeyword = captureKeyword,
				Target = target,
				Body = body
			};
		}

		public override ScriptNode Visit(ScriptCaseStatement node)
		{
			ScriptKeyword caseKeyword = (ScriptKeyword)Visit((ScriptNode?)node.CaseKeyword);
			ScriptExpression value = (ScriptExpression)Visit(node.Value);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			return new ScriptCaseStatement
			{
				CaseKeyword = caseKeyword,
				Value = value,
				Body = body
			};
		}

		public override ScriptNode Visit(ScriptConditionalExpression node)
		{
			ScriptExpression condition = (ScriptExpression)Visit(node.Condition);
			ScriptToken questionToken = (ScriptToken)Visit((ScriptNode?)node.QuestionToken);
			ScriptExpression thenValue = (ScriptExpression)Visit(node.ThenValue);
			ScriptToken colonToken = (ScriptToken)Visit((ScriptNode?)node.ColonToken);
			ScriptExpression elseValue = (ScriptExpression)Visit(node.ElseValue);
			return new ScriptConditionalExpression
			{
				Condition = condition,
				QuestionToken = questionToken,
				ThenValue = thenValue,
				ColonToken = colonToken,
				ElseValue = elseValue
			};
		}

		public override ScriptNode Visit(ScriptContinueStatement node)
		{
			ScriptKeyword continueKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ContinueKeyword);
			return new ScriptContinueStatement
			{
				ContinueKeyword = continueKeyword
			};
		}

		public override ScriptNode Visit(ScriptElseStatement node)
		{
			ScriptKeyword elseKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ElseKeyword);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			return new ScriptElseStatement
			{
				ElseKeyword = elseKeyword,
				Body = body
			};
		}

		public override ScriptNode Visit(ScriptEndStatement node)
		{
			ScriptKeyword endKeyword = (ScriptKeyword)Visit((ScriptNode?)node.EndKeyword);
			return new ScriptEndStatement
			{
				EndKeyword = endKeyword,
				ExpectEos = node.ExpectEos
			};
		}

		public override ScriptNode Visit(ScriptEscapeStatement node)
		{
			return new ScriptEscapeStatement
			{
				WhitespaceMode = node.WhitespaceMode,
				Indent = node.Indent,
				IsEntering = node.IsEntering,
				EscapeCount = node.EscapeCount
			};
		}

		public override ScriptNode Visit(ScriptExpressionStatement node)
		{
			ScriptExpression expression = (ScriptExpression)Visit(node.Expression);
			return new ScriptExpressionStatement
			{
				Expression = expression
			};
		}

		public override ScriptNode Visit(ScriptForStatement node)
		{
			ScriptKeyword forOrTableRowKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ForOrTableRowKeyword);
			ScriptExpression variable = (ScriptExpression)Visit(node.Variable);
			ScriptKeyword inKeyword = (ScriptKeyword)Visit((ScriptNode?)node.InKeyword);
			ScriptExpression iterator = (ScriptExpression)Visit(node.Iterator);
			ScriptList<ScriptNamedArgument> namedArguments = VisitAll(node.NamedArguments);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			ScriptElseStatement scriptElseStatement = (ScriptElseStatement)Visit((ScriptNode?)node.Else);
			return new ScriptForStatement
			{
				ForOrTableRowKeyword = forOrTableRowKeyword,
				Variable = variable,
				InKeyword = inKeyword,
				Iterator = iterator,
				NamedArguments = namedArguments,
				Body = body,
				Else = scriptElseStatement,
				SetContinue = node.SetContinue
			};
		}

		public override ScriptNode Visit(ScriptFrontMatter node)
		{
			ScriptToken startMarker = (ScriptToken)Visit((ScriptNode?)node.StartMarker);
			ScriptBlockStatement statements = (ScriptBlockStatement)Visit((ScriptNode?)node.Statements);
			ScriptToken endMarker = (ScriptToken)Visit((ScriptNode?)node.EndMarker);
			return new ScriptFrontMatter
			{
				StartMarker = startMarker,
				Statements = statements,
				EndMarker = endMarker
			};
		}

		public override ScriptNode Visit(ScriptFunction node)
		{
			ScriptKeyword funcToken = (ScriptKeyword)Visit((ScriptNode?)node.FuncToken);
			ScriptNode nameOrDoToken = Visit(node.NameOrDoToken);
			ScriptToken openParen = (ScriptToken)Visit((ScriptNode?)node.OpenParen);
			ScriptList<ScriptParameter> parameters = VisitAll(node.Parameters);
			ScriptToken closeParen = (ScriptToken)Visit((ScriptNode?)node.CloseParen);
			ScriptToken equalToken = (ScriptToken)Visit((ScriptNode?)node.EqualToken);
			ScriptStatement body = (ScriptStatement)Visit(node.Body);
			return new ScriptFunction
			{
				FuncToken = funcToken,
				NameOrDoToken = nameOrDoToken,
				OpenParen = openParen,
				Parameters = parameters,
				CloseParen = closeParen,
				EqualToken = equalToken,
				Body = body
			};
		}

		public override ScriptNode Visit(ScriptFunctionCall node)
		{
			ScriptExpression target = (ScriptExpression)Visit(node.Target);
			ScriptToken openParent = (ScriptToken)Visit((ScriptNode?)node.OpenParent);
			ScriptList<ScriptExpression> arguments = VisitAll(node.Arguments);
			ScriptToken closeParen = (ScriptToken)Visit((ScriptNode?)node.CloseParen);
			return new ScriptFunctionCall
			{
				Target = target,
				OpenParent = openParent,
				Arguments = arguments,
				CloseParen = closeParen,
				ExplicitCall = node.ExplicitCall
			};
		}

		public override ScriptNode Visit(ScriptIdentifier node)
		{
			return new ScriptIdentifier
			{
				Value = node.Value
			};
		}

		public override ScriptNode Visit(ScriptIfStatement node)
		{
			ScriptKeyword elseKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ElseKeyword);
			ScriptKeyword ifKeyword = (ScriptKeyword)Visit((ScriptNode?)node.IfKeyword);
			ScriptExpression condition = (ScriptExpression)Visit(node.Condition);
			ScriptBlockStatement then = (ScriptBlockStatement)Visit((ScriptNode?)node.Then);
			ScriptConditionStatement scriptConditionStatement = (ScriptConditionStatement)Visit(node.Else);
			return new ScriptIfStatement
			{
				ElseKeyword = elseKeyword,
				IfKeyword = ifKeyword,
				Condition = condition,
				Then = then,
				Else = scriptConditionStatement
			};
		}

		public override ScriptNode Visit(ScriptImportStatement node)
		{
			ScriptKeyword importKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ImportKeyword);
			ScriptExpression expression = (ScriptExpression)Visit(node.Expression);
			return new ScriptImportStatement
			{
				ImportKeyword = importKeyword,
				Expression = expression
			};
		}

		public override ScriptNode Visit(ScriptIncrementDecrementExpression node)
		{
			ScriptToken operatorToken = (ScriptToken)Visit((ScriptNode?)node.OperatorToken);
			ScriptExpression right = (ScriptExpression)Visit(node.Right);
			return new ScriptIncrementDecrementExpression
			{
				OperatorToken = operatorToken,
				Right = right,
				Operator = node.Operator,
				Post = node.Post
			};
		}

		public override ScriptNode Visit(ScriptIndexerExpression node)
		{
			ScriptExpression target = (ScriptExpression)Visit(node.Target);
			ScriptToken openBracket = (ScriptToken)Visit((ScriptNode?)node.OpenBracket);
			ScriptExpression index = (ScriptExpression)Visit(node.Index);
			ScriptToken closeBracket = (ScriptToken)Visit((ScriptNode?)node.CloseBracket);
			return new ScriptIndexerExpression
			{
				Target = target,
				OpenBracket = openBracket,
				Index = index,
				CloseBracket = closeBracket
			};
		}

		public override ScriptNode Visit(ScriptInterpolatedExpression node)
		{
			ScriptToken openBrace = (ScriptToken)Visit((ScriptNode?)node.OpenBrace);
			ScriptExpression expression = (ScriptExpression)Visit(node.Expression);
			ScriptToken closeBrace = (ScriptToken)Visit((ScriptNode?)node.CloseBrace);
			return new ScriptInterpolatedExpression
			{
				OpenBrace = openBrace,
				Expression = expression,
				CloseBrace = closeBrace
			};
		}

		public override ScriptNode Visit(ScriptInterpolatedStringExpression node)
		{
			ScriptList<ScriptExpression> parts = VisitAll(node.Parts);
			return new ScriptInterpolatedStringExpression
			{
				Parts = parts
			};
		}

		public override ScriptNode Visit(ScriptIsEmptyExpression node)
		{
			ScriptExpression target = (ScriptExpression)Visit(node.Target);
			ScriptToken dotToken = (ScriptToken)Visit((ScriptNode?)node.DotToken);
			ScriptVariable member = (ScriptVariable)Visit(node.Member);
			ScriptToken questionToken = (ScriptToken)Visit((ScriptNode?)node.QuestionToken);
			return new ScriptIsEmptyExpression
			{
				Target = target,
				DotToken = dotToken,
				Member = member,
				QuestionToken = questionToken
			};
		}

		public override ScriptNode Visit(ScriptKeyword node)
		{
			return new ScriptKeyword
			{
				Value = node.Value
			};
		}

		public override ScriptNode Visit(ScriptLiteral node)
		{
			return new ScriptLiteral
			{
				Value = node.Value,
				StringQuoteType = node.StringQuoteType,
				StringTokenType = node.StringTokenType
			};
		}

		public override ScriptNode Visit(ScriptMemberExpression node)
		{
			ScriptExpression target = (ScriptExpression)Visit(node.Target);
			ScriptToken dotToken = (ScriptToken)Visit((ScriptNode?)node.DotToken);
			ScriptVariable member = (ScriptVariable)Visit(node.Member);
			return new ScriptMemberExpression
			{
				Target = target,
				DotToken = dotToken,
				Member = member
			};
		}

		public override ScriptNode Visit(ScriptNamedArgument node)
		{
			ScriptVariable name = (ScriptVariable)Visit(node.Name);
			ScriptToken colonToken = (ScriptToken)Visit((ScriptNode?)node.ColonToken);
			ScriptExpression value = (ScriptExpression)Visit(node.Value);
			return new ScriptNamedArgument
			{
				Name = name,
				ColonToken = colonToken,
				Value = value
			};
		}

		public override ScriptNode Visit(ScriptNestedExpression node)
		{
			ScriptToken openParen = (ScriptToken)Visit((ScriptNode?)node.OpenParen);
			ScriptExpression expression = (ScriptExpression)Visit(node.Expression);
			ScriptToken closeParen = (ScriptToken)Visit((ScriptNode?)node.CloseParen);
			return new ScriptNestedExpression
			{
				OpenParen = openParen,
				Expression = expression,
				CloseParen = closeParen
			};
		}

		public override ScriptNode Visit(ScriptNopStatement node)
		{
			return new ScriptNopStatement();
		}

		public override ScriptNode Visit(ScriptObjectInitializerExpression node)
		{
			ScriptToken openBrace = (ScriptToken)Visit((ScriptNode?)node.OpenBrace);
			ScriptList<ScriptObjectMember> members = VisitAll(node.Members);
			ScriptToken closeBrace = (ScriptToken)Visit((ScriptNode?)node.CloseBrace);
			return new ScriptObjectInitializerExpression
			{
				OpenBrace = openBrace,
				Members = members,
				CloseBrace = closeBrace
			};
		}

		public override ScriptNode Visit(ScriptObjectMember node)
		{
			ScriptExpression name = (ScriptExpression)Visit(node.Name);
			ScriptToken colonToken = (ScriptToken)Visit((ScriptNode?)node.ColonToken);
			ScriptExpression value = (ScriptExpression)Visit(node.Value);
			return new ScriptObjectMember
			{
				Name = name,
				ColonToken = colonToken,
				Value = value
			};
		}

		public override ScriptNode Visit(ScriptPage node)
		{
			ScriptFrontMatter frontMatter = (ScriptFrontMatter)Visit((ScriptNode?)node.FrontMatter);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			return new ScriptPage
			{
				FrontMatter = frontMatter,
				Body = body
			};
		}

		public override ScriptNode Visit(ScriptParameter node)
		{
			ScriptVariable name = (ScriptVariable)Visit(node.Name);
			ScriptToken equalOrTripleDotToken = (ScriptToken)Visit((ScriptNode?)node.EqualOrTripleDotToken);
			ScriptLiteral defaultValue = (ScriptLiteral)Visit((ScriptNode?)node.DefaultValue);
			return new ScriptParameter
			{
				Name = name,
				EqualOrTripleDotToken = equalOrTripleDotToken,
				DefaultValue = defaultValue
			};
		}

		public override ScriptNode Visit(ScriptPipeCall node)
		{
			ScriptExpression scriptExpression = (ScriptExpression)Visit(node.From);
			ScriptToken pipeToken = (ScriptToken)Visit((ScriptNode?)node.PipeToken);
			ScriptExpression to = (ScriptExpression)Visit(node.To);
			return new ScriptPipeCall
			{
				From = scriptExpression,
				PipeToken = pipeToken,
				To = to
			};
		}

		public override ScriptNode Visit(ScriptRawStatement node)
		{
			return new ScriptRawStatement
			{
				Text = node.Text,
				IsEscape = node.IsEscape
			};
		}

		public override ScriptNode Visit(ScriptReadOnlyStatement node)
		{
			ScriptKeyword readOnlyKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ReadOnlyKeyword);
			ScriptVariable variable = (ScriptVariable)Visit(node.Variable);
			return new ScriptReadOnlyStatement
			{
				ReadOnlyKeyword = readOnlyKeyword,
				Variable = variable
			};
		}

		public override ScriptNode Visit(ScriptReturnStatement node)
		{
			ScriptKeyword retKeyword = (ScriptKeyword)Visit((ScriptNode?)node.RetKeyword);
			ScriptExpression expression = (ScriptExpression)Visit(node.Expression);
			return new ScriptReturnStatement
			{
				RetKeyword = retKeyword,
				Expression = expression
			};
		}

		public override ScriptNode Visit(ScriptTableRowStatement node)
		{
			ScriptKeyword forOrTableRowKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ForOrTableRowKeyword);
			ScriptExpression variable = (ScriptExpression)Visit(node.Variable);
			ScriptKeyword inKeyword = (ScriptKeyword)Visit((ScriptNode?)node.InKeyword);
			ScriptExpression iterator = (ScriptExpression)Visit(node.Iterator);
			ScriptList<ScriptNamedArgument> namedArguments = VisitAll(node.NamedArguments);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			ScriptElseStatement scriptElseStatement = (ScriptElseStatement)Visit((ScriptNode?)node.Else);
			return new ScriptTableRowStatement
			{
				ForOrTableRowKeyword = forOrTableRowKeyword,
				Variable = variable,
				InKeyword = inKeyword,
				Iterator = iterator,
				NamedArguments = namedArguments,
				Body = body,
				Else = scriptElseStatement,
				SetContinue = node.SetContinue
			};
		}

		public override ScriptNode Visit(ScriptThisExpression node)
		{
			ScriptKeyword thisKeyword = (ScriptKeyword)Visit((ScriptNode?)node.ThisKeyword);
			return new ScriptThisExpression
			{
				ThisKeyword = thisKeyword
			};
		}

		public override ScriptNode Visit(ScriptToken node)
		{
			return new ScriptToken
			{
				Value = node.Value,
				TokenType = node.TokenType
			};
		}

		public override ScriptNode Visit(ScriptUnaryExpression node)
		{
			ScriptToken operatorToken = (ScriptToken)Visit((ScriptNode?)node.OperatorToken);
			ScriptExpression right = (ScriptExpression)Visit(node.Right);
			return new ScriptUnaryExpression
			{
				OperatorToken = operatorToken,
				Right = right,
				Operator = node.Operator
			};
		}

		public override ScriptNode Visit(ScriptWhenStatement node)
		{
			ScriptKeyword whenKeyword = (ScriptKeyword)Visit((ScriptNode?)node.WhenKeyword);
			ScriptList<ScriptExpression> values = VisitAll(node.Values);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			ScriptConditionStatement next = (ScriptConditionStatement)Visit(node.Next);
			return new ScriptWhenStatement
			{
				WhenKeyword = whenKeyword,
				Values = values,
				Body = body,
				Next = next
			};
		}

		public override ScriptNode Visit(ScriptWhileStatement node)
		{
			ScriptKeyword whileKeyword = (ScriptKeyword)Visit((ScriptNode?)node.WhileKeyword);
			ScriptExpression condition = (ScriptExpression)Visit(node.Condition);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			return new ScriptWhileStatement
			{
				WhileKeyword = whileKeyword,
				Condition = condition,
				Body = body
			};
		}

		public override ScriptNode Visit(ScriptWithStatement node)
		{
			ScriptKeyword withKeyword = (ScriptKeyword)Visit((ScriptNode?)node.WithKeyword);
			ScriptExpression name = (ScriptExpression)Visit(node.Name);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			return new ScriptWithStatement
			{
				WithKeyword = withKeyword,
				Name = name,
				Body = body
			};
		}

		public override ScriptNode Visit(ScriptWrapStatement node)
		{
			ScriptKeyword wrapKeyword = (ScriptKeyword)Visit((ScriptNode?)node.WrapKeyword);
			ScriptExpression target = (ScriptExpression)Visit(node.Target);
			ScriptBlockStatement body = (ScriptBlockStatement)Visit((ScriptNode?)node.Body);
			return new ScriptWrapStatement
			{
				WrapKeyword = wrapKeyword,
				Target = target,
				Body = body
			};
		}

		protected ScriptRewriter()
		{
			CopyTrivias = true;
		}

		public override ScriptNode? Visit(ScriptNode? node)
		{
			if (node == null)
			{
				return null;
			}
			ScriptNode scriptNode = node.Accept(this);
			if (scriptNode == null)
			{
				return null;
			}
			scriptNode.Span = node.Span;
			if (CopyTrivias && node != scriptNode && node is IScriptTerminal scriptTerminal && scriptNode is IScriptTerminal scriptTerminal2)
			{
				scriptTerminal2.Trivias = scriptTerminal.Trivias;
			}
			return scriptNode;
		}

		public override ScriptNode Visit(ScriptVariableGlobal node)
		{
			return new ScriptVariableGlobal(node.BaseName);
		}

		public override ScriptNode Visit(ScriptVariableLocal node)
		{
			return new ScriptVariableLocal(node.BaseName);
		}

		protected ScriptList<TNode>? VisitAll<TNode>(ScriptList<TNode>? nodes) where TNode : ScriptNode
		{
			if (nodes == null)
			{
				return null;
			}
			ScriptList<TNode> scriptList = new ScriptList<TNode>();
			foreach (TNode node in nodes)
			{
				TNode val = (TNode)Visit(node);
				if (val != null)
				{
					scriptList.Add(val);
				}
			}
			return scriptList;
		}
	}
	public abstract class ScriptVisitor
	{
		public virtual void Visit(ScriptAnonymousFunction node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptArgumentBinary node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptArrayInitializerExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptAssignExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptBinaryExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptBlockStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptBreakStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptCaptureStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptCaseStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptConditionalExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptContinueStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptElseStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptEndStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptEscapeStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptExpressionStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptForStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptFrontMatter node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptFunction node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptFunctionCall node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptIdentifier node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptIfStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptImportStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptIncrementDecrementExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptIndexerExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptInterpolatedExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptInterpolatedStringExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptIsEmptyExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptKeyword node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptLiteral node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptMemberExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptNamedArgument node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptNestedExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptNopStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptObjectInitializerExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptObjectMember node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptPage node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptParameter node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptPipeCall node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptRawStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptReadOnlyStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptReturnStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptTableRowStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptThisExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptToken node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptUnaryExpression node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptVariableGlobal node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptVariableLocal node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptWhenStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptWhileStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptWithStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptWrapStatement node)
		{
			DefaultVisit(node);
		}

		public virtual void Visit(ScriptNode? node)
		{
			node?.Accept(this);
		}

		public virtual void Visit(ScriptList? list)
		{
			if (list != null)
			{
				int childrenCount = list.ChildrenCount;
				for (int i = 0; i < childrenCount; i++)
				{
					ScriptNode node = list[i];
					Visit(node);
				}
			}
		}

		protected virtual void DefaultVisit(ScriptNode? node)
		{
			if (node != null)
			{
				int childrenCount = node.ChildrenCount;
				for (int i = 0; i < childrenCount; i++)
				{
					ScriptNode children = node.GetChildren(i);
					Visit(children);
				}
			}
		}
	}
	public abstract class ScriptVisitor<TResult>
	{
		public virtual TResult Visit(ScriptAnonymousFunction node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptArgumentBinary node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptArrayInitializerExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptAssignExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptBinaryExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptBlockStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptBreakStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptCaptureStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptCaseStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptConditionalExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptContinueStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptElseStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptEndStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptEscapeStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptExpressionStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptForStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptFrontMatter node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptFunction node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptFunctionCall node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptIdentifier node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptIfStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptImportStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptIncrementDecrementExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptIndexerExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptInterpolatedExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptInterpolatedStringExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptIsEmptyExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptKeyword node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptLiteral node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptMemberExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptNamedArgument node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptNestedExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptNopStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptObjectInitializerExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptObjectMember node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptPage node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptParameter node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptPipeCall node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptRawStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptReadOnlyStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptReturnStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptTableRowStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptThisExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptToken node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptUnaryExpression node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptVariableGlobal node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptVariableLocal node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptWhenStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptWhileStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptWithStatement node)
		{
			return DefaultVisit(node);
		}

		public virtual TResult Visit(ScriptWrapStatement node)
		{
			return DefaultVisit(node);
		}

		[return: MaybeNull]
		public virtual TResult Visit(ScriptNode? node)
		{
			if (node == null)
			{
				return default(TResult);
			}
			return node.Accept(this);
		}

		[return: MaybeNull]
		protected virtual TResult DefaultVisit(ScriptNode? node)
		{
			if (node == null)
			{
				return default(TResult);
			}
			int childrenCount = node.ChildrenCount;
			for (int i = 0; i < childrenCount; i++)
			{
				ScriptNode children = node.GetChildren(i);
				Visit(children);
			}
			return default(TResult);
		}
	}
	public interface IScriptTerminal
	{
		ScriptTrivias Trivias { get; set; }
	}
	public enum ScriptBinaryOperator
	{
		None = 0,
		EmptyCoalescing = 1,
		NotEmptyCoalescing = 2,
		Or = 3,
		And = 4,
		BinaryOr = 5,
		BinaryAnd = 6,
		CompareEqual = 7,
		CompareNotEqual = 8,
		CompareLessOrEqual = 9,
		CompareGreaterOrEqual = 10,
		CompareLess = 11,
		CompareGreater = 12,
		LiquidContains = 13,
		LiquidStartsWith = 14,
		LiquidEndsWith = 15,
		LiquidHasKey = 16,
		LiquidHasValue = 17,
		Add = 18,
		Subtract = 19,
		[Obsolete]
		Substract = 19,
		Multiply = 20,
		Divide = 21,
		DivideRound = 22,
		Modulus = 23,
		ShiftLeft = 24,
		ShiftRight = 25,
		Power = 26,
		RangeInclude = 27,
		RangeExclude = 28,
		Custom = 29
	}
	public static class ScriptBinaryOperatorExtensions
	{
		public static ScriptToken ToToken(this ScriptBinaryOperator op)
		{
			return new ScriptToken(op.ToTokenType());
		}

		public static TokenType ToTokenType(this ScriptBinaryOperator op)
		{
			return op switch
			{
				ScriptBinaryOperator.Add => TokenType.Plus, 
				ScriptBinaryOperator.Subtract => TokenType.Minus, 
				ScriptBinaryOperator.Divide => TokenType.Divide, 
				ScriptBinaryOperator.DivideRound => TokenType.DoubleDivide, 
				ScriptBinaryOperator.Multiply => TokenType.Asterisk, 
				ScriptBinaryOperator.Modulus => TokenType.Percent, 
				ScriptBinaryOperator.RangeInclude => TokenType.DoubleDot, 
				ScriptBinaryOperator.RangeExclude => TokenType.DoubleDotLess, 
				ScriptBinaryOperator.CompareEqual => TokenType.DoubleEqual, 
				ScriptBinaryOperator.CompareNotEqual => TokenType.ExclamationEqual, 
				ScriptBinaryOperator.CompareLessOrEqual => TokenType.LessEqual, 
				ScriptBinaryOperator.CompareGreaterOrEqual => TokenType.GreaterEqual, 
				ScriptBinaryOperator.CompareLess => TokenType.Less, 
				ScriptBinaryOperator.CompareGreater => TokenType.Greater, 
				ScriptBinaryOperator.And => TokenType.DoubleAmp, 
				ScriptBinaryOperator.Or => TokenType.DoubleVerticalBar, 
				ScriptBinaryOperator.EmptyCoalescing => TokenType.DoubleQuestion, 
				ScriptBinaryOperator.NotEmptyCoalescing => TokenType.QuestionExclamation, 
				ScriptBinaryOperator.ShiftLeft => TokenType.DoubleLessThan, 
				ScriptBinaryOperator.ShiftRight => TokenType.DoubleGreaterThan, 
				ScriptBinaryOperator.Power => TokenType.Caret, 
				ScriptBinaryOperator.BinaryAnd => TokenType.Amp, 
				ScriptBinaryOperator.BinaryOr => TokenType.VerticalBar, 
				_ => throw new ArgumentOutOfRangeException("op"), 
			};
		}

		public static string ToText(this ScriptBinaryOperator op)
		{
			return op switch
			{
				ScriptBinaryOperator.Add => "+", 
				ScriptBinaryOperator.Subtract => "-", 
				ScriptBinaryOperator.Divide => "/", 
				ScriptBinaryOperator.DivideRound => "//", 
				ScriptBinaryOperator.Multiply => "*", 
				ScriptBinaryOperator.Modulus => "%", 
				ScriptBinaryOperator.RangeInclude => "..", 
				ScriptBinaryOperator.RangeExclude => "..<", 
				ScriptBinaryOperator.CompareEqual => "==", 
				ScriptBinaryOperator.CompareNotEqual => "!=", 
				ScriptBinaryOperator.CompareLessOrEqual => "<=", 
				ScriptBinaryOperator.CompareGreaterOrEqual => ">=", 
				ScriptBinaryOperator.CompareLess => "<", 
				ScriptBinaryOperator.CompareGreater => ">", 
				ScriptBinaryOperator.And => "&&", 
				ScriptBinaryOperator.Or => "||", 
				ScriptBinaryOperator.EmptyCoalescing => "??", 
				ScriptBinaryOperator.NotEmptyCoalescing => "?!", 
				ScriptBinaryOperator.ShiftLeft => "<<", 
				ScriptBinaryOperator.ShiftRight => ">>", 
				ScriptBinaryOperator.LiquidContains => "| string.contains ", 
				ScriptBinaryOperator.LiquidStartsWith => "| string.starts_with ", 
				ScriptBinaryOperator.LiquidEndsWith => "| string.ends_with ", 
				ScriptBinaryOperator.LiquidHasKey => "| object.has_key ", 
				ScriptBinaryOperator.LiquidHasValue => "| object.has_value ", 
				ScriptBinaryOperator.Power => "^", 
				ScriptBinaryOperator.BinaryAnd => "&", 
				ScriptBinaryOperator.BinaryOr => "|", 
				_ => throw new ArgumentOutOfRangeException("op"), 
			};
		}
	}
	public abstract class ScriptExpression : ScriptNode
	{
	}
	public enum ScriptLiteralStringQuoteType
	{
		DoubleQuote,
		SimpleQuote,
		Verbatim
	}
	public enum ScriptUnaryOperator
	{
		None,
		Not,
		Negate,
		Plus,
		FunctionAlias,
		FunctionParametersExpand,
		Increment,
		Decrement,
		Custom
	}
	public static class ScriptUnaryOperatorExtensions
	{
		public static string ToText(this ScriptUnaryOperator op)
		{
			return op switch
			{
				ScriptUnaryOperator.Not => "!", 
				ScriptUnaryOperator.Negate => "-", 
				ScriptUnaryOperator.Plus => "+", 
				ScriptUnaryOperator.FunctionAlias => "@", 
				ScriptUnaryOperator.FunctionParametersExpand => "^", 
				ScriptUnaryOperator.Decrement => "--", 
				ScriptUnaryOperator.Increment => "++", 
				_ => throw new ArgumentOutOfRangeException("op"), 
			};
		}
	}
	public enum ScriptVariableScope
	{
		Global,
		Local
	}
	public interface IScriptConvertibleFrom
	{
		bool TryConvertFrom(TemplateContext context, SourceSpan span, object value);
	}
	public interface IScriptConvertibleTo
	{
		bool TryConvertTo(TemplateContext context, SourceSpan span, Type type, out object value);
	}
	public interface IScriptCustomBinaryOperation
	{
		bool TryEvaluate(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, SourceSpan leftSpan, object? leftValue, SourceSpan rightSpan, object? rightValue, out object? result);
	}
	public interface IScriptCustomImplicitMultiplyPrecedence
	{
	}
	public interface IScriptCustomType : IScriptCustomTypeInfo, IScriptCustomBinaryOperation, IScriptCustomUnaryOperation, IScriptConvertibleTo
	{
	}
	public interface IScriptCustomTypeInfo
	{
		string TypeName { get; }
	}
	public interface IScriptCustomUnaryOperation
	{
		bool TryEvaluate(TemplateContext context, SourceSpan span, ScriptUnaryOperator op, object rightValue, out object result);
	}
	public interface IScriptNamedArgumentContainer
	{
		ScriptList<ScriptNamedArgument> NamedArguments { get; set; }
	}
	public interface IScriptVariablePath
	{
		object? GetValue(TemplateContext context);

		void SetValue(TemplateContext context, object? valueToSet);

		string GetFirstPath();

		ValueTask<object?> GetValueAsync(TemplateContext context);

		ValueTask SetValueAsync(TemplateContext context, object? valueToSet);
	}
	public interface IScriptVisitorContext
	{
		ScriptNode Current { get; }

		ScriptNode Parent { get; }

		IEnumerable<ScriptNode> Ancestors { get; }
	}
	public class ScriptArgumentException : Exception
	{
		public int ArgumentIndex { get; }

		public ScriptArgumentException(int argumentIndex, string message)
			: base(message)
		{
			ArgumentIndex = argumentIndex;
		}
	}
	internal sealed class ScriptCloner : ScriptRewriter
	{
		public static readonly ScriptCloner Instance = new ScriptCloner
		{
			CopyTrivias = false
		};

		public static readonly ScriptCloner WithTrivias = new ScriptCloner
		{
			CopyTrivias = true
		};
	}
	public class ScriptFormatter : ScriptRewriter
	{
		private class CompressWhitespacesVisitor : ScriptVisitor
		{
			private ScriptTrivias? _leftTrivias;

			private ScriptTrivias? _rightTrivias;

			public void CompressSpaces(ScriptNode node)
			{
				_leftTrivias = null;
				_rightTrivias = null;
				node.RemoveLeadingSpace();
				Visit(node);
				if (_rightTrivias != null)
				{
					bool previousHasSpaces = false;
					CompactSpaces(_rightTrivias.After, ref previousHasSpaces);
				}
				node.RemoveTrailingSpace();
			}

			public override void Visit(ScriptNode? node)
			{
				if (node == null)
				{
					return;
				}
				base.Visit(node);
				if (!(node is IScriptTerminal scriptTerminal))
				{
					return;
				}
				ScriptTrivias trivias = scriptTerminal.Trivias;
				if (trivias != null)
				{
					if (_leftTrivias == null)
					{
						_leftTrivias = trivias;
						bool previousHasSpaces = false;
						CompactSpaces(_leftTrivias.Before, ref previousHasSpaces);
						previousHasSpaces = false;
						CompactSpaces(_leftTrivias.After, ref previousHasSpaces);
						return;
					}
					if (_rightTrivias != null)
					{
						_leftTrivias = _rightTrivias;
					}
					_rightTrivias = trivias;
					bool previousHasSpaces2 = false;
					CompactSpaces(_leftTrivias.After, ref previousHasSpaces2);
					CompactSpaces(_rightTrivias.Before, ref previousHasSpaces2);
					previousHasSpaces2 = false;
					CompactSpaces(_rightTrivias.After, ref previousHasSpaces2);
				}
				else
				{
					_leftTrivias = null;
					_rightTrivias = null;
				}
			}

			private static void CompactSpaces(List<ScriptTrivia> trivias, ref bool previousHasSpaces)
			{
				for (int i = 0; i < trivias.Count; i++)
				{
					ScriptTrivia scriptTrivia = trivias[i];
					bool flag = scriptTrivia.Type.IsNewLine();
					if (scriptTrivia.Type.IsSpace() || flag)
					{
						if (flag)
						{
							trivias[i] = scriptTrivia.WithText(scriptTrivia.Text.TrimEndKeepNewLine());
							RemoveSpacesBefore(trivias, ref i);
						}
						else if (previousHasSpaces)
						{
							trivias.RemoveAt(i);
							i--;
						}
						else
						{
							trivias[i] = scriptTrivia.WithText((ScriptStringSlice)" ");
						}
						previousHasSpaces = true;
					}
					else
					{
						previousHasSpaces = false;
						if (scriptTrivia.Type == ScriptTriviaType.SemiColon)
						{
							RemoveSpacesBefore(trivias, ref i);
						}
					}
				}
			}

			private static void RemoveSpacesBefore(List<ScriptTrivia> trivias, ref int i)
			{
				int num = i - 1;
				while (num >= 0)
				{
					ScriptTrivia scriptTrivia = trivias[num];
					if (scriptTrivia.Type.IsSpace())
					{
						trivias.RemoveAt(num);
						i--;
						num--;
						continue;
					}
					if (scriptTrivia.Type.IsNewLine())
					{
						trivias[num] = scriptTrivia.WithText(scriptTrivia.Text.TrimEndKeepNewLine());
					}
					break;
				}
			}
		}

		private readonly TemplateContext? _context;

		private readonly ScriptFormatterFlags _flags;

		private readonly bool _isScientific;

		private readonly CompressWhitespacesVisitor? _compressWhitespacesVisitor;

		public readonly ScriptFormatterOptions Options;

		public ScriptFormatter(ScriptFormatterOptions options)
		{
			Options = options;
			_flags = options.Flags;
			base.CopyTrivias = !_flags.HasFlags(ScriptFormatterFlags.RemoveExistingTrivias);
			_isScientific = options.Language == ScriptLang.Scientific;
			if (options.Context == null && _isScientific)
			{
				throw new InvalidOperationException("The context within the options cannot be null when the scientific language is used.");
			}
			_context = options.Context;
			_compressWhitespacesVisitor = (_flags.HasFlags(ScriptFormatterFlags.CompressSpaces) ? new CompressWhitespacesVisitor() : null);
		}

		public ScriptNode Format(ScriptNode node)
		{
			ScriptNode scriptNode;
			if (_context != null)
			{
				bool strictVariables = _context.StrictVariables;
				bool enableRelaxedIndexerAccess = _context.EnableRelaxedIndexerAccess;
				bool enableRelaxedMemberAccess = _context.EnableRelaxedMemberAccess;
				bool enableRelaxedTargetAccess = _context.EnableRelaxedTargetAccess;
				bool enableNullIndexer = _context.EnableNullIndexer;
				bool ignoreExceptionsWhileRewritingScientific = _context.IgnoreExceptionsWhileRewritingScientific;
				_context.StrictVariables = false;
				_context.EnableRelaxedIndexerAccess = true;
				_context.EnableRelaxedMemberAccess = true;
				_context.EnableRelaxedTargetAccess = true;
				_context.EnableNullIndexer = true;
				_context.IgnoreExceptionsWhileRewritingScientific = true;
				try
				{
					scriptNode = Visit(node) ?? node;
				}
				finally
				{
					_context.StrictVariables = strictVariables;
					_context.EnableRelaxedIndexerAccess = enableRelaxedIndexerAccess;
					_context.EnableRelaxedMemberAccess = enableRelaxedMemberAccess;
					_context.EnableRelaxedTargetAccess = enableRelaxedTargetAccess;
					_context.EnableNullIndexer = enableNullIndexer;
					_context.IgnoreExceptionsWhileRewritingScientific = ignoreExceptionsWhileRewritingScientific;
				}
			}
			else
			{
				scriptNode = Visit(node) ?? node;
			}
			if (_flags.HasFlags(ScriptFormatterFlags.CompressSpaces))
			{
				_compressWhitespacesVisitor?.CompressSpaces(scriptNode);
			}
			return scriptNode;
		}

		public override ScriptNode? Visit(ScriptNode? node)
		{
			return base.Visit(node);
		}

		public override ScriptNode Visit(ScriptAssignExpression node)
		{
			ScriptAssignExpression scriptAssignExpression = (ScriptAssignExpression)base.Visit(node);
			if (_flags.HasFlags(ScriptFormatterFlags.AddSpaceBetweenOperators))
			{
				scriptAssignExpression.EqualToken.AddLeadingSpace();
				scriptAssignExpression.EqualToken.AddSpaceAfter();
			}
			return scriptAssignExpression;
		}

		public override ScriptNode Visit(ScriptPipeCall node)
		{
			ScriptPipeCall scriptPipeCall = (ScriptPipeCall)base.Visit(node);
			if (_flags.HasFlags(ScriptFormatterFlags.AddSpaceBetweenOperators) && scriptPipeCall.PipeToken != null)
			{
				scriptPipeCall.PipeToken.AddLeadingSpace();
				scriptPipeCall.PipeToken.AddSpaceAfter();
			}
			return scriptPipeCall;
		}

		public override ScriptNode Visit(ScriptBinaryExpression node)
		{
			if (_isScientific && _context != null)
			{
				ScriptExpression scriptExpression = ScientificFunctionCallRewriter.Rewrite(_context, node);
				if (scriptExpression != node)
				{
					return Visit(scriptExpression) ?? scriptExpression;
				}
			}
			ScriptBinaryExpression scriptBinaryExpression = (ScriptBinaryExpression)base.Visit(node);
			if (_flags.HasFlags(ScriptFormatterFlags.AddSpaceBetweenOperators) && scriptBinaryExpression.Operator < ScriptBinaryOperator.RangeInclude && scriptBinaryExpression.OperatorToken != null)
			{
				scriptBinaryExpression.OperatorToken.AddLeadingSpace();
				scriptBinaryExpression.OperatorToken.AddSpaceAfter();
			}
			if (_flags.HasFlags(ScriptFormatterFlags.ExplicitParenthesis))
			{
				if (scriptBinaryExpression.Operator == ScriptBinaryOperator.Divide || scriptBinaryExpression.Operator == ScriptBinaryOperator.DivideRound || (_isScientific && scriptBinaryExpression.Operator == ScriptBinaryOperator.Power))
				{
					if (scriptBinaryExpression.Left is ScriptBinaryExpression scriptBinaryExpression2 && HasSimilarPrecedenceThanMultiply(scriptBinaryExpression2.Operator))
					{
						scriptBinaryExpression.Left = null;
						ScriptNestedExpression scriptNestedExpression = (ScriptNestedExpression)(scriptBinaryExpression.Left = new ScriptNestedExpression(scriptBinaryExpression2));
						scriptBinaryExpression2.MoveTrailingTriviasTo(scriptNestedExpression.CloseParen, before: true);
					}
					if (scriptBinaryExpression.Right is ScriptBinaryExpression scriptBinaryExpression3 && HasSimilarPrecedenceThanMultiply(scriptBinaryExpression3.Operator))
					{
						scriptBinaryExpression.Right = null;
						ScriptNestedExpression scriptNestedExpression2 = (ScriptNestedExpression)(scriptBinaryExpression.Right = new ScriptNestedExpression(scriptBinaryExpression3));
						scriptBinaryExpression3.MoveTrailingTriviasTo(scriptNestedExpression2.CloseParen, before: true);
					}
				}
				if (scriptBinaryExpression.Operator == ScriptBinaryOperator.Divide || scriptBinaryExpression.Operator == ScriptBinaryOperator.DivideRound || (_isScientific && scriptBinaryExpression.Operator == ScriptBinaryOperator.Power))
				{
					ScriptNestedExpression scriptNestedExpression3 = new ScriptNestedExpression
					{
						Expression = scriptBinaryExpression
					};
					scriptBinaryExpression.MoveTrailingTriviasTo(scriptNestedExpression3.CloseParen, before: true);
					return scriptNestedExpression3;
				}
			}
			return scriptBinaryExpression;
		}

		public override ScriptNode Visit(ScriptExpressionStatement node)
		{
			ScriptExpressionStatement scriptExpressionStatement = (ScriptExpressionStatement)base.Visit(node);
			if (scriptExpressionStatement.Expression != null)
			{
				scriptExpressionStatement.Expression = DeNestExpression(scriptExpressionStatement.Expression);
			}
			return scriptExpressionStatement;
		}

		public override ScriptNode Visit(ScriptFunctionCall node)
		{
			ScriptFunctionCall scriptFunctionCall = (ScriptFunctionCall)base.Visit(node);
			if (_isScientific && (_flags.HasFlags(ScriptFormatterFlags.ExplicitParenthesis) || scriptFunctionCall.Arguments.Count > 1))
			{
				scriptFunctionCall.ExplicitCall = true;
				ScriptFunctionCall scriptFunctionCall2 = scriptFunctionCall;
				if (scriptFunctionCall2.OpenParent == null)
				{
					ScriptToken scriptToken = (scriptFunctionCall2.OpenParent = ScriptToken.OpenParen());
				}
				scriptFunctionCall2 = scriptFunctionCall;
				if (scriptFunctionCall2.CloseParen == null)
				{
					ScriptToken scriptToken = (scriptFunctionCall2.CloseParen = ScriptToken.CloseParen());
				}
				if (scriptFunctionCall.Target != null)
				{
					scriptFunctionCall.Target.RemoveTrailingSpace();
				}
				scriptFunctionCall.Arguments.RemoveLeadingSpace();
				scriptFunctionCall.Arguments.MoveTrailingTriviasTo(scriptFunctionCall.CloseParen, before: false);
			}
			for (int i = 0; i < scriptFunctionCall.Arguments.Count; i++)
			{
				ScriptExpression expr = scriptFunctionCall.Arguments[i];
				expr = DeNestExpression(expr);
				if (expr == null)
				{
					continue;
				}
				if (i + 1 < scriptFunctionCall.Arguments.Count)
				{
					IScriptTerminal scriptTerminal = expr.FindLastTerminal() as IScriptTerminal;
					if (_isScientific)
					{
						scriptTerminal?.AddCommaAfter();
					}
					if (_flags.HasFlags(ScriptFormatterFlags.AddSpaceBetweenOperators))
					{
						scriptTerminal?.AddSpaceAfter();
					}
				}
				scriptFunctionCall.Arguments[i] = expr;
			}
			return scriptFunctionCall;
		}

		public override ScriptNode Visit(ScriptFunction node)
		{
			ScriptFunction scriptFunction;
			if (_context != null)
			{
				bool hasParameters = node.HasParameters;
				if (hasParameters)
				{
					_context.PushGlobal(new ScriptObject());
				}
				else
				{
					_context.PushLocal();
				}
				try
				{
					_context.SetValue(ScriptVariable.Arguments, string.Empty, asReadOnly: true);
					if (node.HasParameters)
					{
						ScriptList<ScriptParameter> parameters = node.Parameters;
						if (parameters == null)
						{
							return (ScriptFunction)base.Visit(node);
						}
						IScriptObject scriptObject = _context.CurrentGlobal ?? throw new InvalidOperationException("No current global object is available.");
						for (int i = 0; i < parameters.Count; i++)
						{
							ScriptParameter scriptParameter = parameters[i];
							if ((object)scriptParameter.Name != null)
							{
								scriptObject.SetValue(scriptParameter.Name.Name, string.Empty, readOnly: false);
							}
						}
					}
					scriptFunction = (ScriptFunction)base.Visit(node);
				}
				finally
				{
					if (hasParameters)
					{
						_context.PopGlobal();
					}
					else
					{
						_context.PopLocal();
					}
				}
			}
			else
			{
				scriptFunction = (ScriptFunction)base.Visit(node);
			}
			if (_flags.HasFlags(ScriptFormatterFlags.Clean) && scriptFunction.OpenParen != null)
			{
				if (scriptFunction.NameOrDoToken != null)
				{
					scriptFunction.NameOrDoToken.RemoveTrailingSpace();
				}
				if (scriptFunction.Parameters != null)
				{
					scriptFunction.Parameters.RemoveLeadingSpace();
					scriptFunction.Parameters.RemoveTrailingSpace();
				}
			}
			if (_flags.HasFlags(ScriptFormatterFlags.AddSpaceBetweenOperators) && scriptFunction.EqualToken != null)
			{
				scriptFunction.EqualToken.AddLeadingSpace();
				scriptFunction.EqualToken.AddSpaceAfter();
			}
			return scriptFunction;
		}

		private ScriptExpression? DeNestExpression(ScriptExpression? expr)
		{
			if (expr == null)
			{
				return null;
			}
			if (_flags.HasFlags(ScriptFormatterFlags.MinimizeParenthesisNesting))
			{
				while (expr is ScriptNestedExpression { Expression: not null } scriptNestedExpression)
				{
					expr = scriptNestedExpression.Expression;
					scriptNestedExpression.Expression = null;
				}
			}
			return expr;
		}

		private static bool HasSimilarPrecedenceThanMultiply(ScriptBinaryOperator op)
		{
			if ((uint)(op - 20) <= 6u)
			{
				return true;
			}
			return false;
		}
	}
	public static class ScriptFormatterExtensions
	{
		public static ScriptNode Format(this ScriptNode node, ScriptFormatterOptions options)
		{
			return new ScriptFormatter(options).Format(node);
		}

		public static bool HasFlags(this ScriptFormatterFlags input, ScriptFormatterFlags flags)
		{
			return (input & flags) == flags;
		}
	}
	[Flags]
	public enum ScriptFormatterFlags
	{
		None = 0,
		ExplicitParenthesis = 1,
		AddSpaceBetweenOperators = 2,
		RemoveExistingTrivias = 4,
		CompressSpaces = 8,
		MinimizeParenthesisNesting = 0x10,
		Clean = 0x1A,
		ExplicitClean = 0x1B
	}
	[DebuggerDisplay("Lang: {Language} Flags: {Flags}")]
	public readonly struct ScriptFormatterOptions
	{
		public readonly ScriptLang Language;

		public readonly ScriptFormatterFlags Flags;

		public readonly TemplateContext? Context;

		public ScriptFormatterOptions(ScriptFormatterFlags flags)
		{
			Language = ScriptLang.Default;
			Flags = flags;
			Context = null;
		}

		public ScriptFormatterOptions(TemplateContext? context, ScriptLang language, ScriptFormatterFlags flags)
		{
			Language = language;
			Flags = flags;
			if (context == null && language == ScriptLang.Scientific)
			{
				throw new ArgumentNullException("context", "Context cannot be null with scientific language.");
			}
			Context = context;
		}
	}
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ScriptListDebug))]
	public abstract class ScriptList : ScriptNode
	{
		private sealed class ScriptListDebug
		{
			private readonly InlineList<ScriptNode> _children;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public ScriptNode[] Items => _children.ToArray();

			public ScriptListDebug(ScriptList list)
			{
				_children = list._children;
			}
		}

		internal InlineList<ScriptNode> _children;

		public int Count => _children.Count;

		public sealed override int ChildrenCount => _children.Count;

		public ScriptNode this[int index] => _children[index];

		internal ScriptList()
		{
			_children = new InlineList<ScriptNode>(0);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return _children[index];
		}
	}
	[DebuggerTypeProxy(typeof(ScriptList<>.DebugListView))]
	[DebuggerDisplay("Count = {Count}")]
	public sealed class ScriptList<TScriptNode> : ScriptList, IList<TScriptNode>, ICollection<TScriptNode>, IEnumerable<TScriptNode>, IEnumerable, IReadOnlyList<TScriptNode>, IReadOnlyCollection<TScriptNode> where TScriptNode : ScriptNode
	{
		public struct Enumerator : IEnumerator<TScriptNode>, IEnumerator, IDisposable
		{
			private readonly ScriptNode[] _nodes;

			private readonly int _count;

			private int _index;

			public TScriptNode Current
			{
				get
				{
					if (_index < 0)
					{
						throw new InvalidOperationException("MoveNext must be called before accessing Current");
					}
					return (TScriptNode)_nodes[_index];
				}
			}

			object IEnumerator.Current => Current;

			public Enumerator(ScriptNode[] nodes, int count)
			{
				_nodes = nodes;
				_count = count;
				_index = -1;
			}

			public bool MoveNext()
			{
				if (_index + 1 == _count)
				{
					return false;
				}
				_index++;
				return true;
			}

			public void Reset()
			{
				_index = -1;
			}

			public void Dispose()
			{
			}
		}

		internal class DebugListView
		{
			private readonly ScriptList<TScriptNode> _collection;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public TScriptNode[] Items
			{
				get
				{
					TScriptNode[] array = new TScriptNode[_collection.Count];
					for (int i = 0; i < array.Length; i++)
					{
						array[i] = _collection[i];
					}
					return array;
				}
			}

			public DebugListView(ScriptList<TScriptNode> collection)
			{
				_collection = collection;
			}
		}

		public bool IsReadOnly => false;

		public new TScriptNode this[int index]
		{
			get
			{
				return (TScriptNode)_children[index];
			}
			set
			{
				ScriptNode scriptNode = _children[index];
				if (scriptNode != value)
				{
					AssertNoParent(value);
					_children[index] = value;
					if (scriptNode != null)
					{
						scriptNode.Parent = null;
					}
				}
			}
		}

		public void Add(TScriptNode node)
		{
			if (node == null)
			{
				throw new ArgumentNullException("node");
			}
			if (node.Parent != null)
			{
				throw ThrowHelper.GetExpectingNoParentException();
			}
			_children.Add(node);
			node.Parent = this;
		}

		public void AddRange(IEnumerable<TScriptNode> nodes)
		{
			if (nodes == null)
			{
				throw new ArgumentNullException("nodes");
			}
			foreach (TScriptNode node in nodes)
			{
				Add(node);
			}
		}

		public void Clear()
		{
			InlineList<ScriptNode> children = _children;
			ScriptNode[] array = children.Items ?? Array.Empty<ScriptNode>();
			for (int i = 0; i < children.Count; i++)
			{
				array[i].Parent = null;
			}
			_children.Clear();
		}

		public bool Contains(TScriptNode item)
		{
			return _children.Contains(item);
		}

		public void CopyTo(TScriptNode[] array, int arrayIndex)
		{
			_children.CopyTo(array, arrayIndex);
		}

		public bool Remove(TScriptNode item)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			if (_children.Remove(item))
			{
				item.Parent = null;
				return true;
			}
			return false;
		}

		public override object? Evaluate(TemplateContext context)
		{
			throw new InvalidOperationException("A list cannot be evaluated.");
		}

		public new TScriptNode GetChildren(int index)
		{
			return (TScriptNode)base.GetChildren(index);
		}

		protected override ScriptNode GetChildrenImpl(int index)
		{
			return _children[index];
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			throw new NotImplementedException();
		}

		public override void Accept(ScriptVisitor visitor)
		{
			visitor.Visit(this);
		}

		[return: MaybeNull]
		public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			return visitor.Visit(this);
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(_children.Items ?? Array.Empty<ScriptNode>(), _children.Count);
		}

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

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

		public int IndexOf(TScriptNode item)
		{
			return _children.IndexOf(item);
		}

		public void Insert(int index, TScriptNode item)
		{
			AssertNoParent(item);
			_children.Insert(index, item);
			if (item != null)
			{
				item.Parent = this;
			}
		}

		public void RemoveAt(int index)
		{
			ScriptNode scriptNode = _children[index];
			_children.RemoveAt(index);
			if (scriptNode != null)
			{
				scriptNode.Parent = null;
			}
		}

		private void AssertNoParent(ScriptNode node)
		{
			if (node != null && node.Parent != null)
			{
				throw new ArgumentException("Cannot add this node which is already attached to another list instance");
			}
		}
	}
	public abstract class ScriptNode
	{
		public SourceSpan Span;

		public ScriptNode? Parent { get; internal set; }

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public virtual int ChildrenCount => 0;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public IEnumerable<ScriptNode> Children
		{
			get
			{
				int count = ChildrenCount;
				for (int i = 0; i < count; i++)
				{
					ScriptNode childrenImpl = GetChildrenImpl(i);
					if (childrenImpl != null)
					{
						yield return childrenImpl;
					}
				}
			}
		}

		public abstract object? Evaluate(TemplateContext context);

		public ScriptNode Clone()
		{
			return Clone(withTrivias: true);
		}

		public ScriptNode Clone(bool withTrivias)
		{
			return (withTrivias ? ScriptCloner.WithTrivias : ScriptCloner.Instance).Visit(this) ?? throw new InvalidOperationException($"Unable to clone node `{GetType()}`.");
		}

		public ScriptNode GetChildren(int index)
		{
			if (index < 0)
			{
				throw ThrowHelper.GetIndexNegativeArgumentOutOfRangeException();
			}
			if (index > ChildrenCount)
			{
				throw ThrowHelper.GetIndexArgumentOutOfRangeException(ChildrenCount);
			}
			return GetChildrenImpl(index);
		}

		protected virtual ScriptNode? GetChildrenImpl(int index)
		{
			return null;
		}

		public virtual ValueTask<object?> EvaluateAsync(TemplateContext context)
		{
			return new ValueTask<object>(Evaluate(context));
		}

		public virtual bool CanHaveLeadingTrivia()
		{
			return true;
		}

		public abstract void PrintTo(ScriptPrinter printer);

		public virtual void Accept(ScriptVisitor visitor)
		{
			throw new NotImplementedException($"This method must be implemented by the type {GetType()}");
		}

		[return: MaybeNull]
		public virtual TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
		{
			throw new NotImplementedException($"This method must be implemented by the type {GetType()}");
		}

		protected void ParentToThis<TSyntaxNode>(ref TSyntaxNode set, TSyntaxNode? node) where TSyntaxNode : ScriptNode
		{
			if (node == null)
			{
				throw new ArgumentNullException("node");
			}
			if (node != set)
			{
				if (node.Parent != null)
				{
					throw ThrowHelper.GetExpectingNoParentException();
				}
				if (set != null)
				{
					set.Parent = null;
				}
				node.Parent = this;
				set = node;
			}
		}

		protected void ParentToThisNullable<TSyntaxNode>(ref TSyntaxNode? set, TSyntaxNode? node) where TSyntaxNode : ScriptNode
		{
			if (node != set)
			{
				if (node?.Parent != null)
				{
					throw ThrowHelper.GetExpectingNoParentException();
				}
				if (set != null)
				{
					set.Parent = null;
				}
				if (node != null)
				{
					node.Parent = this;
				}
				set = node;
			}
		}

		public sealed override string ToString()
		{
			StringBuilderOutput stringBuilderOutput = new StringBuilderOutput();
			new ScriptPrinter(stringBuilderOutput, new ScriptPrinterOptions
			{
				Mode = ScriptMode.ScriptOnly
			}).Write(this);
			string result = stringBuilderOutput.ToString();
			stringBuilderOutput.Builder.Length = 0;
			return result;
		}
	}
	public static class ScriptNodeExtensions
	{
		public static ScriptNode? FindFirstTerminal(this ScriptNode? node)
		{
			if (node == null)
			{
				return null;
			}
			if (node is IScriptTerminal)
			{
				return node;
			}
			int childrenCount = node.ChildrenCount;
			for (int i = 0; i < childrenCount; i++)
			{
				ScriptNode children = node.GetChildren(i);
				if (children != null)
				{
					ScriptNode scriptNode = children.FindFirstTerminal();
					if (scriptNode != null)
					{
						return scriptNode;
					}
				}
			}
			return null;
		}

		public static ScriptNode? FindLastTerminal(this ScriptNode? node)
		{
			if (node == null)
			{
				return null;
			}
			if (node is IScriptTerminal)
			{
				return node;
			}
			for (int num = node.ChildrenCount - 1; num >= 0; num--)
			{
				ScriptNode children = node.GetChildren(num);
				if (children != null)
				{
					ScriptNode scriptNode = children.FindLastTerminal();
					if (scriptNode != null)
					{
						return scriptNode;
					}
				}
			}
			return null;
		}

		public static T RemoveLeadingSpace<T>(this T node) where T : ScriptNode
		{
			ScriptTrivias scriptTrivias = (node.FindFirstTerminal() as IScriptTerminal)?.Trivias;
			if (scriptTrivias != null)
			{
				List<ScriptTrivia> before = scriptTrivias.Before;
				if (before.Count > 0)
				{
					int num = 0;
					while (num < before.Count && before[num].Type.IsSpaceOrNewLine())
					{
						before.RemoveAt(num);
						num--;
						num++;
					}
				}
			}
			return node;
		}

		public static T RemoveTrailingSpace<T>(this T node) where T : ScriptNode
		{
			ScriptTrivias scriptTrivias = (node.FindLastTerminal() as IScriptTerminal)?.Trivias;
			if (scriptTrivias != null)
			{
				List<ScriptTrivia> after = scriptTrivias.After;
				if (after.Count > 0)
				{
					int num = after.Count - 1;
					while (num >= 0 && after[num].Type.IsSpaceOrNewLine())
					{
						after.RemoveAt(num);
						num--;
					}
				}
			}
			return node;
		}

		public static void MoveLeadingTriviasTo<T>(this ScriptNode node, T destinationNode) where T : ScriptNode, IScriptTerminal
		{
			ScriptTrivias scriptTrivias = (node.FindFirstTerminal() as IScriptTerminal)?.Trivias;
			if (scriptTrivias == null)
			{
				return;
			}
			List<ScriptTrivia> before = scriptTrivias.Before;
			foreach (ScriptTrivia item in before)
			{
				destinationNode.AddTrivia(item, before: true);
			}
			before.Clear();
		}

		public static void MoveTrailingTriviasTo<T>(this ScriptNode node, T destinationNode, bool before) where T : ScriptNode, IScriptTerminal
		{
			ScriptTrivias scriptTrivias = (node.FindLastTerminal() as IScriptTerminal)?.Trivias;
			if (scriptTrivias == null)
			{
				return;
			}
			List<ScriptTrivia> after = scriptTrivias.After;
			if (before)
			{
				for (int num = after.Count - 1; num >= 0; num--)
				{
					ScriptTrivia trivia = after[num];
					destinationNode.InsertTrivia(trivia, before: false);
				}
			}
			else
			{
				foreach (ScriptTrivia item in after)
				{
					destinationNode.AddTrivia(item, before: false);
				}
			}
			after.Clear();
		}

		public static void AddLeadingSpace(this IScriptTerminal node)
		{
			if (!node.HasLeadingSpaceTrivias())
			{
				node.AddTrivia(ScriptTrivia.Space, before: true);
			}
		}

		public static void AddCommaAfter(this IScriptTerminal node)
		{
			if (!node.HasTrivia(ScriptTriviaType.Comma, before: false))
			{
				node.AddTrivia(ScriptTrivia.Comma, before: false);
			}
		}

		public static void AddSemiColonAfter(this IScriptTerminal node)
		{
			if (!node.HasTrivia(ScriptTriviaType.SemiColon, before: false))
			{
				node.AddTrivia(ScriptTrivia.SemiColon, before: false);
			}
		}

		public static void AddSpaceAfter(this IScriptTerminal node)
		{
			if (!node.HasTrailingSpaceTrivias())
			{
				node.AddTrivia(ScriptTrivia.Space, before: false);
			}
		}

		public static void AddTrivia(this IScriptTerminal node, ScriptTrivia trivia, bool before)
		{
			ScriptTrivias scriptTrivias = node.Trivias;
			if (scriptTrivias == null)
			{
				scriptTrivias = (node.Trivias = new ScriptTrivias());
			}
			(before ? scriptTrivias.Before : scriptTrivias.After).Add(trivia);
		}

		public static void InsertTrivia(this IScriptTerminal node, ScriptTrivia trivia, bool before)
		{
			ScriptTrivias scriptTrivias = node.Trivias;
			if (scriptTrivias == null)
			{
				scriptTrivias = (node.Trivias = new ScriptTrivias());
			}
			(before ? scriptTrivias.Before : scriptTrivias.After).Insert(0, trivia);
		}

		public static void AddTrivias<T>(this IScriptTerminal node, T trivias, bool before) where T : IEnumerable<ScriptTrivia>
		{
			foreach (ScriptTrivia item in trivias)
			{
				node.AddTrivia(item, before);
			}
		}

		public static bool HasLeadingSpaceTrivias(this IScriptTerminal node)
		{
			if (node.Trivias == null)
			{
				return false;
			}
			using (List<ScriptTrivia>.Enumerator enumerator = node.Trivias.Before.GetEnumerator())
			{
				if (enumerator.MoveNext() && enumerator.Current.Type.IsSpaceOrNewLine())
				{
					return true;
				}
			}
			return false;
		}

		public static bool HasTrailingSpaceTrivias(this IScriptTerminal node)
		{
			if (node.Trivias == null)
			{
				return false;
			}
			List<ScriptTrivia> after = node.Trivias.After;
			if (after.Count > 0 && after[after.Count - 1].Type.IsSpaceOrNewLine())
			{
				return true;
			}
			return false;
		}

		public static bool HasTrivia(this IScriptTerminal node, ScriptTriviaType triviaType, bool before)
		{
			if (node.Trivias == null)
			{
				return false;
			}
			foreach (ScriptTrivia item in before ? node.Trivias.Before : node.Trivias.After)
			{
				if (item.Type == triviaType)
				{
					return true;
				}
			}
			return false;
		}

		public static bool HasTriviaEndOfStatement(this IScriptTerminal node, bool before)
		{
			if (node.Trivias == null)
			{
				return false;
			}
			foreach (ScriptTrivia item in before ? node.Trivias.Before : node.Trivias.After)
			{
				if (item.Type == ScriptTriviaType.NewLine || item.Type == ScriptTriviaType.SemiColon)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class ScriptParameterContainerExtensions
	{
		public static void AddParameter(this IScriptNamedArgumentContainer container, ScriptNamedArgument argument)
		{
			if (container.NamedArguments == null)
			{
				container.NamedArguments = new ScriptList<ScriptNamedArgument>();
			}
			container.NamedArguments.Add(argument);
		}

		public static void Write(this ScriptPrinter printer, List<ScriptNamedArgument> parameters)
		{
			if (parameters != null)
			{
				for (int i = 0; i < parameters.Count; i++)
				{
					ScriptNamedArgument node = parameters[i];
					printer.ExpectSpace();
					printer.Write(node);
				}
			}
		}
	}
	public class ScriptRuntimeException : Exception
	{
		public SourceSpan Span { get; }

		public override string Message => new LogMessage(ParserMessageType.Error, Span, base.Message).ToString();

		public static bool EnableDisplayInnerException { get; set; }

		public string OriginalMessage => base.Message;

		public ScriptRuntimeException(SourceSpan span, string message)
			: base(message)
		{
			Span = span;
		}

		public ScriptRuntimeException(SourceSpan span, string message, Exception? innerException)
			: base(message, innerException)
		{
			Span = span;
		}

		public override string ToString()
		{
			if (EnableDisplayInnerException && base.InnerException != null)
			{
				return base.ToString();
			}
			return Message;
		}
	}
	public class ScriptAbortException : ScriptRuntimeException
	{
		public CancellationToken CancellationToken { get; }

		public ScriptAbortException(SourceSpan span, CancellationToken cancellationToken)
			: this(span, "The operation was cancelled", cancellationToken)
		{
			CancellationToken = cancellationToken;
		}

		public ScriptAbortException(SourceSpan span, string message, CancellationToken cancellationToken)
			: base(span, message)
		{
			CancellationToken = cancellationToken;
		}
	}
	public class ScriptParserRuntimeException : ScriptRuntimeException
	{
		public LogMessageBag ParserMessages { get; }

		public override string Message => $"{base.Message} Parser messages:\n {ParserMessages}";

		public ScriptParserRuntimeException(SourceSpan span, string message, LogMessageBag parserMessages)
			: this(span, message, parserMessages, null)
		{
		}

		public ScriptParserRuntimeException(SourceSpan span, string message, LogMessageBag parserMessages, Exception? innerException)
			: base(span, message, innerException)
		{
			if (parserMessages == null)
			{
				throw new ArgumentNullException("parserMessages");
			}
			ParserMessages = parserMessages;
		}
	}
	[DebuggerDisplay("{ToString()}")]
	public readonly struct ScriptStringSlice : IEquatable<ScriptStringSlice>, IComparable<ScriptStringSlice>, IComparable<string>
	{
		public static readonly ScriptStringSlice Empty = new ScriptStringSlice(string.Empty);

		public readonly string? FullText;

		public readonly int Index;

		public readonly int Length;

		public char this[int index]
		{
			get
			{
				if ((uint)index >= (uint)Length)
				{
					throw new ArgumentOutOfRangeException("index");
				}
				return (FullText ?? string.Empty)[Index + index];
			}
		}

		public ScriptStringSlice(string? fullText)
		{
			FullText = fullText;
			Index = 0;
			Length = fullText?.Length ?? 0;
		}

		public ScriptStringSlice(string? fullText, int index, int length)
		{
			if (index < 0 || (fullText != null && index >= fullText.Length))
			{
				throw new ArgumentOutOfRangeException("index");
			}
			if (length < 0 || (fullText != null && index + length > fullText.Length))
			{
				throw new ArgumentOutOfRangeException("length");
			}
			FullText = fullText;
			Index = index;
			Length = length;
		}

		public string Substring(int index)
		{
			if (index == Length)
			{
				return "";
			}
			if ((uint)index > (uint)Length)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			return FullText?.Substring(Index + index, Length - index) ?? string.Empty;
		}

		public override string ToString()
		{
			return FullText?.Substring(Index, Length) ?? string.Empty;
		}

		public bool Equals(ScriptStringSlice other)
		{
			if (Length != other.Length)
			{
				return false;
			}
			if (FullText == null && other.FullText == null)
			{
				return true;
			}
			if (FullText == null || other.FullText == null)
			{
				return false;
			}
			return string.CompareOrdinal(FullText, Index, other.FullText, other.Index, Length) == 0;
		}

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

		public override int GetHashCode()
		{
			if (FullText == null)
			{
				return 0;
			}
			int num = Length;
			for (int i = Index; i < Length; i++)
			{
				num = (num * 397) ^ FullText[i];
			}
			return num;
		}

		public static bool operator ==(ScriptStringSlice left, ScriptStringSlice right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(ScriptStringSlice left, ScriptStringSlice right)
		{
			return !left.Equals(right);
		}

		public static bool operator ==(ScriptStringSlice left, string right)
		{
			return left.CompareTo(right) == 0;
		}

		public static bool operator !=(ScriptStringSlice left, string right)
		{
			return left.CompareTo(right) != 0;
		}

		public static bool operator ==(string left, ScriptStringSlice right)
		{
			return right.CompareTo(left) == 0;
		}

		public static bool operator !=(string left, ScriptStringSlice right)
		{
			return right.CompareTo(left) != 0;
		}

		public int CompareTo(ScriptStringSlice other)
		{
			if (FullText == null || other.FullText == null)
			{
				if ((object)FullText == other.FullText)
				{
					return 0;
				}
				if (FullText != null)
				{
					return 1;
				}
				return -1;
			}
			if (Length == 0 && other.Length == 0)
			{
				return 0;
			}
			int length = Math.Min(Length, other.Length);
			int num = string.CompareOrdinal(FullText, Index, other.FullText, other.Index, length);
			if (num == 0)
			{
				int length2 = Length;
				return length2.CompareTo(other.Length);
			}
			if (num >= 0)
			{
				return 1;
			}
			return -1;
		}

		public int CompareTo(string? other)
		{
			if (FullText == null || other == null)
			{
				if ((object)FullText == other)
				{
					return 0;
				}
				if (FullText != null)
				{
					return 1;
				}
				return -1;
			}
			if (Length == 0 && other.Length == 0)
			{
				return 0;
			}
			int length = Math.Min(Length, other.Length);
			int num = string.CompareOrdinal(FullText, Index, other, 0, length);
			if (num == 0)
			{
				int length2 = Length;
				return length2.CompareTo(other.Length);
			}
			if (num >= 0)
			{
				return 1;
			}
			return -1;
		}

		public static explicit operator ScriptStringSlice(string text)
		{
			return new ScriptStringSlice(text);
		}

		public static explicit operator string(ScriptStringSlice slice)
		{
			return slice.ToString() ?? string.Empty;
		}

		public ScriptStringSlice TrimStart()
		{
			string fullText = FullText;
			if (fullText == null)
			{
				return Empty;
			}
			for (int i = 0; i < Length; i++)
			{
				if (!char.IsWhiteSpace(fullText[Index + i]))
				{
					return new ScriptStringSlice(fullText, Index + i, Length - i);
				}
			}
			return Empty;
		}

		public ScriptStringSlice TrimEnd()
		{
			string fullText = FullText;
			if (fullText == null)
			{
				return Empty;
			}
			for (int num = Length - 1; num >= 0; num--)
			{
				if (!char.IsWhiteSpace(fullText[Index + num]))
				{
					return new ScriptStringSlice(fullText, Index, num + 1);
				}
			}
			return Empty;
		}

		public ScriptStringSlice TrimEndKeepNewLine()
		{
			string fullText = FullText;
			if (fullText == null)
			{
				return Empty;
			}
			for (int num = Length - 1; num >= 0; num--)
			{
				char c = fullText[Index + num];
				if (!char.IsWhiteSpace(c) || c == '\n')
				{
					return new ScriptStringSlice(fullText, Index, num + 1);
				}
			}
			return Empty;
		}
	}
	public static class ScriptStringSliceExtensions
	{
		public static ScriptStringSlice Slice(this string text, int index)
		{
			return new ScriptStringSlice(text, index, text.Length - index);
		}

		public static ScriptStringSlice Slice(this string text, int index, int length)
		{
			return new ScriptStringSlice(text, index, length);
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum)]
	public class ScriptTypeNameAttribute : Attribute
	{
		public string TypeName { get; }

		public ScriptTypeNameAttribute(string typeName)
		{
			TypeName = typeName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum)]
	public class ScriptSyntaxAttribute : ScriptTypeNameAttribute
	{
		public string Example { get; }

		public ScriptSyntaxAttribute(string typeName, string example)
			: base(typeName)
		{
			Example = example;
		}

		public static ScriptSyntaxAttribute? Get(object? obj)
		{
			if (obj == null)
			{
				return null;
			}
			return Get(obj.GetType());
		}

		public static ScriptSyntaxAttribute Get(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			return type.GetCustomAttribute<ScriptSyntaxAttribute>() ?? new ScriptSyntaxAttribute(type.Name, "...");
		}
	}
	public readonly struct ScriptTrivia
	{
		public static readonly ScriptTrivia Space = new ScriptTrivia(default(SourceSpan), ScriptTriviaType.Whitespace, (ScriptStringSlice)" ");

		public static readonly ScriptTrivia Comma = new ScriptTrivia(default(SourceSpan), ScriptTriviaType.Comma, (ScriptStringSlice)",");

		public static readonly ScriptTrivia SemiColon = new ScriptTrivia(default(SourceSpan), ScriptTriviaType.SemiColon, (ScriptStringSlice)";");

		public readonly SourceSpan Span;

		public readonly ScriptTriviaType Type;

		public readonly ScriptStringSlice Text;

		public ScriptTrivia(SourceSpan span, ScriptTriviaType type, ScriptStringSlice text)
		{
			Span = span;
			Type = type;
			Text = text;
		}

		public ScriptTrivia WithText(ScriptStringSlice text)
		{
			return new ScriptTrivia(Span, Type, text);
		}

		public void Write(ScriptPrinter printer)
		{
			string text = ToString();
			int num;
			if (Type == ScriptTriviaType.CommentMulti)
			{
				num = ((!text.StartsWith("##")) ? 1 : 0);
				if (num != 0)
				{
					text = text.Replace("#", "\\#");
					text = text.Replace("}", "\\}");
					printer.Write("## ");
				}
			}
			else
			{
				num = 0;
			}
			printer.Write(text);
			if (num != 0)
			{
				printer.Write(" ##");
			}
		}

		public override string ToString()
		{
			return Type switch
			{
				ScriptTriviaType.Empty => string.Empty, 
				ScriptTriviaType.Comma => ",", 
				ScriptTriviaType.SemiColon => ";", 
				_ => (string)Text, 
			};
		}
	}
	public class ScriptTrivias
	{
		public List<ScriptTrivia> Before { get; }

		public List<ScriptTrivia> After { get; }

		public ScriptTrivias()
		{
			Before = new List<ScriptTrivia>();
			After = new List<ScriptTrivia>();
		}
	}
	public enum ScriptTriviaType
	{
		Empty,
		Whitespace,
		WhitespaceFull,
		Comment,
		Comma,
		CommentMulti,
		NewLine,
		SemiColon
	}
	public static class ScriptTriviaTypeExtensions
	{
		public static bool IsSpace(this ScriptTriviaType triviaType)
		{
			return triviaType switch
			{
				ScriptTriviaType.Whitespace => true, 
				ScriptTriviaType.WhitespaceFull => true, 
				_ => false, 
			};
		}

		public static bool IsNewLine(this ScriptTriviaType triviaType)
		{
			return triviaType == ScriptTriviaType.NewLine;
		}

		public static bool IsSpaceOrNewLine(this ScriptTriviaType triviaType)
		{
			return triviaType switch
			{
				ScriptTriviaType.Whitespace => true, 
				ScriptTriviaType.WhitespaceFull => true, 
				ScriptTriviaType.NewLine => true, 
				_ => false, 
			};
		}
	}
	public abstract class ScriptVerbatim : ScriptNode, IScriptTerminal
	{
		public ScriptTrivias Trivias { get; set; }

		public string Value { get; set; }

		protected ScriptVerbatim()
		{
			Trivias = new ScriptTrivias();
			Value = string.Empty;
		}

		protected ScriptVerbatim(string value)
		{
			Trivias = new ScriptTrivias();
			Value = value;
		}

		public override object? Evaluate(TemplateContext context)
		{
			return null;
		}

		public override void PrintTo(ScriptPrinter printer)
		{
			printer.Write(Value);
		}
	}
	public abstract class ScriptConditionStatement : ScriptStatement
	{
	}
	public enum ScriptFlowState
	{
		None,
		Break,
		Continue,
		Return
	}
	public abstract class ScriptStatement : ScriptNode
	{
		public bool CanSkipEvaluation { get; protected set; }

		public bool CanOutput { get; protected set; }

		protected ScriptStatement()
		{
			CanOutput = true;
		}
	}
	public enum ScriptWhitespaceMode
	{
		None,
		Greedy,
		NonGreedy
	}
}
namespace Scriban.Runtime
{
	public abstract class DynamicCustomFunction : IScriptCustomFunction, IScriptFunctionInfo
	{
		private class Functionbool_IEnumerable_object : DynamicCustomFunction
		{
			private delegate bool InternalDelegate(IEnumerable? arg0, object? arg1);

			private readonly InternalDelegate _delegate;

			public Functionbool_IEnumerable_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class Functionbool_object : DynamicCustomFunction
		{
			private delegate bool InternalDelegate(object? arg0);

			private readonly InternalDelegate _delegate;

			public Functionbool_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionbool_string : DynamicCustomFunction
		{
			private delegate bool InternalDelegate(string? arg0);

			private readonly InternalDelegate _delegate;

			public Functionbool_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionbool_string_string : DynamicCustomFunction
		{
			private delegate bool InternalDelegate(string? arg0, string? arg1);

			private readonly InternalDelegate _delegate;

			public Functionbool_string_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class Functionbool_TemplateContext_SourceSpan_IEnumerable_object : DynamicCustomFunction
		{
			private delegate bool InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, object? arg3);

			private readonly InternalDelegate _delegate;

			public Functionbool_TemplateContext_SourceSpan_IEnumerable_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class Functionbool_TemplateContext_SourceSpan_IEnumerable_object_objectArray : DynamicCustomFunction
		{
			private delegate bool InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, object? arg3, object?[] arg4);

			private readonly InternalDelegate _delegate;

			public Functionbool_TemplateContext_SourceSpan_IEnumerable_object_objectArray(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[1], 1);
				object[] arg3 = ((arguments[2] as ScriptArray) ?? throw new ScriptRuntimeException(sourceSpan, "Invalid params array for function `" + Method.Name + "`.")).ToArray();
				return _delegate(context, sourceSpan, arg, arg2, arg3);
			}
		}

		private class FunctionDateTime : DynamicCustomFunction
		{
			private delegate DateTime InternalDelegate();

			private readonly InternalDelegate _delegate;

			public FunctionDateTime(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				if (callerContext == null)
				{
					_ = context.CurrentSpan;
				}
				else
				{
					_ = callerContext.Span;
				}
				return _delegate();
			}
		}

		private class FunctionDateTime_DateTime_double : DynamicCustomFunction
		{
			private delegate DateTime InternalDelegate(DateTime arg0, double arg1);

			private readonly InternalDelegate _delegate;

			public FunctionDateTime_DateTime_double(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				DateTime arg = ConvertStructArgument<DateTime>(context, span, arguments[0], 0);
				double arg2 = ConvertStructArgument<double>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class FunctionDateTime_DateTime_int : DynamicCustomFunction
		{
			private delegate DateTime InternalDelegate(DateTime arg0, int arg1);

			private readonly InternalDelegate _delegate;

			public FunctionDateTime_DateTime_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				DateTime arg = ConvertStructArgument<DateTime>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class Functiondouble_double : DynamicCustomFunction
		{
			private delegate double InternalDelegate(double arg0);

			private readonly InternalDelegate _delegate;

			public Functiondouble_double(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				double arg = ConvertStructArgument<double>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functiondouble_double_int___Opt : DynamicCustomFunction
		{
			private delegate double InternalDelegate(double arg0, int arg1);

			private readonly InternalDelegate _delegate;

			public Functiondouble_double_int___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				double arg = ConvertStructArgument<double>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class FunctionIEnumerable_IEnumerable : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(IEnumerable? arg0);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class FunctionIEnumerable_IEnumerable_IEnumerable : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(IEnumerable? arg0, IEnumerable? arg1);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_IEnumerable_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				IEnumerable arg2 = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class FunctionIEnumerable_IEnumerable_int : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(IEnumerable? arg0, int arg1);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_IEnumerable_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class FunctionIEnumerable_IEnumerable_int_object : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(IEnumerable? arg0, int arg1, object? arg2);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_IEnumerable_int_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				object arg3 = ConvertNullableReferenceArgument<object>(context, span, arguments[2], 2);
				return _delegate(arg, arg2, arg3);
			}
		}

		private class FunctionIEnumerable_IEnumerable_object : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(IEnumerable? arg0, object? arg1);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_IEnumerable_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class FunctionIEnumerable_string_string : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(string? arg0, string? arg1);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_string_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				return _delegate(context, sourceSpan, arg);
			}
		}

		private class FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_IEnumerable : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, IEnumerable? arg3);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				IEnumerable arg2 = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_int : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, int arg3);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_int_object : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, int arg3, object? arg4);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_int_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, sourceSpan, arguments[1], 1);
				object arg3 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[2], 2);
				return _delegate(context, sourceSpan, arg, arg2, arg3);
			}
		}

		private class FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_object : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, object? arg3);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class FunctionIEnumerable_TemplateContext_SourceSpan_object_string : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(TemplateContext arg0, SourceSpan arg1, object? arg2, string? arg3);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_TemplateContext_SourceSpan_object_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class FunctionIEnumerable_TemplateContext_SourceSpan_object_string___Opt : DynamicCustomFunction
		{
			private delegate IEnumerable InternalDelegate(TemplateContext arg0, SourceSpan arg1, object? arg2, string? arg3);

			private readonly InternalDelegate _delegate;

			public FunctionIEnumerable_TemplateContext_SourceSpan_object_string___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class FunctionIList_IList_int : DynamicCustomFunction
		{
			private delegate IList InternalDelegate(IList? arg0, int arg1);

			private readonly InternalDelegate _delegate;

			public FunctionIList_IList_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IList arg = ConvertNullableReferenceArgument<IList>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class FunctionIList_TemplateContext_SourceSpan_IList_int : DynamicCustomFunction
		{
			private delegate IList InternalDelegate(TemplateContext arg0, SourceSpan arg1, IList? arg2, int arg3);

			private readonly InternalDelegate _delegate;

			public FunctionIList_TemplateContext_SourceSpan_IList_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IList arg = ConvertNullableReferenceArgument<IList>(context, sourceSpan, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class Functionint_IEnumerable : DynamicCustomFunction
		{
			private delegate int InternalDelegate(IEnumerable? arg0);

			private readonly InternalDelegate _delegate;

			public Functionint_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionint_object : DynamicCustomFunction
		{
			private delegate int InternalDelegate(object? arg0);

			private readonly InternalDelegate _delegate;

			public Functionint_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionint_string : DynamicCustomFunction
		{
			private delegate int InternalDelegate(string? arg0);

			private readonly InternalDelegate _delegate;

			public Functionint_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionint_TemplateContext_SourceSpan_IEnumerable : DynamicCustomFunction
		{
			private delegate int InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2);

			private readonly InternalDelegate _delegate;

			public Functionint_TemplateContext_SourceSpan_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				return _delegate(context, sourceSpan, arg);
			}
		}

		private class Functionint_TemplateContext_SourceSpan_object : DynamicCustomFunction
		{
			private delegate int InternalDelegate(TemplateContext arg0, SourceSpan arg1, object? arg2);

			private readonly InternalDelegate _delegate;

			public Functionint_TemplateContext_SourceSpan_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[0], 0);
				return _delegate(context, sourceSpan, arg);
			}
		}

		private class Functionobject_IEnumerable : DynamicCustomFunction
		{
			private delegate object InternalDelegate(IEnumerable? arg0);

			private readonly InternalDelegate _delegate;

			public Functionobject_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionobject_object_object : DynamicCustomFunction
		{
			private delegate object InternalDelegate(object? arg0, object? arg1);

			private readonly InternalDelegate _delegate;

			public Functionobject_object_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, span, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class Functionobject_TemplateContext_SourceSpan_double_object : DynamicCustomFunction
		{
			private delegate object InternalDelegate(TemplateContext arg0, SourceSpan arg1, double arg2, object? arg3);

			private readonly InternalDelegate _delegate;

			public Functionobject_TemplateContext_SourceSpan_double_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				double arg = ConvertStructArgument<double>(context, sourceSpan, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class Functionobject_TemplateContext_SourceSpan_IEnumerable : DynamicCustomFunction
		{
			private delegate object InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2);

			private readonly InternalDelegate _delegate;

			public Functionobject_TemplateContext_SourceSpan_IEnumerable(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				return _delegate(context, sourceSpan, arg);
			}
		}

		private class Functionobject_TemplateContext_SourceSpan_IList_object___Opt : DynamicCustomFunction
		{
			private delegate object InternalDelegate(TemplateContext arg0, SourceSpan arg1, IList? arg2, object? arg3);

			private readonly InternalDelegate _delegate;

			public Functionobject_TemplateContext_SourceSpan_IList_object___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IList arg = ConvertNullableReferenceArgument<IList>(context, sourceSpan, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class Functionobject_TemplateContext_SourceSpan_int_int : DynamicCustomFunction
		{
			private delegate object InternalDelegate(TemplateContext arg0, SourceSpan arg1, int arg2, int arg3);

			private readonly InternalDelegate _delegate;

			public Functionobject_TemplateContext_SourceSpan_int_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				int arg = ConvertStructArgument<int>(context, sourceSpan, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class Functionobject_TemplateContext_SourceSpan_object : DynamicCustomFunction
		{
			private delegate object InternalDelegate(TemplateContext arg0, SourceSpan arg1, object? arg2);

			private readonly InternalDelegate _delegate;

			public Functionobject_TemplateContext_SourceSpan_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[0], 0);
				return _delegate(context, sourceSpan, arg);
			}
		}

		private class Functionobject_TemplateContext_SourceSpan_object_object : DynamicCustomFunction
		{
			private delegate object InternalDelegate(TemplateContext arg0, SourceSpan arg1, object? arg2, object? arg3);

			private readonly InternalDelegate _delegate;

			public Functionobject_TemplateContext_SourceSpan_object_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class Functionobject_TemplateContext_string : DynamicCustomFunction
		{
			private delegate object InternalDelegate(TemplateContext arg0, string? arg1);

			private readonly InternalDelegate _delegate;

			public Functionobject_TemplateContext_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				return _delegate(context, arg);
			}
		}

		private class FunctionScriptArray_TemplateContext_object : DynamicCustomFunction
		{
			private delegate ScriptArray InternalDelegate(TemplateContext arg0, object? arg1);

			private readonly InternalDelegate _delegate;

			public FunctionScriptArray_TemplateContext_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, span, arguments[0], 0);
				return _delegate(context, arg);
			}
		}

		private class FunctionScriptArray_TemplateContext_string_string_string___Opt : DynamicCustomFunction
		{
			private delegate ScriptArray InternalDelegate(TemplateContext arg0, string? arg1, string? arg2, string? arg3);

			private readonly InternalDelegate _delegate;

			public FunctionScriptArray_TemplateContext_string_string_string___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				return _delegate(context, arg, arg2, arg3);
			}
		}

		private class FunctionScriptRange_TemplateContext_SourceSpan_IEnumerable_object : DynamicCustomFunction
		{
			private delegate ScriptRange InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, object? arg3);

			private readonly InternalDelegate _delegate;

			public FunctionScriptRange_TemplateContext_SourceSpan_IEnumerable_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				object arg2 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[1], 1);
				return _delegate(context, sourceSpan, arg, arg2);
			}
		}

		private class Functionstring : DynamicCustomFunction
		{
			private delegate string InternalDelegate();

			private readonly InternalDelegate _delegate;

			public Functionstring(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				if (callerContext == null)
				{
					_ = context.CurrentSpan;
				}
				else
				{
					_ = callerContext.Span;
				}
				return _delegate();
			}
		}

		private class Functionstring_int_string_string : DynamicCustomFunction
		{
			private delegate string InternalDelegate(int arg0, string? arg1, string? arg2);

			private readonly InternalDelegate _delegate;

			public Functionstring_int_string_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				int arg = ConvertStructArgument<int>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				return _delegate(arg, arg2, arg3);
			}
		}

		private class Functionstring_object : DynamicCustomFunction
		{
			private delegate string InternalDelegate(object? arg0);

			private readonly InternalDelegate _delegate;

			public Functionstring_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionstring_string : DynamicCustomFunction
		{
			private delegate string InternalDelegate(string? arg0);

			private readonly InternalDelegate _delegate;

			public Functionstring_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class Functionstring_string_int : DynamicCustomFunction
		{
			private delegate string InternalDelegate(string? arg0, int arg1);

			private readonly InternalDelegate _delegate;

			public Functionstring_string_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class Functionstring_string_int_int___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(string? arg0, int arg1, int arg2);

			private readonly InternalDelegate _delegate;

			public Functionstring_string_int_int___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				int arg3 = ConvertStructArgument<int>(context, span, arguments[2], 2);
				return _delegate(arg, arg2, arg3);
			}
		}

		private class Functionstring_string_int_string___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(string? arg0, int arg1, string? arg2);

			private readonly InternalDelegate _delegate;

			public Functionstring_string_int_string___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				return _delegate(arg, arg2, arg3);
			}
		}

		private class Functionstring_string_string : DynamicCustomFunction
		{
			private delegate string InternalDelegate(string? arg0, string? arg1);

			private readonly InternalDelegate _delegate;

			public Functionstring_string_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				return _delegate(arg, arg2);
			}
		}

		private class Functionstring_string_string_string : DynamicCustomFunction
		{
			private delegate string InternalDelegate(string? arg0, string? arg1, string? arg2);

			private readonly InternalDelegate _delegate;

			public Functionstring_string_string_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				return _delegate(arg, arg2, arg3);
			}
		}

		private class Functionstring_string_string_string_bool___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(string? arg0, string? arg1, string? arg2, bool arg3);

			private readonly InternalDelegate _delegate;

			public Functionstring_string_string_string_bool___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				bool arg4 = ConvertStructArgument<bool>(context, span, arguments[3], 3);
				return _delegate(arg, arg2, arg3, arg4);
			}
		}

		private class Functionstring_TemplateContext_object : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, object? arg1);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_object(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, span, arguments[0], 0);
				return _delegate(context, arg);
			}
		}

		private class Functionstring_TemplateContext_SourceSpan_IEnumerable_string_object___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, SourceSpan arg1, IEnumerable? arg2, string? arg3, object? arg4);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_SourceSpan_IEnumerable_string_object___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				IEnumerable arg = ConvertNullableReferenceArgument<IEnumerable>(context, sourceSpan, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, sourceSpan, arguments[1], 1);
				object arg3 = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[2], 2);
				return _delegate(context, sourceSpan, arg, arg2, arg3);
			}
		}

		private class Functionstring_TemplateContext_SourceSpan_object_string_string___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, SourceSpan arg1, object? arg2, string? arg3, string? arg4);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_SourceSpan_object_string_string___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
				object arg = ConvertNullableReferenceArgument<object>(context, sourceSpan, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, sourceSpan, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, sourceSpan, arguments[2], 2);
				return _delegate(context, sourceSpan, arg, arg2, arg3);
			}
		}

		private class Functionstring_TemplateContext_string : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, string? arg1);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				return _delegate(context, arg);
			}
		}

		private class Functionstring_TemplateContext_string_int : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, string? arg1, int arg2);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_string_int(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				int arg2 = ConvertStructArgument<int>(context, span, arguments[1], 1);
				return _delegate(context, arg, arg2);
			}
		}

		private class Functionstring_TemplateContext_string_string : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, string? arg1, string? arg2);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_string_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				return _delegate(context, arg, arg2);
			}
		}

		private class Functionstring_TemplateContext_string_string___Opt_string___Opt_string___Opt_string___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, string? arg1, string? arg2, string? arg3, string? arg4, string? arg5);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_string_string___Opt_string___Opt_string___Opt_string___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				string arg4 = ConvertNullableReferenceArgument<string>(context, span, arguments[3], 3);
				string arg5 = ConvertNullableReferenceArgument<string>(context, span, arguments[4], 4);
				return _delegate(context, arg, arg2, arg3, arg4, arg5);
			}
		}

		private class Functionstring_TemplateContext_string_string_string : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, string? arg1, string? arg2, string? arg3);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_string_string_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				return _delegate(context, arg, arg2, arg3);
			}
		}

		private class Functionstring_TemplateContext_string_string_string_bool___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, string? arg1, string? arg2, string? arg3, bool arg4);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_string_string_string_bool___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				bool arg4 = ConvertStructArgument<bool>(context, span, arguments[3], 3);
				return _delegate(context, arg, arg2, arg3, arg4);
			}
		}

		private class Functionstring_TemplateContext_string_string_string_string___Opt : DynamicCustomFunction
		{
			private delegate string InternalDelegate(TemplateContext arg0, string? arg1, string? arg2, string? arg3, string? arg4);

			private readonly InternalDelegate _delegate;

			public Functionstring_TemplateContext_string_string_string_string___Opt(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				string arg2 = ConvertNullableReferenceArgument<string>(context, span, arguments[1], 1);
				string arg3 = ConvertNullableReferenceArgument<string>(context, span, arguments[2], 2);
				string arg4 = ConvertNullableReferenceArgument<string>(context, span, arguments[3], 3);
				return _delegate(context, arg, arg2, arg3, arg4);
			}
		}

		private class FunctionTimeSpan_double : DynamicCustomFunction
		{
			private delegate TimeSpan InternalDelegate(double arg0);

			private readonly InternalDelegate _delegate;

			public FunctionTimeSpan_double(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				double arg = ConvertStructArgument<double>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		private class FunctionTimeSpan_string : DynamicCustomFunction
		{
			private delegate TimeSpan InternalDelegate(string? arg0);

			private readonly InternalDelegate _delegate;

			public FunctionTimeSpan_string(MethodInfo method)
				: base(method)
			{
				_delegate = (InternalDelegate)method.CreateDelegate(typeof(InternalDelegate));
			}

			public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
			{
				SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
				string arg = ConvertNullableReferenceArgument<string>(context, span, arguments[0], 0);
				return _delegate(arg);
			}
		}

		protected struct ArgumentValue
		{
			public readonly int Index;

			public readonly Type Type;

			public readonly object? Value;

			public ArgumentValue(int index, Type type, object? value)
			{
				Index = index;
				Type = type;
				Value = value;
			}
		}

		private class MethodComparer : IEqualityComparer<MethodInfo>
		{
			public static readonly MethodComparer Default = new MethodComparer();

			public bool Equals(MethodInfo? method, MethodInfo? otherMethod)
			{
				if ((object)method != null && (object)otherMethod != null && method.ReturnType == otherMethod.ReturnType && method.IsStatic == otherMethod.IsStatic)
				{
					if (method.DeclaringType?.FullName != otherMethod.DeclaringType?.FullName)
					{
						return false;
					}
					if (method.Name != otherMethod.Name)
					{
						return false;
					}
					ParameterInfo[] parameters = method.GetParameters();
					ParameterInfo[] parameters2 = otherMethod.GetParameters();
					int num = parameters.Length;
					if (num == parameters2.Length)
					{
						for (int i = 0; i < num; i++)
						{
							ParameterInfo parameterInfo = parameters[i];
							ParameterInfo parameterInfo2 = parameters2[i];
							if (parameterInfo.ParameterType != parameterInfo2.ParameterType || parameterInfo.IsOptional != parameterInfo2.IsOptional)
							{
								return false;
							}
						}
						return true;
					}
				}
				return false;
			}

			public int GetHashCode(MethodInfo method)
			{
				int num = method.ReturnType.GetHashCode();
				if (!method.IsStatic)
				{
					num = (num * 397) ^ 1;
				}
				ParameterInfo[] parameters = method.GetParameters();
				for (int i = 0; i < parameters.Length; i++)
				{
					num = (num * 397) ^ parameters[i].ParameterType.GetHashCode();
				}
				return num;
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <ConfigureAwait>d__82 : IAsyncStateMachine
		{
			private static class <>o__82
			{
				public static CallSite<Func<CallSite, object, object>> <>p__0;

				public static CallSite<Func<CallSite, object, object>> <>p__1;

				public static CallSite<Func<CallSite, object, bool>> <>p__2;

				public static CallSite<Func<CallSite, object, object>> <>p__3;
			}

			public int <>1__state;

			public AsyncValueTaskMethodBuilder<object> <>t__builder;

			public object result;

			private ConfiguredTaskAwaitable<object>.ConfiguredTaskAwaiter <>u__1;

			private ConfiguredTaskAwaitable<string>.ConfiguredTaskAwaiter <>u__2;

			private object <>u__3;

			private void MoveNext()
			{
				int num = <>1__state;
				object obj;
				try
				{
					ConfiguredTaskAwaitable<string>.ConfiguredTaskAwaiter awaiter;
					dynamic val;
					ConfiguredTaskAwaitable<object>.ConfiguredTaskAwaiter awaiter2;
					switch (num)
					{
					default:
						if (result != null)
						{
							if (!(result is Task<object> task))
							{
								if (result is Task<string> task2)
								{
									awaiter = task2.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
									if (!awaiter.IsCompleted)
									{
										num = (<>1__state = 1);
										<>u__2 = awaiter;
										<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
										return;
									}
									goto IL_0110;
								}
								val = ((dynamic)result).GetAwaiter();
								if (!(bool)val.IsCompleted)
								{
									num = (<>1__state = 2);
									<>u__3 = val;
									ICriticalNotifyCompletion awaiter3 = val as ICriticalNotifyCompletion;
									if (awaiter3 == null)
									{
										INotifyCompletion awaiter4 = (INotifyCompletion)(object)val;
										<>t__builder.AwaitOnCompleted(ref awaiter4, ref this);
										awaiter4 = null;
									}
									else
									{
										<>t__builder.AwaitUnsafeOnCompleted(ref awaiter3, ref this);
									}
									awaiter3 = null;
									return;
								}
								break;
							}
							awaiter2 = task.ConfigureAwait(continueOnCapturedContext: false).GetAwaiter();
							if (!awaiter2.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = awaiter2;
								<>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref this);
								return;
							}
							goto IL_00a7;
						}
						obj = null;
						goto end_IL_0007;
					case 0:
						awaiter2 = <>u__1;
						<>u__1 = default(ConfiguredTaskAwaitable<object>.ConfiguredTaskAwaiter);
						num = (<>1__state = -1);
						goto IL_00a7;
					case 1:
						awaiter = <>u__2;
						<>u__2 = default(ConfiguredTaskAwaitable<string>.ConfiguredTaskAwaiter);
						num = (<>1__state = -1);
						goto IL_0110;
					case 2:
						{
							val = <>u__3;
							<>u__3 = null;
							num = (<>1__state = -1);
							break;
						}
						IL_0110:
						obj = awaiter.GetResult();
						goto end_IL_0007;
						IL_00a7:
						obj = awaiter2.GetResult();
						goto end_IL_0007;
					}
					obj = val.GetResult();
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<>t__builder.SetResult(obj);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				<>t__builder.SetStateMachine(stateMachine);
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		private static readonly Dictionary<MethodInfo, Func<MethodInfo, DynamicCustomFunction>> BuiltinFunctionDelegates;

		public readonly MethodInfo Method;

		protected readonly ParameterInfo[] Parameters;

		private readonly Type _returnType;

		private readonly ScriptParameterInfo[] _parameterInfos;

		protected readonly bool IsAwaitable;

		protected readonly ScriptVarParamKind _varParamKind;

		protected readonly int _paramsIndex;

		protected readonly bool _hasTemplateContext;

		protected readonly bool _hasSpan;

		protected readonly int _optionalParameterCount;

		protected readonly Type? _paramsElementType;

		protected readonly int _expectedNumberOfParameters;

		protected readonly int _minimumRequiredParameters;

		protected readonly int _firstIndexOfUserParameters;

		public int RequiredParameterCount => _minimumRequiredParameters;

		public int ParameterCount => _expectedNumberOfParameters;

		public ScriptVarParamKind VarParamKind => _varParamKind;

		public Type ReturnType => _returnType;

		public object? Tag { get; set; }

		static DynamicCustomFunction()
		{
			BuiltinFunctionDelegates = new Dictionary<MethodInfo, Func<MethodInfo, DynamicCustomFunction>>(MethodComparer.Default);
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Contains", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(IEnumerable),
				typeof(object)
			}, null), (MethodInfo method) => new Functionbool_IEnumerable_object(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("IsNumber", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(object) }, null), (MethodInfo method) => new Functionbool_object(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Empty", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionbool_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Whitespace", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionbool_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Contains", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionbool_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("EndsWith", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionbool_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("EqualsIgnoreCase", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionbool_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("StartsWith", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionbool_string_string(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Contains", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(object)
			}, null), (MethodInfo method) => new Functionbool_TemplateContext_SourceSpan_IEnumerable_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Any", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[5]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(object),
				typeof(object[])
			}, null), (MethodInfo method) => new Functionbool_TemplateContext_SourceSpan_IEnumerable_object_objectArray(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("Now", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null), (MethodInfo method) => new FunctionDateTime(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("UtcNow", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null), (MethodInfo method) => new FunctionDateTime(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("AddDays", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(DateTime),
				typeof(double)
			}, null), (MethodInfo method) => new FunctionDateTime_DateTime_double(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("AddHours", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(DateTime),
				typeof(double)
			}, null), (MethodInfo method) => new FunctionDateTime_DateTime_double(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("AddMinutes", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(DateTime),
				typeof(double)
			}, null), (MethodInfo method) => new FunctionDateTime_DateTime_double(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("AddSeconds", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(DateTime),
				typeof(double)
			}, null), (MethodInfo method) => new FunctionDateTime_DateTime_double(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("AddMilliseconds", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(DateTime),
				typeof(double)
			}, null), (MethodInfo method) => new FunctionDateTime_DateTime_double(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("AddMonths", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(DateTime),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionDateTime_DateTime_int(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("AddYears", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(DateTime),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionDateTime_DateTime_int(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Ceil", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(double) }, null), (MethodInfo method) => new Functiondouble_double(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Floor", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(double) }, null), (MethodInfo method) => new Functiondouble_double(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Round", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(double),
				typeof(int)
			}, null), (MethodInfo method) => new Functiondouble_double_int___Opt(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Compact", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(IEnumerable) }, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Reverse", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(IEnumerable) }, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Uniq", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(IEnumerable) }, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("AddRange", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(IEnumerable),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Concat", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(IEnumerable),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Limit", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(IEnumerable),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable_int(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Offset", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(IEnumerable),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable_int(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("InsertAt", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(IEnumerable),
				typeof(int),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable_int_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Add", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(IEnumerable),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionIEnumerable_IEnumerable_object(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Split", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new FunctionIEnumerable_string_string(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Compact", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Reverse", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Uniq", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("AddRange", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Concat", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Limit", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_int(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Offset", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_int(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("InsertAt", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[5]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(int),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_int_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Add", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_IEnumerable_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Map", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(string)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_object_string(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Sort", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(string)
			}, null), (MethodInfo method) => new FunctionIEnumerable_TemplateContext_SourceSpan_object_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("RemoveAt", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(IList),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionIList_IList_int(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("RemoveAt", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IList),
				typeof(int)
			}, null), (MethodInfo method) => new FunctionIList_TemplateContext_SourceSpan_IList_int(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Size", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(IEnumerable) }, null), (MethodInfo method) => new Functionint_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Size", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(object) }, null), (MethodInfo method) => new Functionint_object(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Size", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionint_string(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Size", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new Functionint_TemplateContext_SourceSpan_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Size", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object)
			}, null), (MethodInfo method) => new Functionint_TemplateContext_SourceSpan_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("First", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(IEnumerable) }, null), (MethodInfo method) => new Functionobject_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Last", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(IEnumerable) }, null), (MethodInfo method) => new Functionobject_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Default", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(object),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_object_object(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("DividedBy", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(double),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_double_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Last", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_IEnumerable(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Cycle", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IList),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_IList_object___Opt(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Random", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(int),
				typeof(int)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_int_int(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Abs", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_object(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Eval", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_object(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("EvalTemplate", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_object(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Minus", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_object_object(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Modulo", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_object_object(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Plus", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_object_object(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Times", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(object)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_SourceSpan_object_object(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("FromJson", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(string)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("ToInt", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(string)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("ToLong", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(string)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("ToFloat", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(string)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("ToDouble", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(string)
			}, null), (MethodInfo method) => new Functionobject_TemplateContext_string(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Keys", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionScriptArray_TemplateContext_object(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Values", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionScriptArray_TemplateContext_object(method));
			AddBuiltinFunctionDelegate(typeof(RegexFunctions).GetMethod("Match", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new FunctionScriptArray_TemplateContext_string_string_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(RegexFunctions).GetMethod("Matches", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new FunctionScriptArray_TemplateContext_string_string_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(RegexFunctions).GetMethod("Split", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new FunctionScriptArray_TemplateContext_string_string_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Each", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionScriptRange_TemplateContext_SourceSpan_IEnumerable_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Filter", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(object)
			}, null), (MethodInfo method) => new FunctionScriptRange_TemplateContext_SourceSpan_IEnumerable_object(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Uuid", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null), (MethodInfo method) => new Functionstring(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Pluralize", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(int),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_int_string_string(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Typeof", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(object) }, null), (MethodInfo method) => new Functionstring_object(method));
			AddBuiltinFunctionDelegate(typeof(HtmlFunctions).GetMethod("Escape", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(HtmlFunctions).GetMethod("NewlineToBr", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(HtmlFunctions).GetMethod("UrlEncode", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(HtmlFunctions).GetMethod("UrlEscape", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(RegexFunctions).GetMethod("Escape", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(RegexFunctions).GetMethod("Unescape", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Escape", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Capitalize", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Capitalizewords", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Downcase", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Handleize", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Literal", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("LStrip", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("RStrip", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Strip", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("StripNewlines", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Upcase", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Md5", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Sha1", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Sha256", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Sha512", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Base64Encode", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Base64Decode", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new Functionstring_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("PadLeft", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(int)
			}, null), (MethodInfo method) => new Functionstring_string_int(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("PadRight", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(int)
			}, null), (MethodInfo method) => new Functionstring_string_int(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Slice1", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(string),
				typeof(int),
				typeof(int)
			}, null), (MethodInfo method) => new Functionstring_string_int_int___Opt(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Truncate", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(string),
				typeof(int),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_int_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Truncatewords", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(string),
				typeof(int),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_int_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Append", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Prepend", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Remove", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("RemoveFirst", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("RemoveLast", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("HmacSha1", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("HmacSha256", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("HmacSha512", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Replace", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(string),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_string_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("ReplaceFirst", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(string),
				typeof(string),
				typeof(string),
				typeof(bool)
			}, null), (MethodInfo method) => new Functionstring_string_string_string_bool___Opt(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Kind", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(object)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_object(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("ToJson", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(object)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_object(method));
			AddBuiltinFunctionDelegate(typeof(ArrayFunctions).GetMethod("Join", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[5]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(IEnumerable),
				typeof(string),
				typeof(object)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_SourceSpan_IEnumerable_string_object___Opt(method));
			AddBuiltinFunctionDelegate(typeof(MathFunctions).GetMethod("Format", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[5]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_SourceSpan_object_string_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(ObjectFunctions).GetMethod("Format", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[5]
			{
				typeof(TemplateContext),
				typeof(SourceSpan),
				typeof(object),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_SourceSpan_object_string_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(HtmlFunctions).GetMethod("Strip", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
			{
				typeof(TemplateContext),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("PadLeft", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(int)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_int(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("PadRight", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(int)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_int(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Append", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Prepend", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_string(method));
			AddBuiltinFunctionDelegate(typeof(DateTimeFunctions).GetMethod("ParseToString", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[6]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string),
				typeof(string),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_string___Opt_string___Opt_string___Opt_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("Replace", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[4]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_string_string(method));
			AddBuiltinFunctionDelegate(typeof(StringFunctions).GetMethod("ReplaceFirst", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[5]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string),
				typeof(string),
				typeof(bool)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_string_string_bool___Opt(method));
			AddBuiltinFunctionDelegate(typeof(RegexFunctions).GetMethod("Replace", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[5]
			{
				typeof(TemplateContext),
				typeof(string),
				typeof(string),
				typeof(string),
				typeof(string)
			}, null), (MethodInfo method) => new Functionstring_TemplateContext_string_string_string_string___Opt(method));
			AddBuiltinFunctionDelegate(typeof(TimeSpanFunctions).GetMethod("FromDays", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(double) }, null), (MethodInfo method) => new FunctionTimeSpan_double(method));
			AddBuiltinFunctionDelegate(typeof(TimeSpanFunctions).GetMethod("FromHours", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(double) }, null), (MethodInfo method) => new FunctionTimeSpan_double(method));
			AddBuiltinFunctionDelegate(typeof(TimeSpanFunctions).GetMethod("FromMinutes", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(double) }, null), (MethodInfo method) => new FunctionTimeSpan_double(method));
			AddBuiltinFunctionDelegate(typeof(TimeSpanFunctions).GetMethod("FromSeconds", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(double) }, null), (MethodInfo method) => new FunctionTimeSpan_double(method));
			AddBuiltinFunctionDelegate(typeof(TimeSpanFunctions).GetMethod("FromMilliseconds", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(double) }, null), (MethodInfo method) => new FunctionTimeSpan_double(method));
			AddBuiltinFunctionDelegate(typeof(TimeSpanFunctions).GetMethod("Parse", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null), (MethodInfo method) => new FunctionTimeSpan_string(method));
		}

		protected DynamicCustomFunction(MethodInfo method, ParameterInfo[]? parameters = null)
		{
			Method = method ?? throw new ArgumentNullException("method");
			_returnType = method.ReturnType;
			Parameters = parameters ?? method.GetParameters();
			IsAwaitable = (object)method.ReturnType.GetMethod("GetAwaiter") != null;
			_paramsIndex = -1;
			if (Parameters.Length != 0)
			{
				if (typeof(TemplateContext).IsAssignableFrom(Parameters[0].ParameterType))
				{
					_hasTemplateContext = true;
					if (Parameters.Length > 1)
					{
						_hasSpan = typeof(SourceSpan).IsAssignableFrom(Parameters[1].ParameterType);
					}
				}
				ParameterInfo parameterInfo = Parameters[Parameters.Length - 1];
				if (parameterInfo.ParameterType.IsArray && (parameterInfo.ParameterType == typeof(object[]) || parameterInfo.ParameterType == typeof(ScriptExpression[]) || parameterInfo.GetCustomAttributes(typeof(ParamArrayAttribute), inherit: false).Length != 0))
				{
					_varParamKind = ScriptVarParamKind.LastParameter;
					_paramsElementType = parameterInfo.ParameterType.GetElementType();
					_paramsIndex = Parameters.Length - 1;
				}
			}
			_expectedNumberOfParameters = Parameters.Length;
			_firstIndexOfUserParameters = 0;
			if (_varParamKind == ScriptVarParamKind.None)
			{
				for (int i = 0; i < Parameters.Length; i++)
				{
					if (Parameters[i].IsOptional)
					{
						_optionalParameterCount++;
					}
				}
			}
			if (_hasTemplateContext)
			{
				_firstIndexOfUserParameters++;
				if (_hasSpan)
				{
					_firstIndexOfUserParameters++;
				}
			}
			_expectedNumberOfParameters -= _firstIndexOfUserParameters;
			_minimumRequiredParameters = _expectedNumberOfParameters - _optionalParameterCount;
			if (_varParamKind == ScriptVarParamKind.LastParameter)
			{
				_minimumRequiredParameters--;
			}
			_parameterInfos = new ScriptParameterInfo[_expectedNumberOfParameters];
			for (int j = 0; j < _expectedNumberOfParameters; j++)
			{
				int num = _firstIndexOfUserParameters + j;
				ParameterInfo parameterInfo2 = Parameters[num];
				Type parameterType = ((num == Parameters.Length - 1 && _varParamKind == ScriptVarParamKind.LastParameter) ? (_paramsElementType ?? parameterInfo2.ParameterType) : parameterInfo2.ParameterType);
				string name = parameterInfo2.Name ?? string.Empty;
				_parameterInfos[j] = (parameterInfo2.HasDefaultValue ? new ScriptParameterInfo(parameterType, name, parameterInfo2.DefaultValue) : new ScriptParameterInfo(parameterType, name));
			}
		}

		protected unsafe async ValueTask<object?> ConfigureAwait(object? result)
		{
			if (result == null)
			{
				return null;
			}
			if (!(result is Task<object> task))
			{
				if (result is Task<string> task2)
				{
					return await task2.ConfigureAwait(continueOnCapturedContext: false);
				}
				dynamic awaiter = ((dynamic)result).GetAwaiter();
				if (!(bool)awaiter.IsCompleted)
				{
					ICriticalNotifyCompletion awaiter2 = awaiter as ICriticalNotifyCompletion;
					AsyncValueTaskMethodBuilder<object> asyncValueTaskMethodBuilder = default(AsyncValueTaskMethodBuilder<object>);
					if (awaiter2 == null)
					{
						INotifyCompletion awaiter3 = (INotifyCompletion)(object)awaiter;
						asyncValueTaskMethodBuilder.AwaitOnCompleted(ref awaiter3, ref *(<ConfigureAwait>d__82*)/*Error near IL_022d: stateMachine*/);
					}
					else
					{
						asyncValueTaskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter2, ref *(<ConfigureAwait>d__82*)/*Error near IL_0240: stateMachine*/);
					}
					/*Error near IL_0249: leave MoveNext - await not detected correctly*/;
				}
				return awaiter.GetResult();
			}
			return await task.ConfigureAwait(continueOnCapturedContext: false);
		}

		protected ArgumentValue GetValueFromNamedArgument(TemplateContext context, ScriptNode callerContext, ScriptNamedArgument namedArg)
		{
			for (int i = 0; i < Parameters.Length; i++)
			{
				ParameterInfo parameterInfo = Parameters[i];
				if (parameterInfo.Name == namedArg.Name?.Name)
				{
					return new ArgumentValue(i, parameterInfo.ParameterType, context.Evaluate(namedArg));
				}
			}
			throw new ScriptRuntimeException(callerContext.Span, $"Invalid argument `{namedArg.Name}` not found for function `{callerContext}`");
		}

		public abstract object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement);

		public ScriptParameterInfo GetParameterInfo(int index)
		{
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", "Argument index must be >= 0");
			}
			if (index >= _parameterInfos.Length)
			{
				if (_varParamKind != ScriptVarParamKind.LastParameter)
				{
					throw new ArgumentOutOfRangeException("index", $"Argument index must be < {ParameterCount}");
				}
				index = _parameterInfos.Length - 1;
			}
			return _parameterInfos[index];
		}

		public virtual ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			return new ValueTask<object>(Invoke(context, callerContext, arguments, blockStatement));
		}

		protected T ConvertReferenceArgument<T>(TemplateContext context, SourceSpan span, object? value, int parameterIndex) where T : class
		{
			object obj = ConvertArgument(context, span, value, typeof(T), parameterIndex);
			if (obj == null)
			{
				int num = _firstIndexOfUserParameters + parameterIndex;
				string text = ((num < Parameters.Length) ? (Parameters[num].Name ?? $"arg{parameterIndex}") : $"arg{parameterIndex}");
				throw new ScriptRuntimeException(span, "Argument `" + text + "` cannot be null for function `" + Method.Name + "`.");
			}
			return (T)obj;
		}

		protected T? ConvertNullableReferenceArgument<T>(TemplateContext context, SourceSpan span, object? value, int parameterIndex) where T : class
		{
			return (T)ConvertArgument(context, span, value, typeof(T), parameterIndex);
		}

		protected T ConvertStructArgument<T>(TemplateContext context, SourceSpan span, object? value, int parameterIndex) where T : struct
		{
			object obj = ConvertArgument(context, span, value, typeof(T), parameterIndex);
			if (obj == null)
			{
				return default(T);
			}
			return (T)obj;
		}

		[return: MaybeNull]
		protected T ConvertGenericArgument<T>(TemplateContext context, SourceSpan span, object? value, int parameterIndex)
		{
			object obj = ConvertArgument(context, span, value, typeof(T), parameterIndex);
			if (obj == null)
			{
				return default(T);
			}
			return (T)obj;
		}

		protected object? ConvertArgument(TemplateContext context, SourceSpan span, object? value, Type destinationType, int parameterIndex)
		{
			object obj = context.ToObject(span, value, destinationType);
			int num = _firstIndexOfUserParameters + parameterIndex;
			if (obj == null && num < Parameters.Length && !CanAcceptNull(Parameters[num]))
			{
				string text = Parameters[num].Name ?? $"arg{parameterIndex}";
				throw new ScriptRuntimeException(span, "Argument `" + text + "` cannot be null for function `" + Method.Name + "`.");
			}
			return obj;
		}

		protected static void AddBuiltinFunctionDelegate(MethodInfo? method, Func<MethodInfo, DynamicCustomFunction> factory)
		{
			if (factory == null)
			{
				throw new ArgumentNullException("factory");
			}
			if ((object)method == null)
			{
				throw new InvalidOperationException("Unable to resolve a generated builtin method.");
			}
			BuiltinFunctionDelegates.Add(method, factory);
		}

		private static bool CanAcceptNull(ParameterInfo parameter)
		{
			Type parameterType = parameter.ParameterType;
			if ((object)Nullable.GetUnderlyingType(parameterType) != null)
			{
				return true;
			}
			if (parameterType.IsValueType)
			{
				return false;
			}
			if (!HasNullableMetadata(parameter) && !HasNullableContext(parameter.Member))
			{
				return HasNullableContext(parameter.Member.DeclaringType);
			}
			return true;
		}

		private static bool HasNullableMetadata(ParameterInfo provider)
		{
			foreach (CustomAttributeData customAttributesDatum in provider.GetCustomAttributesData())
			{
				if (!(customAttributesDatum.AttributeType.FullName != "System.Runtime.CompilerServices.NullableAttribute") && TryGetNullableFlag(customAttributesDatum, out var flag))
				{
					return flag == 2;
				}
			}
			return false;
		}

		private static bool HasNullableContext(MemberInfo? provider)
		{
			if ((object)provider == null)
			{
				return false;
			}
			foreach (CustomAttributeData customAttributesDatum in provider.GetCustomAttributesData())
			{
				if (!(customAttributesDatum.AttributeType.FullName != "System.Runtime.CompilerServices.NullableContextAttribute") && TryGetNullableFlag(customAttributesDatum, out var flag))
				{
					return flag == 2;
				}
			}
			return false;
		}

		private static bool HasNullableContext(Type? provider)
		{
			if ((object)provider == null)
			{
				return false;
			}
			foreach (CustomAttributeData customAttributesDatum in provider.GetCustomAttributesData())
			{
				if (!(customAttributesDatum.AttributeType.FullName != "System.Runtime.CompilerServices.NullableContextAttribute") && TryGetNullableFlag(customAttributesDatum, out var flag))
				{
					return flag == 2;
				}
			}
			return false;
		}

		private static bool TryGetNullableFlag(CustomAttributeData attribute, out byte flag)
		{
			flag = 0;
			if (attribute.ConstructorArguments.Count == 0)
			{
				return false;
			}
			object value = attribute.ConstructorArguments[0].Value;
			if (value is byte b)
			{
				flag = b;
				return true;
			}
			if (value is IReadOnlyCollection<CustomAttributeTypedArgument> { Count: >0 } readOnlyCollection)
			{
				foreach (CustomAttributeTypedArgument item in readOnlyCollection)
				{
					if (item.Value is byte b2)
					{
						flag = b2;
						return true;
					}
				}
			}
			return false;
		}

		public static DynamicCustomFunction Create(object? target, MethodInfo method)
		{
			if ((object)method == null)
			{
				throw new ArgumentNullException("method");
			}
			if (target == null && method.IsStatic && BuiltinFunctionDelegates.TryGetValue(method, out Func<MethodInfo, DynamicCustomFunction> value))
			{
				return value(method);
			}
			return new DelegateCustomFunction(target, method);
		}

		public static DynamicCustomFunction Create(Delegate del)
		{
			if ((object)del == null)
			{
				throw new ArgumentNullException("del");
			}
			return new DelegateCustomFunction(del);
		}

		protected async ValueTask<ArgumentValue> GetValueFromNamedArgumentAsync(TemplateContext context, ScriptNode callerContext, ScriptNamedArgument namedArg)
		{
			for (int i = 0; i < Parameters.Length; i++)
			{
				ParameterInfo parameterInfo = Parameters[i];
				if (parameterInfo.Name == namedArg.Name?.Name)
				{
					int index = i;
					Type parameterType = parameterInfo.ParameterType;
					return new ArgumentValue(index, parameterType, await context.EvaluateAsync(namedArg).ConfigureAwait(continueOnCapturedContext: false));
				}
			}
			throw new ScriptRuntimeException(callerContext.Span, $"Invalid argument `{namedArg.Name}` not found for function `{callerContext}`");
		}
	}
	public class DelegateCustomFunction : DynamicCustomFunction
	{
		private class InternalDelegateCustomFunction<TResult> : DelegateCustomFunction
		{
			public Func<TResult> Func { get; }

			public InternalDelegateCustomFunction(Func<TResult> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return Func();
			}
		}

		private class InternalDelegateCustomFunction<T, TResult> : DelegateCustomFunction
		{
			public Func<T, TResult> Func { get; }

			public InternalDelegateCustomFunction(Func<T, TResult> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class DelegateCustomAction<T> : DelegateCustomFunction
		{
			public Action<T> Func { get; }

			public DelegateCustomAction(Action<T> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class InternalDelegateCustomFunction<T1, T2, TResult> : DelegateCustomFunction
		{
			public Func<T1, T2, TResult> Func { get; }

			public InternalDelegateCustomFunction(Func<T1, T2, TResult> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class DelegateCustomAction<T1, T2> : DelegateCustomFunction
		{
			public Action<T1, T2> Func { get; }

			public DelegateCustomAction(Action<T1, T2> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class InternalDelegateCustomFunction<T1, T2, T3, TResult> : DelegateCustomFunction
		{
			public Func<T1, T2, T3, TResult> Func { get; }

			public InternalDelegateCustomFunction(Func<T1, T2, T3, TResult> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class DelegateCustomAction<T1, T2, T3> : DelegateCustomFunction
		{
			public Action<T1, T2, T3> Func { get; }

			public DelegateCustomAction(Action<T1, T2, T3> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class InternalDelegateCustomFunction<T1, T2, T3, T4, TResult> : DelegateCustomFunction
		{
			public Func<T1, T2, T3, T4, TResult> Func { get; }

			public InternalDelegateCustomFunction(Func<T1, T2, T3, T4, TResult> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class DelegateCustomAction<T1, T2, T3, T4> : DelegateCustomFunction
		{
			public Action<T1, T2, T3, T4> Func { get; }

			public DelegateCustomAction(Action<T1, T2, T3, T4> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class InternalDelegateCustomFunction<T1, T2, T3, T4, T5, TResult> : DelegateCustomFunction
		{
			public Func<T1, T2, T3, T4, T5, TResult> Func { get; }

			public InternalDelegateCustomFunction(Func<T1, T2, T3, T4, T5, TResult> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private class DelegateCustomAction<T1, T2, T3, T4, T5> : DelegateCustomFunction
		{
			public Action<T1, T2, T3, T4, T5> Func { get; }

			public DelegateCustomAction(Action<T1, T2, T3, T4, T5> func)
				: base(func)
			{
				Func = func;
			}

			protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
			{
				return base.InvokeImpl(context, span, arguments);
			}
		}

		private readonly Delegate? _del;

		public object? Target { get; }

		public DelegateCustomFunction(Delegate del)
			: base(GetDelegateMethod(del), GetDelegateParameterInfos(del))
		{
			_del = del ?? throw new ArgumentNullException("del");
			Target = del.Target;
		}

		public DelegateCustomFunction(object? target, MethodInfo method)
			: base(method)
		{
			Target = target;
		}

		public override object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray scriptArguments, ScriptBlockStatement? blockStatement)
		{
			Array paramsArguments = null;
			object[] array = PrepareArguments(context, callerContext, scriptArguments, ref paramsArguments);
			SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
			try
			{
				return InvokeImpl(context, span, array);
			}
			catch (TargetInvocationException ex)
			{
				if (ex.InnerException != null)
				{
					throw ex.InnerException;
				}
				throw new ScriptRuntimeException(span, $"Unexpected exception when calling {callerContext}");
			}
			finally
			{
				context.ReleaseReflectionArguments(array);
			}
		}

		public override async ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray scriptArguments, ScriptBlockStatement? blockStatement)
		{
			Array paramsArguments = null;
			object?[] arguments = PrepareArguments(context, callerContext, scriptArguments, ref paramsArguments);
			SourceSpan callerSpan = callerContext?.Span ?? context.CurrentSpan;
			try
			{
				object result = InvokeImpl(context, callerSpan, arguments);
				if (!IsAwaitable)
				{
					return result;
				}
				return await ConfigureAwait(result);
			}
			catch (TargetInvocationException ex)
			{
				if (ex.InnerException != null)
				{
					throw ex.InnerException;
				}
				throw new ScriptRuntimeException(callerSpan, $"Unexpected exception when calling {callerContext}");
			}
			finally
			{
				context.ReleaseReflectionArguments(arguments);
			}
		}

		public static DelegateCustomFunction Create(Action action)
		{
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			return new DelegateCustomAction(action);
		}

		public static DelegateCustomFunction Create<T>(Action<T> action)
		{
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			return new DelegateCustomAction<T>(action);
		}

		public static DelegateCustomFunction Create<T1, T2>(Action<T1, T2> action)
		{
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			return new DelegateCustomAction<T1, T2>(action);
		}

		public static DelegateCustomFunction Create<T1, T2, T3>(Action<T1, T2, T3> action)
		{
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			return new DelegateCustomAction<T1, T2, T3>(action);
		}

		public static DelegateCustomFunction Create<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action)
		{
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			return new DelegateCustomAction<T1, T2, T3, T4>(action);
		}

		public static DelegateCustomFunction Create<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action)
		{
			if (action == null)
			{
				throw new ArgumentNullException("action");
			}
			return new DelegateCustomAction<T1, T2, T3, T4, T5>(action);
		}

		public static DelegateCustomFunction CreateFunc<TResult>(Func<TResult> func)
		{
			if (func == null)
			{
				throw new ArgumentNullException("func");
			}
			return new InternalDelegateCustomFunction<TResult>(func);
		}

		public static DelegateCustomFunction CreateFunc<T1, TResult>(Func<T1, TResult> func)
		{
			if (func == null)
			{
				throw new ArgumentNullException("func");
			}
			return new InternalDelegateCustomFunction<T1, TResult>(func);
		}

		public static DelegateCustomFunction CreateFunc<T1, T2, TResult>(Func<T1, T2, TResult> func)
		{
			if (func == null)
			{
				throw new ArgumentNullException("func");
			}
			return new InternalDelegateCustomFunction<T1, T2, TResult>(func);
		}

		public static DelegateCustomFunction CreateFunc<T1, T2, T3, TResult>(Func<T1, T2, T3, TResult> func)
		{
			if (func == null)
			{
				throw new ArgumentNullException("func");
			}
			return new InternalDelegateCustomFunction<T1, T2, T3, TResult>(func);
		}

		public static DelegateCustomFunction CreateFunc<T1, T2, T3, T4, TResult>(Func<T1, T2, T3, T4, TResult> func)
		{
			if (func == null)
			{
				throw new ArgumentNullException("func");
			}
			return new InternalDelegateCustomFunction<T1, T2, T3, T4, TResult>(func);
		}

		public static DelegateCustomFunction CreateFunc<T1, T2, T3, T4, T5, TResult>(Func<T1, T2, T3, T4, T5, TResult> func)
		{
			if (func == null)
			{
				throw new ArgumentNullException("func");
			}
			return new InternalDelegateCustomFunction<T1, T2, T3, T4, T5, TResult>(func);
		}

		protected virtual object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
		{
			if ((object)_del == null)
			{
				return Method.Invoke(Target, arguments);
			}
			return _del.DynamicInvoke(arguments);
		}

		private static MethodInfo GetDelegateMethod(Delegate del)
		{
			if ((object)del == null)
			{
				throw new ArgumentNullException("del");
			}
			return del.Method;
		}

		private static ParameterInfo[] GetDelegateParameterInfos(Delegate del)
		{
			if ((object)del == null)
			{
				throw new ArgumentNullException("del");
			}
			MethodInfo? obj = del.GetType().GetMethod("Invoke") ?? throw new ArgumentException("Unable to resolve delegate Invoke method.", "del");
			ParameterInfo[] parameters = del.Method.GetParameters();
			ParameterInfo[] parameters2 = obj.GetParameters();
			if (parameters.Length != parameters2.Length)
			{
				return parameters;
			}
			ParameterInfo[] array = new ParameterInfo[parameters.Length];
			for (int i = 0; i < parameters.Length; i++)
			{
				ParameterInfo parameterInfo = parameters[i];
				ParameterInfo parameterInfo2 = parameters2[i];
				array[i] = ((parameterInfo2.HasDefaultValue && !parameterInfo.HasDefaultValue) ? parameterInfo2 : parameterInfo);
			}
			return array;
		}

		private object?[] PrepareArguments(TemplateContext context, ScriptNode? callerContext, ScriptArray scriptArguments, ref Array? paramsArguments)
		{
			object[] orCreateReflectionArguments = context.GetOrCreateReflectionArguments(Parameters.Length);
			SourceSpan sourceSpan = callerContext?.Span ?? context.CurrentSpan;
			if (_hasTemplateContext)
			{
				orCreateReflectionArguments[0] = context;
				if (_hasSpan)
				{
					orCreateReflectionArguments[1] = sourceSpan;
				}
			}
			paramsArguments = null;
			if (_varParamKind == ScriptVarParamKind.LastParameter)
			{
				ScriptArray scriptArray = (scriptArguments[scriptArguments.Count - 1] as ScriptArray) ?? new ScriptArray();
				Type type = _paramsElementType ?? typeof(object);
				int num = scriptArguments.Count - 1;
				for (int i = 0; i < num; i++)
				{
					int num2 = _firstIndexOfUserParameters + i;
					orCreateReflectionArguments[num2] = context.ToObject(sourceSpan, scriptArguments[i], Parameters[num2].ParameterType);
				}
				paramsArguments = ((type == typeof(object)) ? context.GetOrCreateReflectionArguments(scriptArray.Count) : Array.CreateInstance(type, scriptArray.Count));
				orCreateReflectionArguments[_paramsIndex] = paramsArguments;
				for (int j = 0; j < scriptArray.Count; j++)
				{
					object value = context.ToObject(sourceSpan, scriptArray[j], type);
					paramsArguments.SetValue(value, j);
				}
			}
			else
			{
				for (int k = 0; k < scriptArguments.Count; k++)
				{
					int num3 = _firstIndexOfUserParameters + k;
					orCreateReflectionArguments[num3] = context.ToObject(sourceSpan, scriptArguments[k], Parameters[num3].ParameterType);
				}
			}
			for (int l = _firstIndexOfUserParameters + scriptArguments.Count; l < Parameters.Length; l++)
			{
				orCreateReflectionArguments[l] = (Parameters[l].HasDefaultValue ? Parameters[l].DefaultValue : null);
			}
			return orCreateReflectionArguments;
		}
	}
	public class DelegateCustomAction : DelegateCustomFunction
	{
		public Action Func { get; }

		public DelegateCustomAction(Action func)
			: base(func)
		{
			Func = func;
		}

		protected override object? InvokeImpl(TemplateContext context, SourceSpan span, object?[] arguments)
		{
			Func();
			return null;
		}
	}
	[DebuggerDisplay("<empty object>")]
	public sealed class EmptyScriptObject : IScriptObject
	{
		public static readonly EmptyScriptObject Default = new EmptyScriptObject();

		public int Count => 0;

		public bool IsReadOnly
		{
			get
			{
				return true;
			}
			set
			{
			}
		}

		private EmptyScriptObject()
		{
		}

		public IEnumerable<string> GetMembers()
		{
			yield break;
		}

		public bool Contains(string member)
		{
			return false;
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, string member, out object? value)
		{
			value = null;
			return false;
		}

		public bool CanWrite(string member)
		{
			return false;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, string member, object? value, bool readOnly)
		{
			throw new ScriptRuntimeException(span, "Cannot set a property on the empty object");
		}

		public bool Remove(string member)
		{
			return false;
		}

		public void SetReadOnly(string member, bool readOnly)
		{
		}

		public IScriptObject Clone(bool deep)
		{
			return this;
		}

		public override string ToString()
		{
			return string.Empty;
		}
	}
	public interface IListAccessor
	{
		int GetLength(TemplateContext context, SourceSpan span, object target);

		object? GetValue(TemplateContext context, SourceSpan span, object target, int index);

		void SetValue(TemplateContext context, SourceSpan span, object target, int index, object? value);
	}
	public interface IObjectAccessor
	{
		bool HasIndexer { get; }

		Type? IndexType { get; }

		int GetMemberCount(TemplateContext context, SourceSpan span, object target);

		IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target);

		bool HasMember(TemplateContext context, SourceSpan span, object target, string member);

		bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value);

		bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value);

		bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value);

		bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value);
	}
	public interface IScriptCustomFunction : IScriptFunctionInfo
	{
		object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement);

		ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement);
	}
	public enum ScriptVarParamKind
	{
		None,
		Direct,
		LastParameter
	}
	public interface IScriptFunctionInfo
	{
		int RequiredParameterCount { get; }

		int ParameterCount { get; }

		ScriptVarParamKind VarParamKind { get; }

		Type ReturnType { get; }

		ScriptParameterInfo GetParameterInfo(int index);
	}
	public static class ScriptFunctionInfoExtensions
	{
		public static bool IsParameterType<T>(this IScriptFunctionInfo functionInfo, int index)
		{
			ScriptParameterInfo parameterInfo = functionInfo.GetParameterInfo(index);
			return typeof(T).IsAssignableFrom(parameterInfo.ParameterType);
		}
	}
	[DebuggerDisplay("{ParameterType} {Name}")]
	public readonly struct ScriptParameterInfo : IEquatable<ScriptParameterInfo>
	{
		public readonly Type ParameterType;

		public readonly string Name;

		public readonly bool HasDefaultValue;

		public readonly object? DefaultValue;

		public ScriptParameterInfo(Type parameterType, string name)
		{
			ParameterType = parameterType;
			Name = name;
			HasDefaultValue = false;
			DefaultValue = null;
		}

		public ScriptParameterInfo(Type parameterType, string name, object? defaultValue)
		{
			ParameterType = parameterType;
			Name = name;
			HasDefaultValue = true;
			DefaultValue = defaultValue;
		}

		public bool Equals(ScriptParameterInfo other)
		{
			if (ParameterType == other.ParameterType)
			{
				return Name == other.Name;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (ParameterType.GetHashCode() * 397) ^ (Name?.GetHashCode() ?? 0);
		}

		public static bool operator ==(ScriptParameterInfo left, ScriptParameterInfo right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(ScriptParameterInfo left, ScriptParameterInfo right)
		{
			return !left.Equals(right);
		}
	}
	public interface IScriptObject
	{
		int Count { get; }

		bool IsReadOnly { get; set; }

		IEnumerable<string> GetMembers();

		bool Contains(string member);

		bool TryGetValue(TemplateContext context, SourceSpan span, string member, out object? value);

		bool CanWrite(string member);

		bool TrySetValue(TemplateContext context, SourceSpan span, string member, object? value, bool readOnly);

		bool Remove(string member);

		void SetReadOnly(string member, bool readOnly);

		IScriptObject Clone(bool deep);
	}
	public interface IScriptOutput
	{
		void Write(string text, int offset, int count);

		ValueTask WriteAsync(string text, int offset, int count, CancellationToken cancellationToken);
	}
	public static class ScriptOutputExtensions
	{
		public static void Write(this IScriptOutput scriptOutput, string text)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			scriptOutput.Write(text, 0, text.Length);
		}

		public static void Write(this IScriptOutput scriptOutput, ScriptStringSlice text)
		{
			if (text.FullText == null)
			{
				throw new ArgumentNullException("text");
			}
			if (text.Length != 0)
			{
				scriptOutput.Write(text.FullText, text.Index, text.Length);
			}
		}

		public static async ValueTask WriteAsync(this IScriptOutput scriptOutput, string text, CancellationToken cancellationToken)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			await scriptOutput.WriteAsync(text, 0, text.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}

		public static async ValueTask WriteAsync(this IScriptOutput scriptOutput, ScriptStringSlice text, CancellationToken cancellationToken)
		{
			if (text.FullText == null)
			{
				throw new ArgumentNullException("text");
			}
			if (text.Length != 0)
			{
				await scriptOutput.WriteAsync(text.FullText, text.Index, text.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
		}
	}
	public interface IScriptTransformable
	{
		Type ElementType { get; }

		bool CanTransform(Type transformType);

		bool Visit(TemplateContext context, SourceSpan span, Func<object?, bool> visit);

		object? Transform(TemplateContext context, SourceSpan span, Func<object?, object?> apply, Type destType);
	}
	public interface ITemplateLoader
	{
		string? GetPath(TemplateContext context, SourceSpan callerSpan, string templateName);

		string? Load(TemplateContext context, SourceSpan callerSpan, string templatePath);

		ValueTask<string?> LoadAsync(TemplateContext context, SourceSpan callerSpan, string templatePath);
	}
	internal static class JsonElementExtensions
	{
		internal static object? ToScriban(this JsonElement model)
		{
			return model.ValueKind switch
			{
				JsonValueKind.Array => model.CopyToScriptArray(new ScriptArray()), 
				JsonValueKind.Object => model.CopyToScriptObject(new ScriptObject()), 
				JsonValueKind.False => false, 
				JsonValueKind.True => true, 
				JsonValueKind.Null => null, 
				JsonValueKind.Number => model.GetDecimal(), 
				JsonValueKind.String => model.GetString(), 
				JsonValueKind.Undefined => null, 
				_ => throw new ArgumentOutOfRangeException("model", model.ValueKind, null), 
			};
		}

		internal static IScriptObject CopyToScriptObject(this JsonElement json, IScriptObject obj)
		{
			foreach (JsonProperty item in json.EnumerateObject())
			{
				obj.SetValue(item.Name, item.Value.ToScriban(), readOnly: false);
			}
			return obj;
		}

		internal static ScriptArray CopyToScriptArray(this JsonElement json, ScriptArray array)
		{
			foreach (JsonElement item in json.EnumerateArray())
			{
				array.Add(item.ToScriban());
			}
			return array;
		}
	}
	public delegate bool MemberFilterDelegate(MemberInfo member);
	public delegate string MemberRenamerDelegate(MemberInfo member);
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ScriptArray<>.DebugListView))]
	public class ScriptArray<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IScriptObject, IScriptCustomBinaryOperation, IScriptTransformable
	{
		internal class DebugListView
		{
			private readonly ScriptArray<T> _collection;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public object?[] Items => _collection._values.Cast<object>().ToArray();

			public DebugListView(ScriptArray<T> collection)
			{
				_collection = collection;
			}
		}

		private List<T> _values;

		private bool _isReadOnly;

		private ScriptObject? _script;

		public int Capacity
		{
			get
			{
				return _values.Capacity;
			}
			set
			{
				_values.Capacity = value;
			}
		}

		public virtual bool IsReadOnly
		{
			get
			{
				return _isReadOnly;
			}
			set
			{
				if (_script != null)
				{
					_script.IsReadOnly = value;
				}
				_isReadOnly = value;
			}
		}

		public ScriptObject ScriptObject
		{
			get
			{
				ScriptObject scriptObject = _script;
				if (scriptObject == null)
				{
					ScriptObject obj = new ScriptObject
					{
						IsReadOnly = IsReadOnly
					};
					ScriptObject scriptObject2 = obj;
					_script = obj;
					scriptObject = scriptObject2;
				}
				return scriptObject;
			}
		}

		public int Count => _values.Count;

		public virtual T this[int index]
		{
			get
			{
				return _values[index];
			}
			[param: AllowNull]
			set
			{
				if (index >= 0)
				{
					this.AssertNotReadOnly();
					for (int i = _values.Count; i <= index; i++)
					{
						((IList)_values).Add((object?)GetDefaultValue());
					}
					((IList)_values)[index] = value;
				}
			}
		}

		object? IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				((IList)_values)[index] = ConvertValue(value);
			}
		}

		bool IList.IsFixedSize => ((IList)_values).IsFixedSize;

		bool ICollection.IsSynchronized => ((ICollection)_values).IsSynchronized;

		object ICollection.SyncRoot => ((ICollection)_values).SyncRoot;

		bool IList.IsReadOnly => IsReadOnly;

		bool ICollection<T>.IsReadOnly => IsReadOnly;

		public Type ElementType => typeof(T);

		public ScriptArray()
		{
			_values = new List<T>();
		}

		public ScriptArray(int capacity)
		{
			_values = new List<T>(capacity);
		}

		public ScriptArray(T[] array)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			_values = new List<T>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				_values.Add(array[i]);
			}
		}

		public ScriptArray(IEnumerable<T> values)
		{
			_values = new List<T>(values);
		}

		public ScriptArray(IEnumerable values)
		{
			_values = new List<T>();
			foreach (object value in values)
			{
				((IList)_values).Add((object?)ConvertValue(value));
			}
		}

		public virtual IScriptObject Clone(bool deep)
		{
			ScriptArray<T> scriptArray = (ScriptArray<T>)MemberwiseClone();
			scriptArray._values = new List<T>(_values.Count);
			scriptArray._script = null;
			if (deep)
			{
				foreach (T value in _values)
				{
					T item = value;
					if (value is IScriptObject)
					{
						item = (T)((IScriptObject)(object)value).Clone(deep: true);
					}
					scriptArray._values.Add(item);
				}
				if (_script != null)
				{
					scriptArray._script = (ScriptObject)_script.Clone(deep: true);
				}
			}
			else
			{
				foreach (T value2 in _values)
				{
					scriptArray._values.Add(value2);
				}
				if (_script != null)
				{
					scriptArray._script = (ScriptObject)_script.Clone(deep: false);
				}
			}
			return scriptArray;
		}

		public T[] ToArray()
		{
			return _values.ToArray();
		}

		public virtual void Add([AllowNull] T item)
		{
			this.AssertNotReadOnly();
			((IList)_values).Add((object?)item);
		}

		public void AddRange(IEnumerable<T> items)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			foreach (T item in items)
			{
				Add(item);
			}
		}

		int IList.Add(object? value)
		{
			((IList)_values).Add((object?)ConvertValue(value));
			return 0;
		}

		bool IList.Contains(object? value)
		{
			return ((IList)_values).Contains(value);
		}

		public virtual void Clear()
		{
			this.AssertNotReadOnly();
			_values.Clear();
		}

		int IList.IndexOf(object? value)
		{
			return ((IList)_values).IndexOf(value);
		}

		void IList.Insert(int index, object? value)
		{
			((IList)_values).Insert(index, (object?)ConvertValue(value));
		}

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

		public virtual void CopyTo(T[] array, int arrayIndex)
		{
			_values.CopyTo(array, arrayIndex);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void CopyTo(int index, T[] array, int arrayIndex, int count)
		{
			_values.CopyTo(index, array, arrayIndex, count);
		}

		public virtual int IndexOf(T item)
		{
			return _values.IndexOf(item);
		}

		public virtual void Insert(int index, [AllowNull] T item)
		{
			this.AssertNotReadOnly();
			for (int i = _values.Count; i < index; i++)
			{
				((IList)_values).Add((object?)GetDefaultValue());
			}
			((IList)_values).Insert(index, (object?)item);
		}

		void IList.Remove(object? value)
		{
			((IList)_values).Remove((object?)ConvertValue(value));
		}

		public virtual void RemoveAt(int index)
		{
			this.AssertNotReadOnly();
			if (index >= 0 && index < _values.Count)
			{
				_values.RemoveAt(index);
			}
		}

		public virtual bool Remove(T item)
		{
			this.AssertNotReadOnly();
			return _values.Remove(item);
		}

		public List<T>.Enumerator GetEnumerator()
		{
			return _values.GetEnumerator();
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			return _values.GetEnumerator();
		}

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

		void ICollection.CopyTo(Array array, int index)
		{
			((ICollection)_values).CopyTo(array, index);
		}

		public IEnumerable<string> GetMembers()
		{
			yield return "size";
			if (_script == null)
			{
				yield break;
			}
			foreach (string member in _script.GetMembers())
			{
				yield return member;
			}
		}

		public virtual bool Contains(string member)
		{
			return ScriptObject.Contains(member);
		}

		public virtual bool TryGetValue(TemplateContext context, SourceSpan span, string member, out object? value)
		{
			if (member == "size")
			{
				value = Count;
				return true;
			}
			return ScriptObject.TryGetValue(context, span, member, out value);
		}

		public virtual bool CanWrite(string member)
		{
			if (member == "size")
			{
				return false;
			}
			return ScriptObject.CanWrite(member);
		}

		public virtual bool TrySetValue(TemplateContext context, SourceSpan span, string member, object? value, bool readOnly)
		{
			return ScriptObject.TrySetValue(context, span, member, value, readOnly);
		}

		public virtual bool Remove(string member)
		{
			return ScriptObject.Remove(member);
		}

		public virtual void SetReadOnly(string member, bool readOnly)
		{
			ScriptObject.SetReadOnly(member, readOnly);
		}

		public bool TryEvaluate(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, SourceSpan leftSpan, object? leftValue, SourceSpan rightSpan, object? rightValue, out object? result)
		{
			result = null;
			ScriptArray<T> scriptArray = TryGetArray(leftValue);
			ScriptArray<T> scriptArray2 = TryGetArray(rightValue);
			int num = 0;
			SourceSpan sourceSpan = leftSpan;
			SourceSpan span2 = span;
			string text = null;
			switch (op)
			{
			case ScriptBinaryOperator.BinaryOr:
			case ScriptBinaryOperator.BinaryAnd:
			case ScriptBinaryOperator.CompareEqual:
			case ScriptBinaryOperator.CompareNotEqual:
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareLess:
			case ScriptBinaryOperator.CompareGreater:
			case ScriptBinaryOperator.Add:
				if (scriptArray == null)
				{
					span2 = leftSpan;
					text = " Expecting an array for the left argument.";
				}
				if (scriptArray2 == null)
				{
					span2 = rightSpan;
					text = " Expecting an array for the right argument.";
				}
				break;
			case ScriptBinaryOperator.Multiply:
				if ((scriptArray == null && scriptArray2 == null) || (scriptArray != null && scriptArray2 != null))
				{
					text = " Expecting only one array for the left or right argument.";
					break;
				}
				num = context.ToInt(span, (scriptArray == null) ? leftValue : rightValue);
				if (scriptArray2 == null)
				{
					sourceSpan = rightSpan;
				}
				break;
			case ScriptBinaryOperator.Divide:
			case ScriptBinaryOperator.DivideRound:
			case ScriptBinaryOperator.Modulus:
				if (scriptArray == null)
				{
					span2 = leftSpan;
					text = " Expecting an array for the left argument.";
				}
				else
				{
					num = context.ToInt(span, rightValue);
					sourceSpan = rightSpan;
				}
				break;
			case ScriptBinaryOperator.ShiftLeft:
				if (scriptArray == null)
				{
					span2 = leftSpan;
					text = " Expecting an array for the left argument.";
				}
				break;
			case ScriptBinaryOperator.ShiftRight:
				if (scriptArray2 == null)
				{
					span2 = rightSpan;
					text = " Expecting an array for the right argument.";
				}
				break;
			default:
				text = string.Empty;
				break;
			}
			if (num < 0)
			{
				span2 = sourceSpan;
				text = $" Integer {num} cannot be negative when multiplying";
			}
			if (text != null)
			{
				throw new ScriptRuntimeException(span2, "The operator `" + op.ToText() + "` is not supported between " + context.GetTypeName(leftValue) + " and " + context.GetTypeName(rightValue) + "." + text);
			}
			switch (op)
			{
			case ScriptBinaryOperator.BinaryOr:
				if (scriptArray == null || scriptArray2 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires array operands.");
				}
				result = new ScriptArray<T>(scriptArray.Union(scriptArray2));
				return true;
			case ScriptBinaryOperator.BinaryAnd:
				if (scriptArray == null || scriptArray2 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires array operands.");
				}
				result = new ScriptArray<T>(scriptArray.Intersect(scriptArray2));
				return true;
			case ScriptBinaryOperator.Add:
				if (scriptArray == null || scriptArray2 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires array operands.");
				}
				result = ArrayFunctions.Concat(scriptArray, scriptArray2);
				return true;
			case ScriptBinaryOperator.CompareEqual:
			case ScriptBinaryOperator.CompareNotEqual:
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareLess:
			case ScriptBinaryOperator.CompareGreater:
				if (scriptArray == null || scriptArray2 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires array operands.");
				}
				result = CompareTo(context, span, op, scriptArray, scriptArray2);
				return true;
			case ScriptBinaryOperator.Multiply:
			{
				ScriptArray<T> scriptArray7 = scriptArray ?? scriptArray2;
				if (scriptArray7 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires an array operand.");
				}
				if (num == 0)
				{
					result = new ScriptArray<T>();
					return true;
				}
				if (scriptArray7.Count == 0)
				{
					result = new ScriptArray<T>();
					return true;
				}
				long num2 = (long)num * (long)scriptArray7.Count;
				if (num2 > int.MaxValue)
				{
					throw new ScriptRuntimeException(span, "Array multiplication result length exceeds the maximum supported array length.");
				}
				if (context.LoopLimit > 0 && num2 > context.LoopLimit)
				{
					throw new ScriptRuntimeException(span, $"Exceeding number of iteration limit `{context.LoopLimit}` for internal iteration.");
				}
				ScriptArray<T> scriptArray8 = new ScriptArray<T>((int)num2);
				int loopStep = 0;
				for (int j = 0; j < num; j++)
				{
					context.StepLoop(span, ref loopStep);
					scriptArray8.AddRange(scriptArray7);
				}
				result = scriptArray8;
				return true;
			}
			case ScriptBinaryOperator.Divide:
			case ScriptBinaryOperator.DivideRound:
			{
				ScriptArray<T> scriptArray9 = scriptArray ?? scriptArray2;
				if (scriptArray9 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires an array operand.");
				}
				if (num == 0)
				{
					throw new ScriptRuntimeException(sourceSpan, "Cannot divide by 0");
				}
				int num3 = scriptArray9.Count / num;
				ScriptArray<T> scriptArray10 = new ScriptArray<T>(num3);
				for (int k = 0; k < num3; k++)
				{
					scriptArray10.Add(scriptArray9[k]);
				}
				result = scriptArray10;
				return true;
			}
			case ScriptBinaryOperator.Modulus:
			{
				ScriptArray<T> scriptArray4 = scriptArray ?? scriptArray2;
				if (scriptArray4 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires an array operand.");
				}
				if (num == 0)
				{
					throw new ScriptRuntimeException(sourceSpan, "Cannot divide by 0");
				}
				ScriptArray<T> scriptArray5 = new ScriptArray<T>(scriptArray4.Count);
				for (int i = 0; i < scriptArray4.Count; i++)
				{
					if (i % num == 0)
					{
						scriptArray5.Add(scriptArray4[i]);
					}
				}
				result = scriptArray5;
				return true;
			}
			case ScriptBinaryOperator.ShiftLeft:
			{
				if (scriptArray == null)
				{
					throw new ScriptRuntimeException(leftSpan, "Expecting an array for the left argument.");
				}
				ScriptArray<T> scriptArray6 = new ScriptArray<T>(scriptArray);
				((IList)scriptArray6._values).Add((object?)((typeof(T) == typeof(object)) ? ConvertValue(rightValue) : context.ToObject<T>(rightSpan, rightValue)));
				result = scriptArray6;
				return true;
			}
			case ScriptBinaryOperator.ShiftRight:
			{
				if (scriptArray2 == null)
				{
					throw new ScriptRuntimeException(rightSpan, "Expecting an array for the right argument.");
				}
				ScriptArray<T> scriptArray3 = new ScriptArray<T>(scriptArray2);
				((IList)scriptArray3._values).Insert(0, (object?)((typeof(T) == typeof(object)) ? ConvertValue(leftValue) : context.ToObject<T>(leftSpan, leftValue)));
				result = scriptArray3;
				return true;
			}
			default:
				return false;
			}
		}

		private static ScriptArray<T>? TryGetArray(object? rightValue)
		{
			ScriptArray<T> scriptArray = rightValue as ScriptArray<T>;
			if (scriptArray == null)
			{
				if (rightValue is IList values)
				{
					scriptArray = new ScriptArray<T>(values);
				}
				else if (rightValue is IEnumerable values2 && !(rightValue is string))
				{
					scriptArray = new ScriptArray<T>(values2);
				}
			}
			return scriptArray;
		}

		private static bool CompareTo(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, ScriptArray<T> left, ScriptArray<T> right)
		{
			int num = left.Count.CompareTo(right.Count);
			switch (op)
			{
			case ScriptBinaryOperator.CompareEqual:
				if (num != 0)
				{
					return false;
				}
				break;
			case ScriptBinaryOperator.CompareNotEqual:
				if (num != 0)
				{
					return true;
				}
				if (left.Count == 0)
				{
					return false;
				}
				break;
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareLess:
				if (num < 0)
				{
					return true;
				}
				if (num > 0)
				{
					return false;
				}
				if (left.Count == 0 && op == ScriptBinaryOperator.CompareLess)
				{
					return false;
				}
				break;
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareGreater:
				if (num < 0)
				{
					return false;
				}
				if (num > 0)
				{
					return true;
				}
				if (left.Count == 0 && op == ScriptBinaryOperator.CompareGreater)
				{
					return false;
				}
				break;
			default:
				throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not supported between " + context.GetTypeName(left) + " and " + context.GetTypeName(right) + ".");
			}
			for (int i = 0; i < left.Count; i++)
			{
				object obj = ScriptBinaryExpression.Evaluate(context, span, op, left[i], right[i]);
				if (!(obj is bool) || !(bool)obj)
				{
					return false;
				}
			}
			return true;
		}

		public virtual bool CanTransform(Type transformType)
		{
			return true;
		}

		public virtual bool Visit(TemplateContext context, SourceSpan span, Func<object?, bool> visit)
		{
			using (List<T>.Enumerator enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					if (!visit(current))
					{
						return false;
					}
				}
			}
			return true;
		}

		public virtual object? Transform(TemplateContext context, SourceSpan span, Func<object?, object?> apply, Type destType)
		{
			if (apply == null)
			{
				throw new ArgumentNullException("apply");
			}
			ScriptArray<T> scriptArray = (ScriptArray<T>)Clone(deep: true);
			List<T> values = scriptArray._values;
			if (typeof(T) == typeof(object))
			{
				for (int i = 0; i < values.Count; i++)
				{
					((IList)values)[i] = ConvertValue(apply(values[i]));
				}
			}
			else
			{
				for (int j = 0; j < values.Count; j++)
				{
					((IList)values)[j] = context.ToObject<T>(span, apply(values[j]));
				}
			}
			return scriptArray;
		}

		[return: MaybeNull]
		private static T ConvertValue(object? value)
		{
			if (value is T)
			{
				return (T)value;
			}
			if (value == null)
			{
				if (default(T) == null)
				{
					return default(T);
				}
				throw new ArgumentNullException("value");
			}
			return (T)Convert.ChangeType(value, typeof(T));
		}

		[return: MaybeNull]
		private static T GetDefaultValue()
		{
			_ = (object)default(T);
			return default(T);
		}
	}
	public class ScriptArray : ScriptArray<object?>
	{
		public override object? this[int index]
		{
			get
			{
				if (index < 0 || index >= base.Count)
				{
					return null;
				}
				return base[index];
			}
			set
			{
				base[index] = value;
			}
		}

		public ScriptArray()
		{
		}

		public ScriptArray(int capacity)
			: base(capacity)
		{
		}

		public ScriptArray(IEnumerable<object?> values)
			: base(values)
		{
		}

		public ScriptArray(IEnumerable values)
			: base(values)
		{
		}

		[ScriptMemberIgnore]
		public static ScriptArray From(object? obj)
		{
			if (obj == null)
			{
				throw new ArgumentNullException("obj");
			}
			if (obj is JsonElement json)
			{
				if (json.ValueKind == JsonValueKind.Array)
				{
					return json.CopyToScriptArray(new ScriptArray());
				}
				throw new ArgumentException($"Unsupported JsonElement ValueKind `{json.ValueKind}`. Expecting Array.", "obj");
			}
			if (obj is IEnumerable enumerable)
			{
				ScriptArray scriptArray = new ScriptArray();
				{
					foreach (object item in enumerable)
					{
						scriptArray.Add(item);
					}
					return scriptArray;
				}
			}
			throw new ArgumentException($"Unsupported object type `{obj.GetType()}`. Expecting an IEnumerable or a JsonElement array.", "obj");
		}
	}
	public class ScriptLazy<T> : IScriptCustomFunction, IScriptFunctionInfo
	{
		private readonly Lazy<T> _lazy;

		public int RequiredParameterCount => 0;

		public int ParameterCount => 0;

		public ScriptVarParamKind VarParamKind => ScriptVarParamKind.None;

		public Type ReturnType => typeof(T);

		public ScriptLazy(Func<T> valueFactory)
		{
			_lazy = new Lazy<T>(valueFactory);
		}

		public ScriptParameterInfo GetParameterInfo(int index)
		{
			return default(ScriptParameterInfo);
		}

		public object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			return _lazy.Value;
		}

		public ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			return new ValueTask<object>(_lazy.Value);
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field)]
	public class ScriptMemberIgnoreAttribute : Attribute
	{
	}
	[Flags]
	public enum ScriptMemberImportFlags
	{
		Field = 1,
		Property = 2,
		Method = 4,
		[Obsolete("Importing Method Instance is actually not supported - This flag will be removed in a future release")]
		MethodInstance = 8,
		All = 7
	}
	public class ScriptObject : IDictionary<string, object?>, ICollection<KeyValuePair<string, object?>>, IEnumerable<KeyValuePair<string, object?>>, IEnumerable, IScriptObject, IDictionary, ICollection, IFormattable
	{
		internal struct InternalValue
		{
			public object? Value { get; }

			public bool IsReadOnly { get; set; }

			public InternalValue(object? value, bool isReadOnly)
			{
				Value = value;
				IsReadOnly = isReadOnly;
			}

			public InternalValue(object? value)
			{
				this = default(InternalValue);
				Value = value;
			}
		}

		internal Dictionary<string, InternalValue> Store { get; private set; }

		bool IDictionary.IsFixedSize => ((IDictionary)Store).IsFixedSize;

		public int Count => Store.Count;

		bool ICollection.IsSynchronized => ((ICollection)Store).IsSynchronized;

		object ICollection.SyncRoot => ((ICollection)Store).SyncRoot;

		public virtual bool IsReadOnly { get; set; }

		object? IDictionary.this[object key]
		{
			get
			{
				string key2 = (key as string) ?? key?.ToString() ?? throw new ArgumentNullException("key");
				return Store[key2].Value;
			}
			set
			{
				this.AssertNotReadOnly();
				string key2 = (key as string) ?? key?.ToString() ?? throw new ArgumentNullException("key");
				if (Store.TryGetValue(key2, out var value2))
				{
					Store[key2] = new InternalValue(value, value2.IsReadOnly);
				}
				else
				{
					Store[key2] = new InternalValue(value);
				}
			}
		}

		public virtual object? this[string key]
		{
			get
			{
				if (key == null)
				{
					throw new ArgumentNullException("key");
				}
				TryGetValue(new TemplateContext(), default(SourceSpan), key, out object value);
				return value;
			}
			set
			{
				if (key == null)
				{
					throw new ArgumentNullException("key");
				}
				this.AssertNotReadOnly();
				TrySetValue(new TemplateContext(), default(SourceSpan), key, value, readOnly: false);
			}
		}

		public ICollection<string> Keys => Store.Keys;

		ICollection IDictionary.Values => ((IDictionary)Store).Values;

		ICollection IDictionary.Keys => ((IDictionary)Store).Keys;

		public ICollection<object?> Values => Store.Values.Select((InternalValue val) => val.Value).ToList();

		bool ICollection<KeyValuePair<string, object>>.IsReadOnly => IsReadOnly;

		public ScriptObject()
			: this(0)
		{
		}

		public ScriptObject(IEqualityComparer<string>? keyComparer)
			: this(0, true, keyComparer)
		{
		}

		public ScriptObject(int capacity)
			: this(capacity, true, null)
		{
		}

		public ScriptObject(int capacity, IEqualityComparer<string>? keyComparer)
			: this(capacity, true, keyComparer)
		{
		}

		public ScriptObject(int capacity, bool? autoImportStaticsFromThisType)
			: this(capacity, autoImportStaticsFromThisType, null)
		{
		}

		public ScriptObject(int capacity, bool? autoImportStaticsFromThisType, IEqualityComparer<string>? keyComparer)
		{
			Store = new Dictionary<string, InternalValue>(capacity, keyComparer);
			if (GetType() != typeof(ScriptObject) && autoImportStaticsFromThisType == true)
			{
				this.Import(GetType());
			}
		}

		void IDictionary.Add(object key, object? value)
		{
			this.AssertNotReadOnly();
			Store.Add((string)key, new InternalValue(value));
		}

		public void Clear()
		{
			Store.Clear();
		}

		bool IDictionary.Contains(object key)
		{
			return ((IDictionary)Store).Contains(key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return ((IDictionary)Store).GetEnumerator();
		}

		void IDictionary.Remove(object key)
		{
			((IDictionary)Store).Remove(key);
		}

		void ICollection.CopyTo(Array array, int index)
		{
			((ICollection)Store).CopyTo(array, index);
		}

		public IEnumerable<string> GetMembers()
		{
			return Store.Keys;
		}

		public virtual bool Contains(string member)
		{
			if (member == null)
			{
				throw new ArgumentNullException("member");
			}
			return Store.ContainsKey(member);
		}

		public virtual bool TryGetValue(TemplateContext context, SourceSpan span, string member, out object? value)
		{
			InternalValue value2;
			bool result = Store.TryGetValue(member, out value2);
			value = value2.Value;
			return result;
		}

		public T? GetSafeValue<T>(string name)
		{
			return GetSafeValue(name, default(T));
		}

		public T GetSafeValue<T>(string name, T defaultValue)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			object obj = this[name];
			if (obj == null)
			{
				return defaultValue;
			}
			if (!(obj is T))
			{
				obj = (this[name] = defaultValue);
			}
			if (obj is T)
			{
				return (T)obj;
			}
			return defaultValue;
		}

		bool IDictionary<string, object>.TryGetValue(string key, out object? value)
		{
			return TryGetValue(new TemplateContext(), default(SourceSpan), key, out value);
		}

		public virtual bool CanWrite(string member)
		{
			Store.TryGetValue(member, out var value);
			return !value.IsReadOnly;
		}

		public virtual bool TrySetValue(TemplateContext context, SourceSpan span, string member, object? value, bool readOnly)
		{
			if (!CanWrite(member))
			{
				return false;
			}
			this.AssertNotReadOnly();
			Store[member] = new InternalValue(value, readOnly);
			return true;
		}

		public void SetValue(string member, object? value, bool readOnly)
		{
			Store[member] = new InternalValue(value, readOnly);
		}

		public void Add(string key, object? value)
		{
			Store.Add(key, new InternalValue(value, isReadOnly: false));
		}

		public bool ContainsKey(string key)
		{
			return Contains(key);
		}

		public virtual bool Remove(string member)
		{
			this.AssertNotReadOnly();
			return Store.Remove(member);
		}

		public virtual void SetReadOnly(string member, bool readOnly)
		{
			this.AssertNotReadOnly();
			if (Store.TryGetValue(member, out var value))
			{
				value.IsReadOnly = readOnly;
				Store[member] = value;
			}
		}

		private static bool IsSimpleKey(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				return false;
			}
			char c = key[0];
			if (!char.IsLetter(key[0]) && c != '_')
			{
				return false;
			}
			for (int i = 1; i < key.Length; i++)
			{
				c = key[i];
				if (!char.IsLetterOrDigit(c) && c != '_')
				{
					return false;
				}
			}
			return true;
		}

		public virtual string ToString(string? format, IFormatProvider? formatProvider)
		{
			TemplateContext templateContext = formatProvider as TemplateContext;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{");
			bool flag = true;
			using (IEnumerator<KeyValuePair<string, object>> enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					KeyValuePair<string, object> current = enumerator.Current;
					if (!flag)
					{
						stringBuilder.Append(", ");
					}
					if (IsSimpleKey(current.Key))
					{
						stringBuilder.Append(current.Key);
					}
					else
					{
						stringBuilder.Append((templateContext != null) ? templateContext.ObjectToString(current.Key, nested: true) : ("\"" + StringFunctions.Escape(current.Key) + "\""));
					}
					stringBuilder.Append(": ");
					if (templateContext != null)
					{
						stringBuilder.Append(templateContext.ObjectToString(current.Value, nested: true));
					}
					else
					{
						object value = current.Value;
						if (value is IFormattable formattable)
						{
							stringBuilder.Append(formattable.ToString(null, formatProvider));
						}
						else
						{
							stringBuilder.Append(value);
						}
					}
					flag = false;
				}
			}
			stringBuilder.Append("}");
			return stringBuilder.ToString();
		}

		public string ToString(IFormatProvider formatProvider)
		{
			return ToString(null, formatProvider);
		}

		public sealed override string ToString()
		{
			return ToString(null, null);
		}

		public virtual void CopyTo(ScriptObject dest)
		{
			if (dest == null)
			{
				throw new ArgumentNullException("dest");
			}
			foreach (KeyValuePair<string, InternalValue> item in Store)
			{
				dest.Store[item.Key] = item.Value;
			}
		}

		public virtual IScriptObject Clone(bool deep)
		{
			ScriptObject scriptObject = (ScriptObject)MemberwiseClone();
			scriptObject.Store = new Dictionary<string, InternalValue>(Store.Count);
			if (deep)
			{
				foreach (KeyValuePair<string, InternalValue> item in Store)
				{
					object obj = item.Value.Value;
					if (obj is ScriptObject)
					{
						obj = ((ScriptObject)obj).Clone(deep: true);
					}
					else if (obj is ScriptArray)
					{
						obj = ((ScriptArray)obj).Clone(deep: true);
					}
					scriptObject.Store[item.Key] = new InternalValue(obj, item.Value.IsReadOnly);
				}
			}
			else
			{
				foreach (KeyValuePair<string, InternalValue> item2 in Store)
				{
					scriptObject.Store[item2.Key] = item2.Value;
				}
			}
			return scriptObject;
		}

		public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
		{
			foreach (KeyValuePair<string, InternalValue> item in Store)
			{
				yield return new KeyValuePair<string, object>(item.Key, item.Value.Value);
			}
		}

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

		[ScriptMemberIgnore]
		public static ScriptObject From(object? obj)
		{
			ScriptObject scriptObject = new ScriptObject();
			scriptObject.Import(obj);
			return scriptObject;
		}

		[ScriptMemberIgnore]
		public static bool IsImportable(object obj)
		{
			if (obj == null)
			{
				return true;
			}
			Type type = (obj as Type) ?? obj.GetType();
			if (!(obj is string) && !type.IsPrimitive && !(type == typeof(decimal)) && !type.IsEnum)
			{
				return !type.IsArray;
			}
			return false;
		}

		void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object?> item)
		{
			Add(item.Key, item.Value);
		}

		bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object?> item)
		{
			if (Store.TryGetValue(item.Key, out var value))
			{
				return object.Equals(value.Value, item.Value);
			}
			return false;
		}

		void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object?>[] array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (arrayIndex > array.Length)
			{
				throw new ArgumentOutOfRangeException("arrayIndex", arrayIndex, "The arrayIndex parameter is larger than the array's length.");
			}
			if (array.Length - arrayIndex < Count)
			{
				throw new ArgumentException("The array is too small to fit.", "array");
			}
			_ = Count;
			_ = Store;
			foreach (KeyValuePair<string, InternalValue> item in Store)
			{
				array[arrayIndex++] = new KeyValuePair<string, object>(item.Key, item.Value.Value);
			}
		}

		bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object?> item)
		{
			if (Store.TryGetValue(item.Key, out var value) && object.Equals(value.Value, item.Value))
			{
				Remove(item.Key);
				return true;
			}
			return false;
		}
	}
	public static class ScriptObjectExtensions
	{
		public static void AssertNotReadOnly(this IScriptObject scriptObject)
		{
			if (scriptObject.IsReadOnly)
			{
				throw new InvalidOperationException("The object is readonly");
			}
		}

		public static void Import(this IScriptObject script, object? obj, MemberFilterDelegate? filter = null, MemberRenamerDelegate? renamer = null)
		{
			if (obj is IScriptObject other)
			{
				script.Import(other);
			}
			else if (obj is IDictionary dictionary)
			{
				script.ImportDictionary(dictionary);
			}
			else if (obj is JsonElement json)
			{
				script.Import(json);
			}
			else
			{
				script.Import(obj, ScriptMemberImportFlags.All, filter, renamer);
			}
		}

		public static void Import(this IScriptObject script, JsonElement json)
		{
			if (json.ValueKind == JsonValueKind.Object && script is ScriptObject)
			{
				json.CopyToScriptObject(script);
			}
			else if (json.ValueKind == JsonValueKind.Array && script is ScriptArray array)
			{
				json.CopyToScriptArray(array);
			}
			else if (json.ValueKind != JsonValueKind.Null && json.ValueKind != JsonValueKind.Undefined)
			{
				throw new ArgumentOutOfRangeException(string.Format("Unsupported object type `{0}`. Expecting Json {1}.", json.ValueKind, (script is ScriptObject) ? "Object" : "Array"));
			}
		}

		public static bool TryGetValue(this IScriptObject @this, string key, out object? value)
		{
			return @this.TryGetValue(new TemplateContext(), default(SourceSpan), key, out value);
		}

		public static void SetValue(this IScriptObject @this, string member, object? value, bool readOnly)
		{
			@this.TrySetValue(new TemplateContext(), default(SourceSpan), member, value, readOnly);
		}

		public static void Import(this IScriptObject @this, IScriptObject other)
		{
			if (other == null)
			{
				return;
			}
			ScriptObject scriptObject = @this.GetScriptObject();
			scriptObject.AssertNotReadOnly();
			foreach (KeyValuePair<string, ScriptObject.InternalValue> item in other.GetScriptObject().Store)
			{
				string key = item.Key;
				if (scriptObject.CanWrite(key))
				{
					scriptObject.Store[item.Key] = item.Value;
				}
			}
		}

		private static void ImportDictionary(this IScriptObject @this, IDictionary dictionary)
		{
			if (dictionary == null)
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				string text = item.Key?.ToString();
				if (text != null && @this.CanWrite(text))
				{
					ScriptObject scriptObject = @this.GetScriptObject();
					scriptObject.AssertNotReadOnly();
					scriptObject[text] = ConvertValue(item.Value);
				}
			}
		}

		public static ScriptObject GetScriptObject(this IScriptObject @this)
		{
			ScriptObject scriptObject = @this as ScriptObject;
			if (scriptObject == null)
			{
				scriptObject = ((@this as ScriptArray) ?? throw new ArgumentException("Expecting ScriptObject or ScriptArray instance", "this")).ScriptObject;
			}
			return scriptObject;
		}

		public static void ImportMember(this IScriptObject script, object obj, string memberName, string? exportName = null)
		{
			MemberRenamerDelegate renamer = ((exportName != null) ? ((MemberRenamerDelegate)((MemberInfo _) => exportName)) : null);
			script.Import(obj, ScriptMemberImportFlags.All, (MemberInfo member) => member.Name == memberName, renamer);
		}

		public static void Import(this IScriptObject script, object? obj, ScriptMemberImportFlags flags, MemberFilterDelegate? filter = null, MemberRenamerDelegate? renamer = null)
		{
			if (obj == null)
			{
				return;
			}
			if (!ScriptObject.IsImportable(obj))
			{
				throw new ArgumentOutOfRangeException("obj", $"Unsupported object type `{obj.GetType()}`. Expecting plain class or struct");
			}
			Type type = (obj as Type) ?? obj.GetType();
			bool flag = false;
			bool flag2 = false;
			if (obj is Type)
			{
				flag = true;
				obj = null;
			}
			else
			{
				flag2 = true;
			}
			renamer = renamer ?? StandardMemberRenamer.Default;
			Stack<Type> stack = new Stack<Type>();
			while ((object)type != null)
			{
				stack.Push(type);
				if (type.BaseType == typeof(object))
				{
					break;
				}
				type = type.BaseType;
			}
			ScriptObject scriptObject = script as ScriptObject;
			while (stack.Count > 0)
			{
				type = stack.Pop();
				if ((flags & ScriptMemberImportFlags.Field) != 0)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
					foreach (FieldInfo fieldInfo in fields)
					{
						if (fieldInfo.IsPublic && !fieldInfo.IsLiteral && (filter == null || filter(fieldInfo)) && fieldInfo.GetCustomAttribute<ScriptMemberIgnoreAttribute>() == null && ((fieldInfo.IsStatic && flag) || flag2))
						{
							string text = renamer(fieldInfo);
							if (string.IsNullOrEmpty(text))
							{
								text = fieldInfo.Name;
							}
							if (scriptObject == null)
							{
								script.TrySetValue(new TemplateContext(), default(SourceSpan), text, ConvertValue(fieldInfo.GetValue(obj)), fieldInfo.IsInitOnly || fieldInfo.IsLiteral);
							}
							else
							{
								scriptObject.SetValue(text, ConvertValue(fieldInfo.GetValue(obj)), fieldInfo.IsInitOnly || fieldInfo.IsLiteral);
							}
						}
					}
				}
				if ((flags & ScriptMemberImportFlags.Property) != 0)
				{
					PropertyInfo[] properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
					foreach (PropertyInfo propertyInfo in properties)
					{
						MethodInfo getMethod = propertyInfo.GetMethod;
						if (propertyInfo.CanRead && (object)getMethod != null && getMethod.IsPublic && (filter == null || filter(propertyInfo)) && propertyInfo.GetCustomAttribute<ScriptMemberIgnoreAttribute>() == null && ((getMethod.IsStatic && flag) || flag2))
						{
							string text2 = renamer(propertyInfo);
							if (string.IsNullOrEmpty(text2))
							{
								text2 = propertyInfo.Name;
							}
							if (scriptObject == null)
							{
								script.TrySetValue(new TemplateContext(), default(SourceSpan), text2, ConvertValue(propertyInfo.GetValue(obj)), readOnly: false);
							}
							else if (propertyInfo.GetIndexParameters().Length == 0)
							{
								scriptObject.SetValue(text2, ConvertValue(propertyInfo.GetValue(obj)), readOnly: false);
							}
						}
					}
				}
				if (!((flags & ScriptMemberImportFlags.Method) != 0 && flag))
				{
					continue;
				}
				MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public);
				foreach (MethodInfo methodInfo in methods)
				{
					if ((filter == null || filter(methodInfo)) && methodInfo.GetCustomAttribute<ScriptMemberIgnoreAttribute>() == null && methodInfo.IsPublic && methodInfo.IsStatic && !methodInfo.IsSpecialName)
					{
						string text3 = renamer(methodInfo);
						if (string.IsNullOrEmpty(text3))
						{
							text3 = methodInfo.Name;
						}
						if (scriptObject == null)
						{
							script.TrySetValue(new TemplateContext(), default(SourceSpan), text3, DynamicCustomFunction.Create(obj, methodInfo), readOnly: true);
						}
						else
						{
							scriptObject.SetValue(text3, DynamicCustomFunction.Create(obj, methodInfo), readOnly: true);
						}
					}
				}
			}
		}

		public static void Import(this IScriptObject script, string member, Delegate function)
		{
			if (member == null)
			{
				throw new ArgumentNullException("member");
			}
			if ((object)function == null)
			{
				throw new ArgumentNullException("function");
			}
			script.TrySetValue(new TemplateContext(), default(SourceSpan), member, DynamicCustomFunction.Create(function), readOnly: true);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static object? ConvertValue(object? value)
		{
			if (value is JsonElement)
			{
				return ((JsonElement)value).ToScriban();
			}
			return value;
		}
	}
	internal class ScriptPipeArguments : Stack<ScriptExpression>
	{
		public ScriptPipeArguments()
		{
		}

		public ScriptPipeArguments(int capacity)
			: base(capacity)
		{
		}
	}
	public class ScriptRange : IList<object?>, ICollection<object?>, IEnumerable<object?>, IEnumerable, IList, ICollection, IScriptTransformable, IScriptCustomBinaryOperation
	{
		private IEnumerable _values;

		public IEnumerable Values => _values;

		public Type ElementType => typeof(object);

		public int Count
		{
			get
			{
				if (_values is IList list)
				{
					return list.Count;
				}
				return _values.Cast<object>().Count();
			}
		}

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		public bool IsReadOnly => false;

		bool IList.IsFixedSize => false;

		public object? this[int index]
		{
			get
			{
				if (_values is IList list)
				{
					return list[index];
				}
				return _values.Cast<object>().ElementAtOrDefault(index);
			}
			set
			{
				IList list = _values as IList;
				if (list == null)
				{
					list = (IList)(_values = new ScriptArray(_values));
				}
				list[index] = value;
			}
		}

		public ScriptRange()
		{
			_values = Enumerable.Empty<object>();
		}

		public ScriptRange(IEnumerable values)
		{
			_values = values ?? throw new ArgumentNullException("values");
		}

		public IEnumerator<object?> GetEnumerator()
		{
			IEnumerator enumerator = _values.GetEnumerator();
			while (enumerator.MoveNext())
			{
				yield return enumerator.Current;
			}
		}

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

		public bool CanTransform(Type transformType)
		{
			return true;
		}

		public virtual bool Visit(TemplateContext context, SourceSpan span, Func<object?, bool> visit)
		{
			using (IEnumerator<object> enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					object current = enumerator.Current;
					if (!visit(current))
					{
						return false;
					}
				}
			}
			return true;
		}

		public virtual object? Transform(TemplateContext context, SourceSpan span, Func<object?, object?> apply, Type destType)
		{
			return new ScriptRange(TransformImpl(apply));
		}

		private IEnumerable TransformImpl(Func<object?, object?> apply)
		{
			using IEnumerator<object?> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				object current = enumerator.Current;
				yield return apply(current);
			}
		}

		public static ScriptRange? Offset(IEnumerable? list, int index)
		{
			if (list != null)
			{
				return new ScriptRange(OffsetImpl(list, index));
			}
			return null;
		}

		internal static ScriptRange? Offset(TemplateContext context, SourceSpan span, IEnumerable? list, int index)
		{
			if (list != null)
			{
				return new ScriptRange(OffsetImpl(context, span, list, index));
			}
			return null;
		}

		private static IEnumerable OffsetImpl(IEnumerable list, int index)
		{
			foreach (object item in list)
			{
				if (index <= 0)
				{
					yield return item;
				}
				else
				{
					index--;
				}
			}
		}

		private static IEnumerable OffsetImpl(TemplateContext context, SourceSpan span, IEnumerable list, int index)
		{
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (index <= 0)
				{
					yield return item;
				}
				else
				{
					index--;
				}
			}
		}

		public static ScriptRange? Limit(IEnumerable? list, int count)
		{
			if (list != null)
			{
				return new ScriptRange(LimitImpl(list, count));
			}
			return null;
		}

		internal static ScriptRange? Limit(TemplateContext context, SourceSpan span, IEnumerable? list, int count)
		{
			if (list != null)
			{
				return new ScriptRange(LimitImpl(context, span, list, count));
			}
			return null;
		}

		private static IEnumerable LimitImpl(IEnumerable list, int count)
		{
			foreach (object item in list)
			{
				if (count <= 0)
				{
					break;
				}
				count--;
				yield return item;
			}
		}

		private static IEnumerable LimitImpl(TemplateContext context, SourceSpan span, IEnumerable list, int count)
		{
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (count <= 0)
				{
					break;
				}
				count--;
				yield return item;
			}
		}

		public static ScriptRange? Compact(IEnumerable? list)
		{
			if (list != null)
			{
				return new ScriptRange(CompactImpl(list));
			}
			return null;
		}

		internal static ScriptRange? Compact(TemplateContext context, SourceSpan span, IEnumerable? list)
		{
			if (list != null)
			{
				return new ScriptRange(CompactImpl(context, span, list));
			}
			return null;
		}

		public static ScriptRange? Uniq(IEnumerable? list)
		{
			if (list != null)
			{
				return new ScriptRange(list.Cast<object>().Distinct());
			}
			return null;
		}

		internal static ScriptRange? Uniq(TemplateContext context, SourceSpan span, IEnumerable? list)
		{
			if (list != null)
			{
				return new ScriptRange(UniqImpl(context, span, list));
			}
			return null;
		}

		public static ScriptRange Reverse(IEnumerable list)
		{
			if (list == null)
			{
				return new ScriptRange(Enumerable.Empty<object>());
			}
			return new ScriptRange(list.Cast<object>().Reverse());
		}

		internal static ScriptRange Reverse(TemplateContext context, SourceSpan span, IEnumerable list)
		{
			if (list == null)
			{
				return new ScriptRange(Enumerable.Empty<object>());
			}
			return new ScriptRange(ReverseImpl(context, span, list));
		}

		private static IEnumerable CompactImpl(IEnumerable list)
		{
			if (list == null)
			{
				yield break;
			}
			foreach (object item in list)
			{
				if (item != null)
				{
					yield return item;
				}
			}
		}

		private static IEnumerable CompactImpl(TemplateContext context, SourceSpan span, IEnumerable list)
		{
			if (list == null)
			{
				yield break;
			}
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (item != null)
				{
					yield return item;
				}
			}
		}

		private static IEnumerable UniqImpl(TemplateContext context, SourceSpan span, IEnumerable list)
		{
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			HashSet<object?> distinct = new HashSet<object>();
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (distinct.Add(item))
				{
					yield return item;
				}
			}
		}

		private static IEnumerable ReverseImpl(TemplateContext context, SourceSpan span, IEnumerable list)
		{
			List<object?> items = new List<object>();
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				items.Add(item);
			}
			for (int i = items.Count - 1; i >= 0; i--)
			{
				yield return items[i];
			}
		}

		public static ScriptRange BinaryOr(IEnumerable<object?> left, IEnumerable<object?> right)
		{
			return new ScriptRange(left.Union<object>(right));
		}

		private static ScriptRange BinaryOr(TemplateContext context, SourceSpan span, IEnumerable<object?> left, IEnumerable<object?> right)
		{
			return new ScriptRange(BinaryOrImpl(context, span, left, right));
		}

		public static ScriptRange BinaryAnd(IEnumerable<object?> left, IEnumerable<object?> right)
		{
			return new ScriptRange(left.Intersect<object>(right));
		}

		private static ScriptRange BinaryAnd(TemplateContext context, SourceSpan span, IEnumerable<object?> left, IEnumerable<object?> right)
		{
			return new ScriptRange(BinaryAndImpl(context, span, left, right));
		}

		public static ScriptRange ShiftLeft(IEnumerable left, object? value)
		{
			return new ScriptRange(ShiftLeftImpl(left, value));
		}

		private static ScriptRange ShiftLeft(TemplateContext context, SourceSpan span, IEnumerable left, object? value)
		{
			return new ScriptRange(ShiftLeftImpl(context, span, left, value));
		}

		private static IEnumerable ShiftLeftImpl(IEnumerable left, object? value)
		{
			foreach (object item in left)
			{
				yield return item;
			}
			yield return value;
		}

		private static IEnumerable ShiftLeftImpl(TemplateContext context, SourceSpan span, IEnumerable left, object? value)
		{
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(left);
			foreach (object item in left)
			{
				context.StepLoop(span, ref loopStep, loopType);
				yield return item;
			}
			yield return value;
		}

		public static ScriptRange ShiftRight(object? value, IEnumerable right)
		{
			return new ScriptRange(ShiftRightImpl(value, right));
		}

		private static ScriptRange ShiftRight(TemplateContext context, SourceSpan span, object? value, IEnumerable right)
		{
			return new ScriptRange(ShiftRightImpl(context, span, value, right));
		}

		private static IEnumerable ShiftRightImpl(object? value, IEnumerable right)
		{
			yield return value;
			foreach (object item in right)
			{
				yield return item;
			}
		}

		private static IEnumerable ShiftRightImpl(TemplateContext context, SourceSpan span, object? value, IEnumerable right)
		{
			yield return value;
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(right);
			foreach (object item in right)
			{
				context.StepLoop(span, ref loopStep, loopType);
				yield return item;
			}
		}

		public static ScriptRange Multiply(IEnumerable left, int count)
		{
			return new ScriptRange(MultiplyImpl(left, count));
		}

		private static ScriptRange Multiply(TemplateContext context, SourceSpan span, IEnumerable left, int count)
		{
			return new ScriptRange(MultiplyImpl(context, span, left, count));
		}

		private static IEnumerable MultiplyImpl(IEnumerable left, int count)
		{
			for (int i = 0; i < count; i++)
			{
				foreach (object item in left)
				{
					yield return item;
				}
			}
		}

		private static IEnumerable MultiplyImpl(TemplateContext context, SourceSpan span, IEnumerable left, int count)
		{
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(left);
			for (int i = 0; i < count; i++)
			{
				foreach (object item in left)
				{
					context.StepLoop(span, ref loopStep, loopType);
					yield return item;
				}
			}
		}

		public static ScriptRange Divide(IEnumerable left, int count)
		{
			return new ScriptRange(DivideImpl(left, count));
		}

		private static ScriptRange Divide(TemplateContext context, SourceSpan span, IEnumerable left, int count)
		{
			return new ScriptRange(DivideImpl(context, span, left, count));
		}

		public static ScriptRange Modulus(IEnumerable left, int count)
		{
			return new ScriptRange(ModulusImpl(left, count));
		}

		private static ScriptRange Modulus(TemplateContext context, SourceSpan span, IEnumerable left, int count)
		{
			return new ScriptRange(ModulusImpl(context, span, left, count));
		}

		private static IEnumerable DivideImpl(IEnumerable left, int count)
		{
			foreach (object item in left)
			{
				if (count < 0)
				{
					break;
				}
				yield return item;
				count--;
			}
		}

		private static IEnumerable DivideImpl(TemplateContext context, SourceSpan span, IEnumerable left, int count)
		{
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(left);
			foreach (object item in left)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (count < 0)
				{
					break;
				}
				yield return item;
				count--;
			}
		}

		private static IEnumerable ModulusImpl(IEnumerable left, int modulus)
		{
			int index = 0;
			foreach (object item in left)
			{
				if (index % modulus == 0)
				{
					yield return item;
				}
				index++;
			}
		}

		private static IEnumerable ModulusImpl(TemplateContext context, SourceSpan span, IEnumerable left, int modulus)
		{
			int index = 0;
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(left);
			foreach (object item in left)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (index % modulus == 0)
				{
					yield return item;
				}
				index++;
			}
		}

		public static ScriptRange? Concat(IEnumerable? left, IEnumerable? right)
		{
			if (right == null && left == null)
			{
				return null;
			}
			if (right == null)
			{
				return new ScriptRange(left ?? throw new InvalidOperationException("left"));
			}
			if (left == null)
			{
				return new ScriptRange(right ?? throw new InvalidOperationException("right"));
			}
			return new ScriptRange(ConcatImpl(left, right));
		}

		internal static ScriptRange? Concat(TemplateContext context, SourceSpan span, IEnumerable? left, IEnumerable? right)
		{
			if (right == null && left == null)
			{
				return null;
			}
			if (right == null)
			{
				return new ScriptRange(left ?? throw new InvalidOperationException("left"));
			}
			if (left == null)
			{
				return new ScriptRange(right ?? throw new InvalidOperationException("right"));
			}
			return new ScriptRange(ConcatImpl(context, span, left, right));
		}

		private static IEnumerable ConcatImpl(IEnumerable left, IEnumerable right)
		{
			foreach (object item in left)
			{
				yield return item;
			}
			foreach (object item2 in right)
			{
				yield return item2;
			}
		}

		private static IEnumerable ConcatImpl(TemplateContext context, SourceSpan span, IEnumerable left, IEnumerable right)
		{
			int loopStep = 0;
			TemplateContext.LoopType leftLoopType = GetLoopType(left);
			foreach (object item in left)
			{
				context.StepLoop(span, ref loopStep, leftLoopType);
				yield return item;
			}
			TemplateContext.LoopType rightLoopType = GetLoopType(right);
			foreach (object item2 in right)
			{
				context.StepLoop(span, ref loopStep, rightLoopType);
				yield return item2;
			}
		}

		public bool TryEvaluate(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, SourceSpan leftSpan, object? leftValue, SourceSpan rightSpan, object? rightValue, out object? result)
		{
			result = null;
			IEnumerable<object> enumerable = TryGetRange(leftValue);
			IEnumerable<object> enumerable2 = TryGetRange(rightValue);
			int num = 0;
			SourceSpan sourceSpan = leftSpan;
			SourceSpan span2 = span;
			string text = null;
			switch (op)
			{
			case ScriptBinaryOperator.BinaryOr:
			case ScriptBinaryOperator.BinaryAnd:
			case ScriptBinaryOperator.CompareEqual:
			case ScriptBinaryOperator.CompareNotEqual:
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareLess:
			case ScriptBinaryOperator.CompareGreater:
			case ScriptBinaryOperator.Add:
				if (enumerable == null)
				{
					span2 = leftSpan;
					text = " Expecting an array for the left argument.";
				}
				if (enumerable2 == null)
				{
					span2 = rightSpan;
					text = " Expecting an array for the right argument.";
				}
				break;
			case ScriptBinaryOperator.Multiply:
				if ((enumerable == null && enumerable2 == null) || (enumerable != null && enumerable2 != null))
				{
					text = " Expecting only one array for the left or right argument.";
					break;
				}
				num = context.ToInt(span, (enumerable == null) ? leftValue : rightValue);
				if (enumerable2 == null)
				{
					sourceSpan = rightSpan;
				}
				break;
			case ScriptBinaryOperator.Divide:
			case ScriptBinaryOperator.DivideRound:
			case ScriptBinaryOperator.Modulus:
				if (enumerable == null)
				{
					span2 = leftSpan;
					text = " Expecting an array for the left argument.";
				}
				else
				{
					num = context.ToInt(span, rightValue);
					sourceSpan = rightSpan;
				}
				break;
			case ScriptBinaryOperator.ShiftLeft:
				if (enumerable == null)
				{
					span2 = leftSpan;
					text = " Expecting an array for the left argument.";
				}
				break;
			case ScriptBinaryOperator.ShiftRight:
				if (enumerable2 == null)
				{
					span2 = rightSpan;
					text = " Expecting an array for the right argument.";
				}
				break;
			default:
				text = string.Empty;
				break;
			}
			if (num < 0)
			{
				span2 = sourceSpan;
				text = $" Integer {num} cannot be negative when multiplying";
			}
			if (text != null)
			{
				throw new ScriptRuntimeException(span2, "The operator `" + op.ToText() + "` is not supported between " + context.GetTypeName(leftValue) + " and " + context.GetTypeName(rightValue) + "." + text);
			}
			switch (op)
			{
			case ScriptBinaryOperator.BinaryOr:
				if (enumerable == null || enumerable2 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires array operands.");
				}
				result = BinaryOr(context, span, enumerable, enumerable2);
				return true;
			case ScriptBinaryOperator.BinaryAnd:
				if (enumerable == null || enumerable2 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires array operands.");
				}
				result = BinaryAnd(context, span, enumerable, enumerable2);
				return true;
			case ScriptBinaryOperator.Add:
				result = Concat(context, span, enumerable, enumerable2);
				return true;
			case ScriptBinaryOperator.CompareEqual:
			case ScriptBinaryOperator.CompareNotEqual:
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareLess:
			case ScriptBinaryOperator.CompareGreater:
				if (enumerable == null || enumerable2 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires array operands.");
				}
				result = CompareTo(context, span, op, enumerable, enumerable2);
				return true;
			case ScriptBinaryOperator.Multiply:
			{
				IEnumerable<object> enumerable4 = enumerable ?? enumerable2;
				if (enumerable4 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires an array operand.");
				}
				if (num == 0)
				{
					result = new ScriptRange();
					return true;
				}
				result = Multiply(context, span, enumerable4, num);
				return true;
			}
			case ScriptBinaryOperator.Divide:
			case ScriptBinaryOperator.DivideRound:
			{
				IEnumerable<object> enumerable5 = enumerable ?? enumerable2;
				if (enumerable5 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires an array operand.");
				}
				if (num == 0)
				{
					throw new ScriptRuntimeException(sourceSpan, "Cannot divide by 0");
				}
				result = Divide(context, span, enumerable5, num);
				return true;
			}
			case ScriptBinaryOperator.Modulus:
			{
				IEnumerable<object> enumerable3 = enumerable ?? enumerable2;
				if (enumerable3 == null)
				{
					throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` requires an array operand.");
				}
				if (num == 0)
				{
					throw new ScriptRuntimeException(sourceSpan, "Cannot divide by 0");
				}
				result = Modulus(context, span, enumerable3, num);
				return true;
			}
			case ScriptBinaryOperator.ShiftLeft:
				if (enumerable == null)
				{
					throw new ScriptRuntimeException(leftSpan, "Expecting an array for the left argument.");
				}
				result = ShiftLeft(context, span, enumerable, rightValue);
				return true;
			case ScriptBinaryOperator.ShiftRight:
				if (enumerable2 == null)
				{
					throw new ScriptRuntimeException(rightSpan, "Expecting an array for the right argument.");
				}
				result = ShiftRight(context, span, leftValue, enumerable2);
				return true;
			default:
				return false;
			}
		}

		private static IEnumerable<object?>? TryGetRange(object? rightValue)
		{
			return rightValue as IEnumerable<object>;
		}

		private static bool CompareTo(TemplateContext context, SourceSpan span, ScriptBinaryOperator op, IEnumerable<object?> left, IEnumerable<object?> right)
		{
			List<object> list = MaterializeValues(context, span, left);
			List<object> list2 = MaterializeValues(context, span, right);
			int count = list.Count;
			int count2 = list2.Count;
			int num = count.CompareTo(count2);
			switch (op)
			{
			case ScriptBinaryOperator.CompareEqual:
				if (num != 0)
				{
					return false;
				}
				break;
			case ScriptBinaryOperator.CompareNotEqual:
				if (num != 0)
				{
					return true;
				}
				if (count == 0)
				{
					return false;
				}
				break;
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareLess:
				if (num < 0)
				{
					return true;
				}
				if (num > 0)
				{
					return false;
				}
				if (count == 0 && op == ScriptBinaryOperator.CompareLess)
				{
					return false;
				}
				break;
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareGreater:
				if (num < 0)
				{
					return false;
				}
				if (num > 0)
				{
					return true;
				}
				if (count == 0 && op == ScriptBinaryOperator.CompareGreater)
				{
					return false;
				}
				break;
			default:
				throw new ScriptRuntimeException(span, "The operator `" + op.ToText() + "` is not supported between " + context.GetTypeName(left) + " and " + context.GetTypeName(right) + ".");
			}
			for (int i = 0; i < list.Count; i++)
			{
				object leftValue = list[i];
				object rightValue = list2[i];
				object obj = ScriptBinaryExpression.Evaluate(context, span, op, leftValue, rightValue);
				if (!(obj is bool) || !(bool)obj)
				{
					return false;
				}
			}
			return true;
		}

		private static IEnumerable<object?> BinaryOrImpl(TemplateContext context, SourceSpan span, IEnumerable<object?> left, IEnumerable<object?> right)
		{
			HashSet<object?> seen = new HashSet<object>();
			int loopStep = 0;
			TemplateContext.LoopType leftLoopType = GetLoopType(left);
			foreach (object item in left)
			{
				context.StepLoop(span, ref loopStep, leftLoopType);
				if (seen.Add(item))
				{
					yield return item;
				}
			}
			TemplateContext.LoopType rightLoopType = GetLoopType(right);
			foreach (object item2 in right)
			{
				context.StepLoop(span, ref loopStep, rightLoopType);
				if (seen.Add(item2))
				{
					yield return item2;
				}
			}
		}

		private static IEnumerable<object?> BinaryAndImpl(TemplateContext context, SourceSpan span, IEnumerable<object?> left, IEnumerable<object?> right)
		{
			HashSet<object?> rightValues = new HashSet<object>();
			HashSet<object?> yielded = new HashSet<object>();
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(right);
			foreach (object item in right)
			{
				context.StepLoop(span, ref loopStep, loopType);
				rightValues.Add(item);
			}
			TemplateContext.LoopType leftLoopType = GetLoopType(left);
			foreach (object item2 in left)
			{
				context.StepLoop(span, ref loopStep, leftLoopType);
				if (rightValues.Contains(item2) && yielded.Add(item2))
				{
					yield return item2;
				}
			}
		}

		private static List<object?> MaterializeValues(TemplateContext context, SourceSpan span, IEnumerable<object?> values)
		{
			List<object> list = new List<object>();
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(values);
			foreach (object value in values)
			{
				context.StepLoop(span, ref loopStep, loopType);
				list.Add(value);
			}
			return list;
		}

		private static TemplateContext.LoopType GetLoopType(IEnumerable values)
		{
			if (!(values is IQueryable))
			{
				return TemplateContext.LoopType.Default;
			}
			return TemplateContext.LoopType.Queryable;
		}

		public void Add(object? item)
		{
			AddImpl(item);
		}

		private int AddImpl(object? item)
		{
			IList list = _values as IList;
			if (list == null || list.IsFixedSize)
			{
				list = (IList)(_values = new ScriptArray(_values));
			}
			return list.Add(item);
		}

		int IList.Add(object? value)
		{
			return AddImpl(value);
		}

		public void Clear()
		{
			_values = Enumerable.Empty<object>();
		}

		public bool Contains(object? item)
		{
			if (_values is IList list)
			{
				return list.Contains(item);
			}
			return _values.Cast<object>().Any((object value) => value == item);
		}

		public void CopyTo(object?[] array, int arrayIndex)
		{
			if (_values is IList list)
			{
				list.CopyTo(array, arrayIndex);
			}
			foreach (object value in _values)
			{
				array[arrayIndex++] = value;
			}
		}

		public bool Remove(object? item)
		{
			IList list = _values as IList;
			if (list == null)
			{
				list = (IList)(_values = new ScriptArray(_values));
			}
			bool result = list.Contains(item);
			list.Remove(item);
			return result;
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (_values is ICollection collection)
			{
				collection.CopyTo(array, index);
			}
			foreach (object value in _values)
			{
				array.SetValue(value, index++);
			}
		}

		public int IndexOf(object? item)
		{
			if (_values is IList list)
			{
				return list.IndexOf(item);
			}
			int num = 0;
			foreach (object value in _values)
			{
				if (value == item)
				{
					return num;
				}
				num++;
			}
			return -1;
		}

		public void Insert(int index, object? item)
		{
			IList list = _values as IList;
			if (list == null)
			{
				list = (IList)(_values = new ScriptArray(_values));
			}
			list.Insert(index, item);
		}

		void IList.Remove(object? value)
		{
			Remove(value);
		}

		public void RemoveAt(int index)
		{
			IList list = _values as IList;
			if (list == null)
			{
				list = (IList)(_values = new ScriptArray(_values));
			}
			list.RemoveAt(index);
		}
	}
	public sealed class StandardMemberRenamer
	{
		public static readonly MemberRenamerDelegate Default = Rename;

		public static string Rename(MemberInfo member)
		{
			return Rename(member.Name);
		}

		public static string Rename(string name)
		{
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			for (int i = 0; i < name.Length; i++)
			{
				char c = name[i];
				if (char.IsUpper(c))
				{
					if (i > 0 && !flag)
					{
						stringBuilder.Append("_");
					}
					stringBuilder.Append(char.ToLowerInvariant(c));
					flag = true;
				}
				else
				{
					stringBuilder.Append(c);
					flag = false;
				}
			}
			return stringBuilder.ToString();
		}
	}
	public class StringBuilderOutput : IScriptOutput
	{
		[ThreadStatic]
		private static StringBuilder? TlsBuilder;

		public StringBuilder Builder { get; }

		public StringBuilderOutput()
			: this(new StringBuilder())
		{
		}

		public StringBuilderOutput(StringBuilder builder)
		{
			Builder = builder ?? throw new ArgumentNullException("builder");
		}

		public void Write(string text, int offset, int count)
		{
			Builder.Append(text, offset, count);
		}

		public static StringBuilderOutput GetThreadInstance()
		{
			if (TlsBuilder == null)
			{
				TlsBuilder = new StringBuilder();
			}
			TlsBuilder.Length = 0;
			return new StringBuilderOutput(TlsBuilder);
		}

		public ValueTask WriteAsync(string text, int offset, int count, CancellationToken cancellationToken)
		{
			Builder.Append(text, offset, count);
			return default(ValueTask);
		}

		public override string ToString()
		{
			return Builder.ToString();
		}
	}
	public class TextWriterOutput : IScriptOutput
	{
		public TextWriter Writer { get; }

		public TextWriterOutput()
			: this(new StringWriter())
		{
		}

		public TextWriterOutput(TextWriter writer)
		{
			Writer = writer ?? throw new ArgumentNullException("writer");
		}

		public void Write(string text, int offset, int count)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			Writer.Write(text.Substring(offset, count));
		}

		public async ValueTask WriteAsync(string text, int offset, int count, CancellationToken cancellationToken)
		{
			await Writer.WriteAsync(text.Substring(offset, count));
		}

		public override string ToString()
		{
			return Writer.ToString() ?? string.Empty;
		}
	}
}
namespace Scriban.Runtime.Accessors
{
	public class ArrayAccessor : IListAccessor, IObjectAccessor
	{
		public static ArrayAccessor Default = new ArrayAccessor();

		public bool HasIndexer => false;

		public Type? IndexType => null;

		private ArrayAccessor()
		{
		}

		public int GetLength(TemplateContext context, SourceSpan span, object target)
		{
			return ((Array)target).Length;
		}

		public object? GetValue(TemplateContext context, SourceSpan span, object target, int index)
		{
			return ((Array)target).GetValue(index);
		}

		public void SetValue(TemplateContext context, SourceSpan span, object target, int index, object? value)
		{
			((Array)target).SetValue(value, index);
		}

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return 1;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			yield return "size";
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return member == "size";
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			if (member == "size")
			{
				value = GetLength(context, span, target);
				return true;
			}
			value = null;
			return false;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			return false;
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			throw new NotImplementedException();
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			throw new NotImplementedException();
		}
	}
	public sealed class DictionaryAccessor : IObjectAccessor
	{
		public static readonly DictionaryAccessor Default = new DictionaryAccessor();

		public bool HasIndexer => true;

		public Type IndexType => typeof(object);

		private DictionaryAccessor()
		{
		}

		public static bool TryGet(object target, out IObjectAccessor? accessor)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (target is IDictionary<string, object>)
			{
				accessor = DictionaryStringObjectAccessor.Default;
				return true;
			}
			Type baseOrInterface = target.GetType().GetBaseOrInterface(typeof(IDictionary<, >));
			if ((object)baseOrInterface == null)
			{
				if (target is IDictionary)
				{
					accessor = Default;
					return true;
				}
				accessor = null;
				return false;
			}
			Type type = baseOrInterface.GetGenericArguments()[0];
			Type type2 = baseOrInterface.GetGenericArguments()[1];
			Type type3 = typeof(GenericDictionaryAccessor<, >).MakeGenericType(type, type2);
			accessor = (IObjectAccessor)Activator.CreateInstance(type3);
			return true;
		}

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return ((IDictionary)target).Count;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			foreach (object key in ((IDictionary)target).Keys)
			{
				yield return context.ObjectToString(key) ?? string.Empty;
			}
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return ((IDictionary)target).Contains(member);
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			value = null;
			if (((IDictionary)target).Contains(member))
			{
				value = ((IDictionary)target)[member];
				return true;
			}
			return false;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			((IDictionary)target)[member] = value;
			return true;
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			value = null;
			if (((IDictionary)target).Contains(index))
			{
				value = ((IDictionary)target)[index];
				return true;
			}
			return false;
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			((IDictionary)target)[index] = value;
			return true;
		}
	}
	internal class DictionaryStringObjectAccessor : GenericDictionaryAccessor<string, object?>
	{
		public static readonly DictionaryStringObjectAccessor Default = new DictionaryStringObjectAccessor();
	}
	internal class GenericDictionaryAccessor<TKey, TValue> : IObjectAccessor
	{
		public bool HasIndexer => true;

		public Type IndexType => typeof(TKey);

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return ((IDictionary<TKey, TValue>)target).Count;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			foreach (TKey key in ((IDictionary<TKey, TValue>)target).Keys)
			{
				yield return context.ObjectToString(key) ?? string.Empty;
			}
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object value, string member)
		{
			return ((IDictionary<TKey, TValue>)value).ContainsKey(TransformToKey(context, member));
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			TValue value2;
			bool result = ((IDictionary<TKey, TValue>)target).TryGetValue(TransformToKey(context, member), out value2);
			value = value2;
			return result;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			((IDictionary)target)[TransformToKey(context, member)] = ConvertValue(context, span, value);
			return true;
		}

		private TKey TransformToKey(TemplateContext context, string member)
		{
			object obj = context.ToObject(default(SourceSpan), member, typeof(TKey));
			if (obj is TKey)
			{
				return (TKey)obj;
			}
			throw new InvalidOperationException($"Unable to convert member `{member}` to dictionary key type `{typeof(TKey)}`.");
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			if (((IDictionary<TKey, TValue>)target).TryGetValue((TKey)index, out var value2))
			{
				value = value2;
				return true;
			}
			value = null;
			return false;
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			((IDictionary)target)[index] = ConvertValue(context, span, value);
			return true;
		}

		[return: MaybeNull]
		private static TValue ConvertValue(TemplateContext context, SourceSpan span, object? value)
		{
			object obj = context.ToObject(span, value, typeof(TValue));
			if (obj is TValue)
			{
				return (TValue)obj;
			}
			if (obj == null && default(TValue) == null)
			{
				return default(TValue);
			}
			throw new ScriptRuntimeException(span, $"Unable to convert dictionary value to `{typeof(TValue)}`.");
		}
	}
	public class ListAccessor : IListAccessor, IObjectAccessor
	{
		public static ListAccessor Default = new ListAccessor();

		public bool HasIndexer => false;

		public Type? IndexType => null;

		private ListAccessor()
		{
		}

		public int GetLength(TemplateContext context, SourceSpan span, object target)
		{
			return ((IList)target).Count;
		}

		public object? GetValue(TemplateContext context, SourceSpan span, object target, int index)
		{
			IList list = (IList)target;
			if (index < 0 || index >= list.Count)
			{
				return null;
			}
			return list[index];
		}

		public void SetValue(TemplateContext context, SourceSpan span, object target, int index, object? value)
		{
			IList list = (IList)target;
			if (index >= 0)
			{
				for (int i = list.Count; i <= index; i++)
				{
					list.Add(null);
				}
				list[index] = value;
			}
		}

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return 1;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			yield return "size";
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return member == "size";
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			if (member == "size")
			{
				value = GetLength(context, span, target);
				return true;
			}
			if (target is IScriptObject)
			{
				return ((IScriptObject)target).TryGetValue(context, span, member, out value);
			}
			value = null;
			return false;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			if (member == "size")
			{
				return false;
			}
			if (target is IScriptObject)
			{
				return ((IScriptObject)target).TrySetValue(context, span, member, value, readOnly: false);
			}
			return false;
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			throw new NotImplementedException();
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			throw new NotImplementedException();
		}
	}
	public class NullAccessor : IObjectAccessor
	{
		public static readonly NullAccessor Default = new NullAccessor();

		public bool HasIndexer => false;

		public Type? IndexType => null;

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return 0;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			yield break;
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return false;
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			value = null;
			return false;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			return false;
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			value = null;
			return false;
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			return false;
		}
	}
	internal class PrimitiveAccessor : IObjectAccessor, IListAccessor
	{
		public static readonly PrimitiveAccessor Default = new PrimitiveAccessor();

		public bool HasIndexer => false;

		public Type? IndexType => null;

		private PrimitiveAccessor()
		{
		}

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return 0;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			yield break;
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return false;
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			if (!context.EnableRelaxedMemberAccess)
			{
				throw new ScriptRuntimeException(span, $"Cannot get or set a member on the primitive `{target}/{context.GetTypeName(target)}` when accessing member: {member}");
			}
			value = null;
			return true;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			throw new ScriptRuntimeException(span, $"Cannot get or set a member on the primitive `{target}/{context.GetTypeName(target)}` when accessing member: {member}");
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			if (!context.EnableRelaxedMemberAccess)
			{
				throw new ScriptRuntimeException(span, $"Cannot get or set a member on the primitive `{target}/{context.GetTypeName(target)}` when accessing index: {index}");
			}
			value = null;
			return true;
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			throw new ScriptRuntimeException(span, $"Cannot get or set a member on the primitive `{target}/{context.GetTypeName(target)}` when accessing index: {index}");
		}

		public int GetLength(TemplateContext context, SourceSpan span, object target)
		{
			throw new ScriptRuntimeException(span, $"Cannot use the {context.GetTypeName(target)} primitive `{target}` as a list.");
		}

		public object GetValue(TemplateContext context, SourceSpan span, object target, int index)
		{
			throw new ScriptRuntimeException(span, $"Cannot index the {context.GetTypeName(target)} primitive `{target}`.");
		}

		public void SetValue(TemplateContext context, SourceSpan span, object target, int index, object? value)
		{
			throw new ScriptRuntimeException(span, $"Cannot index the {context.GetTypeName(target)} primitive `{target}`.");
		}
	}
	public class ScriptObjectAccessor : IObjectAccessor
	{
		public static readonly IObjectAccessor Default = new ScriptObjectAccessor();

		public bool HasIndexer => false;

		public Type? IndexType => null;

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return ((IScriptObject)target).Count;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			return ((IScriptObject)target).GetMembers();
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return ((IScriptObject)target).Contains(member);
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			return ((IScriptObject)target).TryGetValue(context, span, member, out value);
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			return ((IScriptObject)target).TrySetValue(context, span, member, value, readOnly: false);
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			throw new NotImplementedException();
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			throw new NotImplementedException();
		}
	}
	public class StringAccessor : IListAccessor, IObjectAccessor
	{
		public static StringAccessor Default = new StringAccessor();

		public bool HasIndexer => false;

		public Type? IndexType => null;

		private StringAccessor()
		{
		}

		public int GetLength(TemplateContext context, SourceSpan span, object target)
		{
			return ((string)target).Length;
		}

		public object GetValue(TemplateContext context, SourceSpan span, object target, int index)
		{
			return ((string)target)[index].ToString();
		}

		public void SetValue(TemplateContext context, SourceSpan span, object target, int index, object? value)
		{
			throw new ScriptRuntimeException(span, "Cannot replace a character in a string");
		}

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return 1;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			yield return "size";
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return member == "size";
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			if (member == "size")
			{
				value = GetLength(context, span, target);
				return true;
			}
			value = null;
			return false;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			return false;
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			throw new NotImplementedException();
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			throw new NotImplementedException();
		}
	}
	public class TypedObjectAccessor : IObjectAccessor
	{
		private const DynamicallyAccessedMemberTypes TypeAccessedMembers = DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties;

		private readonly MemberFilterDelegate? _filter;

		private readonly Type _type;

		private readonly MemberRenamerDelegate _renamer;

		private readonly Dictionary<string, MemberInfo> _members;

		private PropertyInfo? _indexer;

		public Type? IndexType { get; private set; }

		public bool HasIndexer => (object)_indexer != null;

		public TypedObjectAccessor(Type targetType, MemberFilterDelegate? filter, MemberRenamerDelegate? renamer)
			: this(targetType, null, filter, renamer)
		{
		}

		public TypedObjectAccessor(Type targetType, IEqualityComparer<string>? keyComparer, MemberFilterDelegate? filter, MemberRenamerDelegate? renamer)
		{
			_type = targetType ?? throw new ArgumentNullException("targetType");
			_filter = filter;
			_renamer = renamer ?? StandardMemberRenamer.Default;
			_members = new Dictionary<string, MemberInfo>(keyComparer);
			PrepareMembers();
		}

		public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
		{
			return _members.Count;
		}

		public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
		{
			return _members.Keys;
		}

		public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
		{
			return _members.ContainsKey(member);
		}

		public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object? value)
		{
			value = null;
			if (_members.TryGetValue(member, out MemberInfo value2))
			{
				if (value2 is FieldInfo fieldInfo)
				{
					value = fieldInfo.GetValue(target);
					return true;
				}
				PropertyInfo propertyInfo = (PropertyInfo)value2;
				value = propertyInfo.GetValue(target);
				return true;
			}
			return false;
		}

		public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object? value)
		{
			if ((object)_indexer == null)
			{
				value = null;
				return false;
			}
			value = _indexer.GetValue(target, new object[1] { index });
			return true;
		}

		public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object? value)
		{
			if ((object)_indexer == null)
			{
				return false;
			}
			MethodInfo setMethod = _indexer.GetSetMethod(nonPublic: false);
			if ((object)setMethod == null || IsInitOnly(setMethod))
			{
				return false;
			}
			_indexer.SetValue(target, value, new object[1] { index });
			return true;
		}

		public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object? value)
		{
			if (!_members.TryGetValue(member, out MemberInfo value2) || (object)value2 == null)
			{
				return false;
			}
			if (value2 is FieldInfo fieldInfo)
			{
				if (fieldInfo.IsInitOnly || fieldInfo.IsLiteral)
				{
					return false;
				}
				fieldInfo.SetValue(target, context.ToObject(span, value, fieldInfo.FieldType));
				return true;
			}
			PropertyInfo propertyInfo = (PropertyInfo)value2;
			MethodInfo setMethod = propertyInfo.GetSetMethod(nonPublic: false);
			if ((object)setMethod == null || IsInitOnly(setMethod))
			{
				return false;
			}
			propertyInfo.SetValue(target, context.ToObject(span, value, propertyInfo.PropertyType));
			return true;
		}

		private void PrepareMembers()
		{
			Type type = _type;
			while ((object)type != null)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo.GetCustomAttribute<ScriptMemberIgnoreAttribute>() == null && !fieldInfo.IsStatic && fieldInfo.IsPublic && !fieldInfo.IsLiteral && (_filter == null || _filter(fieldInfo)))
					{
						string text = Rename(fieldInfo);
						if (string.IsNullOrEmpty(text))
						{
							text = fieldInfo.Name;
						}
						if (!_members.ContainsKey(text))
						{
							_members.Add(text, fieldInfo);
						}
					}
				}
				PropertyInfo[] properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
				foreach (PropertyInfo propertyInfo in properties)
				{
					bool num = propertyInfo.GetCustomAttribute<ScriptMemberIgnoreAttribute>() == null;
					MethodInfo getMethod = propertyInfo.GetMethod;
					if (!num || !propertyInfo.CanRead || (object)getMethod == null || getMethod.IsStatic || !getMethod.IsPublic || (_filter != null && !_filter(propertyInfo)))
					{
						continue;
					}
					ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
					if (indexParameters.Length != 0)
					{
						IndexType = indexParameters[0].ParameterType;
						_indexer = propertyInfo;
						continue;
					}
					string text2 = Rename(propertyInfo);
					if (string.IsNullOrEmpty(text2))
					{
						text2 = propertyInfo.Name;
					}
					if (!_members.ContainsKey(text2))
					{
						_members.Add(text2, propertyInfo);
					}
				}
				if (!(type.BaseType == typeof(object)))
				{
					type = type.BaseType;
					continue;
				}
				break;
			}
		}

		private string Rename(MemberInfo member)
		{
			return _renamer(member);
		}

		private static bool IsInitOnly(MethodInfo setMethod)
		{
			Type[] requiredCustomModifiers = setMethod.ReturnParameter.GetRequiredCustomModifiers();
			for (int i = 0; i < requiredCustomModifiers.Length; i++)
			{
				if (requiredCustomModifiers[i].FullName == "System.Runtime.CompilerServices.IsExternalInit")
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace Scriban.Parsing
{
	public class Lexer : IEnumerable<Token>, IEnumerable
	{
		private enum BlockType
		{
			Code,
			Escape,
			Raw
		}

		public struct Enumerator : IEnumerator<Token>, IEnumerator, IDisposable
		{
			private readonly Lexer lexer;

			public Token Current => lexer._token;

			object IEnumerator.Current => Current;

			public Enumerator(Lexer lexer)
			{
				this.lexer = lexer;
				lexer.Reset();
			}

			public bool MoveNext()
			{
				return lexer.MoveNext();
			}

			public void Reset()
			{
				lexer.Reset();
			}

			public void Dispose()
			{
			}
		}

		private TextPosition _position;

		private readonly int _textLength;

		private Token _token;

		private char c;

		private BlockType _blockType;

		private bool _isLiquidTagBlock;

		private List<LogMessage>? _errors;

		private int _openBraceCount;

		private int _escapeRawCharCount;

		private bool _isExpectingFrontMatter;

		private readonly bool _isLiquid;

		private readonly Stack<char> _openingStringChars;

		private bool _interpJustOpened;

		private bool _interpJustClosed;

		private readonly char _stripWhiteSpaceFullSpecialChar;

		private readonly char _stripWhiteSpaceRestrictedSpecialChar;

		private const char RawEscapeSpecialChar = '%';

		private readonly Queue<Token> _pendingTokens;

		private readonly TryMatchCustomTokenDelegate? _tryMatchCustomToken;

		public readonly LexerOptions Options;

		private bool AnyInterpolationOpen => _openingStringChars.Count > 0;

		public string Text { get; }

		public string SourcePath { get; private set; }

		public bool HasErrors
		{
			get
			{
				if (_errors != null)
				{
					return _errors.Count > 0;
				}
				return false;
			}
		}

		public IEnumerable<LogMessage> Errors
		{
			get
			{
				IEnumerable<LogMessage> errors = _errors;
				return errors ?? Enumerable.Empty<LogMessage>();
			}
		}

		public Lexer(string text, string? sourcePath = null, LexerOptions? options = null)
		{
			Text = text ?? throw new ArgumentNullException("text");
			LexerOptions options2 = options ?? LexerOptions.Default;
			Options = options2;
			_tryMatchCustomToken = Options.TryMatchCustomToken;
			_position = Options.StartPosition;
			if (_position.Offset > text.Length)
			{
				throw new ArgumentOutOfRangeException($"The starting position `{_position.Offset}` of range [0, {text.Length - 1}]");
			}
			_textLength = text.Length;
			SourcePath = sourcePath ?? "<input>";
			_blockType = ((Options.Mode != ScriptMode.ScriptOnly) ? BlockType.Raw : BlockType.Code);
			_pendingTokens = new Queue<Token>();
			_isExpectingFrontMatter = Options.Mode == ScriptMode.FrontMatterOnly || Options.Mode == ScriptMode.FrontMatterAndContent;
			_isLiquid = Options.Lang == ScriptLang.Liquid;
			_stripWhiteSpaceFullSpecialChar = '-';
			_stripWhiteSpaceRestrictedSpecialChar = '~';
			_openingStringChars = new Stack<char>();
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		private bool MoveNext()
		{
			TextPosition textPosition = default(TextPosition);
			bool flag = true;
			while (true)
			{
				if (_pendingTokens.Count > 0)
				{
					_token = _pendingTokens.Dequeue();
					return true;
				}
				if (_token.Type == TokenType.Eof)
				{
					return false;
				}
				if (_position.Offset == _textLength)
				{
					_token = Token.Eof;
					return true;
				}
				if (!flag && textPosition == _position)
				{
					throw new InvalidOperationException("Invalid internal state of the lexer in a forever loop");
				}
				flag = false;
				textPosition = _position;
				if (Options.Mode != ScriptMode.ScriptOnly)
				{
					if (_blockType == BlockType.Raw)
					{
						if (IsCodeEnterOrEscape(out var _))
						{
							ReadCodeEnterOrEscape();
							return true;
						}
						if (_isExpectingFrontMatter && TryParseFrontMatterMarker())
						{
							_blockType = BlockType.Code;
							return true;
						}
					}
					if (_blockType != BlockType.Raw && IsCodeExit())
					{
						bool num = _blockType == BlockType.Code;
						ReadCodeExitOrEscape();
						if (num)
						{
							return true;
						}
						continue;
					}
					if (_blockType == BlockType.Code && _isExpectingFrontMatter && TryParseFrontMatterMarker())
					{
						_blockType = BlockType.Raw;
						_isExpectingFrontMatter = false;
						return true;
					}
				}
				if (_position.Offset == _textLength)
				{
					_token = Token.Eof;
					return true;
				}
				if (_blockType == BlockType.Code)
				{
					if (_isLiquid)
					{
						if (ReadCodeLiquid())
						{
							break;
						}
					}
					else if (ReadCode())
					{
						break;
					}
				}
				else if (ReadRaw())
				{
					break;
				}
			}
			return true;
		}

		private bool TryParseFrontMatterMarker()
		{
			TextPosition position = _position;
			TextPosition position2 = _position;
			string frontMatterMarker = Options.FrontMatterMarker;
			int i;
			for (i = 0; i < frontMatterMarker.Length; i++)
			{
				if (PeekChar(i) != frontMatterMarker[i])
				{
					return false;
				}
			}
			char c = PeekChar(i);
			while (c == ' ' || c == '\t')
			{
				i++;
				c = PeekChar(i);
			}
			bool flag = false;
			switch (c)
			{
			case '\n':
				flag = true;
				break;
			case '\r':
				flag = true;
				if (PeekChar(i + 1) == '\n')
				{
					i++;
				}
				break;
			}
			if (flag)
			{
				while (i-- >= 0)
				{
					position2 = _position;
					NextChar();
				}
				_token = new Token(TokenType.FrontMatterMarker, position, position2);
				return true;
			}
			return false;
		}

		private bool IsCodeEnterOrEscape(out TokenType whitespaceMode)
		{
			whitespaceMode = TokenType.Invalid;
			if (this.c == '{')
			{
				int num = 1;
				char c = PeekChar(num);
				if (!_isLiquid)
				{
					while (c == '%')
					{
						num++;
						c = PeekChar(num);
					}
				}
				if (c == '{' || (_isLiquid && c == '%'))
				{
					char c2 = PeekChar(num + 1);
					if (c2 == _stripWhiteSpaceFullSpecialChar)
					{
						whitespaceMode = TokenType.WhitespaceFull;
					}
					else if (!_isLiquid && c2 == _stripWhiteSpaceRestrictedSpecialChar)
					{
						whitespaceMode = TokenType.Whitespace;
					}
					return true;
				}
			}
			return false;
		}

		private void ReadCodeEnterOrEscape()
		{
			TextPosition position = _position;
			TextPosition textPosition = _position;
			NextChar();
			if (!_isLiquid)
			{
				while (c == '%')
				{
					_escapeRawCharCount++;
					textPosition = textPosition.NextColumn();
					NextChar();
				}
			}
			textPosition = textPosition.NextColumn();
			if (_isLiquid && c == '%')
			{
				_isLiquidTagBlock = true;
			}
			NextChar();
			if (c == _stripWhiteSpaceFullSpecialChar || (!_isLiquid && c == _stripWhiteSpaceRestrictedSpecialChar))
			{
				textPosition = textPosition.NextColumn();
				NextChar();
			}
			if (_escapeRawCharCount > 0)
			{
				_blockType = BlockType.Escape;
				_token = new Token(TokenType.EscapeEnter, position, textPosition);
			}
			else if (!_isLiquid || !_isLiquidTagBlock || !TryReadLiquidCommentOrRaw(position, textPosition))
			{
				_blockType = BlockType.Code;
				_token = new Token(_isLiquidTagBlock ? TokenType.LiquidTagEnter : TokenType.CodeEnter, position, textPosition);
			}
		}

		private bool TryReadLiquidCommentOrRaw(TextPosition codeEnterStart, TextPosition codeEnterEnd)
		{
			TextPosition position = _position;
			int i = 0;
			PeekSkipSpaces(ref i);
			bool flag;
			if ((flag = TryMatchPeek("comment", i, out i)) || TryMatchPeek("raw", i, out i))
			{
				PeekSkipSpaces(ref i);
				if (TryMatchPeek("%}", i, out i))
				{
					codeEnterEnd = new TextPosition(position.Offset + i - 1, position.Line, position.Column + i - 1);
					position = new TextPosition(position.Offset + i, position.Line, position.Column + i);
					_position = new TextPosition(position.Offset - 1, position.Line, position.Column - 1);
					c = '}';
					while (true)
					{
						TextPosition position2 = _position;
						NextChar();
						TextPosition position3 = _position;
						if (c == '{')
						{
							NextChar();
							if (c != '%')
							{
								continue;
							}
							NextChar();
							if (c == '-')
							{
								NextChar();
							}
							SkipSpaces();
							if (!TryMatch(flag ? "endcomment" : "endraw"))
							{
								continue;
							}
							SkipSpaces();
							if (c == '-')
							{
								NextChar();
							}
							if (c != '%')
							{
								continue;
							}
							NextChar();
							if (c == '}')
							{
								TextPosition position4 = _position;
								NextChar();
								_blockType = BlockType.Raw;
								if (flag)
								{
									_token = new Token(TokenType.CodeEnter, codeEnterStart, codeEnterEnd);
									_pendingTokens.Enqueue(new Token(TokenType.CommentMulti, position, position2));
									_pendingTokens.Enqueue(new Token(TokenType.CodeExit, position3, position4));
								}
								else
								{
									_token = new Token(TokenType.EscapeEnter, codeEnterStart, codeEnterEnd);
									_pendingTokens.Enqueue(new Token(TokenType.Escape, position, position2));
									_pendingTokens.Enqueue(new Token(TokenType.EscapeExit, position3, position4));
								}
								_isLiquidTagBlock = false;
								return true;
							}
						}
						else if (c == '\0')
						{
							break;
						}
					}
				}
			}
			return false;
		}

		private void SkipSpaces()
		{
			while (IsWhitespace(c))
			{
				NextChar();
			}
		}

		private void PeekSkipSpaces(ref int i)
		{
			while (true)
			{
				char c = PeekChar(i);
				if (c == ' ' || c == '\t')
				{
					i++;
					continue;
				}
				break;
			}
		}

		private bool TryMatchPeek(string text, int offset, out int offsetOut)
		{
			offsetOut = offset;
			for (int i = 0; i < text.Length; i++)
			{
				if (PeekChar(offset) != text[i])
				{
					return false;
				}
				offset++;
			}
			offsetOut = offset;
			return true;
		}

		private bool TryMatch(string text)
		{
			for (int i = 0; i < text.Length; i++)
			{
				if (c != text[i])
				{
					return false;
				}
				NextChar();
			}
			return true;
		}

		private bool IsCodeExit()
		{
			if (_openBraceCount > 0)
			{
				return false;
			}
			int num = 0;
			if (c == _stripWhiteSpaceFullSpecialChar || (!_isLiquid && c == _stripWhiteSpaceRestrictedSpecialChar))
			{
				num = 1;
			}
			if (PeekChar(num) != (_isLiquidTagBlock ? 37 : 125) || AnyInterpolationOpen)
			{
				return false;
			}
			num++;
			if (!_isLiquid)
			{
				for (int i = 0; i < _escapeRawCharCount; i++)
				{
					if (PeekChar(i + num) != '%')
					{
						return false;
					}
				}
			}
			return PeekChar(_escapeRawCharCount + num) == '}';
		}

		private void ReadCodeExitOrEscape()
		{
			TextPosition position = _position;
			TokenType tokenType = TokenType.Invalid;
			if (c == _stripWhiteSpaceFullSpecialChar)
			{
				tokenType = TokenType.WhitespaceFull;
				NextChar();
			}
			else if (!_isLiquid && c == _stripWhiteSpaceRestrictedSpecialChar)
			{
				tokenType = TokenType.Whitespace;
				NextChar();
			}
			NextChar();
			if (!_isLiquid)
			{
				for (int i = 0; i < _escapeRawCharCount; i++)
				{
					NextChar();
				}
			}
			TextPosition position2 = _position;
			NextChar();
			if (_escapeRawCharCount > 0)
			{
				_pendingTokens.Enqueue(new Token(TokenType.EscapeExit, position, position2));
				_escapeRawCharCount = 0;
			}
			else
			{
				_token = new Token(_isLiquidTagBlock ? TokenType.LiquidTagExit : TokenType.CodeExit, position, position2);
			}
			if (tokenType != TokenType.Invalid)
			{
				TextPosition position3 = _position;
				TextPosition lastSpace = default(TextPosition);
				if (ConsumeWhitespace(tokenType == TokenType.Whitespace, ref lastSpace, tokenType == TokenType.Whitespace))
				{
					_pendingTokens.Enqueue(new Token(tokenType, position3, lastSpace));
				}
			}
			_isLiquidTagBlock = false;
			_blockType = BlockType.Raw;
		}

		private bool ReadRaw()
		{
			TextPosition position = _position;
			TextPosition textPosition = new TextPosition(-1, 0, 0);
			bool flag = false;
			TokenType whitespaceMode = TokenType.Invalid;
			bool flag2 = false;
			TextPosition textPosition2 = TextPosition.Eof;
			TextPosition textPosition3 = TextPosition.Eof;
			TextPosition textPosition4 = TextPosition.Eof;
			TextPosition textPosition5 = TextPosition.Eof;
			while (c != 0)
			{
				if ((_blockType == BlockType.Raw && IsCodeEnterOrEscape(out whitespaceMode)) || (_blockType == BlockType.Escape && IsCodeExit()))
				{
					flag2 = textPosition.Offset < 0;
					flag = true;
					break;
				}
				if (char.IsWhiteSpace(c))
				{
					if (textPosition4.Offset < 0)
					{
						textPosition4 = _position;
						textPosition2 = textPosition;
					}
					if (c != '\n' && (c != '\r' || PeekChar() == '\n'))
					{
						if (textPosition5.Offset < 0)
						{
							textPosition5 = _position;
							textPosition3 = textPosition;
						}
					}
					else
					{
						textPosition5.Offset = -1;
						textPosition3.Offset = -1;
					}
				}
				else
				{
					textPosition4.Offset = -1;
					textPosition2.Offset = -1;
					textPosition5.Offset = -1;
					textPosition3.Offset = -1;
				}
				textPosition = _position;
				NextChar();
			}
			if (textPosition.Offset < 0)
			{
				textPosition = position;
			}
			TextPosition start = textPosition4;
			TextPosition textPosition6 = textPosition2;
			if (whitespaceMode == TokenType.Whitespace)
			{
				start = textPosition5;
				textPosition6 = textPosition3;
			}
			if (whitespaceMode != TokenType.Invalid && start.Offset >= 0)
			{
				_pendingTokens.Enqueue(new Token(whitespaceMode, start, textPosition));
				if (textPosition6.Offset < 0)
				{
					return false;
				}
				textPosition = textPosition6;
			}
			if (flag && flag2)
			{
				textPosition = new TextPosition(position.Offset - 1, position.Line, position.Column - 1);
			}
			_token = new Token((_blockType == BlockType.Escape) ? TokenType.Escape : TokenType.Raw, position, textPosition);
			if (!flag)
			{
				NextChar();
			}
			return true;
		}

		private bool ReadCode()
		{
			bool result = true;
			TextPosition position = _position;
			if (TryMatchCustomToken(position))
			{
				return true;
			}
			if (_interpJustOpened)
			{
				TextPosition textPosition = new TextPosition(_position.Offset - 1, _position.Line, _position.Column - 1);
				_token = new Token(TokenType.OpenInterpolatedBrace, textPosition, textPosition);
				_interpJustOpened = false;
				return result;
			}
			if (_interpJustClosed)
			{
				_interpJustClosed = false;
				ReadInterpolatedString();
				return result;
			}
			switch (this.c)
			{
			case '\n':
				_token = new Token(TokenType.NewLine, position, _position);
				NextChar();
				ConsumeWhitespace(stopAtNewLine: false, ref _token.End);
				break;
			case ';':
				_token = new Token(TokenType.SemiColon, position, _position);
				NextChar();
				break;
			case '\r':
				NextChar();
				if (this.c == '\n')
				{
					_token = new Token(TokenType.NewLine, position, _position);
					NextChar();
					ConsumeWhitespace(stopAtNewLine: false, ref _token.End);
				}
				else
				{
					_token = new Token(TokenType.NewLine, position, position);
					ConsumeWhitespace(stopAtNewLine: false, ref _token.End);
				}
				break;
			case ':':
				_token = new Token(TokenType.Colon, position, position);
				NextChar();
				break;
			case '@':
				_token = new Token(TokenType.Arroba, position, position);
				NextChar();
				break;
			case '^':
				NextChar();
				if (this.c == '^')
				{
					_token = new Token(TokenType.DoubleCaret, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Caret, position, position);
				}
				break;
			case '*':
				NextChar();
				if (this.c == '=')
				{
					_token = new Token(TokenType.AsteriskEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Asterisk, position, position);
				}
				break;
			case '/':
				NextChar();
				if (this.c == '/')
				{
					_token = new Token(TokenType.DoubleDivide, position, _position);
					NextChar();
					if (this.c == '=')
					{
						_token = new Token(TokenType.DoubleDivideEqual, position, _position);
						NextChar();
					}
				}
				else if (this.c == '=')
				{
					_token = new Token(TokenType.DivideEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Divide, position, position);
				}
				break;
			case '+':
				NextChar();
				if (this.c == '+')
				{
					_token = new Token(TokenType.DoublePlus, position, _position);
					NextChar();
				}
				else if (this.c == '=')
				{
					_token = new Token(TokenType.PlusEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Plus, position, position);
				}
				break;
			case '-':
				NextChar();
				if (this.c == '-')
				{
					_token = new Token(TokenType.DoubleMinus, position, _position);
					NextChar();
				}
				else if (this.c == '=')
				{
					_token = new Token(TokenType.MinusEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Minus, position, position);
				}
				break;
			case '%':
				NextChar();
				if (this.c == '=')
				{
					_token = new Token(TokenType.PercentEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Percent, position, position);
				}
				break;
			case ',':
				_token = new Token(TokenType.Comma, position, position);
				NextChar();
				break;
			case '&':
				NextChar();
				if (this.c == '&')
				{
					_token = new Token(TokenType.DoubleAmp, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Amp, position, position);
				}
				break;
			case '?':
				NextChar();
				if (this.c == '?')
				{
					_token = new Token(TokenType.DoubleQuestion, position, _position);
					NextChar();
				}
				else if (this.c == '.')
				{
					_token = new Token(TokenType.QuestionDot, position, _position);
					NextChar();
				}
				else if (this.c == '!')
				{
					_token = new Token(TokenType.QuestionExclamation, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Question, position, position);
				}
				break;
			case '|':
				NextChar();
				if (this.c == '|')
				{
					_token = new Token(TokenType.DoubleVerticalBar, position, _position);
					NextChar();
				}
				else if (this.c == '>')
				{
					_token = new Token(TokenType.PipeGreater, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.VerticalBar, position, position);
				}
				break;
			case '.':
				NextChar();
				if (this.c == '.')
				{
					TextPosition position2 = _position;
					NextChar();
					if (this.c == '<')
					{
						_token = new Token(TokenType.DoubleDotLess, position, _position);
						NextChar();
					}
					else if (this.c == '.')
					{
						_token = new Token(TokenType.TripleDot, position, _position);
						NextChar();
					}
					else
					{
						_token = new Token(TokenType.DoubleDot, position, position2);
					}
				}
				else
				{
					_token = new Token(TokenType.Dot, position, position);
				}
				break;
			case '!':
				NextChar();
				if (this.c == '=')
				{
					_token = new Token(TokenType.ExclamationEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Exclamation, position, position);
				}
				break;
			case '=':
				NextChar();
				if (this.c == '=')
				{
					_token = new Token(TokenType.DoubleEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Equal, position, position);
				}
				break;
			case '<':
				NextChar();
				if (this.c == '=')
				{
					_token = new Token(TokenType.LessEqual, position, _position);
					NextChar();
				}
				else if (this.c == '<')
				{
					_token = new Token(TokenType.DoubleLessThan, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Less, position, position);
				}
				break;
			case '>':
				NextChar();
				if (this.c == '=')
				{
					_token = new Token(TokenType.GreaterEqual, position, _position);
					NextChar();
				}
				else if (this.c == '>')
				{
					_token = new Token(TokenType.DoubleGreaterThan, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Greater, position, position);
				}
				break;
			case '(':
				_token = new Token(TokenType.OpenParen, _position, _position);
				NextChar();
				break;
			case ')':
				_token = new Token(TokenType.CloseParen, _position, _position);
				NextChar();
				break;
			case '[':
				_token = new Token(TokenType.OpenBracket, _position, _position);
				NextChar();
				break;
			case ']':
				_token = new Token(TokenType.CloseBracket, _position, _position);
				NextChar();
				break;
			case '{':
				_openBraceCount++;
				_token = new Token(TokenType.OpenBrace, _position, _position);
				NextChar();
				break;
			case '}':
				if (AnyInterpolationOpen)
				{
					_interpJustClosed = true;
					_token = new Token(TokenType.CloseInterpolatedBrace, _position, _position);
				}
				else if (_openBraceCount > 0)
				{
					_openBraceCount--;
					_token = new Token(TokenType.CloseBrace, _position, _position);
					NextChar();
				}
				else if (Options.Mode != ScriptMode.ScriptOnly && IsCodeExit())
				{
					result = false;
				}
				else
				{
					AddError("Unexpected } while no matching {", _position, _position);
					_token = new Token(TokenType.CloseBrace, _position, _position);
					NextChar();
				}
				break;
			case '#':
				ReadComment();
				break;
			case '"':
			case '\'':
				ReadString();
				break;
			case '`':
				ReadVerbatimString();
				break;
			case '\0':
				_token = Token.Eof;
				break;
			default:
			{
				TextPosition lastSpace = default(TextPosition);
				if (ConsumeWhitespace(stopAtNewLine: true, ref lastSpace))
				{
					if (Options.KeepTrivia)
					{
						_token = new Token(TokenType.Whitespace, position, lastSpace);
					}
					else
					{
						result = false;
					}
					break;
				}
				bool flag = this.c == '$';
				char c = PeekChar();
				if (flag && (c == '"' || c == '\''))
				{
					ReadInterpolatedString();
					break;
				}
				if (IsFirstIdentifierLetter(this.c) || flag)
				{
					ReadIdentifier(flag);
					break;
				}
				if (char.IsDigit(this.c))
				{
					ReadNumber();
					break;
				}
				_token = new Token(TokenType.Invalid, _position, _position);
				NextChar();
				break;
			}
			}
			return result;
		}

		private bool TryMatchCustomToken(TextPosition start)
		{
			if (_tryMatchCustomToken == null)
			{
				return false;
			}
			if (!_tryMatchCustomToken(Text, _position, out var length, out var tokenType))
			{
				return false;
			}
			if (length <= 0)
			{
				throw new InvalidOperationException($"Invalid match length ({length}) for custom token must be > 0");
			}
			if (_position.Offset + length > Text.Length)
			{
				throw new InvalidOperationException($"Invalid match length ({length}) out of range of the input text.");
			}
			if (tokenType < TokenType.Custom && tokenType > TokenType.Custom9)
			{
				throw new InvalidOperationException(string.Format("Invalid token type {0}. Expecting between {1}.{2} ... {3}.{4}.", tokenType, "TokenType", TokenType.Custom, "TokenType", TokenType.Custom9));
			}
			TextPosition position = _position;
			while (length > 0)
			{
				NextChar();
				if (_position.Line != start.Line)
				{
					throw new InvalidOperationException($"Invalid match, cannot match between new lines at {_position}");
				}
				position = _position;
				length--;
			}
			_token = new Token(tokenType, start, position);
			return true;
		}

		private bool ReadCodeLiquid()
		{
			bool result = true;
			TextPosition position = _position;
			switch (c)
			{
			case ':':
				_token = new Token(TokenType.Colon, position, position);
				NextChar();
				break;
			case ',':
				_token = new Token(TokenType.Comma, position, position);
				NextChar();
				break;
			case '|':
				_token = new Token(TokenType.VerticalBar, position, position);
				NextChar();
				break;
			case '?':
				NextChar();
				_token = new Token(TokenType.Question, position, position);
				break;
			case '-':
				_token = new Token(TokenType.Minus, position, position);
				NextChar();
				break;
			case '.':
				NextChar();
				if (c == '.')
				{
					_token = new Token(TokenType.DoubleDot, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Dot, position, position);
				}
				break;
			case '!':
				NextChar();
				if (c == '=')
				{
					_token = new Token(TokenType.ExclamationEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Invalid, position, position);
				}
				break;
			case '=':
				NextChar();
				if (c == '=')
				{
					_token = new Token(TokenType.DoubleEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Equal, position, position);
				}
				break;
			case '<':
				NextChar();
				if (c == '=')
				{
					_token = new Token(TokenType.LessEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Less, position, position);
				}
				break;
			case '>':
				NextChar();
				if (c == '=')
				{
					_token = new Token(TokenType.GreaterEqual, position, _position);
					NextChar();
				}
				else
				{
					_token = new Token(TokenType.Greater, position, position);
				}
				break;
			case '(':
				_token = new Token(TokenType.OpenParen, _position, _position);
				NextChar();
				break;
			case ')':
				_token = new Token(TokenType.CloseParen, _position, _position);
				NextChar();
				break;
			case '[':
				_token = new Token(TokenType.OpenBracket, _position, _position);
				NextChar();
				break;
			case ']':
				_token = new Token(TokenType.CloseBracket, _position, _position);
				NextChar();
				break;
			case '"':
			case '\'':
				ReadString();
				break;
			case '\0':
				_token = Token.Eof;
				break;
			default:
			{
				TextPosition lastSpace = default(TextPosition);
				if (ConsumeWhitespace(stopAtNewLine: true, ref lastSpace))
				{
					if (Options.KeepTrivia)
					{
						_token = new Token(TokenType.Whitespace, position, lastSpace);
					}
					else
					{
						result = false;
					}
				}
				else if (IsFirstIdentifierLetter(c))
				{
					ReadIdentifier(special: false);
				}
				else if (char.IsDigit(c))
				{
					ReadNumber();
				}
				else
				{
					_token = new Token(TokenType.Invalid, _position, _position);
					NextChar();
				}
				break;
			}
			}
			return result;
		}

		private bool ConsumeWhitespace(bool stopAtNewLine, ref TextPosition lastSpace, bool keepNewLine = false)
		{
			TextPosition position = _position;
			while (char.IsWhiteSpace(c))
			{
				if (stopAtNewLine && IsNewLine(c))
				{
					if (keepNewLine)
					{
						lastSpace = _position;
						NextChar();
					}
					break;
				}
				lastSpace = _position;
				NextChar();
			}
			return position != _position;
		}

		private static bool IsNewLine(char c)
		{
			return c == '\n';
		}

		private void ReadIdentifier(bool special)
		{
			TextPosition position = _position;
			bool flag = true;
			TextPosition position2;
			do
			{
				position2 = _position;
				NextChar();
				if (flag && special && c == '$')
				{
					_token = new Token(TokenType.IdentifierSpecial, position, _position);
					NextChar();
					return;
				}
				flag = false;
			}
			while (IsIdentifierLetter(c));
			_token = new Token(special ? TokenType.IdentifierSpecial : TokenType.Identifier, position, position2);
			if (_isLiquid && Options.EnableIncludeImplicitString && _token.Match("include", Text) && char.IsWhiteSpace(c))
			{
				TextPosition lastSpace = _position;
				TextPosition end = lastSpace;
				ConsumeWhitespace(stopAtNewLine: false, ref lastSpace);
				_pendingTokens.Enqueue(new Token(TokenType.Whitespace, lastSpace, end));
				TextPosition position3 = _position;
				TextPosition end2 = position3;
				while (!char.IsWhiteSpace(c) && c != 0 && c != '%' && PeekChar() != '}')
				{
					end2 = _position;
					NextChar();
				}
				_pendingTokens.Enqueue(new Token(TokenType.ImplicitString, position3, end2));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsFirstIdentifierLetter(char c)
		{
			if (c != '_')
			{
				return char.IsLetter(c);
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool IsIdentifierLetter(char c)
		{
			if (!IsFirstIdentifierLetter(c) && !char.IsDigit(c))
			{
				if (_isLiquid)
				{
					return c == '-';
				}
				return false;
			}
			return true;
		}

		private void ReadNumber()
		{
			TextPosition position = _position;
			TextPosition position2 = _position;
			bool flag = false;
			bool flag2 = this.c == '0';
			NextChar();
			if (flag2 && this.c == 'x')
			{
				ReadHexa(position);
				return;
			}
			if (flag2 && this.c == 'b')
			{
				ReadBinary(position);
				return;
			}
			if (char.IsDigit(this.c) || this.c == '_')
			{
				do
				{
					position2 = _position;
					NextChar();
				}
				while (char.IsDigit(this.c) || this.c == '_');
			}
			if (this.c == '.')
			{
				char c = PeekChar();
				if (c != '.' && (IsNumberPostFix(c) || char.IsDigit(c) || !char.IsLetter(c) || c == 'e' || c == 'E'))
				{
					flag = true;
					position2 = _position;
					NextChar();
					while (char.IsDigit(this.c))
					{
						position2 = _position;
						NextChar();
					}
				}
			}
			if (this.c == 'e' || this.c == 'E')
			{
				position2 = _position;
				NextChar();
				if (this.c == '+' || this.c == '-')
				{
					position2 = _position;
					NextChar();
				}
				if (!char.IsDigit(this.c))
				{
					AddError("Expecting at least one digit after the exponent", _position, _position);
					return;
				}
				while (char.IsDigit(this.c))
				{
					position2 = _position;
					NextChar();
				}
			}
			if (!IsIdentifierLetter(PeekChar()) && IsNumberPostFix(this.c))
			{
				flag = true;
				position2 = _position;
				NextChar();
			}
			_token = new Token(flag ? TokenType.Float : TokenType.Integer, position, position2);
		}

		private static bool IsNumberPostFix(char c)
		{
			if (c != 'f' && c != 'F' && c != 'd' && c != 'D' && c != 'm')
			{
				return c == 'M';
			}
			return true;
		}

		private void ReadHexa(TextPosition start)
		{
			TextPosition position = _position;
			NextChar();
			bool flag = false;
			while (true)
			{
				if (CharHelper.IsHexa(c))
				{
					flag = true;
				}
				else if (c != '_')
				{
					break;
				}
				position = _position;
				NextChar();
			}
			if (!IsIdentifierLetter(PeekChar()) && (c == 'u' || c == 'U'))
			{
				position = _position;
				NextChar();
			}
			if (!flag)
			{
				AddError("Invalid hex number, expecting at least a hex digit [0-9a-fA-F] after 0x", start, position);
			}
			else
			{
				_token = new Token(TokenType.HexaInteger, start, position);
			}
		}

		private void ReadBinary(TextPosition start)
		{
			TextPosition position = _position;
			NextChar();
			bool flag = false;
			bool flag2 = false;
			while (true)
			{
				if (CharHelper.IsBinary(this.c))
				{
					flag = true;
				}
				else if (this.c != '_')
				{
					break;
				}
				position = _position;
				NextChar();
				if (this.c == '.')
				{
					if (flag2)
					{
						break;
					}
					char c = PeekChar();
					if (c != '0' && c != '1')
					{
						break;
					}
					flag2 = true;
					NextChar();
				}
			}
			if (!IsIdentifierLetter(PeekChar()) && (this.c == 'u' || this.c == 'U' || (flag2 && (this.c == 'f' || this.c == 'F' || this.c == 'd' || this.c == 'D'))))
			{
				position = _position;
				NextChar();
			}
			if (!flag)
			{
				AddError("Invalid binary number, expecting at least a binary digit 0 or 1 after 0b", start, position);
			}
			else
			{
				_token = new Token(TokenType.BinaryInteger, start, position);
			}
		}

		private void ReadString()
		{
			TextPosition position = _position;
			TextPosition position2 = _position;
			char c = this.c;
			NextChar();
			while (true)
			{
				if (this.c == '\\')
				{
					position2 = _position;
					NextChar();
					switch (this.c)
					{
					case '\n':
						position2 = _position;
						NextChar();
						continue;
					case '\r':
						position2 = _position;
						NextChar();
						if (this.c == '\n')
						{
							position2 = _position;
							NextChar();
						}
						continue;
					case '"':
					case '\'':
					case '0':
					case '\\':
					case 'b':
					case 'f':
					case 'n':
					case 'r':
					case 't':
					case 'v':
						position2 = _position;
						NextChar();
						continue;
					case 'u':
						position2 = _position;
						NextChar();
						if (this.c.IsHex())
						{
							position2 = _position;
							NextChar();
							if (this.c.IsHex())
							{
								position2 = _position;
								NextChar();
								if (this.c.IsHex())
								{
									position2 = _position;
									NextChar();
									if (this.c.IsHex())
									{
										position2 = _position;
										NextChar();
										continue;
									}
								}
							}
						}
						AddError($"Unexpected hex number `{this.c}` following `\\u`. Expecting `\\u0000` to `\\uffff`.", _position, _position);
						break;
					case 'x':
						position2 = _position;
						NextChar();
						if (this.c.IsHex())
						{
							position2 = _position;
							NextChar();
							if (this.c.IsHex())
							{
								position2 = _position;
								NextChar();
								continue;
							}
						}
						AddError($"Unexpected hex number `{this.c}` following `\\x`. Expecting `\\x00` to `\\xff`", _position, _position);
						break;
					}
					AddError($"Unexpected escape character `{this.c}` in string. Only 0 ' \\ \" b f n r t v u0000-uFFFF x00-xFF are allowed", _position, _position);
				}
				else
				{
					if (this.c == '\0')
					{
						AddError($"Unexpected end of file while parsing a string not terminated by a {c}", position2, position2);
						return;
					}
					if (this.c == c)
					{
						break;
					}
					position2 = _position;
					NextChar();
				}
			}
			position2 = _position;
			NextChar();
			_token = new Token(TokenType.String, position, position2);
		}

		private void ReadVerbatimString()
		{
			TextPosition position = _position;
			TextPosition position2 = _position;
			char c = this.c;
			NextChar();
			while (true)
			{
				if (this.c == '\0')
				{
					AddError($"Unexpected end of file while parsing a verbatim string not terminated by a {c}", position2, position2);
					return;
				}
				if (this.c == c)
				{
					position2 = _position;
					NextChar();
					if (this.c != c)
					{
						break;
					}
					position2 = _position;
					NextChar();
				}
				else
				{
					position2 = _position;
					NextChar();
				}
			}
			_token = new Token(TokenType.VerbatimString, position, position2);
		}

		private void ReadInterpolatedString()
		{
			TextPosition position = _position;
			TextPosition position2 = _position;
			char c = this.c;
			bool flag = this.c != '"' && this.c != '\'' && this.c != '$';
			if (flag)
			{
				c = _openingStringChars.Peek();
			}
			if (c == '$')
			{
				NextChar();
				c = this.c;
			}
			NextChar();
			while (true)
			{
				if (this.c == '\\')
				{
					position2 = _position;
					NextChar();
					switch (this.c)
					{
					case '\n':
						position2 = _position;
						NextChar();
						continue;
					case '\r':
						position2 = _position;
						NextChar();
						if (this.c == '\n')
						{
							position2 = _position;
							NextChar();
						}
						continue;
					case '"':
					case '\'':
					case '0':
					case '\\':
					case 'b':
					case 'f':
					case 'n':
					case 'r':
					case 't':
					case 'v':
					case '{':
						position2 = _position;
						NextChar();
						continue;
					case 'u':
						position2 = _position;
						NextChar();
						if (this.c.IsHex())
						{
							position2 = _position;
							NextChar();
							if (this.c.IsHex())
							{
								position2 = _position;
								NextChar();
								if (this.c.IsHex())
								{
									position2 = _position;
									NextChar();
									if (this.c.IsHex())
									{
										position2 = _position;
										NextChar();
										continue;
									}
								}
							}
						}
						AddError($"Unexpected hex number `{this.c}` following `\\u`. Expecting `\\u0000` to `\\uffff`.", _position, _position);
						break;
					case 'x':
						position2 = _position;
						NextChar();
						if (this.c.IsHex())
						{
							position2 = _position;
							NextChar();
							if (this.c.IsHex())
							{
								position2 = _position;
								NextChar();
								continue;
							}
						}
						AddError($"Unexpected hex number `{this.c}` following `\\x`. Expecting `\\x00` to `\\xff`", _position, _position);
						break;
					}
					AddError($"Unexpected escape character `{this.c}` in string. Only 0 ' \\ \" b f n r t v u0000-uFFFF x00-xFF are allowed", _position, _position);
					continue;
				}
				if (this.c == '\0')
				{
					AddError($"Unexpected end of file while parsing a string not terminated by a {c}", position2, position2);
					return;
				}
				if (this.c == '{')
				{
					position2 = _position;
					if (!flag)
					{
						_token = new Token(TokenType.BeginInterpolatedString, position, position2);
						_openingStringChars.Push(c);
					}
					else
					{
						_token = new Token(TokenType.ContinuationInterpolatedString, position, position2);
					}
					NextChar();
					_interpJustOpened = true;
					return;
				}
				if (this.c == c)
				{
					break;
				}
				position2 = _position;
				NextChar();
			}
			position2 = _position;
			NextChar();
			if (flag)
			{
				_openingStringChars.Pop();
				_token = new Token(TokenType.EndingInterpolatedString, position, position2);
			}
			else
			{
				position = new TextPosition(position.Offset, position.Line, position.Column);
				_token = new Token(TokenType.InterpolatedString, position, position2);
			}
		}

		private void ReadComment()
		{
			TextPosition position = _position;
			TextPosition position2 = _position;
			NextChar();
			bool flag = false;
			if (c == '#')
			{
				flag = true;
				position2 = _position;
				NextChar();
				while (!IsCodeExit() && c != 0)
				{
					bool num = c == '#';
					position2 = _position;
					NextChar();
					if (num && c == '#')
					{
						position2 = _position;
						NextChar();
						break;
					}
				}
			}
			else
			{
				while ((Options.Mode == ScriptMode.ScriptOnly || !IsCodeExit()) && c != 0 && c != '\r' && c != '\n')
				{
					position2 = _position;
					NextChar();
				}
			}
			_token = new Token(flag ? TokenType.CommentMulti : TokenType.Comment, position, position2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private char PeekChar(int count = 1)
		{
			int num = _position.Offset + count;
			if (num < 0 || num >= _textLength)
			{
				return '\0';
			}
			return Text[num];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void NextChar()
		{
			_position.Offset++;
			if (_position.Offset < _textLength)
			{
				char c = Text[_position.Offset];
				if (this.c == '\n' || (this.c == '\r' && c != '\n'))
				{
					_position.Column = 0;
					_position.Line++;
				}
				else
				{
					_position.Column++;
				}
				this.c = c;
			}
			else
			{
				_position.Offset = _textLength;
				this.c = '\0';
			}
		}

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

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

		private void AddError(string message, TextPosition start, TextPosition end)
		{
			_token = new Token(TokenType.Invalid, start, end);
			if (_errors == null)
			{
				_errors = new List<LogMessage>();
			}
			_errors.Add(new LogMessage(ParserMessageType.Error, new SourceSpan(SourcePath, start, end), message));
		}

		private void Reset()
		{
			c = ((Text.Length > 0) ? Text[Options.StartPosition.Offset] : '\0');
			_position = Options.StartPosition;
			_errors = null;
		}

		private static bool IsWhitespace(char c)
		{
			if (c != ' ')
			{
				return c == '\t';
			}
			return true;
		}
	}
	public record LexerOptions
	{
		public ScriptMode Mode { get; init; }

		public ScriptLang Lang { get; init; }

		public string FrontMatterMarker { get; init; } = "+++";

		public bool EnableIncludeImplicitString { get; init; }

		public TextPosition StartPosition { get; init; }

		public bool KeepTrivia { get; init; }

		public TryMatchCustomTokenDelegate? TryMatchCustomToken { get; init; }

		public const string DefaultFrontMatterMarker = "+++";

		public static readonly LexerOptions Default = new LexerOptions();

		[CompilerGenerated]
		protected LexerOptions(LexerOptions original)
		{
			Mode = original.Mode;
			Lang = original.Lang;
			FrontMatterMarker = original.FrontMatterMarker;
			EnableIncludeImplicitString = original.EnableIncludeImplicitString;
			StartPosition = original.StartPosition;
			KeepTrivia = original.KeepTrivia;
			TryMatchCustomToken = original.TryMatchCustomToken;
		}

		public LexerOptions()
		{
		}
	}
	public delegate bool TryMatchCustomTokenDelegate(string text, TextPosition position, out int length, out TokenType tokenType);
	public class LogMessage
	{
		public ParserMessageType Type { get; set; }

		public SourceSpan Span { get; set; }

		public string Message { get; set; }

		public LogMessage(ParserMessageType type, SourceSpan span, string message)
		{
			Type = type;
			Span = span;
			Message = message;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(Span.ToStringSimple());
			stringBuilder.Append(" : ");
			stringBuilder.Append(Type.ToString().ToLowerInvariant());
			stringBuilder.Append(" : ");
			if (Message != null)
			{
				stringBuilder.Append(Message);
			}
			return stringBuilder.ToString();
		}
	}
	public enum ParserMessageType
	{
		Error,
		Warning
	}
	public class Parser
	{
		private sealed class FatalParserException : Exception
		{
			public static readonly FatalParserException Instance = new FatalParserException();

			private FatalParserException()
			{
			}
		}

		private enum ParseExpressionMode
		{
			Default,
			DefaultNoNamedArgument,
			BasicExpression,
			WhenExpression
		}

		private class ScriptExpressionAsStatement : ScriptExpression
		{
			public ScriptStatement Statement { get; }

			public ScriptExpressionAsStatement(ScriptStatement statement)
			{
				Statement = statement;
			}

			public override object? Evaluate(TemplateContext context)
			{
				throw new NotSupportedException();
			}

			public override void PrintTo(ScriptPrinter printer)
			{
				throw new NotSupportedException();
			}

			public override void Accept(ScriptVisitor visitor)
			{
				throw new NotSupportedException();
			}

			public override TResult Accept<TResult>(ScriptVisitor<TResult> visitor)
			{
				throw new NotSupportedException();
			}
		}

		private readonly Lexer _lexer;

		private readonly bool _isLiquid;

		private Lexer.Enumerator _tokenIt;

		private readonly List<Token> _tokensPreview;

		private int _tokensPreviewStart;

		private Token _previousToken;

		private Token _token;

		private bool _inCodeSection;

		private bool _isLiquidTagSection;

		private int _blockLevel;

		private bool _inFrontMatter;

		private bool _isExpressionDepthLimitReached;

		private int _expressionDepth;

		private bool _hasFatalError;

		private readonly bool _isScientific;

		private readonly bool _isKeepTrivia;

		private readonly List<ScriptTrivia> _trivias;

		private readonly Queue<ScriptStatement> _pendingStatements;

		private IScriptTerminal? _lastTerminalWithTrivias;

		private Stack<char> _interpolatedNestedStringChars;

		public readonly ParserOptions Options;

		private ScriptFrontMatter? _frontmatter;

		private int _allowNewLineLevel;

		private int _expressionLevel;

		internal const int PrecedenceOfAdd = 100;

		internal const int PrecedenceOfMultiply = 110;

		private ScriptBlockStatement? _currentBlockStatement;

		public LogMessageBag Messages { get; private set; }

		public bool HasErrors { get; private set; }

		private Stack<ScriptNode> Blocks { get; }

		private Token Current => _token;

		private Token Previous => _previousToken;

		private bool AnyInterpolation => _interpolatedNestedStringChars.Count > 0;

		public SourceSpan CurrentSpan => GetSpanForToken(Current);

		private ScriptMode CurrentParsingMode { get; set; }

		private ScriptStringSlice CurrentStringSlice => GetAsStringSlice(Current);

		public int ExpressionLevel => _expressionLevel;

		public Parser(Lexer lexer, ParserOptions? options = null)
		{
			_lexer = lexer ?? throw new ArgumentNullException("lexer");
			_isLiquid = _lexer.Options.Lang == ScriptLang.Liquid;
			_isScientific = _lexer.Options.Lang == ScriptLang.Scientific;
			_tokensPreview = new List<Token>(4);
			Messages = new LogMessageBag();
			_trivias = new List<ScriptTrivia>();
			Options = options ?? ParserOptions.Default;
			CurrentParsingMode = lexer.Options.Mode;
			_isKeepTrivia = lexer.Options.KeepTrivia;
			_pendingStatements = new Queue<ScriptStatement>(2);
			Blocks = new Stack<ScriptNode>();
			_interpolatedNestedStringChars = new Stack<char>();
			_tokenIt = lexer.GetEnumerator();
			NextToken();
		}

		public ScriptPage? Run()
		{
			Messages = new LogMessageBag();
			HasErrors = false;
			_blockLevel = 0;
			_isExpressionDepthLimitReached = false;
			_hasFatalError = false;
			_expressionDepth = 0;
			Blocks.Clear();
			ScriptPage scriptPage = Open<ScriptPage>();
			try
			{
				ScriptMode currentParsingMode = CurrentParsingMode;
				switch (currentParsingMode)
				{
				case ScriptMode.FrontMatterOnly:
				case ScriptMode.FrontMatterAndContent:
					if (Current.Type != TokenType.FrontMatterMarker)
					{
						LogError($"When `{CurrentParsingMode}` is enabled, expecting a `{_lexer.Options.FrontMatterMarker}` at the beginning of the text instead of `{Current.GetText(_lexer.Text)}`");
						return null;
					}
					_inFrontMatter = true;
					_inCodeSection = true;
					_frontmatter = Open<ScriptFrontMatter>();
					ExpectAndParseTokenTo(_frontmatter.StartMarker, TokenType.FrontMatterMarker);
					_frontmatter.Statements = ParseBlockStatement(_frontmatter);
					if (_inFrontMatter)
					{
						LogError("End of frontmatter `" + _lexer.Options.FrontMatterMarker + "` not found");
					}
					scriptPage.FrontMatter = _frontmatter;
					scriptPage.Span = _frontmatter.Span;
					if (currentParsingMode == ScriptMode.FrontMatterOnly)
					{
						return scriptPage;
					}
					break;
				case ScriptMode.ScriptOnly:
					_inCodeSection = true;
					break;
				}
				scriptPage.Body = ParseBlockStatement(scriptPage);
				if (scriptPage.Body != null)
				{
					scriptPage.Span = scriptPage.Body.Span;
				}
				if (_isKeepTrivia && _lastTerminalWithTrivias != null)
				{
					FlushTriviasToLastTerminal();
				}
				if (scriptPage.FrontMatter != null)
				{
					FixRawStatementAfterFrontMatter(scriptPage);
				}
			}
			catch (FatalParserException)
			{
			}
			if (_lexer.HasErrors)
			{
				foreach (LogMessage error in _lexer.Errors)
				{
					Log(error);
				}
			}
			return scriptPage;
		}

		private void PushTokenToTrivia()
		{
			if (_isKeepTrivia)
			{
				if (Current.Type == TokenType.NewLine)
				{
					_trivias.Add(new ScriptTrivia(CurrentSpan, ScriptTriviaType.NewLine, CurrentStringSlice));
				}
				else if (Current.Type == TokenType.SemiColon)
				{
					_trivias.Add(new ScriptTrivia(CurrentSpan, ScriptTriviaType.SemiColon, CurrentStringSlice));
				}
				else if (Current.Type == TokenType.Comma)
				{
					_trivias.Add(new ScriptTrivia(CurrentSpan, ScriptTriviaType.Comma, CurrentStringSlice));
				}
			}
		}

		private ScriptStringSlice GetAsStringSlice(Token token)
		{
			return new ScriptStringSlice(_lexer.Text, token.Start.Offset, token.End.Offset - token.Start.Offset + 1);
		}

		private T Open<T>(T element) where T : ScriptNode
		{
			element.Span = new SourceSpan
			{
				FileName = _lexer.SourcePath,
				Start = Current.Start
			};
			if (_isKeepTrivia && element is IScriptTerminal element2)
			{
				FlushTrivias(element2, isBefore: true);
			}
			return element;
		}

		private T Open<T>() where T : ScriptNode, new()
		{
			T val = new T
			{
				Span = 
				{
					FileName = _lexer.SourcePath,
					Start = Current.Start
				}
			};
			if (_isKeepTrivia && val is IScriptTerminal element)
			{
				FlushTrivias(element, isBefore: true);
			}
			return val;
		}

		private void FlushTrivias(IScriptTerminal element, bool isBefore)
		{
			if (_isKeepTrivia && _trivias.Count > 0)
			{
				element.AddTrivias(_trivias, isBefore);
				_trivias.Clear();
			}
		}

		private T Close<T>(T node) where T : ScriptNode
		{
			node.Span.End = Previous.End;
			if (_isKeepTrivia && node is IScriptTerminal scriptTerminal)
			{
				_lastTerminalWithTrivias = scriptTerminal;
				FlushTrivias(scriptTerminal, isBefore: false);
			}
			return node;
		}

		private void FlushTriviasToLastTerminal()
		{
			if (_isKeepTrivia && _lastTerminalWithTrivias != null)
			{
				FlushTrivias(_lastTerminalWithTrivias, isBefore: false);
			}
		}

		private string GetAsText(Token localToken)
		{
			return localToken.GetText(_lexer.Text);
		}

		private string GetAsTextForLog(Token localToken)
		{
			string asText = GetAsText(localToken);
			string text = asText;
			for (int i = 0; i < text.Length; i++)
			{
				if (!char.IsControl(text[i]))
				{
					continue;
				}
				StringBuilder stringBuilder = new StringBuilder(asText.Length);
				string text2 = asText;
				foreach (char c in text2)
				{
					if (char.IsControl(c))
					{
						switch (c)
						{
						case '\n':
							stringBuilder.Append("\\n");
							break;
						case '\r':
							stringBuilder.Append("\\r");
							break;
						case '\t':
							stringBuilder.Append("\\t");
							break;
						case '\v':
							stringBuilder.Append("\\v");
							break;
						case '\f':
							stringBuilder.Append("\\f");
							break;
						case '\b':
							stringBuilder.Append("\\b");
							break;
						case '\a':
							stringBuilder.Append("\\a");
							break;
						case '\0':
							stringBuilder.Append("\\0");
							break;
						default:
							stringBuilder.Append($"\\u{(int)c:x4}");
							break;
						}
					}
					else
					{
						stringBuilder.Append(c);
					}
				}
				return stringBuilder.ToString();
			}
			return asText;
		}

		private bool MatchText(Token localToken, string text)
		{
			return localToken.Match(text, _lexer.Text);
		}

		private void NextToken()
		{
			_previousToken = _token;
			while (_tokensPreviewStart < _tokensPreview.Count)
			{
				_token = _tokensPreview[_tokensPreviewStart];
				_tokensPreviewStart++;
				if (_tokensPreviewStart == _tokensPreview.Count)
				{
					_tokensPreviewStart = 0;
					_tokensPreview.Clear();
				}
				if (IsHidden(_token.Type))
				{
					if (_isKeepTrivia)
					{
						PushTrivia(_token);
					}
					continue;
				}
				return;
			}
			bool flag;
			while ((flag = _tokenIt.MoveNext()) && IsHidden(_tokenIt.Current.Type))
			{
				if (_isKeepTrivia)
				{
					PushTrivia(_tokenIt.Current);
				}
			}
			_token = (flag ? _tokenIt.Current : Token.Eof);
		}

		private void PushTrivia(Token token)
		{
			ScriptTrivia item = new ScriptTrivia(type: token.Type switch
			{
				TokenType.Comment => ScriptTriviaType.Comment, 
				TokenType.CommentMulti => ScriptTriviaType.CommentMulti, 
				TokenType.Whitespace => ScriptTriviaType.Whitespace, 
				TokenType.WhitespaceFull => ScriptTriviaType.WhitespaceFull, 
				TokenType.NewLine => ScriptTriviaType.NewLine, 
				_ => throw new InvalidOperationException($"Token type `{token.Type}` not supported by trivia"), 
			}, span: GetSpanForToken(token), text: GetAsStringSlice(token));
			_trivias.Add(item);
		}

		private Token PeekToken()
		{
			for (int i = _tokensPreviewStart; i < _tokensPreview.Count; i++)
			{
				Token result = _tokensPreview[i];
				if (!IsHidden(result.Type))
				{
					return result;
				}
			}
			while (_tokenIt.MoveNext())
			{
				Token current = _tokenIt.Current;
				_tokensPreview.Add(current);
				if (!IsHidden(current.Type))
				{
					return current;
				}
			}
			return Token.Eof;
		}

		private ScriptIdentifier ParseIdentifier()
		{
			ScriptIdentifier scriptIdentifier = Open<ScriptIdentifier>();
			scriptIdentifier.Value = GetAsText(Current);
			NextToken();
			return Close(scriptIdentifier);
		}

		private bool IsHidden(TokenType tokenType)
		{
			switch (tokenType)
			{
			case TokenType.NewLine:
				return _allowNewLineLevel > 0;
			default:
				return false;
			case TokenType.Whitespace:
			case TokenType.WhitespaceFull:
			case TokenType.Comment:
			case TokenType.CommentMulti:
				return true;
			}
		}

		private void LogError(string text, bool isFatal = false)
		{
			LogError(Current, text, isFatal);
		}

		private void LogError(Token tokenArg, string text, bool isFatal = false)
		{
			LogError(GetSpanForToken(tokenArg), text, isFatal);
		}

		private SourceSpan GetSpanForToken(Token tokenArg)
		{
			return new SourceSpan(_lexer.SourcePath, tokenArg.Start, tokenArg.End);
		}

		private void LogError(SourceSpan span, string text, bool isFatal = false)
		{
			Log(new LogMessage(ParserMessageType.Error, span, text), isFatal);
		}

		private void LogError(ScriptNode node, string message, bool isFatal = false)
		{
			LogError(node, node.Span, message, isFatal);
		}

		private void LogError(ScriptNode node, SourceSpan span, string message, bool isFatal = false)
		{
			ScriptSyntaxAttribute scriptSyntaxAttribute = ScriptSyntaxAttribute.Get(node) ?? ScriptSyntaxAttribute.Get(node.GetType());
			string text = " in";
			if (message.EndsWith("after"))
			{
				text = string.Empty;
			}
			LogError(span, "Error while parsing " + scriptSyntaxAttribute.TypeName + ": " + message + text + ": " + scriptSyntaxAttribute.Example, isFatal);
		}

		private void Log(LogMessage logMessage, bool isFatal = false)
		{
			if (logMessage == null)
			{
				throw new ArgumentNullException("logMessage");
			}
			Messages.Add(logMessage);
			if (logMessage.Type == ParserMessageType.Error)
			{
				HasErrors = true;
				if (isFatal)
				{
					_hasFatalError = true;
				}
			}
		}

		private bool TryBinaryOperator(out ScriptBinaryOperator binaryOperator, out int precedence)
		{
			TokenType type = Current.Type;
			precedence = 0;
			binaryOperator = ScriptBinaryOperator.None;
			switch (type)
			{
			case TokenType.Asterisk:
				binaryOperator = ScriptBinaryOperator.Multiply;
				break;
			case TokenType.Divide:
				binaryOperator = ScriptBinaryOperator.Divide;
				break;
			case TokenType.DoubleDivide:
				binaryOperator = ScriptBinaryOperator.DivideRound;
				break;
			case TokenType.Plus:
				binaryOperator = ScriptBinaryOperator.Add;
				break;
			case TokenType.Minus:
				binaryOperator = ScriptBinaryOperator.Subtract;
				break;
			case TokenType.Percent:
				binaryOperator = ScriptBinaryOperator.Modulus;
				break;
			case TokenType.DoubleLessThan:
				binaryOperator = ScriptBinaryOperator.ShiftLeft;
				break;
			case TokenType.DoubleGreaterThan:
				binaryOperator = ScriptBinaryOperator.ShiftRight;
				break;
			case TokenType.DoubleQuestion:
				binaryOperator = ScriptBinaryOperator.EmptyCoalescing;
				break;
			case TokenType.QuestionExclamation:
				binaryOperator = ScriptBinaryOperator.NotEmptyCoalescing;
				break;
			case TokenType.DoubleAmp:
				binaryOperator = ScriptBinaryOperator.And;
				break;
			case TokenType.DoubleVerticalBar:
				binaryOperator = ScriptBinaryOperator.Or;
				break;
			case TokenType.DoubleEqual:
				binaryOperator = ScriptBinaryOperator.CompareEqual;
				break;
			case TokenType.ExclamationEqual:
				binaryOperator = ScriptBinaryOperator.CompareNotEqual;
				break;
			case TokenType.Greater:
				binaryOperator = ScriptBinaryOperator.CompareGreater;
				break;
			case TokenType.GreaterEqual:
				binaryOperator = ScriptBinaryOperator.CompareGreaterOrEqual;
				break;
			case TokenType.Less:
				binaryOperator = ScriptBinaryOperator.CompareLess;
				break;
			case TokenType.LessEqual:
				binaryOperator = ScriptBinaryOperator.CompareLessOrEqual;
				break;
			case TokenType.DoubleDot:
				binaryOperator = ScriptBinaryOperator.RangeInclude;
				break;
			case TokenType.DoubleDotLess:
				binaryOperator = ScriptBinaryOperator.RangeExclude;
				break;
			default:
				if (_isScientific)
				{
					switch (type)
					{
					case TokenType.Caret:
						binaryOperator = ScriptBinaryOperator.Power;
						break;
					case TokenType.Amp:
						binaryOperator = ScriptBinaryOperator.BinaryAnd;
						break;
					case TokenType.VerticalBar:
						binaryOperator = ScriptBinaryOperator.BinaryOr;
						break;
					}
				}
				break;
			}
			if (binaryOperator != ScriptBinaryOperator.None)
			{
				precedence = GetDefaultBinaryOperatorPrecedence(binaryOperator);
			}
			return binaryOperator != ScriptBinaryOperator.None;
		}

		private ScriptExpression? ParseExpressionAsVariableOrStringOrExpression(ScriptNode parentNode)
		{
			switch (Current.Type)
			{
			case TokenType.IdentifierSpecial:
			case TokenType.Identifier:
				return ParseVariable();
			case TokenType.String:
				return ParseString();
			case TokenType.InterpolatedString:
			case TokenType.BeginInterpolatedString:
				return ParseInterpolatedString();
			case TokenType.VerbatimString:
				return ParseVerbatimString();
			default:
				return ParseExpression(parentNode);
			}
		}

		private ScriptExpression? ParseExpression(ScriptNode parentNode, ScriptExpression? parentExpression = null, int precedence = 0, ParseExpressionMode mode = ParseExpressionMode.Default, bool allowAssignment = true)
		{
			bool flag = false;
			int num = 0;
			_expressionLevel++;
			int expressionDepth = _expressionDepth;
			int num2 = precedence;
			ParseExpressionMode parseExpressionMode = mode;
			mode = ((mode != ParseExpressionMode.WhenExpression) ? mode : ParseExpressionMode.Default);
			EnterExpression();
			try
			{
				ScriptFunctionCall scriptFunctionCall = null;
				while (true)
				{
					num++;
					ScriptExpression scriptExpression = null;
					bool flag2 = false;
					switch (Current.Type)
					{
					case TokenType.IdentifierSpecial:
					case TokenType.Identifier:
						scriptExpression = ParseVariable();
						if (_isLiquid && parentNode is ScriptPipeCall && Current.Type == TokenType.Colon)
						{
							NextToken();
						}
						if (ScriptVariable.BlockDelegate.Equals(scriptExpression))
						{
							if (num != 1 || _expressionLevel > 1)
							{
								LogError("Cannot use block delegate $$ in a nested expression");
							}
							if (!(parentNode is ScriptExpressionStatement))
							{
								LogError(parentNode, "Cannot use block delegate $$ outside an expression statement");
							}
							return scriptExpression;
						}
						break;
					case TokenType.Integer:
						scriptExpression = ParseInteger();
						break;
					case TokenType.HexaInteger:
						scriptExpression = ParseHexaInteger();
						break;
					case TokenType.BinaryInteger:
						scriptExpression = ParseBinaryInteger();
						break;
					case TokenType.Float:
						scriptExpression = ParseFloat();
						break;
					case TokenType.String:
						scriptExpression = ParseString();
						break;
					case TokenType.ImplicitString:
						scriptExpression = ParseImplicitString();
						break;
					case TokenType.InterpolatedString:
					case TokenType.BeginInterpolatedString:
						scriptExpression = ParseInterpolatedString();
						break;
					case TokenType.ContinuationInterpolatedString:
						scriptExpression = ParseInterpolatedStringPart();
						break;
					case TokenType.VerbatimString:
						scriptExpression = ParseVerbatimString();
						break;
					case TokenType.OpenParen:
						scriptExpression = ParseParenthesis();
						break;
					case TokenType.OpenBrace:
						scriptExpression = ParseObjectInitializer();
						break;
					case TokenType.OpenInterpolatedBrace:
						scriptExpression = ParseInterpolatedExpression();
						break;
					case TokenType.OpenBracket:
						scriptExpression = ParseArrayInitializer();
						break;
					case TokenType.DoublePlus:
					case TokenType.DoubleMinus:
						scriptExpression = ParseIncrementDecrementExpression();
						break;
					default:
						if (IsStartingAsUnaryExpression())
						{
							scriptExpression = ParseUnaryExpression();
						}
						break;
					}
					if (scriptExpression == null)
					{
						break;
					}
					if (scriptExpression is ScriptAnonymousFunction)
					{
						flag = true;
					}
					while (true)
					{
						if (!flag && Current.Type != TokenType.EndingInterpolatedString && Current.Type != TokenType.CloseInterpolatedBrace && Current.Type != TokenType.ContinuationInterpolatedString && Current.Type != TokenType.OpenInterpolatedBrace)
						{
							if (_isLiquid && Current.Type == TokenType.Comma && scriptFunctionCall != null)
							{
								NextToken();
							}
							if (Current.Type == TokenType.Dot || (!_isLiquid && Current.Type == TokenType.QuestionDot))
							{
								Token tokenArg = PeekToken();
								if (tokenArg.Type == TokenType.Identifier)
								{
									ScriptToken scriptToken = ParseToken(Current.Type);
									string asText = GetAsText(Current);
									if ((asText == "empty" || asText == "blank") && PeekToken().Type == TokenType.Question)
									{
										ScriptIsEmptyExpression scriptIsEmptyExpression = Open<ScriptIsEmptyExpression>();
										scriptIsEmptyExpression.Span = scriptExpression.Span;
										scriptIsEmptyExpression.DotToken = scriptToken;
										if (!(ParseVariable() is ScriptVariable member))
										{
											LogError("Unexpected literal member `{member}`");
											return null;
										}
										scriptIsEmptyExpression.Member = member;
										ExpectAndParseTokenTo(scriptIsEmptyExpression.QuestionToken, TokenType.Question);
										scriptIsEmptyExpression.Target = scriptExpression;
										scriptExpression = Close(scriptIsEmptyExpression);
										continue;
									}
									ScriptMemberExpression scriptMemberExpression = Open<ScriptMemberExpression>();
									scriptMemberExpression.Span = scriptExpression.Span;
									scriptMemberExpression.DotToken = scriptToken;
									scriptMemberExpression.Target = scriptExpression;
									if (scriptExpression is ScriptMemberExpression scriptMemberExpression2 && scriptMemberExpression2.DotToken.TokenType == TokenType.QuestionDot)
									{
										scriptToken.TokenType = TokenType.QuestionDot;
									}
									if (!(ParseVariable() is ScriptVariable member2))
									{
										LogError("Unexpected literal member `{member}`");
										return null;
									}
									scriptMemberExpression.Member = member2;
									scriptExpression = Close(scriptMemberExpression);
									continue;
								}
								LogError(tokenArg, $"Invalid token `{tokenArg.Type}`. The dot operator is expected to be followed by a plain identifier");
								return scriptExpression;
							}
							if (Current.Type == TokenType.DoublePlus || Current.Type == TokenType.DoubleMinus)
							{
								Token current = Current;
								if (!(scriptExpression is IScriptVariablePath))
								{
									LogError("The operand of an increment or decrement operator must be a variable, property or indexer");
								}
								scriptExpression = new ScriptIncrementDecrementExpression
								{
									Right = scriptExpression,
									Span = scriptExpression.Span,
									OperatorToken = ParseToken(current.Type),
									Operator = ((current.Type == TokenType.DoublePlus) ? ScriptUnaryOperator.Increment : ScriptUnaryOperator.Decrement),
									Post = true
								};
							}
							if (Current.Type == TokenType.OpenBracket && (scriptExpression is IScriptVariablePath || scriptExpression is ScriptLiteral || scriptExpression is ScriptFunctionCall) && !IsPreviousCharWhitespace())
							{
								ScriptIndexerExpression scriptIndexerExpression = Open<ScriptIndexerExpression>();
								scriptIndexerExpression.Span = scriptExpression.Span;
								scriptIndexerExpression.Target = scriptExpression;
								ExpectAndParseTokenTo(scriptIndexerExpression.OpenBracket, TokenType.OpenBracket);
								scriptIndexerExpression.Index = ExpectAndParseExpression(scriptIndexerExpression, scriptFunctionCall, 0, "Expecting <index_expression> instead of `" + GetAsTextForLog(Current) + "`", mode);
								if (Current.Type != TokenType.CloseBracket)
								{
									LogError("Unexpected `" + GetAsTextForLog(Current) + "`. Expecting ']'");
								}
								else
								{
									ExpectAndParseTokenTo(scriptIndexerExpression.CloseBracket, TokenType.CloseBracket);
								}
								scriptExpression = Close(scriptIndexerExpression);
								continue;
							}
							if (mode != ParseExpressionMode.BasicExpression && !(parentNode is ScriptUnaryExpression { Operator: ScriptUnaryOperator.FunctionAlias }))
							{
								ScriptFunction function;
								ScriptToken scriptToken2;
								TokenType tokenType;
								ScriptBinaryOperator binaryOperator;
								int precedence2;
								if (mode != ParseExpressionMode.DefaultNoNamedArgument && Current.Type == TokenType.Colon)
								{
									if (!(scriptExpression is ScriptVariable))
									{
										LogError(scriptExpression.Span, "Expecting a simple global or local variable before `:` in order to create a named argument");
									}
									else
									{
										ScriptNamedArgument scriptNamedArgument = Open<ScriptNamedArgument>();
										scriptNamedArgument.Name = (ScriptVariable)scriptExpression;
										scriptNamedArgument.ColonToken = ParseToken(TokenType.Colon);
										scriptNamedArgument.Value = ExpectAndParseExpression(parentNode);
										Close(scriptNamedArgument);
										scriptExpression = scriptNamedArgument;
									}
								}
								else if (Current.Type == TokenType.Equal && scriptExpression is ScriptFunctionCall scriptFunctionCall2 && scriptFunctionCall2.TryGetFunctionDeclaration(out function))
								{
									if (_expressionLevel > 1 || !allowAssignment)
									{
										LogError(scriptExpression, "Creating a function is only allowed for a top level assignment");
									}
									function.EqualToken = ParseToken(TokenType.Equal);
									function.Body = ParseExpressionStatement();
									function.Span.End = function.Body.Span.End;
									scriptExpression = new ScriptExpressionAsStatement(function)
									{
										Span = function.Span
									};
								}
								else if (TryGetCompoundAssignmentOperator(out scriptToken2, out tokenType) && scriptToken2 != null)
								{
									ScriptAssignExpression scriptAssignExpression = Open<ScriptAssignExpression>();
									scriptAssignExpression.EqualToken = scriptToken2;
									if (scriptExpression != null)
									{
										scriptAssignExpression.Span.Start = scriptExpression.Span.Start;
									}
									if ((scriptExpression != null && !(scriptExpression is IScriptVariablePath)) || scriptFunctionCall != null || _expressionLevel > 1 || !allowAssignment)
									{
										LogError(scriptAssignExpression, "Expression is only allowed for a top level assignment");
									}
									ExpectAndParseTokenTo(scriptAssignExpression.EqualToken, tokenType);
									if (scriptExpression == null)
									{
										return null;
									}
									scriptAssignExpression.Target = TransformKeyword(scriptExpression);
									scriptAssignExpression.Value = ExpectAndParseExpression(scriptAssignExpression, parentExpression);
									scriptExpression = Close(scriptAssignExpression);
								}
								else if (TryBinaryOperator(out binaryOperator, out precedence2) || (_isLiquid && TryLiquidBinaryOperator(out binaryOperator, out precedence2)))
								{
									if (parseExpressionMode != ParseExpressionMode.WhenExpression || binaryOperator != ScriptBinaryOperator.Or)
									{
										if (precedence2 > precedence)
										{
											EnterExpression();
											ScriptBinaryExpression scriptBinaryExpression = Open<ScriptBinaryExpression>();
											scriptBinaryExpression.Span = scriptExpression.Span;
											scriptBinaryExpression.Left = scriptExpression;
											scriptBinaryExpression.Operator = binaryOperator;
											scriptBinaryExpression.OperatorToken = ParseToken(Current.Type);
											if (_isLiquid && binaryOperator != ScriptBinaryOperator.Custom)
											{
												scriptBinaryExpression.OperatorToken.Value = binaryOperator.ToText();
											}
											string message = "Expecting an <expression> to the right of the operator instead of `" + GetAsTextForLog(Current) + "`";
											scriptBinaryExpression.Right = ExpectAndParseExpression(scriptBinaryExpression, scriptFunctionCall ?? parentExpression, precedence2, message, mode);
											scriptExpression = Close(scriptBinaryExpression);
											continue;
										}
										if (num2 == 0)
										{
											precedence = num2;
											continue;
										}
									}
								}
								else if (!_isLiquid && Current.Type == TokenType.Question)
								{
									if (precedence <= 0)
									{
										if (scriptFunctionCall != null)
										{
											scriptFunctionCall.Arguments.Add(scriptExpression);
											Close(scriptFunctionCall);
											scriptExpression = scriptFunctionCall;
											scriptFunctionCall = null;
										}
										ScriptConditionalExpression scriptConditionalExpression = Open<ScriptConditionalExpression>();
										scriptConditionalExpression.Span = scriptExpression.Span;
										scriptConditionalExpression.Condition = scriptExpression;
										ExpectAndParseTokenTo(scriptConditionalExpression.QuestionToken, TokenType.Question);
										scriptConditionalExpression.ThenValue = ExpectAndParseExpression(scriptConditionalExpression, null, 0, null, ParseExpressionMode.DefaultNoNamedArgument);
										ExpectAndParseTokenTo(scriptConditionalExpression.ColonToken, TokenType.Colon);
										scriptConditionalExpression.ElseValue = ExpectAndParseExpression(scriptConditionalExpression, null, 0, null, ParseExpressionMode.DefaultNoNamedArgument);
										Close(scriptConditionalExpression);
										scriptExpression = scriptConditionalExpression;
									}
								}
								else if (IsStartOfExpression())
								{
									if (parentExpression == null)
									{
										IScriptNamedArgumentContainer scriptNamedArgumentContainer = parentNode as IScriptNamedArgumentContainer;
										if (!_isScientific && Current.Type == TokenType.Identifier && (parentNode is IScriptNamedArgumentContainer || (!_isLiquid && PeekToken().Type == TokenType.Colon)))
										{
											if (scriptNamedArgumentContainer == null)
											{
												if (scriptFunctionCall == null)
												{
													scriptFunctionCall = Open<ScriptFunctionCall>();
													scriptFunctionCall.Target = scriptExpression;
													scriptFunctionCall.Span.Start = scriptExpression.Span.Start;
												}
												else
												{
													scriptFunctionCall.Arguments.Add(scriptExpression);
												}
											}
											Close(scriptExpression);
											flag2 = true;
											while (Current.Type == TokenType.Identifier && (scriptNamedArgumentContainer != null || PeekToken().Type == TokenType.Colon))
											{
												ScriptNamedArgument scriptNamedArgument2 = Open<ScriptNamedArgument>();
												ScriptExpression scriptExpression2 = ParseVariable();
												if (!(scriptExpression2 is ScriptVariable name))
												{
													LogError(scriptExpression2.Span, "Invalid identifier passed as a named argument. Expecting a simple variable name");
													break;
												}
												scriptNamedArgument2.Name = name;
												if (scriptNamedArgumentContainer != null)
												{
													scriptNamedArgumentContainer.AddParameter(Close(scriptNamedArgument2));
												}
												else
												{
													if (scriptFunctionCall == null)
													{
														break;
													}
													scriptFunctionCall.Arguments.Add(scriptNamedArgument2);
												}
												if (Current.Type == TokenType.Colon)
												{
													scriptNamedArgument2.ColonToken = ScriptToken.Colon();
													ExpectAndParseTokenTo(scriptNamedArgument2.ColonToken, TokenType.Colon);
													scriptNamedArgument2.Value = ExpectAndParseExpression(parentNode, null, 0, null, ParseExpressionMode.BasicExpression);
													if (scriptNamedArgument2.Value != null)
													{
														scriptNamedArgument2.Span.End = scriptNamedArgument2.Value.Span.End;
													}
												}
												if (scriptFunctionCall != null)
												{
													scriptFunctionCall.Span.End = scriptNamedArgument2.Span.End;
													if (scriptNamedArgument2.Value is ScriptAnonymousFunction)
													{
														break;
													}
												}
											}
											if (scriptNamedArgumentContainer == null && IsStartOfExpression())
											{
												break;
											}
											if (scriptFunctionCall != null)
											{
												scriptExpression = scriptFunctionCall;
												scriptFunctionCall = null;
											}
											if (IsCurrentPipeOrExpressionContinuation())
											{
												continue;
											}
										}
										else
										{
											bool flag3 = Current.Type == TokenType.OpenParen && !IsPreviousCharWhitespace();
											if (scriptFunctionCall == null || flag3)
											{
												if (!_isScientific || flag3)
												{
													ScriptFunctionCall scriptFunctionCall3 = scriptFunctionCall;
													scriptFunctionCall = Open<ScriptFunctionCall>();
													scriptFunctionCall.Target = scriptExpression;
													if (_isLiquid && Options.LiquidFunctionsToScriban)
													{
														TransformLiquidFunctionCallToScriban(scriptFunctionCall);
													}
													scriptFunctionCall.Span.Start = scriptExpression.Span.Start;
													if (Current.Type != TokenType.OpenParen || IsPreviousCharWhitespace())
													{
														break;
													}
													scriptFunctionCall.ExplicitCall = true;
													scriptFunctionCall.OpenParent = ParseToken(TokenType.OpenParen);
													bool flag4 = true;
													while (true)
													{
														if (Current.Type == TokenType.CloseParen)
														{
															scriptFunctionCall.CloseParen = ParseToken(TokenType.CloseParen);
															break;
														}
														if (!flag4)
														{
															if (Current.Type == TokenType.Comma)
															{
																PushTokenToTrivia();
																NextToken();
																FlushTriviasToLastTerminal();
															}
															else
															{
																LogError(Current, "Expecting a comma to separate arguments in a function call.");
															}
														}
														flag4 = false;
														if (IsStartOfExpression())
														{
															ScriptExpression scriptExpression3 = ParseExpression(scriptFunctionCall);
															if (scriptExpression3 == null)
															{
																break;
															}
															scriptFunctionCall.Arguments.Add(scriptExpression3);
															scriptFunctionCall.Span.End = scriptExpression3.Span.End;
															continue;
														}
														LogError(Current, "Expecting an expression for argument function calls instead of this token.");
														break;
													}
													if (scriptFunctionCall.CloseParen == null)
													{
														LogError(Current, "Expecting a closing parenthesis for a function call.");
													}
													scriptExpression = scriptFunctionCall;
													scriptFunctionCall = scriptFunctionCall3;
													continue;
												}
												precedence2 = 110;
												if (precedence2 > precedence)
												{
													EnterExpression();
													ScriptBinaryExpression scriptBinaryExpression2 = Open<ScriptBinaryExpression>();
													scriptBinaryExpression2.Span = scriptExpression.Span;
													scriptBinaryExpression2.Left = scriptExpression;
													scriptBinaryExpression2.Operator = ScriptBinaryOperator.Multiply;
													scriptBinaryExpression2.Right = ExpectAndParseExpression(scriptBinaryExpression2, scriptFunctionCall ?? parentExpression, precedence2, "Expecting an <expression> to the right of the operator instead of `" + GetAsTextForLog(Current) + "`");
													scriptExpression = Close(scriptBinaryExpression2);
													continue;
												}
												if (num2 == 0)
												{
													precedence = num2;
													continue;
												}
											}
											else
											{
												scriptFunctionCall.AddArgument(scriptExpression);
												scriptFunctionCall.Span.End = scriptExpression.Span.End;
												if (!(scriptExpression is ScriptAnonymousFunction))
												{
													break;
												}
											}
										}
									}
								}
								else if (num2 <= 0)
								{
									if (!_isScientific && parentNode is ScriptPipeCall && scriptFunctionCall == null && scriptExpression is IScriptVariablePath)
									{
										ScriptFunctionCall scriptFunctionCall4 = Open<ScriptFunctionCall>();
										scriptFunctionCall4.Target = scriptExpression;
										scriptFunctionCall4.Span = scriptExpression.Span;
										scriptExpression = scriptFunctionCall4;
									}
									if (IsCurrentPipeOrExpressionContinuation())
									{
										if (scriptFunctionCall != null)
										{
											scriptFunctionCall.Arguments.Add(scriptExpression);
											scriptExpression = scriptFunctionCall;
											scriptFunctionCall = null;
										}
										ScriptPipeCall scriptPipeCall = Open<ScriptPipeCall>();
										if (scriptExpression != null)
										{
											scriptPipeCall.Span.Start = scriptExpression.Span.Start;
										}
										scriptPipeCall.From = scriptExpression;
										_allowNewLineLevel++;
										scriptPipeCall.PipeToken = ParseToken(Current.Type);
										_allowNewLineLevel--;
										scriptPipeCall.To = ExpectAndParseExpression(scriptPipeCall);
										return Close(scriptPipeCall);
									}
								}
							}
						}
						if (scriptFunctionCall != null)
						{
							scriptFunctionCall.Arguments.Add(scriptExpression);
							scriptFunctionCall.Span.End = scriptExpression.Span.End;
							return scriptFunctionCall;
						}
						return flag2 ? scriptExpression : Close(scriptExpression);
					}
				}
				if (scriptFunctionCall != null)
				{
					LogError($"Unexpected token `{GetAsTextForLog(Current)}` while parsing function call `{scriptFunctionCall}`");
				}
				else
				{
					LogError("Unexpected token `" + GetAsTextForLog(Current) + "` while parsing expression");
				}
				return null;
			}
			finally
			{
				LeaveExpression();
				_expressionDepth = expressionDepth;
				_expressionLevel--;
			}
		}

		private bool IsCurrentPipeOrExpressionContinuation()
		{
			if ((!_isScientific || Current.Type != TokenType.PipeGreater) && (_isScientific || Current.Type != TokenType.VerticalBar))
			{
				return Current.Type == TokenType.PipeGreater;
			}
			return true;
		}

		private ScriptExpression ParseArrayInitializer()
		{
			EnterExpression();
			try
			{
				ScriptArrayInitializerExpression scriptArrayInitializerExpression = Open<ScriptArrayInitializerExpression>();
				_allowNewLineLevel++;
				ExpectAndParseTokenTo(scriptArrayInitializerExpression.OpenBracketToken, TokenType.OpenBracket);
				bool flag = false;
				while (Current.Type != TokenType.CloseBracket && !flag)
				{
					ScriptExpression scriptExpression = ExpectAndParseExpression(scriptArrayInitializerExpression);
					if (scriptExpression == null)
					{
						break;
					}
					scriptArrayInitializerExpression.Values.Add(scriptExpression);
					if (Current.Type == TokenType.Comma)
					{
						if (_isKeepTrivia)
						{
							PushTokenToTrivia();
						}
						NextToken();
						if (_isKeepTrivia)
						{
							FlushTriviasToLastTerminal();
						}
					}
					else
					{
						flag = true;
					}
				}
				_allowNewLineLevel--;
				ExpectAndParseTokenTo(scriptArrayInitializerExpression.CloseBracketToken, TokenType.CloseBracket);
				return Close(scriptArrayInitializerExpression);
			}
			finally
			{
				LeaveExpression();
			}
		}

		private ScriptExpression ParseObjectInitializer()
		{
			ScriptObjectInitializerExpression scriptObjectInitializerExpression = Open<ScriptObjectInitializerExpression>();
			_allowNewLineLevel++;
			ExpectAndParseTokenTo(scriptObjectInitializerExpression.OpenBrace, TokenType.OpenBrace);
			bool flag = false;
			bool flag2 = false;
			while (Current.Type != TokenType.CloseBrace)
			{
				if (!flag && (Current.Type == TokenType.Identifier || Current.Type.IsStringToken()))
				{
					Token current = Current;
					ScriptObjectMember scriptObjectMember = Open<ScriptObjectMember>();
					ScriptExpression scriptExpression = ParseExpressionAsVariableOrStringOrExpression(scriptObjectInitializerExpression);
					ScriptVariable scriptVariable = scriptExpression as ScriptVariable;
					ScriptLiteral scriptLiteral = scriptExpression as ScriptLiteral;
					if ((object)scriptVariable == null && scriptLiteral == null)
					{
						flag2 = true;
						string arg = ScriptSyntaxAttribute.Get(scriptExpression)?.TypeName ?? "unknown";
						LogError(current, $"Unexpected member type `{scriptExpression}/{arg}` found for object initializer member name");
						break;
					}
					if (scriptLiteral != null && !(scriptLiteral.Value is string))
					{
						flag2 = true;
						LogError(current, $"Invalid literal member `{scriptLiteral.Value}/{scriptLiteral.Value?.GetType()}` found for object initializer member name. Only literal string or identifier name are allowed");
						break;
					}
					if ((object)scriptVariable != null && scriptVariable.Scope != ScriptVariableScope.Global)
					{
						flag2 = true;
						LogError("Expecting a simple identifier for member names");
						break;
					}
					if (Current.Type != TokenType.Colon)
					{
						flag2 = true;
						LogError("Unexpected token `" + GetAsTextForLog(Current) + "` Expecting a colon : after identifier `" + scriptVariable?.Name + "` for object initializer member name");
						break;
					}
					ExpectAndParseTokenTo(scriptObjectMember.ColonToken, TokenType.Colon);
					scriptObjectMember.Name = scriptExpression;
					if (!IsStartOfExpression())
					{
						flag2 = true;
						LogError("Unexpected token `" + GetAsTextForLog(Current) + "`. Expecting an expression for the value of the member.");
						break;
					}
					ScriptExpression scriptExpression2 = ParseExpression(scriptObjectInitializerExpression);
					if (scriptExpression2 == null)
					{
						flag2 = true;
						break;
					}
					scriptObjectMember.Value = scriptExpression2;
					scriptObjectMember.Span.End = scriptExpression2.Span.End;
					Close(scriptObjectMember);
					scriptObjectInitializerExpression.Members.Add(scriptObjectMember);
					if (Current.Type == TokenType.Comma)
					{
						if (_isKeepTrivia)
						{
							PushTokenToTrivia();
							FlushTriviasToLastTerminal();
						}
						NextToken();
					}
					else
					{
						flag = true;
					}
					continue;
				}
				flag2 = true;
				LogError("Unexpected token `" + GetAsTextForLog(Current) + "` while parsing object initializer. Expecting a simple identifier for the member name.");
				break;
			}
			_allowNewLineLevel--;
			if (!flag2)
			{
				ExpectAndParseTokenTo(scriptObjectInitializerExpression.CloseBrace, TokenType.CloseBrace);
			}
			return Close(scriptObjectInitializerExpression);
		}

		private ScriptExpression ParseParenthesis()
		{
			ScriptNestedExpression scriptNestedExpression = Open<ScriptNestedExpression>();
			ExpectAndParseTokenTo(scriptNestedExpression.OpenParen, TokenType.OpenParen);
			scriptNestedExpression.Expression = ExpectAndParseExpression(scriptNestedExpression);
			if (Current.Type == TokenType.CloseParen)
			{
				ExpectAndParseTokenTo(scriptNestedExpression.CloseParen, TokenType.CloseParen);
			}
			else
			{
				LogError(Current, "Invalid token `" + GetAsTextForLog(Current) + "`. Expecting a closing `)`.");
			}
			return Close(scriptNestedExpression);
		}

		private ScriptInterpolatedStringExpression ParseInterpolatedString()
		{
			ScriptInterpolatedStringExpression scriptInterpolatedStringExpression = Open<ScriptInterpolatedStringExpression>();
			if (Current.Type == TokenType.InterpolatedString)
			{
				scriptInterpolatedStringExpression.Parts.Add(ParseInterpolatedStringPart());
			}
			else
			{
				scriptInterpolatedStringExpression.Parts.Add(ParseInterpolatedStringPart());
				while (Current.Type != TokenType.EndingInterpolatedString)
				{
					ScriptExpression scriptExpression = ParseExpression(scriptInterpolatedStringExpression);
					if (scriptExpression == null)
					{
						break;
					}
					scriptInterpolatedStringExpression.Parts.Add(scriptExpression);
				}
				if (Current.Type == TokenType.EndingInterpolatedString)
				{
					scriptInterpolatedStringExpression.Parts.Add(ParseInterpolatedStringPart());
				}
			}
			return Close(scriptInterpolatedStringExpression);
		}

		private ScriptExpression ParseInterpolatedExpression()
		{
			ScriptInterpolatedExpression scriptInterpolatedExpression = Open<ScriptInterpolatedExpression>();
			ExpectAndParseTokenTo(scriptInterpolatedExpression.OpenBrace, TokenType.OpenInterpolatedBrace);
			scriptInterpolatedExpression.Expression = ExpectAndParseExpression(scriptInterpolatedExpression);
			if (Current.Type != TokenType.CloseInterpolatedBrace)
			{
				LogError(CurrentSpan, "Opened interpolated expression not closed on the same line.");
			}
			else
			{
				ExpectAndParseTokenTo(scriptInterpolatedExpression.CloseBrace, TokenType.CloseInterpolatedBrace);
			}
			return Close(scriptInterpolatedExpression);
		}

		private ScriptToken ParseToken(TokenType tokenType)
		{
			ScriptToken scriptToken = Open<ScriptToken>();
			if (Current.Type != tokenType)
			{
				LogError(CurrentSpan, "Unexpected token found `" + GetAsTextForLog(Current) + "` while expecting `" + tokenType.ToText() + "`.");
			}
			scriptToken.TokenType = Current.Type;
			scriptToken.Value = tokenType.ToText() ?? string.Empty;
			NextToken();
			return Close(scriptToken);
		}

		private void ExpectAndParseTokenTo(ScriptToken existingToken, TokenType expectedTokenType)
		{
			ScriptToken node = Open(existingToken);
			if (Current.Type != expectedTokenType)
			{
				LogError(CurrentSpan, "Unexpected token found `" + GetAsTextForLog(Current) + "` while expecting `" + expectedTokenType.ToText() + "`.");
			}
			NextToken();
			Close(node);
		}

		private ScriptKeyword ExpectAndParseKeywordTo(ScriptKeyword existingKeyword)
		{
			if (existingKeyword == null)
			{
				throw new ArgumentNullException("existingKeyword");
			}
			if (existingKeyword.Value == null)
			{
				throw new InvalidOperationException("ScriptKeyword.Value cannot be null");
			}
			ScriptKeyword node = Open(existingKeyword);
			if (!MatchText(Current, existingKeyword.Value))
			{
				LogError(CurrentSpan, "Unexpected keyword found `" + GetAsTextForLog(Current) + "` while expecting `" + existingKeyword.Value + "`.");
			}
			NextToken();
			Close(node);
			return existingKeyword;
		}

		private ScriptExpression ParseIncrementDecrementExpression()
		{
			TokenType type = Current.Type;
			ScriptIncrementDecrementExpression scriptIncrementDecrementExpression = Open<ScriptIncrementDecrementExpression>();
			scriptIncrementDecrementExpression.OperatorToken = ParseToken(type);
			switch (type)
			{
			case TokenType.DoublePlus:
				scriptIncrementDecrementExpression.Operator = ScriptUnaryOperator.Increment;
				break;
			case TokenType.DoubleMinus:
				scriptIncrementDecrementExpression.Operator = ScriptUnaryOperator.Decrement;
				break;
			default:
				LogError($"Unexpected token `{type}` for unary expression");
				break;
			}
			int defaultUnaryOperatorPrecedence = GetDefaultUnaryOperatorPrecedence(scriptIncrementDecrementExpression.Operator);
			scriptIncrementDecrementExpression.Right = ExpectAndParseExpression(scriptIncrementDecrementExpression, null, defaultUnaryOperatorPrecedence);
			if (!(scriptIncrementDecrementExpression.Right is IScriptVariablePath))
			{
				LogError("The operand of an increment or decrement operator must be a variable, property or indexer");
			}
			return Close(scriptIncrementDecrementExpression);
		}

		private ScriptExpression ParseUnaryExpression()
		{
			ScriptUnaryExpression scriptUnaryExpression = Open<ScriptUnaryExpression>();
			TokenType type = Current.Type;
			scriptUnaryExpression.OperatorToken = ParseToken(Current.Type);
			switch (type)
			{
			case TokenType.Exclamation:
				scriptUnaryExpression.Operator = ScriptUnaryOperator.Not;
				break;
			case TokenType.Minus:
				scriptUnaryExpression.Operator = ScriptUnaryOperator.Negate;
				break;
			case TokenType.Plus:
				scriptUnaryExpression.Operator = ScriptUnaryOperator.Plus;
				break;
			case TokenType.Arroba:
				scriptUnaryExpression.Operator = ScriptUnaryOperator.FunctionAlias;
				break;
			default:
				if ((_isScientific && type == TokenType.DoubleCaret) || (!_isScientific && type == TokenType.Caret))
				{
					scriptUnaryExpression.Operator = ScriptUnaryOperator.FunctionParametersExpand;
				}
				if (scriptUnaryExpression.Operator == ScriptUnaryOperator.None)
				{
					LogError($"Unexpected token `{type}` for unary expression");
				}
				break;
			}
			int defaultUnaryOperatorPrecedence = GetDefaultUnaryOperatorPrecedence(scriptUnaryExpression.Operator);
			scriptUnaryExpression.Right = ExpectAndParseExpression(scriptUnaryExpression, null, defaultUnaryOperatorPrecedence);
			return Close(scriptUnaryExpression);
		}

		private ScriptExpression TransformKeyword(ScriptExpression leftOperand)
		{
			if (_isLiquid && leftOperand is IScriptVariablePath && IsScribanKeyword(((IScriptVariablePath)leftOperand).GetFirstPath()) && !(leftOperand is ScriptNestedExpression))
			{
				return ScriptNestedExpression.Wrap(leftOperand, _isKeepTrivia);
			}
			return leftOperand;
		}

		private void TransformLiquidFunctionCallToScriban(ScriptFunctionCall functionCall)
		{
			if (functionCall.Target is ScriptVariable scriptVariable && LiquidBuiltinsFunctions.TryLiquidToScriban(scriptVariable.Name, out string target, out string member) && target != null && member != null)
			{
				ScriptVariableGlobal scriptVariableGlobal = new ScriptVariableGlobal(target)
				{
					Span = scriptVariable.Span
				};
				ScriptVariableGlobal scriptVariableGlobal2 = new ScriptVariableGlobal(member)
				{
					Span = scriptVariable.Span
				};
				ScriptMemberExpression target2 = new ScriptMemberExpression
				{
					Span = scriptVariable.Span,
					Target = scriptVariableGlobal,
					Member = scriptVariableGlobal2
				};
				if (_isKeepTrivia && scriptVariable.Trivias != null)
				{
					scriptVariableGlobal.AddTrivias(scriptVariable.Trivias.Before, before: true);
					scriptVariableGlobal2.AddTrivias(scriptVariable.Trivias.After, before: false);
				}
				functionCall.Target = target2;
			}
		}

		private void EnterExpression()
		{
			try
			{
				RuntimeHelpers.EnsureSufficientExecutionStack();
			}
			catch (InsufficientExecutionStackException)
			{
				LogError(GetSpanForToken(Previous), "The parser recursive depth limit was reached near a stack overflow", isFatal: true);
				throw FatalParserException.Instance;
			}
			_expressionDepth++;
			int expressionDepthLimit = Options.ExpressionDepthLimit;
			if (expressionDepthLimit > 0 && _expressionDepth > expressionDepthLimit)
			{
				if (!_isExpressionDepthLimitReached)
				{
					LogError(GetSpanForToken(Previous), $"The statement depth limit `{expressionDepthLimit}` was reached when parsing this statement", isFatal: true);
					_isExpressionDepthLimitReached = true;
				}
				throw FatalParserException.Instance;
			}
		}

		private ScriptExpression? ExpectAndParseExpression(ScriptNode parentNode, ScriptExpression? parentExpression = null, int newPrecedence = 0, string? message = null, ParseExpressionMode mode = ParseExpressionMode.Default, bool allowAssignment = true)
		{
			if (IsStartOfExpression())
			{
				return ParseExpression(parentNode, parentExpression, newPrecedence, mode, allowAssignment);
			}
			LogError(parentNode, CurrentSpan, message ?? ("Expecting <expression> instead of `" + GetAsTextForLog(Current) + "`"));
			return null;
		}

		private ScriptExpression? ExpectAndParseExpressionAndAnonymous(ScriptNode parentNode, ParseExpressionMode mode = ParseExpressionMode.Default)
		{
			if (IsStartOfExpression())
			{
				return ParseExpression(parentNode, null, 0, mode);
			}
			LogError(parentNode, CurrentSpan, "Expecting <expression> instead of `" + GetAsTextForLog(Current) + "`");
			return null;
		}

		public bool IsStartOfExpression()
		{
			if (IsStartingAsUnaryExpression())
			{
				return true;
			}
			switch (Current.Type)
			{
			case TokenType.IdentifierSpecial:
			case TokenType.Identifier:
			case TokenType.Integer:
			case TokenType.HexaInteger:
			case TokenType.BinaryInteger:
			case TokenType.Float:
			case TokenType.String:
			case TokenType.InterpolatedString:
			case TokenType.BeginInterpolatedString:
			case TokenType.ContinuationInterpolatedString:
			case TokenType.EndingInterpolatedString:
			case TokenType.ImplicitString:
			case TokenType.VerbatimString:
			case TokenType.OpenParen:
			case TokenType.OpenBrace:
			case TokenType.OpenBracket:
				return true;
			default:
				return false;
			}
		}

		private bool TryGetCompoundAssignmentOperator(out ScriptToken? scriptToken, out TokenType tokenType)
		{
			tokenType = Current.Type;
			scriptToken = tokenType switch
			{
				TokenType.Equal => ScriptToken.Equal(), 
				TokenType.PlusEqual => ScriptToken.PlusEqual(), 
				TokenType.MinusEqual => ScriptToken.MinusEqual(), 
				TokenType.AsteriskEqual => ScriptToken.StarEqual(), 
				TokenType.DivideEqual => ScriptToken.DivideEqual(), 
				TokenType.DoubleDivideEqual => ScriptToken.DoubleDivideEqual(), 
				TokenType.PercentEqual => ScriptToken.ModulusEqual(), 
				_ => null, 
			};
			return scriptToken != null;
		}

		private bool IsStartingAsUnaryExpression()
		{
			switch (Current.Type)
			{
			case TokenType.Arroba:
			case TokenType.Exclamation:
			case TokenType.Plus:
			case TokenType.DoublePlus:
			case TokenType.Minus:
			case TokenType.DoubleMinus:
				return true;
			case TokenType.Caret:
			case TokenType.DoubleCaret:
				if ((_isScientific && Current.Type == TokenType.DoubleCaret) || (!_isScientific && Current.Type == TokenType.Caret))
				{
					return true;
				}
				break;
			}
			return false;
		}

		private bool TryLiquidBinaryOperator(out ScriptBinaryOperator binaryOperator, out int precedence)
		{
			binaryOperator = ScriptBinaryOperator.None;
			precedence = 0;
			string asText = GetAsText(Current);
			if (Current.Type != TokenType.Identifier)
			{
				return false;
			}
			switch (asText)
			{
			case "or":
				binaryOperator = ScriptBinaryOperator.Or;
				break;
			case "and":
				binaryOperator = ScriptBinaryOperator.And;
				break;
			case "contains":
				binaryOperator = ScriptBinaryOperator.LiquidContains;
				break;
			case "startsWith":
				binaryOperator = ScriptBinaryOperator.LiquidStartsWith;
				break;
			case "endsWith":
				binaryOperator = ScriptBinaryOperator.LiquidEndsWith;
				break;
			case "hasKey":
				binaryOperator = ScriptBinaryOperator.LiquidHasKey;
				break;
			case "hasValue":
				binaryOperator = ScriptBinaryOperator.LiquidHasValue;
				break;
			}
			if (binaryOperator != ScriptBinaryOperator.None)
			{
				precedence = GetDefaultBinaryOperatorPrecedence(binaryOperator);
			}
			return binaryOperator != ScriptBinaryOperator.None;
		}

		internal static int GetDefaultBinaryOperatorPrecedence(ScriptBinaryOperator op)
		{
			switch (op)
			{
			case ScriptBinaryOperator.EmptyCoalescing:
			case ScriptBinaryOperator.NotEmptyCoalescing:
				return 20;
			case ScriptBinaryOperator.Or:
				return 30;
			case ScriptBinaryOperator.And:
				return 40;
			case ScriptBinaryOperator.BinaryOr:
				return 50;
			case ScriptBinaryOperator.BinaryAnd:
				return 60;
			case ScriptBinaryOperator.CompareEqual:
			case ScriptBinaryOperator.CompareNotEqual:
				return 70;
			case ScriptBinaryOperator.CompareLessOrEqual:
			case ScriptBinaryOperator.CompareGreaterOrEqual:
			case ScriptBinaryOperator.CompareLess:
			case ScriptBinaryOperator.CompareGreater:
				return 80;
			case ScriptBinaryOperator.LiquidContains:
			case ScriptBinaryOperator.LiquidStartsWith:
			case ScriptBinaryOperator.LiquidEndsWith:
			case ScriptBinaryOperator.LiquidHasKey:
			case ScriptBinaryOperator.LiquidHasValue:
				return 90;
			case ScriptBinaryOperator.Add:
			case ScriptBinaryOperator.Subtract:
				return 100;
			case ScriptBinaryOperator.Multiply:
			case ScriptBinaryOperator.Divide:
			case ScriptBinaryOperator.DivideRound:
			case ScriptBinaryOperator.Modulus:
			case ScriptBinaryOperator.ShiftLeft:
			case ScriptBinaryOperator.ShiftRight:
				return 110;
			case ScriptBinaryOperator.Power:
				return 120;
			case ScriptBinaryOperator.RangeInclude:
			case ScriptBinaryOperator.RangeExclude:
				return 130;
			default:
				return 0;
			}
		}

		private static int GetDefaultUnaryOperatorPrecedence(ScriptUnaryOperator op)
		{
			switch (op)
			{
			case ScriptUnaryOperator.Not:
			case ScriptUnaryOperator.Negate:
			case ScriptUnaryOperator.Plus:
			case ScriptUnaryOperator.FunctionAlias:
			case ScriptUnaryOperator.FunctionParametersExpand:
				return 200;
			case ScriptUnaryOperator.Increment:
			case ScriptUnaryOperator.Decrement:
				return 210;
			default:
				return 0;
			}
		}

		private bool IsPreviousCharWhitespace()
		{
			int num = Current.Start.Offset - 1;
			if (num >= 0)
			{
				return char.IsWhiteSpace(_lexer.Text[num]);
			}
			return false;
		}

		private bool IsNextCharWhitespace()
		{
			int num = Current.End.Offset + 1;
			if (num >= 0 && num < _lexer.Text.Length)
			{
				return char.IsWhiteSpace(_lexer.Text[num]);
			}
			return false;
		}

		private void LeaveExpression()
		{
			_expressionDepth--;
		}

		private ScriptBlockStatement ParseBlockStatement(ScriptNode parentStatement, bool parseEndOfStatementAfterEnd = true)
		{
			Blocks.Push(parentStatement);
			_blockLevel++;
			EnterExpression();
			ScriptBlockStatement scriptBlockStatement = Open<ScriptBlockStatement>();
			ScriptBlockStatement currentBlockStatement = _currentBlockStatement;
			_currentBlockStatement = scriptBlockStatement;
			try
			{
				ScriptStatement statement = null;
				bool hasEnd;
				while (TryParseStatement(parentStatement, parseEndOfStatementAfterEnd, out statement, out hasEnd))
				{
					if (statement != null)
					{
						scriptBlockStatement.Statements.Add(statement);
					}
					if (!hasEnd)
					{
						continue;
					}
					if (_blockLevel == 1)
					{
						SourceSpan span = new SourceSpan(_lexer.SourcePath, Previous.End, Previous.End);
						if (_isLiquid)
						{
							string text = ScriptSyntaxAttribute.Get(parentStatement)?.TypeName ?? string.Empty;
							LogError(parentStatement, span, "Found <end> statement `end" + text + "` without a corresponding beginning of a block");
						}
						else
						{
							LogError(parentStatement, span, "Found <end> statement without a corresponding beginning of a block");
						}
					}
					break;
				}
				if (!parseEndOfStatementAfterEnd && statement is ScriptEndStatement scriptEndStatement)
				{
					scriptEndStatement.ExpectEos = false;
				}
				if (!hasEnd && _blockLevel > 1)
				{
					if (_isLiquid)
					{
						string text2 = ScriptSyntaxAttribute.Get(parentStatement)?.TypeName ?? string.Empty;
						LogError(parentStatement, parentStatement.Span, "The `end" + text2 + "` was not found");
					}
					else
					{
						LogError(parentStatement, GetSpanForToken(Previous), "The <end> statement was not found");
					}
				}
			}
			finally
			{
				_currentBlockStatement = currentBlockStatement;
				LeaveExpression();
				_blockLevel--;
			}
			Blocks.Pop();
			return Close(scriptBlockStatement);
		}

		private bool TryParseStatement(ScriptNode parent, bool parseEndOfStatementAfterEnd, out ScriptStatement? statement, out bool hasEnd)
		{
			hasEnd = false;
			bool nextStatement = true;
			statement = null;
			while (true)
			{
				if (_hasFatalError)
				{
					return false;
				}
				if (_pendingStatements.Count > 0)
				{
					statement = _pendingStatements.Dequeue();
					return true;
				}
				switch (Current.Type)
				{
				case TokenType.Eof:
					nextStatement = false;
					break;
				case TokenType.Raw:
				case TokenType.Escape:
					statement = ParseRawStatement();
					if (parent is ScriptCaseStatement)
					{
						statement = null;
						continue;
					}
					break;
				case TokenType.CodeEnter:
				case TokenType.LiquidTagEnter:
				case TokenType.CodeExit:
				case TokenType.LiquidTagExit:
				case TokenType.EscapeEnter:
				case TokenType.EscapeExit:
					statement = ParseEscapeStatement();
					break;
				case TokenType.FrontMatterMarker:
					if (_inFrontMatter)
					{
						ScriptFrontMatter scriptFrontMatter = _frontmatter ?? throw new InvalidOperationException("No frontmatter block is available.");
						_inFrontMatter = false;
						_inCodeSection = false;
						ExpectAndParseTokenTo(scriptFrontMatter.EndMarker, TokenType.FrontMatterMarker);
						Close(scriptFrontMatter);
						scriptFrontMatter.TextPositionAfterEndMarker = Current.Start;
						if (CurrentParsingMode == ScriptMode.FrontMatterAndContent || CurrentParsingMode == ScriptMode.FrontMatterOnly)
						{
							CurrentParsingMode = ScriptMode.Default;
							nextStatement = false;
						}
					}
					else
					{
						LogError("Unexpected frontmatter marker `" + _lexer.Options.FrontMatterMarker + "` while not inside a frontmatter");
						NextToken();
					}
					break;
				default:
					if (_inCodeSection)
					{
						switch (Current.Type)
						{
						case TokenType.NewLine:
						case TokenType.SemiColon:
							PushTokenToTrivia();
							NextToken();
							continue;
						case TokenType.IdentifierSpecial:
						case TokenType.Identifier:
						{
							string asText = GetAsText(Current);
							if (_isLiquid)
							{
								ParseLiquidStatement(asText, parent, ref statement, ref hasEnd, ref nextStatement);
							}
							else
							{
								ParseScribanStatement(asText, parent, parseEndOfStatementAfterEnd, ref statement, ref hasEnd, ref nextStatement);
							}
							break;
						}
						default:
							if (IsStartOfExpression())
							{
								statement = ParseExpressionStatement();
								break;
							}
							nextStatement = false;
							LogError("Unexpected token " + GetAsTextForLog(Current));
							break;
						}
					}
					else
					{
						nextStatement = false;
						LogError("Unexpected token " + GetAsTextForLog(Current) + " while not in a code block { ... }");
					}
					break;
				}
				break;
			}
			return nextStatement;
		}

		private ScriptCaptureStatement ParseCaptureStatement()
		{
			ScriptCaptureStatement scriptCaptureStatement = Open<ScriptCaptureStatement>();
			ExpectAndParseKeywordTo(scriptCaptureStatement.CaptureKeyword);
			scriptCaptureStatement.Target = ExpectAndParseExpression(scriptCaptureStatement);
			ExpectEndOfStatement();
			scriptCaptureStatement.Body = ParseBlockStatement(scriptCaptureStatement);
			return Close(scriptCaptureStatement);
		}

		private ScriptEscapeStatement ParseEscapeStatement()
		{
			bool flag = Current.Type == TokenType.CodeEnter || Current.Type == TokenType.LiquidTagEnter;
			bool flag2 = Current.Type == TokenType.EscapeEnter || Current.Type == TokenType.EscapeExit;
			bool flag3 = flag || Current.Type == TokenType.EscapeEnter;
			bool flag4 = Current.Type == TokenType.LiquidTagEnter || Current.Type == TokenType.LiquidTagExit;
			if (flag)
			{
				if (_inCodeSection)
				{
					LogError("Unexpected token while already in a code block");
				}
			}
			else if (!flag2)
			{
				if (!_inCodeSection)
				{
					LogError("Unexpected code block exit '}}' while no code block enter '{{' has been found");
				}
				else if (CurrentParsingMode == ScriptMode.ScriptOnly)
				{
					LogError("Unexpected code clock exit '}}' while parsing in script only mode. '}}' is not allowed.");
				}
			}
			_isLiquidTagSection = flag && flag4;
			_inCodeSection = flag;
			ScriptEscapeStatement scriptEscapeStatement = Open<ScriptEscapeStatement>();
			scriptEscapeStatement.IsEntering = flag3;
			string asText = GetAsText(Current);
			char c = asText[flag3 ? (asText.Length - 1) : 0];
			ScriptEscapeStatement scriptEscapeStatement2 = scriptEscapeStatement;
			scriptEscapeStatement2.WhitespaceMode = c switch
			{
				'-' => ScriptWhitespaceMode.Greedy, 
				'~' => ScriptWhitespaceMode.NonGreedy, 
				_ => ScriptWhitespaceMode.None, 
			};
			if (flag2)
			{
				if (_isLiquid)
				{
					scriptEscapeStatement.EscapeCount = 6;
				}
				else
				{
					int num = asText.Length - 2;
					if (c != (flag3 ? 123 : 125))
					{
						num--;
					}
					scriptEscapeStatement.EscapeCount = num;
				}
			}
			NextToken();
			if (flag && _currentBlockStatement != null && _currentBlockStatement.Statements.Count > 0 && _currentBlockStatement.Statements[_currentBlockStatement.Statements.Count - 1] is ScriptRawStatement scriptRawStatement)
			{
				string text = null;
				ScriptStringSlice text2 = scriptRawStatement.Text;
				string fullText = text2.FullText;
				if (fullText == null)
				{
					return Close(scriptEscapeStatement);
				}
				int num2 = text2.Index + text2.Length - 1;
				for (int num3 = num2; num3 >= 0; num3--)
				{
					char c2 = fullText[num3];
					if (c2 == '\n')
					{
						text = fullText.Substring(num3 + 1, num2 - num3);
						break;
					}
					if (!char.IsWhiteSpace(c2))
					{
						break;
					}
					if (num3 == 0)
					{
						text = fullText.Substring(0, num2 + 1);
					}
				}
				scriptEscapeStatement.Indent = text ?? string.Empty;
			}
			return Close(scriptEscapeStatement);
		}

		private ScriptCaseStatement ParseCaseStatement()
		{
			ScriptCaseStatement scriptCaseStatement = Open<ScriptCaseStatement>();
			ExpectAndParseKeywordTo(scriptCaseStatement.CaseKeyword);
			scriptCaseStatement.Value = ExpectAndParseExpression(scriptCaseStatement, null, 0, null, ParseExpressionMode.Default, allowAssignment: false);
			if (ExpectEndOfStatement())
			{
				scriptCaseStatement.Body = ParseBlockStatement(scriptCaseStatement);
			}
			return Close(scriptCaseStatement);
		}

		private ScriptConditionStatement ParseElseStatement(bool isElseIf)
		{
			if (_isLiquid && isElseIf)
			{
				return ParseIfStatement(invert: false, ScriptKeyword.Else());
			}
			Token localToken = PeekToken();
			if (!_isLiquid && localToken.Type == TokenType.Identifier && GetAsText(localToken) == "if")
			{
				ScriptKeyword scriptKeyword = ScriptKeyword.Else();
				ExpectAndParseKeywordTo(scriptKeyword);
				return ParseIfStatement(invert: false, scriptKeyword);
			}
			ScriptElseStatement scriptElseStatement = Open<ScriptElseStatement>();
			ExpectAndParseKeywordTo(scriptElseStatement.ElseKeyword);
			if (ExpectEndOfStatement())
			{
				scriptElseStatement.Body = ParseBlockStatement(scriptElseStatement);
			}
			return Close(scriptElseStatement);
		}

		private ScriptStatement ParseExpressionStatement()
		{
			ScriptExpressionStatement scriptExpressionStatement = Open<ScriptExpressionStatement>();
			ScriptExpression scriptExpression = ExpectAndParseExpressionAndAnonymous(scriptExpressionStatement);
			if (scriptExpression == null)
			{
				scriptExpressionStatement.Expression = null;
				return Close(scriptExpressionStatement);
			}
			ScriptExpression scriptExpression2 = TransformKeyword(scriptExpression);
			if (scriptExpression2 is ScriptExpressionAsStatement scriptExpressionAsStatement)
			{
				return scriptExpressionAsStatement.Statement;
			}
			scriptExpressionStatement.Expression = scriptExpression2;
			ExpectEndOfStatement();
			return Close(scriptExpressionStatement);
		}

		private T ParseForStatement<T>() where T : ScriptForStatement, new()
		{
			T val = Open<T>();
			ExpectAndParseKeywordTo(val.ForOrTableRowKeyword);
			val.Variable = ExpectAndParseExpression(val, null, 0, null, ParseExpressionMode.BasicExpression);
			if (val.Variable != null)
			{
				if (!(val.Variable is IScriptVariablePath))
				{
					LogError(val, $"Expecting a variable instead of `{val.Variable}`");
				}
				if (Current.Type != TokenType.Identifier || GetAsText(Current) != "in")
				{
					LogError(val, "Expecting 'in' word instead of `" + GetAsTextForLog(Current) + "`");
				}
				else
				{
					ExpectAndParseKeywordTo(val.InKeyword);
				}
				val.Iterator = ExpectAndParseExpression(val);
				if (ExpectEndOfStatement())
				{
					val.Body = ParseBlockStatement(val);
				}
			}
			return Close(val);
		}

		private ScriptIfStatement ParseIfStatement(bool invert, ScriptKeyword? elseKeyword = null)
		{
			ScriptIfStatement scriptIfStatement = Open<ScriptIfStatement>();
			scriptIfStatement.ElseKeyword = elseKeyword;
			if (_isLiquid && elseKeyword != null)
			{
				Open(scriptIfStatement.IfKeyword);
				NextToken();
				Close(scriptIfStatement.IfKeyword);
			}
			else if (_isLiquid && invert)
			{
				Open(scriptIfStatement.IfKeyword);
				NextToken();
				Close(scriptIfStatement.IfKeyword);
			}
			else
			{
				ExpectAndParseKeywordTo(scriptIfStatement.IfKeyword);
			}
			ScriptExpression scriptExpression = ExpectAndParseExpression(scriptIfStatement, null, 0, null, ParseExpressionMode.Default, allowAssignment: false);
			if (invert)
			{
				if (scriptExpression == null)
				{
					scriptIfStatement.Condition = null;
					return Close(scriptIfStatement);
				}
				scriptExpression = ScriptUnaryExpression.Wrap(ScriptUnaryOperator.Not, ScriptToken.Exclamation(), ScriptNestedExpression.Wrap(scriptExpression, _isKeepTrivia), _isKeepTrivia);
			}
			scriptIfStatement.Condition = scriptExpression;
			if (ExpectEndOfStatement())
			{
				scriptIfStatement.Then = ParseBlockStatement(scriptIfStatement);
			}
			return Close(scriptIfStatement);
		}

		private ScriptRawStatement ParseRawStatement()
		{
			bool isEscape = Current.Type == TokenType.Escape;
			ScriptRawStatement scriptRawStatement = Open<ScriptRawStatement>();
			scriptRawStatement.IsEscape = isEscape;
			TextPosition start = Current.Start;
			TextPosition end = Current.End;
			NextToken();
			Close(scriptRawStatement);
			scriptRawStatement.Span.End = end;
			scriptRawStatement.Text = new ScriptStringSlice(_lexer.Text, start.Offset, end.Offset - start.Offset + 1);
			return scriptRawStatement;
		}

		private ScriptWhenStatement ParseWhenStatement()
		{
			ScriptWhenStatement scriptWhenStatement = Open<ScriptWhenStatement>();
			ExpectAndParseKeywordTo(scriptWhenStatement.WhenKeyword);
			while (IsStartOfExpression())
			{
				ScriptExpression scriptExpression = ParseExpression(scriptWhenStatement, null, 0, ParseExpressionMode.WhenExpression, allowAssignment: false);
				if (scriptExpression == null)
				{
					break;
				}
				scriptWhenStatement.Values.Add(scriptExpression);
				if (Current.Type == TokenType.Comma || (!_isLiquid && Current.Type == TokenType.DoubleVerticalBar) || (_isLiquid && GetAsText(Current) == "or"))
				{
					NextToken();
				}
			}
			if (scriptWhenStatement.Values.Count == 0)
			{
				LogError(Current, "When is expecting at least one value.");
			}
			if (ExpectEndOfStatement())
			{
				scriptWhenStatement.Body = ParseBlockStatement(scriptWhenStatement);
			}
			return Close(scriptWhenStatement);
		}

		private void CheckNotInCase(ScriptNode parent, Token token)
		{
			if (parent is ScriptCaseStatement)
			{
				LogError(token, "Unexpected statement/expression `" + GetAsTextForLog(token) + "` in the body of a `case` statement. Only `when`/`else` are expected.");
			}
		}

		private ScriptVariable? ExpectAndParseVariable(ScriptNode parentNode)
		{
			if (parentNode == null)
			{
				throw new ArgumentNullException("parentNode");
			}
			if (Current.Type == TokenType.Identifier || Current.Type == TokenType.IdentifierSpecial)
			{
				ScriptExpression scriptExpression = ParseVariable();
				if (scriptExpression is ScriptVariable result)
				{
					return result;
				}
				LogError(parentNode, $"Unexpected variable `{scriptExpression}`");
			}
			else
			{
				LogError(parentNode, "Expecting a variable instead of `" + GetAsTextForLog(Current) + "`");
			}
			return null;
		}

		private bool ExpectEndOfStatement()
		{
			if (_isLiquid)
			{
				if (Current.Type == TokenType.CodeExit || (_isLiquidTagSection && Current.Type == TokenType.LiquidTagExit))
				{
					return true;
				}
			}
			else if (Current.Type == TokenType.NewLine || Current.Type == TokenType.CodeExit || Current.Type == TokenType.SemiColon || Current.Type == TokenType.Eof)
			{
				if (Current.Type == TokenType.NewLine || Current.Type == TokenType.SemiColon)
				{
					PushTokenToTrivia();
					FlushTriviasToLastTerminal();
					NextToken();
				}
				return true;
			}
			LogError(CurrentSpan, "Invalid token found `" + GetAsTextForLog(Current) + "`. Expecting <EOL>/end of line.", isFatal: true);
			return false;
		}

		private ScriptStatement? FindFirstStatementExpectingEnd()
		{
			foreach (ScriptNode block in Blocks)
			{
				if (ExpectStatementEnd(block))
				{
					return (ScriptStatement)block;
				}
			}
			return null;
		}

		private static bool ExpectStatementEnd(ScriptNode scriptNode)
		{
			if ((!(scriptNode is ScriptIfStatement) || ((ScriptIfStatement)scriptNode).IsElseIf) && !(scriptNode is ScriptForStatement) && !(scriptNode is ScriptCaptureStatement) && !(scriptNode is ScriptWithStatement) && !(scriptNode is ScriptWhileStatement) && !(scriptNode is ScriptWrapStatement) && !(scriptNode is ScriptCaseStatement) && !(scriptNode is ScriptFunction))
			{
				return scriptNode is ScriptAnonymousFunction;
			}
			return true;
		}

		private void ParseLiquidStatement(string identifier, ScriptNode parent, ref ScriptStatement? statement, ref bool hasEnd, ref bool nextStatement)
		{
			Token current = Current;
			if (!_isLiquidTagSection)
			{
				statement = ParseLiquidExpressionStatement(parent);
				return;
			}
			if (identifier != "when" && identifier != "case" && !identifier.StartsWith("end") && parent is ScriptCaseStatement)
			{
				LogError(current, "Unexpected statement/expression `" + GetAsTextForLog(current) + "` in the body of a `case` statement. Only `when`/`else` are expected.");
			}
			ScriptStatement scriptStatement = null;
			string text = null;
			switch (identifier)
			{
			case "endif":
				scriptStatement = FindFirstStatementExpectingEnd() as ScriptIfStatement;
				text = "`if`/`else`";
				break;
			case "endifchanged":
				scriptStatement = FindFirstStatementExpectingEnd() as ScriptIfStatement;
				text = "`ifchanged`";
				break;
			case "endunless":
				scriptStatement = FindFirstStatementExpectingEnd() as ScriptIfStatement;
				text = "`unless`";
				break;
			case "endfor":
				scriptStatement = FindFirstStatementExpectingEnd() as ScriptForStatement;
				text = "`for`";
				break;
			case "endcase":
				scriptStatement = FindFirstStatementExpectingEnd() as ScriptCaseStatement;
				text = "`case`";
				break;
			case "endcapture":
				scriptStatement = FindFirstStatementExpectingEnd() as ScriptCaptureStatement;
				text = "`capture`";
				break;
			case "endtablerow":
				scriptStatement = FindFirstStatementExpectingEnd() as ScriptTableRowStatement;
				text = "`tablerow`";
				break;
			case "case":
				statement = ParseCaseStatement();
				break;
			case "when":
			{
				ScriptWhenStatement scriptWhenStatement = ParseWhenStatement();
				ScriptConditionStatement scriptConditionStatement = parent as ScriptConditionStatement;
				if (parent is ScriptWhenStatement)
				{
					if (scriptConditionStatement is ScriptWhenStatement scriptWhenStatement2)
					{
						scriptWhenStatement2.Next = scriptWhenStatement;
					}
				}
				else if (parent is ScriptCaseStatement)
				{
					statement = scriptWhenStatement;
				}
				else
				{
					nextStatement = false;
					LogError(current, "A `when` condition must be preceded by another `when`/`else`/`case` condition");
				}
				hasEnd = true;
				break;
			}
			case "if":
				statement = ParseIfStatement(invert: false);
				break;
			case "ifchanged":
				statement = ParseLiquidIfChanged();
				break;
			case "unless":
				CheckNotInCase(parent, current);
				statement = ParseIfStatement(invert: true);
				break;
			case "elsif":
			case "else":
			{
				ScriptConditionStatement scriptConditionStatement2 = ParseElseStatement(identifier == "elsif");
				ScriptConditionStatement scriptConditionStatement3 = parent as ScriptConditionStatement;
				if (parent is ScriptIfStatement || parent is ScriptWhenStatement)
				{
					if (parent is ScriptIfStatement)
					{
						if (scriptConditionStatement3 is ScriptIfStatement scriptIfStatement)
						{
							scriptIfStatement.Else = scriptConditionStatement2;
						}
					}
					else
					{
						if (identifier == "elseif")
						{
							LogError(current, "A elsif condition is not allowed within a when/case condition");
						}
						if (scriptConditionStatement3 is ScriptWhenStatement scriptWhenStatement3)
						{
							scriptWhenStatement3.Next = scriptConditionStatement2;
						}
					}
				}
				else if (identifier == "else" && parent is ScriptForStatement scriptForStatement2)
				{
					scriptForStatement2.Else = (ScriptElseStatement)scriptConditionStatement2;
				}
				else
				{
					nextStatement = false;
					LogError(current, (identifier == "else") ? "A else condition must be preceded by another if/else/unless condition or a for loop." : "A else condition must be preceded by another if/else/unless.");
				}
				hasEnd = true;
				break;
			}
			case "for":
			{
				ScriptForStatement scriptForStatement = ParseForStatement<ScriptForStatement>();
				scriptForStatement.SetContinue = true;
				statement = scriptForStatement;
				break;
			}
			case "tablerow":
				statement = ParseForStatement<ScriptTableRowStatement>();
				break;
			case "cycle":
				statement = ParseLiquidCycleStatement();
				break;
			case "break":
				ExpectAndParseKeywordTo(((ScriptBreakStatement)(statement = Open<ScriptBreakStatement>())).BreakKeyword);
				ExpectEndOfStatement();
				Close(statement);
				break;
			case "continue":
				ExpectAndParseKeywordTo(((ScriptContinueStatement)(statement = Open<ScriptContinueStatement>())).ContinueKeyword);
				ExpectEndOfStatement();
				FlushTriviasToLastTerminal();
				Close(statement);
				break;
			case "assign":
			{
				if (_isKeepTrivia)
				{
					_trivias.Clear();
				}
				NextToken();
				Token token = _token;
				ScriptStatement scriptStatement2 = ParseExpressionStatement();
				if (!(scriptStatement2 is ScriptExpressionStatement scriptExpressionStatement) || !(scriptExpressionStatement.Expression is ScriptAssignExpression))
				{
					LogError(token, "Expecting an assign expression: <variable> = <expression>");
				}
				statement = scriptStatement2;
				break;
			}
			case "capture":
				statement = ParseCaptureStatement();
				break;
			case "increment":
				statement = ParseLiquidIncDecStatement(isDec: false);
				break;
			case "decrement":
				statement = ParseLiquidIncDecStatement(isDec: true);
				break;
			case "include":
				statement = ParseLiquidIncludeStatement();
				break;
			default:
				statement = ParseLiquidExpressionStatement(parent);
				break;
			}
			if (text != null)
			{
				ScriptEndStatement node = Open<ScriptEndStatement>();
				NextToken();
				statement = Close(node);
				hasEnd = true;
				nextStatement = true;
				if (scriptStatement == null)
				{
					LogError(current, "Unable to find a pending " + text + " for this `" + identifier + "`");
				}
			}
		}

		private ScriptExpressionStatement ParseLiquidCycleStatement()
		{
			ScriptExpressionStatement scriptExpressionStatement = Open<ScriptExpressionStatement>();
			ScriptFunctionCall scriptFunctionCall = (ScriptFunctionCall)(scriptExpressionStatement.Expression = Open<ScriptFunctionCall>());
			scriptFunctionCall.Target = ParseVariable();
			if (Options.LiquidFunctionsToScriban)
			{
				TransformLiquidFunctionCallToScriban(scriptFunctionCall);
			}
			ScriptArrayInitializerExpression scriptArrayInitializerExpression = null;
			bool flag = true;
			while (IsVariableOrLiteral(Current))
			{
				ScriptExpression scriptExpression2 = ParseVariableOrLiteral();
				if (flag && Current.Type == TokenType.Colon)
				{
					ScriptNamedArgument scriptNamedArgument = Open<ScriptNamedArgument>();
					scriptNamedArgument.Name = new ScriptVariableGlobal("group");
					scriptNamedArgument.ColonToken = ScriptToken.Colon();
					ExpectAndParseTokenTo(scriptNamedArgument.ColonToken, TokenType.Colon);
					scriptNamedArgument.Value = scriptExpression2;
					Close(scriptNamedArgument);
					if (scriptExpression2 != null)
					{
						scriptNamedArgument.Span = scriptExpression2.Span;
					}
					flag = false;
					scriptFunctionCall.Arguments.Add(scriptNamedArgument);
					continue;
				}
				if (scriptArrayInitializerExpression == null)
				{
					scriptArrayInitializerExpression = Open<ScriptArrayInitializerExpression>();
					scriptFunctionCall.Arguments.Insert(0, scriptArrayInitializerExpression);
					if (scriptExpression2 != null)
					{
						scriptArrayInitializerExpression.Span.Start = scriptExpression2.Span.Start;
					}
				}
				if (scriptExpression2 == null)
				{
					break;
				}
				scriptArrayInitializerExpression.Values.Add(scriptExpression2);
				scriptArrayInitializerExpression.Span.End = scriptExpression2.Span.End;
				if (Current.Type == TokenType.Comma)
				{
					NextToken();
					continue;
				}
				if (Current.Type != TokenType.LiquidTagExit)
				{
					LogError(Current, $"Unexpected token `{GetAsTextForLog(Current)}` after cycle value `{scriptExpression2}`. Expecting a `,`");
					NextToken();
				}
				break;
			}
			Close(scriptFunctionCall);
			ExpectEndOfStatement();
			return Close(scriptExpressionStatement);
		}

		private ScriptStatement ParseLiquidExpressionStatement(ScriptNode parent)
		{
			Token current = Current;
			CheckNotInCase(parent, current);
			return ParseExpressionStatement();
		}

		private ScriptStatement ParseLiquidIfChanged()
		{
			ScriptIfStatement scriptIfStatement = Open<ScriptIfStatement>();
			scriptIfStatement.IfKeyword.Span = CurrentSpan;
			NextToken();
			scriptIfStatement.Condition = new ScriptMemberExpression
			{
				Target = ScriptVariable.Create(ScriptVariable.ForObject.BaseName, ScriptVariableScope.Global),
				Member = ScriptVariable.Create("changed", ScriptVariableScope.Global)
			};
			scriptIfStatement.Then = ParseBlockStatement(scriptIfStatement);
			Close(scriptIfStatement);
			scriptIfStatement.Condition.Span = scriptIfStatement.Span;
			return scriptIfStatement;
		}

		private ScriptStatement ParseLiquidIncDecStatement(bool isDec)
		{
			ScriptExpressionStatement scriptExpressionStatement = Open<ScriptExpressionStatement>();
			NextToken();
			ScriptBinaryExpression scriptBinaryExpression = Open<ScriptBinaryExpression>();
			scriptBinaryExpression.Left = ExpectAndParseVariable(scriptExpressionStatement);
			scriptBinaryExpression.Right = new ScriptLiteral
			{
				Span = scriptBinaryExpression.Span,
				Value = 1
			};
			scriptBinaryExpression.Operator = (isDec ? ScriptBinaryOperator.Subtract : ScriptBinaryOperator.Add);
			ExpectEndOfStatement();
			scriptExpressionStatement.Expression = scriptBinaryExpression;
			Close(scriptBinaryExpression);
			return Close(scriptExpressionStatement);
		}

		private ScriptStatement ParseLiquidIncludeStatement()
		{
			ScriptFunctionCall scriptFunctionCall = Open<ScriptFunctionCall>();
			scriptFunctionCall.Target = ParseVariable();
			Token current = Current;
			ScriptExpression scriptExpression = ExpectAndParseExpression(scriptFunctionCall, null, 0, null, ParseExpressionMode.BasicExpression);
			if (scriptExpression != null)
			{
				if (!((scriptExpression as ScriptLiteral)?.Value is string) && !(scriptExpression is IScriptVariablePath))
				{
					LogError(current, $"Unexpected include template name `{scriptExpression}` expecting a string or a variable path");
				}
				scriptFunctionCall.Arguments.Add(scriptExpression);
			}
			Close(scriptFunctionCall);
			ScriptExpressionStatement node = new ScriptExpressionStatement
			{
				Span = scriptFunctionCall.Span,
				Expression = scriptFunctionCall
			};
			ScriptForStatement scriptForStatement = null;
			ScriptBlockStatement scriptBlockStatement = null;
			if (Current.Type == TokenType.Identifier)
			{
				string asText = GetAsText(Current);
				if (asText == "with")
				{
					NextToken();
					ScriptAssignExpression scriptAssignExpression = Open<ScriptAssignExpression>();
					scriptAssignExpression.Target = new ScriptIndexerExpression
					{
						Target = new ScriptThisExpression
						{
							Span = CurrentSpan
						},
						Index = (scriptExpression?.Clone() as ScriptExpression)
					};
					scriptAssignExpression.Value = ExpectAndParseExpression(scriptFunctionCall, null, 0, null, ParseExpressionMode.BasicExpression);
					Close(scriptAssignExpression);
					scriptBlockStatement = new ScriptBlockStatement
					{
						Span = scriptFunctionCall.Span
					};
					scriptBlockStatement.Statements.Add(new ScriptExpressionStatement
					{
						Span = scriptAssignExpression.Span,
						Expression = scriptAssignExpression
					});
					scriptBlockStatement.Statements.Add(node);
					Close(scriptBlockStatement);
				}
				else if (asText == "for")
				{
					NextToken();
					scriptForStatement = Open<ScriptForStatement>();
					scriptForStatement.Variable = new ScriptIndexerExpression
					{
						Target = new ScriptThisExpression
						{
							Span = CurrentSpan
						},
						Index = (scriptExpression?.Clone() as ScriptExpression)
					};
					scriptForStatement.Iterator = ExpectAndParseExpression(scriptFunctionCall, null, 0, null, ParseExpressionMode.BasicExpression);
					scriptForStatement.Body = new ScriptBlockStatement
					{
						Span = scriptFunctionCall.Span
					};
					scriptForStatement.Body.Statements.Add(node);
					scriptForStatement.Body.Statements.Add(new ScriptEndStatement());
					Close(scriptForStatement);
				}
				while (Current.Type == TokenType.Identifier)
				{
					Token current2 = Current;
					ScriptVariable scriptVariable = ParseVariable() as ScriptVariable;
					if ((object)scriptVariable == null)
					{
						LogError(current2, "Unexpected variable name `" + GetAsTextForLog(current2) + "` found in include parameter");
					}
					if (Current.Type == TokenType.Colon)
					{
						NextToken();
					}
					else
					{
						LogError(Current, $"Unexpected token `{GetAsTextForLog(Current)}` after variable `{scriptVariable}`. Expecting a `:`");
					}
					if (scriptBlockStatement == null)
					{
						scriptBlockStatement = new ScriptBlockStatement
						{
							Span = scriptFunctionCall.Span
						};
						scriptBlockStatement.Statements.Add(node);
					}
					ScriptAssignExpression scriptAssignExpression2 = Open<ScriptAssignExpression>();
					scriptAssignExpression2.Target = scriptVariable;
					scriptAssignExpression2.Value = ExpectAndParseExpression(scriptFunctionCall, null, 0, null, ParseExpressionMode.BasicExpression);
					scriptBlockStatement.Statements.Insert(0, new ScriptExpressionStatement
					{
						Span = scriptAssignExpression2.Span,
						Expression = scriptAssignExpression2
					});
					if (Current.Type == TokenType.Comma)
					{
						NextToken();
					}
				}
				ExpectEndOfStatement();
				if (scriptForStatement != null)
				{
					if (scriptBlockStatement == null)
					{
						return Close(scriptForStatement);
					}
					scriptBlockStatement.Statements.Add(scriptForStatement);
				}
				if (scriptBlockStatement != null)
				{
					Close(scriptBlockStatement);
					return scriptBlockStatement;
				}
			}
			ExpectEndOfStatement();
			return Close(node);
		}

		private void ParseScribanStatement(string identifier, ScriptNode parent, bool parseEndOfStatementAfterEnd, ref ScriptStatement? statement, ref bool hasEnd, ref bool nextStatement)
		{
			Token current = Current;
			switch (identifier)
			{
			case "end":
				hasEnd = true;
				statement = ParseEndStatement(parseEndOfStatementAfterEnd);
				return;
			case "wrap":
				CheckNotInCase(parent, current);
				statement = ParseWrapStatement();
				return;
			case "if":
				CheckNotInCase(parent, current);
				statement = ParseIfStatement(invert: false);
				return;
			case "case":
				CheckNotInCase(parent, current);
				statement = ParseCaseStatement();
				return;
			case "when":
			{
				ScriptWhenStatement scriptWhenStatement2 = ParseWhenStatement();
				ScriptConditionStatement scriptConditionStatement3 = parent as ScriptConditionStatement;
				if (parent is ScriptWhenStatement)
				{
					if (scriptConditionStatement3 is ScriptWhenStatement scriptWhenStatement3)
					{
						scriptWhenStatement3.Next = scriptWhenStatement2;
					}
				}
				else if (parent is ScriptCaseStatement)
				{
					statement = scriptWhenStatement2;
				}
				else
				{
					nextStatement = false;
					LogError(current, "A `when` condition must be preceded by another `when`/`else`/`case` condition");
				}
				hasEnd = true;
				return;
			}
			case "else":
			{
				ScriptConditionStatement scriptConditionStatement = ParseElseStatement(isElseIf: false);
				ScriptConditionStatement scriptConditionStatement2 = parent as ScriptConditionStatement;
				if (parent is ScriptIfStatement || parent is ScriptWhenStatement)
				{
					if (parent is ScriptIfStatement)
					{
						if (scriptConditionStatement2 is ScriptIfStatement scriptIfStatement)
						{
							scriptIfStatement.Else = scriptConditionStatement;
						}
					}
					else if (scriptConditionStatement2 is ScriptWhenStatement scriptWhenStatement)
					{
						scriptWhenStatement.Next = scriptConditionStatement;
					}
				}
				else if (parent is ScriptForStatement scriptForStatement)
				{
					if (scriptConditionStatement is ScriptElseStatement scriptElseStatement)
					{
						scriptForStatement.Else = scriptElseStatement;
					}
					else
					{
						LogError(scriptConditionStatement.Span, "Invalid if/else combination within a for statement.");
					}
				}
				else
				{
					nextStatement = false;
					LogError(current, "A else condition must be preceded by another if/else/when condition or a for loop.");
				}
				hasEnd = true;
				return;
			}
			case "for":
				CheckNotInCase(parent, current);
				if (PeekToken().Type == TokenType.Dot)
				{
					statement = ParseExpressionStatement();
				}
				else
				{
					statement = ParseForStatement<ScriptForStatement>();
				}
				return;
			case "tablerow":
				if (!_isScientific)
				{
					CheckNotInCase(parent, current);
					if (PeekToken().Type == TokenType.Dot)
					{
						statement = ParseExpressionStatement();
					}
					else
					{
						statement = ParseForStatement<ScriptTableRowStatement>();
					}
					return;
				}
				break;
			case "with":
				CheckNotInCase(parent, current);
				statement = ParseWithStatement();
				return;
			case "import":
				CheckNotInCase(parent, current);
				statement = ParseImportStatement();
				return;
			case "readonly":
				CheckNotInCase(parent, current);
				statement = ParseReadOnlyStatement();
				return;
			case "while":
				CheckNotInCase(parent, current);
				if (PeekToken().Type == TokenType.Dot)
				{
					statement = ParseExpressionStatement();
				}
				else
				{
					statement = ParseWhileStatement();
				}
				return;
			case "break":
				CheckNotInCase(parent, current);
				ExpectAndParseKeywordTo(((ScriptBreakStatement)(statement = Open<ScriptBreakStatement>())).BreakKeyword);
				ExpectEndOfStatement();
				Close(statement);
				return;
			case "continue":
				CheckNotInCase(parent, current);
				ExpectAndParseKeywordTo(((ScriptContinueStatement)(statement = Open<ScriptContinueStatement>())).ContinueKeyword);
				ExpectEndOfStatement();
				Close(statement);
				return;
			case "func":
				CheckNotInCase(parent, current);
				statement = ParseFunctionStatement(isAnonymous: false);
				return;
			case "ret":
				CheckNotInCase(parent, current);
				statement = ParseReturnStatement();
				return;
			case "capture":
				CheckNotInCase(parent, current);
				statement = ParseCaptureStatement();
				return;
			}
			CheckNotInCase(parent, current);
			statement = ParseExpressionStatement();
		}

		private ScriptEndStatement ParseEndStatement(bool parseEndOfStatementAfterEnd)
		{
			ScriptEndStatement scriptEndStatement = Open<ScriptEndStatement>();
			ExpectAndParseKeywordTo(scriptEndStatement.EndKeyword);
			if (parseEndOfStatementAfterEnd)
			{
				ExpectEndOfStatement();
			}
			return Close(scriptEndStatement);
		}

		private ScriptFunction ParseFunctionStatement(bool isAnonymous)
		{
			ScriptFunction scriptFunction = Open<ScriptFunction>();
			int expressionLevel = _expressionLevel;
			try
			{
				_expressionLevel = 0;
				if (isAnonymous)
				{
					scriptFunction.NameOrDoToken = ExpectAndParseKeywordTo(ScriptKeyword.Do());
				}
				else
				{
					scriptFunction.FuncToken = ExpectAndParseKeywordTo(ScriptKeyword.Func());
					scriptFunction.NameOrDoToken = ExpectAndParseVariable(scriptFunction);
				}
				if (Current.Type == TokenType.OpenParen)
				{
					scriptFunction.OpenParen = ParseToken(TokenType.OpenParen);
					ScriptList<ScriptParameter> scriptList = new ScriptList<ScriptParameter>();
					bool flag = false;
					bool flag2 = false;
					bool flag3 = true;
					while (true)
					{
						if (Current.Type == TokenType.CloseParen)
						{
							scriptFunction.CloseParen = ParseToken(TokenType.CloseParen);
							scriptFunction.Span.End = scriptFunction.CloseParen.Span.End;
							break;
						}
						if (!flag3)
						{
							if (Current.Type == TokenType.Comma)
							{
								PushTokenToTrivia();
								NextToken();
								FlushTriviasToLastTerminal();
							}
							else
							{
								LogError(Current, "Expecting a comma to separate arguments in a function call.");
							}
						}
						flag3 = false;
						if (IsStartOfExpression())
						{
							ScriptParameter scriptParameter = Open<ScriptParameter>();
							ScriptVariable scriptVariable = ExpectAndParseVariable(scriptFunction);
							if (!(scriptVariable is ScriptVariableGlobal))
							{
								if ((object)scriptVariable == null)
								{
									break;
								}
								LogError(scriptVariable.Span, "Expecting only a simple name parameter for a function");
							}
							scriptParameter.Name = scriptVariable;
							if (Current.Type == TokenType.Equal)
							{
								if (flag)
								{
									LogError(scriptVariable.Span, "Cannot declare an optional parameter after a variable parameter (`...`).");
								}
								flag2 = true;
								scriptParameter.EqualOrTripleDotToken = ScriptToken.Equal();
								ExpectAndParseTokenTo(scriptParameter.EqualOrTripleDotToken, TokenType.Equal);
								scriptParameter.Span.End = scriptParameter.EqualOrTripleDotToken.Span.End;
								if (ExpectAndParseExpression(scriptParameter) is ScriptLiteral scriptLiteral)
								{
									scriptParameter.DefaultValue = scriptLiteral;
									scriptParameter.Span.End = scriptLiteral.Span.End;
								}
								else
								{
									LogError(scriptVariable.Span, "Expecting only a literal for an optional parameter value.");
								}
							}
							else if (Current.Type == TokenType.TripleDot)
							{
								if (flag)
								{
									LogError(scriptVariable.Span, "Cannot declare multiple variable parameters.");
								}
								flag = true;
								flag2 = true;
								scriptParameter.EqualOrTripleDotToken = ScriptToken.TripleDot();
								ExpectAndParseTokenTo(scriptParameter.EqualOrTripleDotToken, TokenType.TripleDot);
								scriptParameter.Span.End = scriptParameter.EqualOrTripleDotToken.Span.End;
							}
							else if (flag2)
							{
								LogError(scriptVariable.Span, "Cannot declare a normal parameter after an optional parameter.");
							}
							scriptList.Add(scriptParameter);
							scriptFunction.Span.End = scriptParameter.Span.End;
							continue;
						}
						LogError(Current, "Expecting an expression for argument function calls instead of this token.");
						break;
					}
					if (scriptFunction.CloseParen == null)
					{
						LogError(Current, "Expecting a closing parenthesis for a function call.");
					}
					scriptFunction.Parameters = scriptList;
				}
				ExpectEndOfStatement();
				scriptFunction.Body = ParseBlockStatement(scriptFunction, !isAnonymous);
			}
			finally
			{
				_expressionLevel = expressionLevel;
			}
			return Close(scriptFunction);
		}

		private ScriptImportStatement ParseImportStatement()
		{
			ScriptImportStatement scriptImportStatement = Open<ScriptImportStatement>();
			ExpectAndParseKeywordTo(scriptImportStatement.ImportKeyword);
			scriptImportStatement.Expression = ExpectAndParseExpression(scriptImportStatement);
			ExpectEndOfStatement();
			return Close(scriptImportStatement);
		}

		private ScriptReadOnlyStatement ParseReadOnlyStatement()
		{
			ScriptReadOnlyStatement scriptReadOnlyStatement = Open<ScriptReadOnlyStatement>();
			ExpectAndParseKeywordTo(scriptReadOnlyStatement.ReadOnlyKeyword);
			scriptReadOnlyStatement.Variable = ExpectAndParseVariable(scriptReadOnlyStatement);
			ExpectEndOfStatement();
			return Close(scriptReadOnlyStatement);
		}

		private ScriptReturnStatement ParseReturnStatement()
		{
			ScriptReturnStatement scriptReturnStatement = Open<ScriptReturnStatement>();
			ExpectAndParseKeywordTo(scriptReturnStatement.RetKeyword);
			if (IsStartOfExpression())
			{
				scriptReturnStatement.Expression = ParseExpression(scriptReturnStatement);
			}
			ExpectEndOfStatement();
			return Close(scriptReturnStatement);
		}

		private ScriptWhileStatement ParseWhileStatement()
		{
			ScriptWhileStatement scriptWhileStatement = Open<ScriptWhileStatement>();
			ExpectAndParseKeywordTo(scriptWhileStatement.WhileKeyword);
			scriptWhileStatement.Condition = ExpectAndParseExpression(scriptWhileStatement, null, 0, null, ParseExpressionMode.Default, allowAssignment: false);
			if (ExpectEndOfStatement())
			{
				scriptWhileStatement.Body = ParseBlockStatement(scriptWhileStatement);
			}
			return Close(scriptWhileStatement);
		}

		private ScriptWithStatement ParseWithStatement()
		{
			ScriptWithStatement scriptWithStatement = Open<ScriptWithStatement>();
			ExpectAndParseKeywordTo(scriptWithStatement.WithKeyword);
			scriptWithStatement.Name = ExpectAndParseExpression(scriptWithStatement);
			if (ExpectEndOfStatement())
			{
				scriptWithStatement.Body = ParseBlockStatement(scriptWithStatement);
			}
			return Close(scriptWithStatement);
		}

		private ScriptWrapStatement ParseWrapStatement()
		{
			ScriptWrapStatement scriptWrapStatement = Open<ScriptWrapStatement>();
			ExpectAndParseKeywordTo(scriptWrapStatement.WrapKeyword);
			scriptWrapStatement.Target = ExpectAndParseExpression(scriptWrapStatement);
			if (ExpectEndOfStatement())
			{
				scriptWrapStatement.Body = ParseBlockStatement(scriptWrapStatement);
			}
			return Close(scriptWrapStatement);
		}

		private void FixRawStatementAfterFrontMatter(ScriptPage page)
		{
			if (page.Body?.Statements.FirstOrDefault() is ScriptRawStatement scriptRawStatement)
			{
				scriptRawStatement.Text = scriptRawStatement.Text.TrimStart();
			}
		}

		private static bool IsScribanKeyword(string text)
		{
			switch (text)
			{
			case "do":
			case "if":
			case "else":
			case "case":
			case "when":
			case "func":
			case "with":
			case "wrap":
			case "end":
			case "for":
			case "ret":
			case "break":
			case "while":
			case "continue":
			case "readonly":
			case "import":
			case "capture":
				return true;
			default:
				return false;
			}
		}

		private ScriptExpression? ParseVariableOrLiteral()
		{
			ScriptExpression result = null;
			switch (Current.Type)
			{
			case TokenType.IdentifierSpecial:
			case TokenType.Identifier:
				result = ParseVariable();
				break;
			case TokenType.Integer:
				result = ParseInteger();
				break;
			case TokenType.HexaInteger:
				result = ParseHexaInteger();
				break;
			case TokenType.BinaryInteger:
				result = ParseBinaryInteger();
				break;
			case TokenType.Float:
				result = ParseFloat();
				break;
			case TokenType.String:
				result = ParseString();
				break;
			case TokenType.BeginInterpolatedString:
				result = ParseInterpolatedString();
				break;
			case TokenType.ImplicitString:
				result = ParseImplicitString();
				break;
			case TokenType.VerbatimString:
				result = ParseVerbatimString();
				break;
			default:
				LogError(Current, "Unexpected token found `" + GetAsTextForLog(Current) + "` while parsing a variable or literal");
				break;
			}
			return result;
		}

		private ScriptLiteral ParseFloat()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			string asText = GetAsText(Current);
			char c = asText[asText.Length - 1];
			if (c == 'f' || c == 'F')
			{
				if (float.TryParse(asText.Substring(0, asText.Length - 1), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					scriptLiteral.Value = result;
				}
				else
				{
					LogError("Unable to parse float value `" + asText + "`");
				}
			}
			else
			{
				bool flag = c == 'm' || c == 'M';
				double result3;
				if ((Options.ParseFloatAsDecimal || flag) && decimal.TryParse(flag ? asText.Substring(0, asText.Length - 1) : asText, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
				{
					scriptLiteral.Value = result2;
				}
				else if (double.TryParse((c == 'd' || c == 'D') ? asText.Substring(0, asText.Length - 1) : asText, NumberStyles.Float, CultureInfo.InvariantCulture, out result3))
				{
					scriptLiteral.Value = result3;
				}
				if (scriptLiteral.Value == null)
				{
					LogError("Unable to parse double value `" + asText + "`");
				}
			}
			NextToken();
			return Close(scriptLiteral);
		}

		private ScriptLiteral ParseImplicitString()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			scriptLiteral.Value = GetAsText(Current);
			Close(scriptLiteral);
			NextToken();
			return scriptLiteral;
		}

		private ScriptLiteral ParseInteger()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			string text = GetAsText(Current).Replace("_", string.Empty);
			if (!long.TryParse(text, NumberStyles.Integer | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, out var result))
			{
				bool flag = false;
				if (BigInteger.TryParse(text, NumberStyles.Integer | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, out var result2))
				{
					scriptLiteral.Value = result2;
					flag = true;
				}
				if (!flag)
				{
					LogError("Unable to parse the integer " + text);
				}
			}
			else if (result >= int.MinValue && result <= int.MaxValue)
			{
				scriptLiteral.Value = (int)result;
			}
			else
			{
				scriptLiteral.Value = result;
			}
			NextToken();
			return Close(scriptLiteral);
		}

		private ScriptLiteral ParseHexaInteger()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			string text = GetAsText(Current).Substring(2).Replace("_", string.Empty);
			bool flag = false;
			if (text.EndsWith("u", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - 1);
				flag = true;
			}
			if (!ulong.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				bool flag2 = false;
				if (BigInteger.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result2))
				{
					scriptLiteral.Value = result2;
					flag2 = true;
				}
				if (!flag2)
				{
					LogError("Unable to parse the integer " + text);
				}
			}
			else if (result <= uint.MaxValue)
			{
				if (flag)
				{
					scriptLiteral.Value = (long)(uint)result;
				}
				else
				{
					scriptLiteral.Value = (int)result;
				}
			}
			else
			{
				if (flag)
				{
					scriptLiteral.Value = new BigInteger(result);
				}
				if (scriptLiteral.Value == null)
				{
					scriptLiteral.Value = (long)result;
				}
			}
			NextToken();
			return Close(scriptLiteral);
		}

		private ScriptLiteral ParseBinaryInteger()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			string text = GetAsText(Current).Replace("_", string.Empty);
			bool flag = false;
			if (text.EndsWith("u", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - 1);
				flag = true;
			}
			int num = text.IndexOf('.');
			if (num > 2)
			{
				bool flag2 = false;
				if (text.EndsWith("f", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(0, text.Length - 1);
					flag2 = true;
				}
				else if (text.EndsWith("d", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(0, text.Length - 1);
				}
				int num2 = num - 2;
				BigInteger zero = BigInteger.Zero;
				int num3 = 0;
				for (int i = 2; i < text.Length; i++)
				{
					char c = text[i];
					if (c != '.')
					{
						zero <<= 1;
						zero |= (BigInteger)((c != '0') ? 1u : 0u);
						num3++;
					}
				}
				if (flag2)
				{
					scriptLiteral.Value = (float)zero * (float)Math.Pow(2.0, num2 - num3);
				}
				else
				{
					scriptLiteral.Value = (double)zero * Math.Pow(2.0, num2 - num3);
				}
			}
			else
			{
				BigInteger zero2 = BigInteger.Zero;
				for (int j = 2; j < text.Length; j++)
				{
					char c2 = text[j];
					zero2 <<= 1;
					zero2 |= (BigInteger)((c2 != '0') ? 1u : 0u);
				}
				if (zero2 <= 4294967295L)
				{
					if (flag)
					{
						scriptLiteral.Value = (long)(uint)zero2;
					}
					else
					{
						scriptLiteral.Value = (int)(uint)zero2;
					}
				}
				else if (zero2 <= ulong.MaxValue)
				{
					if (flag)
					{
						scriptLiteral.Value = zero2;
					}
					if (scriptLiteral.Value == null)
					{
						scriptLiteral.Value = (long)(ulong)zero2;
					}
				}
				else
				{
					scriptLiteral.Value = zero2;
				}
			}
			NextToken();
			return Close(scriptLiteral);
		}

		private ScriptLiteral ParseString()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			string text = _lexer.Text;
			StringBuilder stringBuilder = new StringBuilder(Current.End.Offset - Current.Start.Offset - 1);
			scriptLiteral.StringQuoteType = ((_lexer.Text[Current.Start.Offset] == '\'') ? ScriptLiteralStringQuoteType.SimpleQuote : ScriptLiteralStringQuoteType.DoubleQuote);
			int offset = Current.End.Offset;
			for (int i = Current.Start.Offset + 1; i < offset; i++)
			{
				char value = text[i];
				if (text[i] == '\\')
				{
					i++;
					switch (text[i])
					{
					case '0':
						stringBuilder.Append('\0');
						break;
					case '\r':
						i++;
						break;
					case '\'':
						stringBuilder.Append('\'');
						break;
					case '"':
						stringBuilder.Append('"');
						break;
					case '\\':
						stringBuilder.Append('\\');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'v':
						stringBuilder.Append('\v');
						break;
					case 'u':
					{
						i++;
						int num2 = 0;
						if (i < text.Length)
						{
							num2 = text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num2 = (num2 << 4) | text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num2 = (num2 << 4) | text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num2 = (num2 << 4) | text[i].HexToInt();
						}
						stringBuilder.Append(ConvertFromUtf32(num2));
						break;
					}
					case 'x':
					{
						i++;
						int num = 0;
						if (i < text.Length)
						{
							num = text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num = (num << 4) | text[i].HexToInt();
						}
						stringBuilder.Append((char)num);
						break;
					}
					default:
						LogError($"Unexpected escape character `{text[i]}` in string");
						break;
					case '\n':
						break;
					}
				}
				else
				{
					stringBuilder.Append(value);
				}
			}
			scriptLiteral.Value = stringBuilder.ToString();
			NextToken();
			return Close(scriptLiteral);
		}

		private ScriptLiteral ParseInterpolatedStringPart()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			string text = _lexer.Text;
			StringBuilder stringBuilder = new StringBuilder(Current.End.Offset - Current.Start.Offset - 1);
			int num = Current.Start.Offset + 1;
			char c = _lexer.Text[num];
			if (Current.Type == TokenType.BeginInterpolatedString || Current.Type == TokenType.InterpolatedString)
			{
				if (Current.Type == TokenType.BeginInterpolatedString)
				{
					_interpolatedNestedStringChars.Push(c);
				}
				num++;
			}
			else if (Current.Type == TokenType.EndingInterpolatedString)
			{
				c = _interpolatedNestedStringChars.Pop();
			}
			scriptLiteral.StringQuoteType = ((c == '\'') ? ScriptLiteralStringQuoteType.SimpleQuote : ScriptLiteralStringQuoteType.DoubleQuote);
			scriptLiteral.StringTokenType = Current.Type;
			int offset = Current.End.Offset;
			for (int i = num; i < offset; i++)
			{
				char value = text[i];
				if (text[i] == '\\')
				{
					i++;
					switch (text[i])
					{
					case '0':
						stringBuilder.Append('\0');
						break;
					case '\r':
						i++;
						break;
					case '\'':
						stringBuilder.Append('\'');
						break;
					case '"':
						stringBuilder.Append('"');
						break;
					case '\\':
						stringBuilder.Append('\\');
						break;
					case '{':
						stringBuilder.Append('{');
						break;
					case 'b':
						stringBuilder.Append('\b');
						break;
					case 'f':
						stringBuilder.Append('\f');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					case 'v':
						stringBuilder.Append('\v');
						break;
					case 'u':
					{
						i++;
						int num3 = 0;
						if (i < text.Length)
						{
							num3 = text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num3 = (num3 << 4) | text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num3 = (num3 << 4) | text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num3 = (num3 << 4) | text[i].HexToInt();
						}
						stringBuilder.Append(ConvertFromUtf32(num3));
						break;
					}
					case 'x':
					{
						i++;
						int num2 = 0;
						if (i < text.Length)
						{
							num2 = text[i++].HexToInt();
						}
						if (i < text.Length)
						{
							num2 = (num2 << 4) | text[i].HexToInt();
						}
						stringBuilder.Append((char)num2);
						break;
					}
					default:
						LogError($"Unexpected escape character `{text[i]}` in string");
						break;
					case '\n':
						break;
					}
				}
				else
				{
					stringBuilder.Append(value);
				}
			}
			scriptLiteral.Value = stringBuilder.ToString();
			NextToken();
			return Close(scriptLiteral);
		}

		private ScriptExpression ParseVariable()
		{
			Token current = Current;
			SourceSpan currentSpan = CurrentSpan;
			SourceSpan sourceSpan = currentSpan;
			string text = GetAsText(current);
			switch (text)
			{
			case "null":
			{
				ScriptLiteral node = Open<ScriptLiteral>();
				NextToken();
				return Close(node);
			}
			case "true":
			{
				ScriptLiteral scriptLiteral2 = Open<ScriptLiteral>();
				scriptLiteral2.Value = true;
				NextToken();
				return Close(scriptLiteral2);
			}
			case "false":
			{
				ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
				scriptLiteral.Value = false;
				NextToken();
				return Close(scriptLiteral);
			}
			case "do":
			{
				ScriptAnonymousFunction scriptAnonymousFunction = Open<ScriptAnonymousFunction>();
				scriptAnonymousFunction.Function = ParseFunctionStatement(isAnonymous: true);
				return Close(scriptAnonymousFunction);
			}
			case "this":
				if (!_isLiquid)
				{
					ScriptThisExpression scriptThisExpression = Open<ScriptThisExpression>();
					ExpectAndParseKeywordTo(scriptThisExpression.ThisKeyword);
					return Close(scriptThisExpression);
				}
				break;
			}
			List<ScriptTrivia> list = null;
			if (_isKeepTrivia && _trivias.Count > 0)
			{
				list = new List<ScriptTrivia>();
				list.AddRange(_trivias);
				_trivias.Clear();
			}
			NextToken();
			ScriptVariableScope scope = ScriptVariableScope.Global;
			if (text.StartsWith("$"))
			{
				scope = ScriptVariableScope.Local;
				text = text.Substring(1);
				if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
				{
					ScriptVariableLocal scriptVariableLocal = new ScriptVariableLocal(ScriptVariable.Arguments.BaseName)
					{
						Span = currentSpan
					};
					ScriptLiteral scriptLiteral3 = new ScriptLiteral
					{
						Span = currentSpan,
						Value = result
					};
					ScriptIndexerExpression result2 = new ScriptIndexerExpression
					{
						Span = currentSpan,
						Target = scriptVariableLocal,
						Index = scriptLiteral3
					};
					if (_isKeepTrivia)
					{
						if (list != null)
						{
							scriptVariableLocal.AddTrivias(list, before: true);
						}
						FlushTrivias(scriptLiteral3, isBefore: false);
						_lastTerminalWithTrivias = scriptLiteral3;
					}
					return result2;
				}
			}
			else
			{
				switch (text)
				{
				default:
					if (!_isLiquid || (!(text == "forloop") && !(text == "tablerowloop")))
					{
						if (_isLiquid && text == "continue")
						{
							scope = ScriptVariableScope.Local;
						}
						break;
					}
					goto case "for";
				case "for":
				case "while":
				case "tablerow":
				{
					if (Current.Type != TokenType.Dot)
					{
						break;
					}
					scope = ScriptVariableScope.Global;
					Token localToken = PeekToken();
					if (localToken.Type == TokenType.Identifier)
					{
						string asText = GetAsText(localToken);
						if (_isLiquid)
						{
							switch (asText)
							{
							case "col":
								if (text != "tablerowloop")
								{
									LogError(current, "The loop variable <" + text + ".col> is invalid");
								}
								break;
							default:
								LogError(current, "The liquid loop variable <" + text + "." + asText + "> is not supported");
								break;
							case "first":
							case "index":
							case "index0":
							case "length":
							case "rindex":
							case "last":
							case "rindex0":
								break;
							}
							if (text == "forloop")
							{
								text = "for";
							}
							else if (text == "tablerowloop")
							{
								text = "tablerow";
							}
							break;
						}
						switch (asText)
						{
						case "last":
						case "length":
						case "rindex":
						case "changed":
							if (text == "while")
							{
								LogError(current, "The loop variable <while." + asText + "> is invalid");
							}
							break;
						case "col":
							if (text != "tablerow")
							{
								LogError(current, "The loop variable <" + text + ".col> is invalid");
							}
							break;
						default:
							LogError(current, "The loop variable <" + text + "." + asText + "> is not supported");
							break;
						case "first":
						case "index":
						case "even":
						case "odd":
							break;
						}
					}
					else
					{
						LogError(current, "Invalid token `" + GetAsTextForLog(Current) + "`. The loop variable <" + text + "> dot must be followed by an identifier");
					}
					break;
				}
				}
			}
			ScriptVariable scriptVariable = ScriptVariable.Create(text, scope);
			scriptVariable.Span = new SourceSpan
			{
				FileName = currentSpan.FileName,
				Start = currentSpan.Start,
				End = sourceSpan.End
			};
			if (_isLiquid && text.IndexOf('-') >= 0)
			{
				ScriptThisExpression scriptThisExpression2 = new ScriptThisExpression
				{
					Span = scriptVariable.Span
				};
				ScriptIndexerExpression scriptIndexerExpression = new ScriptIndexerExpression
				{
					Target = scriptThisExpression2,
					Index = new ScriptLiteral(text)
					{
						Span = scriptVariable.Span
					},
					Span = scriptVariable.Span
				};
				if (_isKeepTrivia)
				{
					if (list != null)
					{
						scriptThisExpression2.ThisKeyword.AddTrivias(list, before: true);
					}
					FlushTrivias(scriptIndexerExpression.CloseBracket, isBefore: false);
					_lastTerminalWithTrivias = scriptIndexerExpression.CloseBracket;
				}
				return scriptIndexerExpression;
			}
			if (_isKeepTrivia)
			{
				if (list != null)
				{
					scriptVariable.AddTrivias(list, before: true);
				}
				FlushTrivias(scriptVariable, isBefore: false);
				_lastTerminalWithTrivias = scriptVariable;
			}
			return scriptVariable;
		}

		private ScriptLiteral ParseVerbatimString()
		{
			ScriptLiteral scriptLiteral = Open<ScriptLiteral>();
			string text = _lexer.Text;
			scriptLiteral.StringQuoteType = ScriptLiteralStringQuoteType.Verbatim;
			StringBuilder stringBuilder = null;
			int num = Current.Start.Offset + 1;
			int num2 = Current.End.Offset - 1;
			int num3 = num;
			while (true)
			{
				int num4 = text.IndexOf("`", num3, num2 - num3 + 1, StringComparison.OrdinalIgnoreCase);
				if (num4 < 0)
				{
					break;
				}
				if (stringBuilder == null)
				{
					stringBuilder = new StringBuilder(num2 - num + 1);
				}
				stringBuilder.Append(text.Substring(num3, num4 - num3 + 1));
				num3 = num4 + 2;
			}
			if (stringBuilder != null)
			{
				int num5 = num2 - num3 + 1;
				if (num5 > 0)
				{
					stringBuilder.Append(text.Substring(num3, num5));
				}
				scriptLiteral.Value = stringBuilder.ToString();
			}
			else
			{
				scriptLiteral.Value = text.Substring(num3, num2 - num3 + 1);
			}
			NextToken();
			return Close(scriptLiteral);
		}

		private static string ConvertFromUtf32(int utf32)
		{
			if (utf32 < 65536)
			{
				return ((char)utf32).ToString();
			}
			utf32 -= 65536;
			return new string(new char[2]
			{
				(char)(utf32 / 1024 + 55296),
				(char)(utf32 % 1024 + 56320)
			});
		}

		private static bool IsVariableOrLiteral(Token token)
		{
			TokenType type = token.Type;
			if ((uint)(type - 15) <= 12u)
			{
				return true;
			}
			return false;
		}
	}
	public record ParserOptions
	{
		public int ExpressionDepthLimit { get; init; } = 250;

		public bool LiquidFunctionsToScriban { get; init; }

		public bool ParseFloatAsDecimal { get; init; }

		public static readonly ParserOptions Default = new ParserOptions();

		[CompilerGenerated]
		protected ParserOptions(ParserOptions original)
		{
			ExpressionDepthLimit = original.ExpressionDepthLimit;
			LiquidFunctionsToScriban = original.LiquidFunctionsToScriban;
			ParseFloatAsDecimal = original.ParseFloatAsDecimal;
		}

		public ParserOptions()
		{
		}
	}
	public enum ScriptLang
	{
		Default,
		Liquid,
		Scientific
	}
	public enum ScriptMode
	{
		Default,
		FrontMatterOnly,
		FrontMatterAndContent,
		ScriptOnly
	}
	public struct SourceSpan
	{
		public string FileName { get; set; }

		public bool IsEmpty => FileName == null;

		public TextPosition Start { get; set; }

		public TextPosition End { get; set; }

		public int Length => End.Offset - Start.Offset + 1;

		public SourceSpan(string fileName, TextPosition start, TextPosition end)
		{
			FileName = fileName;
			Start = start;
			End = end;
		}

		public override string ToString()
		{
			return $"{FileName}({Start})-({End})";
		}

		public string ToStringSimple()
		{
			return FileName + "(" + Start.ToStringSimple() + ")";
		}
	}
	public struct TextPosition : IEquatable<TextPosition>
	{
		public static readonly TextPosition Eof = new TextPosition(-1, -1, -1);

		public int Offset { get; set; }

		public int Column { get; set; }

		public int Line { get; set; }

		public TextPosition(int offset, int line, int column)
		{
			Offset = offset;
			Column = column;
			Line = line;
		}

		public TextPosition NextColumn(int offset = 1)
		{
			return new TextPosition(Offset + offset, Line, Column + offset);
		}

		public TextPosition NextLine(int offset = 1)
		{
			return new TextPosition(Offset + offset, Line + offset, 0);
		}

		public override string ToString()
		{
			return $"({Offset}:{Line},{Column})";
		}

		public string ToStringSimple()
		{
			return $"{Line + 1},{Column + 1}";
		}

		public bool Equals(TextPosition other)
		{
			if (Offset == other.Offset && Column == other.Column)
			{
				return Line == other.Line;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return Offset;
		}

		public static bool operator ==(TextPosition left, TextPosition right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(TextPosition left, TextPosition right)
		{
			return !left.Equals(right);
		}
	}
	public struct Token : IEquatable<Token>
	{
		public static readonly Token Eof = new Token(TokenType.Eof, TextPosition.Eof, TextPosition.Eof);

		public readonly TokenType Type;

		public readonly TextPosition Start;

		public TextPosition End;

		public Token(TokenType type, TextPosition start, TextPosition end)
		{
			Type = type;
			Start = start;
			End = end;
		}

		public override string ToString()
		{
			return $"{Type}({Start}:{End})";
		}

		public string GetText(string text)
		{
			if (Type == TokenType.Eof)
			{
				return "<eof>";
			}
			if (Start.Offset < text.Length && End.Offset < text.Length)
			{
				return text.Substring(Start.Offset, End.Offset - Start.Offset + 1);
			}
			return "<error>";
		}

		public bool Match(string textToMatch, string lexerText)
		{
			int num = End.Offset - Start.Offset + 1;
			if (textToMatch.Length != num)
			{
				return false;
			}
			return string.CompareOrdinal(textToMatch, 0, lexerText, Start.Offset, num) == 0;
		}

		public bool Equals(Token other)
		{
			if (Type == other.Type && Start.Equals(other.Start))
			{
				return End.Equals(other.End);
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (obj is Token)
			{
				return Equals((Token)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((((int)Type * 397) ^ Start.GetHashCode()) * 397) ^ End.GetHashCode();
		}

		public static bool operator ==(Token left, Token right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(Token left, Token right)
		{
			return !left.Equals(right);
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	internal class TokenTextAttribute : Attribute
	{
		public string Text { get; }

		public TokenTextAttribute(string text)
		{
			Text = text;
		}
	}
	public enum TokenType
	{
		Invalid,
		FrontMatterMarker,
		CodeEnter,
		LiquidTagEnter,
		CodeExit,
		LiquidTagExit,
		Raw,
		Escape,
		EscapeEnter,
		EscapeExit,
		NewLine,
		Whitespace,
		WhitespaceFull,
		Comment,
		CommentMulti,
		IdentifierSpecial,
		Identifier,
		Integer,
		HexaInteger,
		BinaryInteger,
		Float,
		String,
		InterpolatedString,
		BeginInterpolatedString,
		ContinuationInterpolatedString,
		EndingInterpolatedString,
		ImplicitString,
		VerbatimString,
		SemiColon,
		Arroba,
		Caret,
		DoubleCaret,
		Colon,
		Equal,
		VerticalBar,
		PipeGreater,
		Exclamation,
		DoubleAmp,
		DoubleVerticalBar,
		Amp,
		Question,
		DoubleQuestion,
		QuestionDot,
		QuestionExclamation,
		DoubleEqual,
		ExclamationEqual,
		Less,
		Greater,
		LessEqual,
		GreaterEqual,
		Divide,
		DivideEqual,
		DoubleDivide,
		DoubleDivideEqual,
		Asterisk,
		AsteriskEqual,
		Plus,
		PlusEqual,
		DoublePlus,
		Minus,
		MinusEqual,
		DoubleMinus,
		Percent,
		PercentEqual,
		DoubleLessThan,
		DoubleGreaterThan,
		Comma,
		Dot,
		DoubleDot,
		TripleDot,
		DoubleDotLess,
		OpenParen,
		CloseParen,
		OpenBrace,
		CloseBrace,
		OpenBracket,
		CloseBracket,
		OpenInterpolatedBrace,
		CloseInterpolatedBrace,
		Custom,
		Custom1,
		Custom2,
		Custom3,
		Custom4,
		Custom5,
		Custom6,
		Custom7,
		Custom8,
		Custom9,
		Eof
	}
	public static class TokenTypeExtensions
	{
		public static bool HasText(this TokenType type)
		{
			return type.ToText() != null;
		}

		public static string? ToText(this TokenType type)
		{
			return type switch
			{
				TokenType.CodeEnter => "{{", 
				TokenType.LiquidTagEnter => "{%", 
				TokenType.CodeExit => "}}", 
				TokenType.LiquidTagExit => "%}", 
				TokenType.SemiColon => ";", 
				TokenType.Arroba => "@", 
				TokenType.Caret => "^", 
				TokenType.DoubleCaret => "^^", 
				TokenType.Colon => ":", 
				TokenType.Equal => "=", 
				TokenType.VerticalBar => "|", 
				TokenType.PipeGreater => "|>", 
				TokenType.Exclamation => "!", 
				TokenType.DoubleAmp => "&&", 
				TokenType.DoubleVerticalBar => "||", 
				TokenType.Amp => "&", 
				TokenType.Question => "?", 
				TokenType.QuestionDot => "?.", 
				TokenType.DoubleQuestion => "??", 
				TokenType.QuestionExclamation => "?!", 
				TokenType.DoubleEqual => "==", 
				TokenType.ExclamationEqual => "!=", 
				TokenType.Less => "<", 
				TokenType.Greater => ">", 
				TokenType.LessEqual => "<=", 
				TokenType.GreaterEqual => ">=", 
				TokenType.Divide => "/", 
				TokenType.DivideEqual => "/=", 
				TokenType.DoubleDivide => "//", 
				TokenType.DoubleDivideEqual => "//=", 
				TokenType.Asterisk => "*", 
				TokenType.AsteriskEqual => "*=", 
				TokenType.Plus => "+", 
				TokenType.PlusEqual => "+=", 
				TokenType.Minus => "-", 
				TokenType.MinusEqual => "-=", 
				TokenType.DoublePlus => "++", 
				TokenType.DoubleMinus => "--", 
				TokenType.Percent => "%", 
				TokenType.PercentEqual => "%=", 
				TokenType.DoubleLessThan => "<<", 
				TokenType.DoubleGreaterThan => ">>", 
				TokenType.Comma => ",", 
				TokenType.Dot => ".", 
				TokenType.DoubleDot => "..", 
				TokenType.TripleDot => "...", 
				TokenType.DoubleDotLess => "..<", 
				TokenType.OpenParen => "(", 
				TokenType.CloseParen => ")", 
				TokenType.OpenBrace => "{", 
				TokenType.CloseBrace => "}", 
				TokenType.OpenBracket => "[", 
				TokenType.CloseBracket => "]", 
				TokenType.OpenInterpolatedBrace => "{", 
				TokenType.CloseInterpolatedBrace => "}", 
				_ => null, 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsStringToken(this TokenType token)
		{
			if (token != TokenType.String && token != TokenType.InterpolatedString && token != TokenType.BeginInterpolatedString && token != TokenType.ContinuationInterpolatedString)
			{
				return token == TokenType.EndingInterpolatedString;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsInterpolationStringToken(this TokenType token)
		{
			if (token != TokenType.InterpolatedString && token != TokenType.BeginInterpolatedString && token != TokenType.ContinuationInterpolatedString)
			{
				return token == TokenType.EndingInterpolatedString;
			}
			return true;
		}
	}
	internal static class Util
	{
		public static bool IsHex(this char c)
		{
			if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
			{
				if (c >= 'A')
				{
					return c <= 'F';
				}
				return false;
			}
			return true;
		}

		public static int HexToInt(this char c)
		{
			if (c >= '0' && c <= '9')
			{
				return c - 48;
			}
			if (c >= 'a' && c <= 'f')
			{
				return c - 97 + 10;
			}
			if (c >= 'A' && c <= 'F')
			{
				return c - 65 + 10;
			}
			return 0;
		}
	}
}
namespace Scriban.Helpers
{
	internal static class BoxHelper
	{
		public static readonly object TrueObject = true;

		public static readonly object FalseObject = false;
	}
	public class CharHelper
	{
		public static bool IsHexa(char c)
		{
			if (!char.IsDigit(c) && (c < 'a' || c > 'f'))
			{
				if (c >= 'A')
				{
					return c <= 'F';
				}
				return false;
			}
			return true;
		}

		public static bool TryParseDigit(char c, out int value)
		{
			if (c >= '0' && c <= '9')
			{
				value = c - 48;
				return true;
			}
			value = 0;
			return false;
		}

		public static bool TryHexaToInt(char c, out int value)
		{
			if (c >= '0' && c <= '9')
			{
				value = c - 48;
				return true;
			}
			if (c >= 'A' && c <= 'F')
			{
				value = 10 + (c - 65);
				return true;
			}
			if (c >= 'a' && c <= 'f')
			{
				value = 10 + (c - 97);
				return true;
			}
			value = 0;
			return false;
		}

		public static bool IsBinary(char c)
		{
			if (c != '0')
			{
				return c == '1';
			}
			return true;
		}
	}
	internal struct FastStack<T>
	{
		private T[] _array;

		private int _size;

		private const int DefaultCapacity = 4;

		public int Count => _size;

		public T[] Items => _array;

		public FastStack(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity", "Capacity must be > 0");
			}
			_array = new T[capacity];
			_size = 0;
		}

		public void Clear()
		{
			Array.Clear(_array, 0, _size);
			_size = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public T Peek()
		{
			if (_size == 0)
			{
				ThrowForEmptyStack();
			}
			return _array[_size - 1];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public T Pop()
		{
			if (_size == 0)
			{
				ThrowForEmptyStack();
			}
			T result = _array[--_size];
			Array.Clear(_array, _size, 1);
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Push(T item)
		{
			if (_size == _array.Length)
			{
				Array.Resize(ref _array, (_array.Length == 0) ? 4 : (2 * _array.Length));
			}
			_array[_size++] = item;
		}

		private void ThrowForEmptyStack()
		{
			throw new InvalidOperationException("Stack is empty");
		}
	}
	[DebuggerTypeProxy(typeof(InlineList<>.DebugListView))]
	[DebuggerDisplay("Count = {Count}")]
	internal struct InlineList<T> : IEnumerable<T>, IEnumerable
	{
		public struct Enumerator : IEnumerator<T>, IEnumerator, IDisposable
		{
			private readonly InlineList<T> list;

			private int index;

			public T Current
			{
				get
				{
					if (index == 0 || index > list.Count)
					{
						throw new InvalidOperationException();
					}
					return list[index - 1];
				}
			}

			object? IEnumerator.Current => Current;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal Enumerator(InlineList<T> list)
			{
				this.list = list;
				index = 0;
			}

			public void Dispose()
			{
			}

			public bool MoveNext()
			{
				if (index < list.Count)
				{
					index++;
					return true;
				}
				return MoveNextRare();
			}

			private bool MoveNextRare()
			{
				index = list.Count + 1;
				return false;
			}

			void IEnumerator.Reset()
			{
				index = 0;
			}
		}

		internal class DebugListView
		{
			private InlineList<T> _collection;

			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public T[] Items
			{
				get
				{
					T[] array = new T[_collection.Count];
					for (int i = 0; i < array.Length; i++)
					{
						array[i] = _collection[i];
					}
					return array;
				}
			}

			public DebugListView(InlineList<T> collection)
			{
				_collection = collection;
			}
		}

		private const int DefaultCapacity = 4;

		public int Count;

		public T[]? Items;

		public int Capacity
		{
			get
			{
				T[]? items = Items;
				if (items == null)
				{
					return 0;
				}
				return items.Length;
			}
			set
			{
				Ensure();
				T[]? items = Items;
				if (value > ((items != null) ? items.Length : 0))
				{
					EnsureCapacity(value);
				}
			}
		}

		public bool IsReadOnly => false;

		public T this[int index]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if ((uint)index >= (uint)Count)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
				}
				return Items[index];
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				if ((uint)index >= (uint)Count)
				{
					ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
				}
				Items[index] = value;
			}
		}

		public InlineList(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity");
			}
			Count = 0;
			Items = ((capacity == 0) ? Array.Empty<T>() : new T[capacity]);
		}

		public static InlineList<T> Create()
		{
			return new InlineList<T>(0);
		}

		public static InlineList<T> Create(int capacity)
		{
			return new InlineList<T>(capacity);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Ensure()
		{
			if (Items == null)
			{
				Items = Array.Empty<T>();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Clear()
		{
			if (Count > 0)
			{
				Array.Clear(Items, 0, Count);
				Count = 0;
			}
		}

		public InlineList<T> Clone()
		{
			T[] items = ((Items == null) ? Array.Empty<T>() : ((T[])Items.Clone()));
			return new InlineList<T>
			{
				Count = Count,
				Items = items
			};
		}

		public bool Contains(T item)
		{
			if (Count > 0)
			{
				return IndexOf(item) >= 0;
			}
			return false;
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (Count > 0)
			{
				Array.Copy(Items, 0, array, arrayIndex, Count);
			}
		}

		public T[] ToArray()
		{
			T[] array = new T[Count];
			CopyTo(array, 0);
			return array;
		}

		public void Reset()
		{
			Clear();
			Count = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Add(T child)
		{
			Ensure();
			if (Count == Items.Length)
			{
				EnsureCapacity(Count + 1);
			}
			Items[Count++] = child;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AddByRef(in T child)
		{
			Ensure();
			if (Count == Items.Length)
			{
				EnsureCapacity(Count + 1);
			}
			Items[Count++] = child;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Insert(int index, T item)
		{
			Ensure();
			if (Count == Items.Length)
			{
				EnsureCapacity(Count + 1);
			}
			if (index < Count)
			{
				Array.Copy(Items, index, Items, index + 1, Count - index);
			}
			Items[index] = item;
			Count++;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ref T InsertReturnRef(int index, T item)
		{
			Ensure();
			if (Count == Items.Length)
			{
				EnsureCapacity(Count + 1);
			}
			if (index < Count)
			{
				Array.Copy(Items, index, Items, index + 1, Count - index);
			}
			Items[index] = item;
			Count++;
			return ref Items[index];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void InsertByRef(int index, in T item)
		{
			Ensure();
			if (Count == Items.Length)
			{
				EnsureCapacity(Count + 1);
			}
			if (index < Count)
			{
				Array.Copy(Items, index, Items, index + 1, Count - index);
			}
			Items[index] = item;
			Count++;
		}

		public bool Remove(T element)
		{
			int num = IndexOf(element);
			if (num >= 0)
			{
				RemoveAt(num);
				return true;
			}
			return false;
		}

		public int IndexOf(T element)
		{
			return Array.IndexOf(Items ?? Array.Empty<T>(), element, 0, Count);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public T RemoveAt(int index)
		{
			if (index < 0 || index >= Count)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index);
			}
			Count--;
			T result = Items[index];
			if (index < Count)
			{
				Array.Copy(Items, index + 1, Items, index, Count - index);
			}
			Array.Clear(Items, Count, 1);
			return result;
		}

		private void EnsureCapacity(int min)
		{
			Ensure();
			if (Items.Length < min)
			{
				int num = ((Items.Length == 0) ? 4 : (Items.Length * 2));
				if (num < min)
				{
					num = min;
				}
				Array.Resize(ref Items, num);
			}
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public static class ReflectionHelper
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPrimitiveOrDecimal(this Type type)
		{
			if (!type.IsPrimitive && !(type == typeof(decimal)))
			{
				return type == typeof(BigInteger);
			}
			return true;
		}

		public static bool IsNumber(this Type type)
		{
			if ((!type.IsPrimitive || !(type != typeof(bool))) && !(type == typeof(decimal)))
			{
				return type == typeof(BigInteger);
			}
			return true;
		}

		internal static Type? GetBaseOrInterface(this Type type, Type lookInterfaceType)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if ((object)lookInterfaceType == null)
			{
				throw new ArgumentNullException("lookInterfaceType");
			}
			if (lookInterfaceType.IsGenericTypeDefinition)
			{
				if (lookInterfaceType.IsInterface)
				{
					Type[] interfaces = type.GetInterfaces();
					foreach (Type type2 in interfaces)
					{
						if (type2.IsGenericType && type2.GetGenericTypeDefinition() == lookInterfaceType)
						{
							return type2;
						}
					}
				}
				Type type3 = type;
				while ((object)type3 != null)
				{
					if (type3.IsGenericType && type3.GetGenericTypeDefinition() == lookInterfaceType)
					{
						return type3;
					}
					type3 = type3.BaseType;
				}
			}
			else if (lookInterfaceType.IsAssignableFrom(type))
			{
				return lookInterfaceType;
			}
			return null;
		}

		public static string ScriptPrettyName(this Type type)
		{
			if ((object)type == null)
			{
				return "null";
			}
			if (type == typeof(bool))
			{
				return "bool";
			}
			if (type == typeof(byte))
			{
				return "byte";
			}
			if (type == typeof(sbyte))
			{
				return "sbyte";
			}
			if (type == typeof(ushort))
			{
				return "ushort";
			}
			if (type == typeof(short))
			{
				return "short";
			}
			if (type == typeof(uint))
			{
				return "uint";
			}
			if (type == typeof(int))
			{
				return "int";
			}
			if (type == typeof(ulong))
			{
				return "ulong";
			}
			if (type == typeof(long))
			{
				return "long";
			}
			if (type == typeof(string))
			{
				return "string";
			}
			if (type == typeof(float))
			{
				return "float";
			}
			if (type == typeof(double))
			{
				return "double";
			}
			if (type == typeof(decimal))
			{
				return "decimal";
			}
			if (type == typeof(BigInteger))
			{
				return "bigint";
			}
			if (type.IsEnum)
			{
				return "enum";
			}
			if (type == typeof(ScriptRange))
			{
				return "range";
			}
			if (type == typeof(ScriptArray) || typeof(IList).IsAssignableFrom(type))
			{
				return "array";
			}
			if (typeof(IScriptObject).IsAssignableFrom(type))
			{
				return "object";
			}
			if (typeof(IScriptCustomFunction).IsAssignableFrom(type))
			{
				return "function";
			}
			string text = type.Name;
			int num = text.IndexOf('`');
			if (num > 0)
			{
				text = text.Substring(0, num);
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append(text);
				stringBuilder.Append('<');
				Type[] genericTypeArguments = type.GenericTypeArguments;
				for (int i = 0; i < genericTypeArguments.Length; i++)
				{
					Type type2 = genericTypeArguments[i];
					if (i > 0)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append(type2.ScriptPrettyName());
				}
				stringBuilder.Append('>');
				text = stringBuilder.ToString();
			}
			ScriptTypeNameAttribute customAttribute = type.GetCustomAttribute<ScriptTypeNameAttribute>();
			if (customAttribute != null)
			{
				return customAttribute.TypeName;
			}
			if (type.Namespace != null && type.Namespace.StartsWith("Scriban."))
			{
				if (text.StartsWith("Script"))
				{
					text = text.Substring("Script".Length);
				}
				return StandardMemberRenamer.Rename(text);
			}
			return text;
		}
	}
	internal static class ThrowHelper
	{
		public static void ThrowArgumentOutOfRangeException(ExceptionArgument ex)
		{
			throw GetArgumentOutOfRangeException(ex);
		}

		private static ArgumentOutOfRangeException GetArgumentOutOfRangeException(ExceptionArgument argument)
		{
			return new ArgumentOutOfRangeException(GetArgumentName(argument));
		}

		public static ArgumentOutOfRangeException GetIndexNegativeArgumentOutOfRangeException()
		{
			return new ArgumentOutOfRangeException("index", "Index must be positive");
		}

		public static ArgumentOutOfRangeException GetIndexArgumentOutOfRangeException(int maxValue)
		{
			return new ArgumentOutOfRangeException("index", $"Index must be less than {maxValue}");
		}

		public static InvalidOperationException GetExpectingNoParentException()
		{
			return new InvalidOperationException("The node is already attached to another parent");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static string GetArgumentName(ExceptionArgument argument)
		{
			return argument.ToString();
		}
	}
	internal enum ExceptionArgument
	{
		parent,
		index,
		element,
		item,
		array,
		value,
		builder,
		capacity,
		dictionary,
		collection,
		Arg_ArrayPlusOffTooSmall,
		key,
		min,
		handle
	}
}
namespace Scriban.Functions
{
	public class ArrayFunctions : ScriptObject
	{
		private delegate IEnumerable ListProcessor(TemplateContext context, ScriptNode? callerContext, SourceSpan span, IEnumerable list, IScriptCustomFunction function, Type destType);

		private class CycleKey : IEquatable<CycleKey>
		{
			public readonly string Group;

			public CycleKey(string group)
			{
				Group = group;
			}

			public bool Equals(CycleKey? other)
			{
				if (other == null)
				{
					return false;
				}
				if (this == other)
				{
					return true;
				}
				return string.Equals(Group, other.Group);
			}

			public override bool Equals(object? obj)
			{
				if (obj == null)
				{
					return false;
				}
				if (this == obj)
				{
					return true;
				}
				if (obj.GetType() != GetType())
				{
					return false;
				}
				return Equals((CycleKey)obj);
			}

			public override int GetHashCode()
			{
				if (Group == null)
				{
					return 0;
				}
				return Group.GetHashCode();
			}

			public override string ToString()
			{
				return "cycle " + Group;
			}
		}

		private static readonly ListProcessor EachProcessor = EachInternal;

		private static readonly ListProcessor FilterProcessor = FilterInternal;

		[ScriptMemberIgnore]
		public static IEnumerable Add(IEnumerable? list, object? value)
		{
			if (list == null)
			{
				return new ScriptRange { value };
			}
			if (!(list is IList))
			{
				return new ScriptRange(list) { value };
			}
			return new ScriptArray(list) { value };
		}

		public static IEnumerable Add(TemplateContext context, SourceSpan span, IEnumerable? list, object? value)
		{
			if (list == null)
			{
				return new ScriptRange { value };
			}
			ScriptArray scriptArray = new ScriptArray();
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				scriptArray.Add(item);
			}
			scriptArray.Add(value);
			return scriptArray;
		}

		[ScriptMemberIgnore]
		public static IEnumerable? AddRange(IEnumerable? list1, IEnumerable? list2)
		{
			return Concat(list1, list2);
		}

		public static IEnumerable? AddRange(TemplateContext context, SourceSpan span, IEnumerable? list1, IEnumerable? list2)
		{
			return Concat(context, span, list1, list2);
		}

		[ScriptMemberIgnore]
		public static IEnumerable? Compact(IEnumerable? list)
		{
			return ScriptRange.Compact(list);
		}

		public static IEnumerable? Compact(TemplateContext context, SourceSpan span, IEnumerable? list)
		{
			return ScriptRange.Compact(context, span, list);
		}

		[ScriptMemberIgnore]
		public static IEnumerable? Concat(IEnumerable? list1, IEnumerable? list2)
		{
			return ScriptRange.Concat(list1, list2);
		}

		public static IEnumerable? Concat(TemplateContext context, SourceSpan span, IEnumerable? list1, IEnumerable? list2)
		{
			return ScriptRange.Concat(context, span, list1, list2);
		}

		public static object? Cycle(TemplateContext context, SourceSpan span, IList? list, object? group = null)
		{
			if (list == null)
			{
				return null;
			}
			CycleKey key = new CycleKey((group == null) ? Join(context, span, list, ",") : (context.ObjectToString(group) ?? string.Empty));
			Dictionary<object, object> tags = context.Tags;
			if (!tags.TryGetValue(key, out object value) || !(value is int))
			{
				value = 0;
			}
			int num = (int)value;
			num = ((list.Count != 0) ? (num % list.Count) : 0);
			object result = null;
			if (list.Count > 0)
			{
				result = list[num];
				num++;
			}
			tags[key] = num;
			return result;
		}

		public static bool Any(TemplateContext context, SourceSpan span, IEnumerable? list, object? function, params object?[] args)
		{
			if (list == null)
			{
				return false;
			}
			if (function == null)
			{
				return false;
			}
			if (!(function is IScriptCustomFunction function2))
			{
				return false;
			}
			ScriptArray scriptArray = new ScriptArray();
			scriptArray.Add(null);
			scriptArray.AddRange(args);
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			bool flag = default(bool);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				scriptArray[0] = item;
				object obj = ScriptFunctionCall.Call(context, context.CurrentNode, function2, scriptArray);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (flag ? 1u : 0u)) != 0)
				{
					return true;
				}
			}
			return false;
		}

		public static ScriptRange? Each(TemplateContext context, SourceSpan span, IEnumerable? list, object? function)
		{
			return ApplyFunction(context, span, list, function, EachProcessor);
		}

		private static IEnumerable EachInternal(TemplateContext context, ScriptNode? callerContext, SourceSpan span, IEnumerable list, IScriptCustomFunction function, Type destType)
		{
			ScriptArray arg = new ScriptArray(1);
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				object value = context.ToObject(span, item, destType);
				arg[0] = value;
				yield return ScriptFunctionCall.Call(context, callerContext, function, arg);
			}
		}

		public static ScriptRange? Filter(TemplateContext context, SourceSpan span, IEnumerable? list, object? function)
		{
			return ApplyFunction(context, span, list, function, FilterProcessor);
		}

		private static IEnumerable FilterInternal(TemplateContext context, ScriptNode? callerContext, SourceSpan span, IEnumerable list, IScriptCustomFunction function, Type destType)
		{
			ScriptArray arg = new ScriptArray(1);
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				object obj = (arg[0] = context.ToObject(span, item, destType));
				object value = ScriptFunctionCall.Call(context, callerContext, function, arg);
				if (context.ToBool(span, value))
				{
					yield return obj;
				}
			}
		}

		public static object? First(IEnumerable? list)
		{
			if (list == null)
			{
				return null;
			}
			if (list is IList list2)
			{
				if (list2.Count <= 0)
				{
					return null;
				}
				return list2[0];
			}
			IEnumerator enumerator = list.GetEnumerator();
			try
			{
				if (enumerator.MoveNext())
				{
					return enumerator.Current;
				}
			}
			finally
			{
				IDisposable disposable = enumerator as IDisposable;
				if (disposable != null)
				{
					disposable.Dispose();
				}
			}
			return null;
		}

		[ScriptMemberIgnore]
		public static IEnumerable InsertAt(IEnumerable? list, int index, object? value)
		{
			if (index < 0)
			{
				index = 0;
			}
			ScriptArray scriptArray = ((list == null) ? new ScriptArray() : new ScriptArray(list));
			for (int i = scriptArray.Count; i < index; i++)
			{
				scriptArray.Add(null);
			}
			scriptArray.Insert(index, value);
			return scriptArray;
		}

		public static IEnumerable InsertAt(TemplateContext context, SourceSpan span, IEnumerable? list, int index, object? value)
		{
			if (index < 0)
			{
				index = 0;
			}
			ScriptArray scriptArray = new ScriptArray();
			int loopStep = 0;
			if (list != null)
			{
				TemplateContext.LoopType loopType = GetLoopType(list);
				foreach (object item in list)
				{
					context.StepLoop(span, ref loopStep, loopType);
					scriptArray.Add(item);
				}
			}
			for (int i = scriptArray.Count; i < index; i++)
			{
				context.StepLoop(span, ref loopStep);
				scriptArray.Add(null);
			}
			scriptArray.Insert(index, value);
			return scriptArray;
		}

		public static string Join(TemplateContext context, SourceSpan span, IEnumerable? list, string? delimiter, object? function = null)
		{
			if (list == null)
			{
				return string.Empty;
			}
			IScriptCustomFunction scriptCustomFunction = function as IScriptCustomFunction;
			if (function != null && scriptCustomFunction == null)
			{
				throw new ArgumentException($"The parameter `{function}` is not a function. Maybe prefix it with @?", "function");
			}
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			ScriptArray scriptArray = new ScriptArray(1);
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (flag)
				{
					ValidateJoinedTextLength(context, span, stringBuilder.Length, delimiter?.Length ?? 0);
					stringBuilder.Append(delimiter);
				}
				string text = context.ObjectToString(item);
				if (scriptCustomFunction != null)
				{
					scriptArray[0] = text;
					object value = ScriptFunctionCall.Call(context, context.CurrentNode, scriptCustomFunction, scriptArray);
					text = context.ObjectToString(value);
				}
				ValidateJoinedTextLength(context, span, stringBuilder.Length, text?.Length ?? 0);
				stringBuilder.Append(text);
				flag = true;
			}
			return stringBuilder.ToString();
		}

		private static void ValidateJoinedTextLength(TemplateContext context, SourceSpan span, int currentLength, int additionalLength)
		{
			if (context.LimitToString > 0 && additionalLength > 0 && (long)currentLength + (long)additionalLength > context.LimitToString)
			{
				throw new ScriptRuntimeException(span, $"Joined string exceeds LimitToString `{context.LimitToString}`.");
			}
		}

		[ScriptMemberIgnore]
		public static object? Last(IEnumerable? list)
		{
			if (list == null)
			{
				return null;
			}
			if (list is IList list2)
			{
				if (list2.Count <= 0)
				{
					return null;
				}
				return list2[list2.Count - 1];
			}
			return list.Cast<object>().LastOrDefault();
		}

		public static object? Last(TemplateContext context, SourceSpan span, IEnumerable? list)
		{
			if (list == null)
			{
				return null;
			}
			if (list is IList list2)
			{
				if (list2.Count <= 0)
				{
					return null;
				}
				return list2[list2.Count - 1];
			}
			object result = null;
			bool flag = false;
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				result = item;
				flag = true;
			}
			if (!flag)
			{
				return null;
			}
			return result;
		}

		[ScriptMemberIgnore]
		public static IEnumerable? Limit(IEnumerable? list, int count)
		{
			return ScriptRange.Limit(list, count);
		}

		public static IEnumerable? Limit(TemplateContext context, SourceSpan span, IEnumerable? list, int count)
		{
			return ScriptRange.Limit(context, span, list, count);
		}

		public static IEnumerable Map(TemplateContext context, SourceSpan span, object? list, string? member)
		{
			return new ScriptRange(MapImpl(context, span, list, member));
		}

		private static IEnumerable MapImpl(TemplateContext context, SourceSpan span, object? list, string? member)
		{
			if (list == null || member == null)
			{
				yield break;
			}
			if (!(list is IEnumerable enumerable))
			{
				IObjectAccessor memberAccessor = context.GetMemberAccessor(list);
				if (memberAccessor.HasMember(context, span, list, member))
				{
					memberAccessor.TryGetValue(context, span, list, member, out object value);
					yield return value;
				}
				yield break;
			}
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(enumerable);
			foreach (object item in enumerable)
			{
				context.StepLoop(span, ref loopStep, loopType);
				IObjectAccessor memberAccessor2 = context.GetMemberAccessor(item);
				if (memberAccessor2.HasMember(context, span, item, member))
				{
					memberAccessor2.TryGetValue(context, span, item, member, out object value2);
					yield return value2;
				}
			}
		}

		[ScriptMemberIgnore]
		public static IEnumerable? Offset(IEnumerable? list, int index)
		{
			return ScriptRange.Offset(list, index);
		}

		public static IEnumerable? Offset(TemplateContext context, SourceSpan span, IEnumerable? list, int index)
		{
			return ScriptRange.Offset(context, span, list, index);
		}

		[ScriptMemberIgnore]
		public static IList RemoveAt(IList? list, int index)
		{
			if (list == null)
			{
				return new ScriptArray();
			}
			list = new ScriptArray(list);
			if (index < 0)
			{
				index = list.Count + index;
			}
			if (index >= 0 && index < list.Count)
			{
				list.RemoveAt(index);
			}
			return list;
		}

		public static IList RemoveAt(TemplateContext context, SourceSpan span, IList? list, int index)
		{
			if (list == null)
			{
				return new ScriptArray();
			}
			ScriptArray scriptArray = new ScriptArray();
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				scriptArray.Add(item);
			}
			if (index < 0)
			{
				index = scriptArray.Count + index;
			}
			if (index >= 0 && index < scriptArray.Count)
			{
				scriptArray.RemoveAt(index);
			}
			return scriptArray;
		}

		[ScriptMemberIgnore]
		public static IEnumerable Reverse(IEnumerable? list)
		{
			if (list == null)
			{
				return new ScriptArray();
			}
			return ScriptRange.Reverse(list);
		}

		public static IEnumerable Reverse(TemplateContext context, SourceSpan span, IEnumerable? list)
		{
			if (list == null)
			{
				return new ScriptArray();
			}
			return ScriptRange.Reverse(context, span, list);
		}

		[ScriptMemberIgnore]
		public static int Size(IEnumerable? list)
		{
			if (list == null)
			{
				return 0;
			}
			if (list is ICollection collection)
			{
				return collection.Count;
			}
			return list.Cast<object>().Count();
		}

		public static int Size(TemplateContext context, SourceSpan span, IEnumerable? list)
		{
			if (list == null)
			{
				return 0;
			}
			if (list is ICollection collection)
			{
				context.CheckAbort();
				return collection.Count;
			}
			int num = 0;
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item in list)
			{
				_ = item;
				context.StepLoop(span, ref loopStep, loopType);
				num++;
			}
			return num;
		}

		public static IEnumerable Sort(TemplateContext context, SourceSpan span, object? list, string? member = null)
		{
			if (list == null)
			{
				return new ScriptRange();
			}
			if (!(list is IEnumerable enumerable))
			{
				return new ScriptArray(1) { list };
			}
			List<object> list2 = new List<object>();
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(enumerable);
			foreach (object item in enumerable)
			{
				context.StepLoop(span, ref loopStep, loopType);
				list2.Add(item);
			}
			if (list2.Count == 0)
			{
				return new ScriptArray();
			}
			string sortMember = member ?? string.Empty;
			list2 = ((!string.IsNullOrEmpty(sortMember)) ? list2.OrderBy<object, object>((object item) => GetSortValue(context, span, item, sortMember), Comparer<object>.Default).ToList() : list2.OrderBy((object item) => item, Comparer<object>.Default).ToList());
			return new ScriptArray(list2);
		}

		private static object? GetSortValue(TemplateContext context, SourceSpan span, object? target, string member)
		{
			if (TryGetSortValue(context, span, target, member, out object value))
			{
				return value;
			}
			if (member.IndexOf('.') >= 0 && TryGetSortValueByPath(context, span, target, member.Split(new char[1] { '.' }), out value))
			{
				return value;
			}
			return null;
		}

		private static bool TryGetSortValue(TemplateContext context, SourceSpan span, object? target, string member, out object? value)
		{
			if (target == null)
			{
				value = null;
				return false;
			}
			if (context.GetMemberAccessor(target).TryGetValue(context, span, target, member, out value))
			{
				return true;
			}
			return context.TryGetMember?.Invoke(context, span, target, member, out value) ?? false;
		}

		private static bool TryGetSortValueByPath(TemplateContext context, SourceSpan span, object? target, string[] pathMembers, out object? value)
		{
			value = target;
			foreach (string member in pathMembers)
			{
				if (value == null || !TryGetSortValue(context, span, value, member, out value))
				{
					value = null;
					return false;
				}
			}
			return true;
		}

		[ScriptMemberIgnore]
		public static IEnumerable? Uniq(IEnumerable? list)
		{
			return ScriptRange.Uniq(list);
		}

		public static IEnumerable? Uniq(TemplateContext context, SourceSpan span, IEnumerable? list)
		{
			return ScriptRange.Uniq(context, span, list);
		}

		[ScriptMemberIgnore]
		public static bool Contains(IEnumerable? list, object? item)
		{
			if (list == null)
			{
				return false;
			}
			foreach (object item2 in list)
			{
				if (item2 == item || (item2 != null && item2.Equals(item)))
				{
					return true;
				}
				if (item2 is Enum e && CompareEnum(e, item))
				{
					return true;
				}
			}
			return false;
		}

		public static bool Contains(TemplateContext context, SourceSpan span, IEnumerable? list, object? item)
		{
			if (list == null)
			{
				return false;
			}
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(list);
			foreach (object item2 in list)
			{
				context.StepLoop(span, ref loopStep, loopType);
				if (item2 == item || (item2 != null && item2.Equals(item)))
				{
					return true;
				}
				if (item2 is Enum e && CompareEnum(e, item))
				{
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool CompareEnum(Enum e, object? item)
		{
			try
			{
				if (item is string value)
				{
					return Enum.Parse(e.GetType(), value)?.Equals(e) ?? false;
				}
				if (item == null)
				{
					return false;
				}
				return Enum.ToObject(e.GetType(), item)?.Equals(e) ?? false;
			}
			catch
			{
				return false;
			}
		}

		private static TemplateContext.LoopType GetLoopType(IEnumerable list)
		{
			if (!(list is IQueryable))
			{
				return TemplateContext.LoopType.Default;
			}
			return TemplateContext.LoopType.Queryable;
		}

		private static ScriptRange? ApplyFunction(TemplateContext context, SourceSpan span, IEnumerable? list, object? function, ListProcessor impl)
		{
			if (list == null)
			{
				return null;
			}
			if (function == null)
			{
				return new ScriptRange(list);
			}
			if (!(function is IScriptCustomFunction scriptCustomFunction))
			{
				throw new ArgumentException($"The parameter `{function}` is not a function. Maybe prefix it with @?", "function");
			}
			ScriptNode currentNode = context.CurrentNode;
			return new ScriptRange(impl(context, currentNode, span, list, scriptCustomFunction, scriptCustomFunction.GetParameterInfo(0).ParameterType));
		}
	}
	public class BuiltinFunctions : ScriptObject
	{
		private class DefaultBuiltins : ScriptObject
		{
			public DefaultBuiltins()
				: base(12, false)
			{
				SetValue("array", new ArrayFunctions(), readOnly: true);
				SetValue("empty", EmptyScriptObject.Default, readOnly: true);
				SetValue("blank", EmptyScriptObject.Default, readOnly: true);
				SetValue("include", new IncludeFunction(), readOnly: true);
				SetValue("include_join", new IncludeJoinFunction(), readOnly: true);
				SetValue(DateTimeFunctions.DateVariable.Name, new DateTimeFunctions(), readOnly: true);
				SetValue("html", new HtmlFunctions(), readOnly: true);
				SetValue("math", new MathFunctions(), readOnly: true);
				SetValue("object", new ObjectFunctions(), readOnly: true);
				SetValue("regex", new RegexFunctions(), readOnly: true);
				SetValue("string", new StringFunctions(), readOnly: true);
				SetValue("timespan", new TimeSpanFunctions(), readOnly: true);
			}
		}

		internal static readonly ScriptObject Default = new DefaultBuiltins();

		public BuiltinFunctions()
			: base(12)
		{
			((ScriptObject)Default.Clone(deep: true)).CopyTo(this);
		}
	}
	public class DateTimeFunctions : ScriptObject, IScriptCustomFunction, IScriptFunctionInfo
	{
		private const string FormatKey = "format";

		public const string DefaultFormat = "%d %b %Y";

		[ScriptMemberIgnore]
		public static readonly ScriptVariable DateVariable = new ScriptVariableGlobal("date");

		private static readonly Dictionary<char, (Func<DateTime, CultureInfo, string>, string?)> Formats = new Dictionary<char, (Func<DateTime, CultureInfo, string>, string)>
		{
			{
				'a',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("ddd", cultureInfo), "ddd")
			},
			{
				'A',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("dddd", cultureInfo), "dddd")
			},
			{
				'b',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("MMM", cultureInfo), "MMM")
			},
			{
				'B',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("MMMM", cultureInfo), "MMM")
			},
			{
				'c',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("ddd MMM dd HH:mm:ss yyyy", cultureInfo), "ddd MMM dd HH:mm:ss yyyy")
			},
			{
				'C',
				((DateTime dateTime, CultureInfo cultureInfo) => (dateTime.Year / 100).ToString("D2", cultureInfo), null)
			},
			{
				'd',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("dd", cultureInfo), "dd")
			},
			{
				'D',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("MM/dd/yy", cultureInfo), "MM/dd/yy")
			},
			{
				'e',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("%d", cultureInfo).PadLeft(2, ' '), "%d")
			},
			{
				'F',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("yyyy-MM-dd", cultureInfo), "yyyy-MM-dd")
			},
			{
				'h',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("MMM", cultureInfo), "MMM")
			},
			{
				'H',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("HH", cultureInfo), "HH")
			},
			{
				'I',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("hh", cultureInfo), "hh")
			},
			{
				'j',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.DayOfYear.ToString("D3", cultureInfo), null)
			},
			{
				'k',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("%H", cultureInfo).PadLeft(2, ' '), "%H")
			},
			{
				'l',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("%h", cultureInfo).PadLeft(2, ' '), "%h")
			},
			{
				'L',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("fff", cultureInfo), "fff")
			},
			{
				'm',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("MM", cultureInfo), "MM")
			},
			{
				'M',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("mm", cultureInfo), "mm")
			},
			{
				'n',
				((DateTime dateTime, CultureInfo cultureInfo) => "\n", null)
			},
			{
				'N',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("fffffff00", cultureInfo), "fffffff00")
			},
			{
				'p',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("tt", cultureInfo), "tt")
			},
			{
				'P',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("tt", cultureInfo).ToLowerInvariant(), "tt")
			},
			{
				'r',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("hh:mm:ss tt", cultureInfo), "hh:mm:ss tt")
			},
			{
				'R',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("HH:mm", cultureInfo), "HH:mm")
			},
			{
				's',
				((DateTime dateTime, CultureInfo cultureInfo) => ((dateTime.ToUniversalTime().Ticks - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks) / 10000000).ToString(cultureInfo), null)
			},
			{
				'S',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("ss", cultureInfo), "ss")
			},
			{
				't',
				((DateTime dateTime, CultureInfo cultureInfo) => "\t", null)
			},
			{
				'T',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("HH:mm:ss", cultureInfo), "HH:mm:ss")
			},
			{
				'u',
				((DateTime dateTime, CultureInfo cultureInfo) => ((int)((dateTime.DayOfWeek == DayOfWeek.Sunday) ? ((DayOfWeek)7) : dateTime.DayOfWeek)).ToString(cultureInfo), null)
			},
			{
				'U',
				((DateTime dateTime, CultureInfo cultureInfo) => cultureInfo.Calendar.GetWeekOfYear(dateTime, cultureInfo.DateTimeFormat.CalendarWeekRule, DayOfWeek.Sunday).ToString("D2", cultureInfo), null)
			},
			{
				'v',
				((DateTime dateTime, CultureInfo cultureInfo) => string.Format(CultureInfo.InvariantCulture, "{0,2}-{1}-{2:D4}", dateTime.Day, dateTime.ToString("MMM", CultureInfo.InvariantCulture).ToUpper(), dateTime.Year), null)
			},
			{
				'V',
				((DateTime dateTime, CultureInfo cultureInfo) => cultureInfo.Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday).ToString("D2", cultureInfo), null)
			},
			{
				'W',
				((DateTime dateTime, CultureInfo cultureInfo) => cultureInfo.Calendar.GetWeekOfYear(dateTime, cultureInfo.DateTimeFormat.CalendarWeekRule, DayOfWeek.Monday).ToString("D2", cultureInfo), null)
			},
			{
				'w',
				((DateTime dateTime, CultureInfo cultureInfo) => ((int)dateTime.DayOfWeek).ToString(cultureInfo), null)
			},
			{
				'x',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("d", cultureInfo), "d")
			},
			{
				'X',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("T", cultureInfo), "T")
			},
			{
				'y',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("yy", cultureInfo), "yy")
			},
			{
				'Y',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("yyyy", cultureInfo), "yyyy")
			},
			{
				'Z',
				((DateTime dateTime, CultureInfo cultureInfo) => dateTime.ToString("zzz", cultureInfo), "zzz")
			},
			{
				'%',
				((DateTime dateTime, CultureInfo cultureInfo) => "%", null)
			}
		};

		private static readonly Regex PlusFollowedByNumberRegex = new Regex("\\+\\d");

		private const string Parameter1Name = "text";

		public string Format
		{
			get
			{
				return GetSafeValue<string>("format") ?? "%d %b %Y";
			}
			set
			{
				SetValue("format", value, readOnly: false);
			}
		}

		public int RequiredParameterCount => 0;

		public int ParameterCount => 0;

		public ScriptVarParamKind VarParamKind => ScriptVarParamKind.Direct;

		public Type ReturnType => typeof(object);

		public DateTimeFunctions()
		{
			SetValue("default_format", "%d %b %Y", readOnly: true);
			SetValue("format", "%d %b %Y", readOnly: false);
			Format = "%d %b %Y";
			CreateImportFunctions();
		}

		public static DateTime Now()
		{
			return DateTime.Now;
		}

		public static DateTime UtcNow()
		{
			return DateTime.UtcNow;
		}

		public static DateTime AddDays(DateTime date, double days)
		{
			return date.AddDays(days);
		}

		public static DateTime AddMonths(DateTime date, int months)
		{
			return date.AddMonths(months);
		}

		public static DateTime AddYears(DateTime date, int years)
		{
			return date.AddYears(years);
		}

		public static DateTime AddHours(DateTime date, double hours)
		{
			return date.AddHours(hours);
		}

		public static DateTime AddMinutes(DateTime date, double minutes)
		{
			return date.AddMinutes(minutes);
		}

		public static DateTime AddSeconds(DateTime date, double seconds)
		{
			return date.AddSeconds(seconds);
		}

		public static DateTime AddMilliseconds(DateTime date, double millis)
		{
			return date.AddMilliseconds(millis);
		}

		private static string? ParseCustomFormat(CultureInfo culture, string? pattern, out CultureInfo cultureOverride)
		{
			cultureOverride = culture;
			if (pattern == null)
			{
				return null;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < pattern.Length; i++)
			{
				char c = pattern[i];
				if (c == '%' && i + 1 < pattern.Length)
				{
					i++;
					char c2 = pattern[i];
					(Func<DateTime, CultureInfo, string>, string) value;
					if (c2 == 'g')
					{
						cultureOverride = CultureInfo.InvariantCulture;
					}
					else if (Formats.TryGetValue(c2, out value))
					{
						if (value.Item2 == null)
						{
							throw new ArgumentException($"The pattern %{c2} is not supported for the parse method", "pattern");
						}
						stringBuilder.Append(value.Item2);
					}
					else
					{
						stringBuilder.Append('%');
						stringBuilder.Append(c2);
					}
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		private static DateTime? ParseDateTime(TemplateContext context, string? text, string? pattern = null, string? culture = null)
		{
			if (text == null || text.Length == 0)
			{
				return null;
			}
			bool flag = PlusFollowedByNumberRegex.IsMatch(text);
			bool flag2 = text.TrimEnd(Array.Empty<char>()).EndsWith("Z", StringComparison.OrdinalIgnoreCase);
			DateTimeStyles dateTimeStyles = ((!(flag || flag2)) ? DateTimeStyles.AssumeLocal : DateTimeStyles.None);
			CultureInfo cultureOverride;
			string text2 = ParseCustomFormat(((culture != null) ? CultureInfo.GetCultureInfo(culture) : context.CurrentCulture) ?? context.CurrentCulture, pattern, out cultureOverride);
			DateTime result = default(DateTime);
			if (text2 != null)
			{
				if (flag || flag2)
				{
					if (DateTimeOffset.TryParseExact(text, text2, cultureOverride, dateTimeStyles, out var result2))
					{
						result = result2.LocalDateTime;
					}
				}
				else if (!DateTime.TryParseExact(text, text2, cultureOverride, dateTimeStyles, out result))
				{
				}
			}
			else if (flag || flag2)
			{
				if (DateTimeOffset.TryParse(text, cultureOverride, dateTimeStyles, out var result3))
				{
					result = result3.LocalDateTime;
				}
			}
			else
			{
				DateTime.TryParse(text, cultureOverride, dateTimeStyles, out result);
			}
			return result;
		}

		public static DateTime? Parse(TemplateContext context, string? text, string? pattern = null, string? culture = null)
		{
			return ParseDateTime(context, text, pattern, culture);
		}

		public static string? ParseToString(TemplateContext context, string? text, string? output_pattern = null, string? output_culture = null, string? input_pattern = null, string? input_culture = null)
		{
			DateTime? dateTime = ParseDateTime(context, text, input_pattern, input_culture);
			if (!dateTime.HasValue)
			{
				return null;
			}
			if (output_pattern == null)
			{
				return dateTime.Value.ToString("%d %b %Y");
			}
			CultureInfo cultureOverride;
			string text2 = ParseCustomFormat(((output_culture != null) ? CultureInfo.GetCultureInfo(output_culture) : context.CurrentCulture) ?? context.CurrentCulture, output_pattern, out cultureOverride);
			return dateTime.Value.ToString(text2, cultureOverride);
		}

		public override IScriptObject Clone(bool deep)
		{
			DateTimeFunctions obj = (DateTimeFunctions)base.Clone(deep);
			obj.CreateImportFunctions();
			return obj;
		}

		public virtual string? ToString(DateTime? datetime, string pattern, CultureInfo culture)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			if (!datetime.HasValue)
			{
				return null;
			}
			if (pattern == "%g")
			{
				pattern = "%g " + Format;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < pattern.Length; i++)
			{
				char c = pattern[i];
				if (c == '%' && i + 1 < pattern.Length)
				{
					i++;
					char c2 = pattern[i];
					(Func<DateTime, CultureInfo, string>, string) value;
					if (c2 == 'g')
					{
						culture = CultureInfo.InvariantCulture;
					}
					else if (Formats.TryGetValue(c2, out value))
					{
						var (func, _) = value;
						stringBuilder.Append(func(datetime.Value, culture));
					}
					else
					{
						stringBuilder.Append('%');
						stringBuilder.Append(c2);
					}
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		public virtual object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
			switch (arguments.Count)
			{
			case 0:
				return this;
			case 1:
			{
				string text = context.ObjectToString(arguments[0]);
				return (text == null) ? ((DateTime?)null) : ParseDateTime(context, text);
			}
			default:
				throw new ScriptRuntimeException(span, $"Invalid number of parameters `{arguments.Count}` for `date` object/function.");
			}
		}

		public ScriptParameterInfo GetParameterInfo(int index)
		{
			return new ScriptParameterInfo(typeof(object), "text");
		}

		public ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			return new ValueTask<object>(Invoke(context, callerContext, arguments, blockStatement));
		}

		private void CreateImportFunctions()
		{
			SetValue("to_string", DynamicCustomFunction.Create(new Func<TemplateContext, DateTime?, string, string, string>(ToStringTrampoline)), readOnly: true);
		}

		private string? ToStringTrampoline(TemplateContext context, DateTime? date, string pattern, string? culture = null)
		{
			CultureInfo cultureInfo = ((culture != null) ? CultureInfo.GetCultureInfo(culture) : null);
			return ToString(date, pattern, cultureInfo ?? context.CurrentCulture);
		}
	}
	public class HtmlFunctions : ScriptObject
	{
		private const string RegexMatchHtml = "<script.*?</script>|<!--.*?-->|<style.*?</style>|<(?:[^>=]|='[^']*'|=\"[^\"]*\"|=[^'\"][^\\s>]*)*>";

		private static readonly Regex _matchNewLine = new Regex("\\r\\n|\\r|\\n");

		public static string? Strip(TemplateContext context, string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			return new Regex("<script.*?</script>|<!--.*?-->|<style.*?</style>|<(?:[^>=]|='[^']*'|=\"[^\"]*\"|=[^'\"][^\\s>]*)*>", RegexOptions.IgnoreCase | RegexOptions.Singleline, context.RegexTimeOut).Replace(text, string.Empty);
		}

		public static string? Escape(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			return WebUtility.HtmlEncode(text);
		}

		public static string? NewlineToBr(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			return _matchNewLine.Replace(text, "<br />$0");
		}

		public static string? UrlEncode(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			return Uri.EscapeDataString(text);
		}

		public static string? UrlEscape(string? text)
		{
			if (text == null || text.Length == 0)
			{
				return text;
			}
			StringBuilder stringBuilder = null;
			int num = 0;
			int num2 = -1;
			for (int i = 0; i < text.Length; i++)
			{
				if (IsAllowedInEscapedUrl(text[i]))
				{
					if (num2 >= 0)
					{
						if (stringBuilder == null)
						{
							stringBuilder = new StringBuilder(text.Length);
						}
						stringBuilder.Append(text, num, num2 - num);
						stringBuilder.Append(Uri.EscapeDataString(text.Substring(num2, i - num2)));
						num = i;
						num2 = -1;
					}
				}
				else if (num2 < 0)
				{
					num2 = i;
				}
			}
			if (num2 >= 0)
			{
				if (stringBuilder == null)
				{
					stringBuilder = new StringBuilder(text.Length);
				}
				stringBuilder.Append(text, num, num2 - num);
				stringBuilder.Append(Uri.EscapeDataString(text.Substring(num2)));
			}
			else
			{
				stringBuilder?.Append(text, num, text.Length - num);
			}
			return stringBuilder?.ToString() ?? text;
		}

		private static bool IsAllowedInEscapedUrl(char c)
		{
			if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
			{
				return true;
			}
			switch (c)
			{
			case '!':
			case '#':
			case '$':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case ':':
			case ';':
			case '=':
			case '?':
			case '@':
			case '[':
			case ']':
			case '_':
			case '~':
				return true;
			default:
				return false;
			}
		}
	}
	public sealed class IncludeFunction : IScriptCustomFunction, IScriptFunctionInfo
	{
		public int RequiredParameterCount => 1;

		public int ParameterCount => 1;

		public ScriptVarParamKind VarParamKind => ScriptVarParamKind.Direct;

		public Type ReturnType => typeof(object);

		public object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
			ScriptNode scriptNode = callerContext ?? context.CurrentNode;
			if (arguments.Count == 0)
			{
				throw new ScriptRuntimeException(span, "Expecting at least the name of the template to include for the <include> function");
			}
			string templateName = context.ObjectToString(arguments[0]);
			if (scriptNode == null)
			{
				throw new ScriptRuntimeException(span, "Unable to resolve the include caller context.");
			}
			string templatePathFromName = context.GetTemplatePathFromName(templateName, scriptNode);
			if (templatePathFromName == null)
			{
				return null;
			}
			Template orCreateTemplate = context.GetOrCreateTemplate(templatePathFromName, scriptNode);
			return context.RenderTemplate(orCreateTemplate, arguments, scriptNode);
		}

		public ScriptParameterInfo GetParameterInfo(int index)
		{
			if (index == 0)
			{
				return new ScriptParameterInfo(typeof(string), "template_name");
			}
			return new ScriptParameterInfo(typeof(object), "value");
		}

		public int GetParameterIndexByName(string name)
		{
			throw new NotImplementedException();
		}

		public async ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			SourceSpan span = callerContext?.Span ?? context.CurrentSpan;
			ScriptNode resolvedCallerContext = callerContext ?? context.CurrentNode;
			if (arguments.Count == 0)
			{
				throw new ScriptRuntimeException(span, "Expecting at least the name of the template to include for the <include> function");
			}
			string templateName = context.ObjectToString(arguments[0]);
			if (resolvedCallerContext == null)
			{
				throw new ScriptRuntimeException(span, "Unable to resolve the include caller context.");
			}
			string templatePathFromName = context.GetTemplatePathFromName(templateName, resolvedCallerContext);
			if (templatePathFromName == null)
			{
				return null;
			}
			return await context.RenderTemplateAsync(await context.GetOrCreateTemplateAsync(templatePathFromName, resolvedCallerContext).ConfigureAwait(continueOnCapturedContext: false), arguments, resolvedCallerContext).ConfigureAwait(continueOnCapturedContext: false);
		}
	}
	public sealed class IncludeJoinFunction : IScriptCustomFunction, IScriptFunctionInfo
	{
		public int RequiredParameterCount => 2;

		public int ParameterCount => 4;

		public ScriptVarParamKind VarParamKind => ScriptVarParamKind.Direct;

		public Type ReturnType => typeof(object);

		public object? Invoke(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			ScriptNode scriptNode = callerContext ?? context.CurrentNode;
			if (scriptNode == null)
			{
				throw new ScriptRuntimeException(context.CurrentSpan, "Unable to resolve the include_join caller context.");
			}
			if (arguments.Count < 2)
			{
				throw new ScriptRuntimeException(scriptNode.Span, "Expecting at least the separator and components to include for the <include_join> function.");
			}
			string[] array = (from x in (arguments[0] as ScriptArray)?.Select((object x) => context.ObjectToString(x))
				where !string.IsNullOrEmpty(x)
				select x).Cast<string>().ToArray() ?? (arguments[0] as IEnumerable<string>)?.ToArray();
			if (array == null)
			{
				return string.Empty;
			}
			string value = RenderComponent(context, scriptNode, arguments, context.ObjectToString(arguments[1]) ?? string.Empty);
			string value2 = RenderComponent(context, scriptNode, arguments, (arguments.Count > 2) ? (context.ObjectToString(arguments[2]) ?? string.Empty) : string.Empty);
			string value3 = RenderComponent(context, scriptNode, arguments, (arguments.Count > 3) ? (context.ObjectToString(arguments[3]) ?? string.Empty) : string.Empty);
			StringBuilder stringBuilder = new StringBuilder();
			if (!string.IsNullOrEmpty(value2))
			{
				stringBuilder.Append(value2);
			}
			for (int num = 0; num < array.Length; num++)
			{
				string templateName = array[num];
				string templatePathFromName = context.GetTemplatePathFromName(templateName, scriptNode);
				if (templatePathFromName != null)
				{
					Template orCreateTemplate = context.GetOrCreateTemplate(templatePathFromName, scriptNode);
					stringBuilder.Append(context.RenderTemplate(orCreateTemplate, arguments, scriptNode));
					if (!string.IsNullOrEmpty(value) && num < array.Length - 1)
					{
						stringBuilder.Append(value);
					}
				}
			}
			if (!string.IsNullOrEmpty(value3))
			{
				stringBuilder.Append(value3);
			}
			return stringBuilder.ToString();
		}

		public ScriptParameterInfo GetParameterInfo(int index)
		{
			return index switch
			{
				0 => new ScriptParameterInfo(typeof(IList), "template_names"), 
				1 => new ScriptParameterInfo(typeof(string), "separator"), 
				2 => new ScriptParameterInfo(typeof(string), "prefix"), 
				3 => new ScriptParameterInfo(typeof(string), "suffix"), 
				_ => throw new IndexOutOfRangeException(), 
			};
		}

		private string RenderComponent(TemplateContext context, ScriptNode callerContext, ScriptArray arguments, string component)
		{
			if (!component.StartsWith("tpl:"))
			{
				return component;
			}
			string templatePathFromName = context.GetTemplatePathFromName(component.Substring(4), callerContext);
			if (templatePathFromName == null)
			{
				return string.Empty;
			}
			Template orCreateTemplate = context.GetOrCreateTemplate(templatePathFromName, callerContext);
			return context.RenderTemplate(orCreateTemplate, arguments, callerContext);
		}

		public async ValueTask<object?> InvokeAsync(TemplateContext context, ScriptNode? callerContext, ScriptArray arguments, ScriptBlockStatement? blockStatement)
		{
			ScriptNode resolvedCallerContext = callerContext ?? context.CurrentNode;
			if (resolvedCallerContext == null)
			{
				throw new ScriptRuntimeException(context.CurrentSpan, "Unable to resolve the include_join caller context.");
			}
			if (arguments.Count < 2)
			{
				throw new ScriptRuntimeException(resolvedCallerContext.Span, "Expecting at least the separator and components to include for the <include_join> function.");
			}
			string[] templateNames = (from x in (arguments[0] as ScriptArray)?.Select((object x) => context.ObjectToString(x))
				where !string.IsNullOrEmpty(x)
				select x).Cast<string>().ToArray() ?? (arguments[0] as IEnumerable<string>)?.ToArray();
			if (templateNames == null)
			{
				return string.Empty;
			}
			string separator = await RenderComponentAsync(context, resolvedCallerContext, arguments, context.ObjectToString(arguments[1]) ?? string.Empty).ConfigureAwait(continueOnCapturedContext: false);
			string start = await RenderComponentAsync(context, resolvedCallerContext, arguments, (arguments.Count > 2) ? (context.ObjectToString(arguments[2]) ?? string.Empty) : string.Empty).ConfigureAwait(continueOnCapturedContext: false);
			string end = await RenderComponentAsync(context, resolvedCallerContext, arguments, (arguments.Count > 3) ? (context.ObjectToString(arguments[3]) ?? string.Empty) : string.Empty).ConfigureAwait(continueOnCapturedContext: false);
			StringBuilder sb = new StringBuilder();
			if (!string.IsNullOrEmpty(start))
			{
				sb.Append(start);
			}
			int i = 0;
			while (i < templateNames.Length)
			{
				string templateName = templateNames[i];
				string templatePathFromName = context.GetTemplatePathFromName(templateName, resolvedCallerContext);
				if (templatePathFromName != null)
				{
					Template template = await context.GetOrCreateTemplateAsync(templatePathFromName, resolvedCallerContext).ConfigureAwait(continueOnCapturedContext: false);
					StringBuilder stringBuilder = sb;
					stringBuilder.Append(await context.RenderTemplateAsync(template, arguments, resolvedCallerContext).ConfigureAwait(continueOnCapturedContext: false));
					if (!string.IsNullOrEmpty(separator) && i < templateNames.Length - 1)
					{
						sb.Append(separator);
					}
				}
				int num = i + 1;
				i = num;
			}
			if (!string.IsNullOrEmpty(end))
			{
				sb.Append(end);
			}
			return sb.ToString();
		}

		private async ValueTask<string> RenderComponentAsync(TemplateContext context, ScriptNode callerContext, ScriptArray arguments, string component)
		{
			if (!component.StartsWith("tpl:"))
			{
				return component;
			}
			string templatePathFromName = context.GetTemplatePathFromName(component.Substring(4), callerContext);
			if (templatePathFromName == null)
			{
				return string.Empty;
			}
			return await context.RenderTemplateAsync(await context.GetOrCreateTemplateAsync(templatePathFromName, callerContext).ConfigureAwait(continueOnCapturedContext: false), arguments, callerContext).ConfigureAwait(continueOnCapturedContext: false);
		}
	}
	public class LiquidBuiltinsFunctions : ScriptObject
	{
		private class DefaultBuiltins : ScriptObject
		{
			public DefaultBuiltins()
				: base(50, false)
			{
				ScriptObject scriptObject = (BuiltinFunctions.Default["math"] as ScriptObject) ?? throw new InvalidOperationException("Missing builtin `math` object.");
				ScriptObject scriptObject2 = (BuiltinFunctions.Default["string"] as ScriptObject) ?? throw new InvalidOperationException("Missing builtin `string` object.");
				ScriptObject scriptObject3 = (BuiltinFunctions.Default["array"] as ScriptObject) ?? throw new InvalidOperationException("Missing builtin `array` object.");
				ScriptObject value = (BuiltinFunctions.Default[DateTimeFunctions.DateVariable.Name] as ScriptObject) ?? throw new InvalidOperationException("Missing builtin `date` object.");
				ScriptObject scriptObject4 = (BuiltinFunctions.Default["html"] as ScriptObject) ?? throw new InvalidOperationException("Missing builtin `html` object.");
				ScriptObject scriptObject5 = (BuiltinFunctions.Default["object"] as ScriptObject) ?? throw new InvalidOperationException("Missing builtin `object` object.");
				SetValue("abs", scriptObject["abs"], readOnly: true);
				SetValue("append", scriptObject2["append"], readOnly: true);
				SetValue("capitalize", scriptObject2["capitalize"], readOnly: true);
				SetValue("ceil", scriptObject["ceil"], readOnly: true);
				SetValue("compact", scriptObject3["compact"], readOnly: true);
				SetValue("concat", scriptObject3["concat"], readOnly: true);
				SetValue("cycle", scriptObject3["cycle"], readOnly: true);
				SetValue("date", value, readOnly: true);
				SetValue("default", scriptObject5["default"], readOnly: true);
				SetValue("divided_by", scriptObject["divided_by"], readOnly: true);
				SetValue("downcase", scriptObject2["downcase"], readOnly: true);
				SetValue("escape", scriptObject4["escape"], readOnly: true);
				SetValue("first", scriptObject3["first"], readOnly: true);
				SetValue("floor", scriptObject["floor"], readOnly: true);
				SetValue("join", scriptObject3["join"], readOnly: true);
				SetValue("last", scriptObject3["last"], readOnly: true);
				SetValue("lstrip", scriptObject2["lstrip"], readOnly: true);
				SetValue("map", scriptObject3["map"], readOnly: true);
				SetValue("minus", scriptObject["minus"], readOnly: true);
				SetValue("modulo", scriptObject["modulo"], readOnly: true);
				SetValue("plus", scriptObject["plus"], readOnly: true);
				SetValue("prepend", scriptObject2["prepend"], readOnly: true);
				SetValue("remove", scriptObject2["remove"], readOnly: true);
				SetValue("remove_first", scriptObject2["remove_first"], readOnly: true);
				SetValue("replace", scriptObject2["replace"], readOnly: true);
				SetValue("replace_first", scriptObject2["replace_first"], readOnly: true);
				SetValue("reverse", scriptObject3["reverse"], readOnly: true);
				SetValue("round", scriptObject["round"], readOnly: true);
				SetValue("rstrip", scriptObject2["rstrip"], readOnly: true);
				SetValue("size", scriptObject5["size"], readOnly: true);
				SetValue("slice", scriptObject2["slice1"], readOnly: true);
				SetValue("sort", scriptObject3["sort"], readOnly: true);
				SetValue("split", scriptObject2["split"], readOnly: true);
				SetValue("strip", scriptObject2["strip"], readOnly: true);
				SetValue("strip_html", scriptObject4["strip"], readOnly: true);
				SetValue("strip_newlines", scriptObject2["strip_newlines"], readOnly: true);
				SetValue("times", scriptObject["times"], readOnly: true);
				SetValue("truncate", scriptObject2["truncate"], readOnly: true);
				SetValue("truncatewords", scriptObject2["truncatewords"], readOnly: true);
				SetValue("uniq", scriptObject3["uniq"], readOnly: true);
				SetValue("upcase", scriptObject2["upcase"], readOnly: true);
				SetValue("contains", scriptObject3["contains"], readOnly: true);
				this.Import(typeof(LiquidBuiltinsFunctions), ScriptMemberImportFlags.All);
			}
		}

		private static readonly DefaultBuiltins Default = new DefaultBuiltins();

		public LiquidBuiltinsFunctions()
			: base(50, false)
		{
			((ScriptObject)BuiltinFunctions.Default.Clone(deep: true)).CopyTo(this);
			((ScriptObject)Default.Clone(deep: false)).CopyTo(this);
		}

		public static bool TryLiquidToScriban(string liquidBuiltin, out string? target, out string? member)
		{
			if (liquidBuiltin == null)
			{
				throw new ArgumentNullException("liquidBuiltin");
			}
			target = null;
			member = null;
			switch (liquidBuiltin)
			{
			case "abs":
				target = "math";
				member = "abs";
				return true;
			case "append":
				target = "string";
				member = "append";
				return true;
			case "capitalize":
				target = "string";
				member = "capitalize";
				return true;
			case "ceil":
				target = "math";
				member = "ceil";
				return true;
			case "compact":
				target = "array";
				member = "compact";
				return true;
			case "concat":
				target = "array";
				member = "concat";
				return true;
			case "cycle":
				target = "array";
				member = "cycle";
				return true;
			case "date":
				target = "date";
				member = "parse_to_string";
				return true;
			case "default":
				target = "object";
				member = "default";
				return true;
			case "divided_by":
				target = "math";
				member = "divided_by";
				return true;
			case "downcase":
				target = "string";
				member = "downcase";
				return true;
			case "escape":
				target = "html";
				member = "escape";
				return true;
			case "escape_once":
				target = "html";
				member = "escape_once";
				return true;
			case "first":
				target = "array";
				member = "first";
				return true;
			case "floor":
				target = "math";
				member = "floor";
				return true;
			case "join":
				target = "array";
				member = "join";
				return true;
			case "last":
				target = "array";
				member = "last";
				return true;
			case "lstrip":
				target = "string";
				member = "lstrip";
				return true;
			case "map":
				target = "array";
				member = "map";
				return true;
			case "minus":
				target = "math";
				member = "minus";
				return true;
			case "modulo":
				target = "math";
				member = "modulo";
				return true;
			case "newline_to_br":
				target = "html";
				member = "newline_to_br";
				return true;
			case "plus":
				target = "math";
				member = "plus";
				return true;
			case "prepend":
				target = "string";
				member = "prepend";
				return true;
			case "remove":
				target = "string";
				member = "remove";
				return true;
			case "remove_first":
				target = "string";
				member = "remove_first";
				return true;
			case "replace":
				target = "string";
				member = "replace";
				return true;
			case "replace_first":
				target = "string";
				member = "replace_first";
				return true;
			case "reverse":
				target = "array";
				member = "reverse";
				return true;
			case "round":
				target = "math";
				member = "round";
				return true;
			case "rstrip":
				target = "string";
				member = "rstrip";
				return true;
			case "size":
				target = "object";
				member = "size";
				return true;
			case "slice":
				target = "string";
				member = "slice1";
				return true;
			case "sort":
				target = "array";
				member = "sort";
				return true;
			case "split":
				target = "string";
				member = "split";
				return true;
			case "strip":
				target = "string";
				member = "strip";
				return true;
			case "strip_html":
				target = "html";
				member = "strip";
				return true;
			case "strip_newlines":
				target = "string";
				member = "strip_newlines";
				return true;
			case "times":
				target = "math";
				member = "times";
				return true;
			case "truncate":
				target = "string";
				member = "truncate";
				return true;
			case "truncatewords":
				target = "string";
				member = "truncatewords";
				return true;
			case "uniq":
				target = "array";
				member = "uniq";
				return true;
			case "upcase":
				target = "string";
				member = "upcase";
				return true;
			case "contains":
				target = "array";
				member = "contains";
				return true;
			default:
				return false;
			}
		}
	}
	public class MathFunctions : ScriptObject
	{
		private const string RandomTagKey = "random";

		public static object? Abs(TemplateContext context, SourceSpan span, object? value)
		{
			if (value == null)
			{
				return null;
			}
			if (value is int)
			{
				return Math.Abs((int)value);
			}
			if (value is float)
			{
				return Math.Abs((float)value);
			}
			if (value is double)
			{
				return Math.Abs((double)value);
			}
			if (value is sbyte)
			{
				return Math.Abs((sbyte)value);
			}
			if (value is short)
			{
				return Math.Abs((short)value);
			}
			if (value is long)
			{
				return Math.Abs((long)value);
			}
			if (value is decimal)
			{
				return Math.Abs((decimal)value);
			}
			if (value.GetType().IsPrimitive)
			{
				return value;
			}
			throw new ScriptRuntimeException(span, $"The value `{value}` is not a number");
		}

		public static double Ceil(double value)
		{
			return Math.Ceiling(value);
		}

		public static object? DividedBy(TemplateContext context, SourceSpan span, double value, object? divisor)
		{
			object obj = ScriptBinaryExpression.Evaluate(context, span, ScriptBinaryOperator.Divide, value, divisor);
			if (divisor is int)
			{
				if (obj is double)
				{
					return (int)Math.Floor((double)obj);
				}
				if (obj is float)
				{
					return (int)Math.Floor((float)obj);
				}
			}
			return obj;
		}

		public static double Floor(double value)
		{
			return Math.Floor(value);
		}

		public static string Format(TemplateContext context, SourceSpan span, object? value, string? format, string? culture = null)
		{
			if (value == null)
			{
				return string.Empty;
			}
			format = format ?? string.Empty;
			IFormattable formattable = value as IFormattable;
			if (!IsNumber(value) || formattable == null)
			{
				throw new ScriptRuntimeException(span, $"Unexpected `{value}`. Must be a formattable number");
			}
			return formattable.ToString(format, (culture != null) ? new CultureInfo(culture) : context.CurrentCulture);
		}

		public static bool IsNumber(object? value)
		{
			if (!(value is sbyte) && !(value is byte) && !(value is short) && !(value is ushort) && !(value is int) && !(value is uint) && !(value is long) && !(value is ulong) && !(value is float) && !(value is double) && !(value is decimal))
			{
				return value is BigInteger;
			}
			return true;
		}

		public static object? Minus(TemplateContext context, SourceSpan span, object? value, object? with)
		{
			return ScriptBinaryExpression.Evaluate(context, span, ScriptBinaryOperator.Subtract, value, with);
		}

		public static object? Modulo(TemplateContext context, SourceSpan span, object? value, object? with)
		{
			return ScriptBinaryExpression.Evaluate(context, span, ScriptBinaryOperator.Modulus, value, with);
		}

		public static object? Plus(TemplateContext context, SourceSpan span, object? value, object? with)
		{
			return ScriptBinaryExpression.Evaluate(context, span, ScriptBinaryOperator.Add, value, with);
		}

		public static double Round(double value, int precision = 0)
		{
			return Math.Round(value, precision);
		}

		public static object? Times(TemplateContext context, SourceSpan span, object? value, object? with)
		{
			return ScriptBinaryExpression.Evaluate(context, span, ScriptBinaryOperator.Multiply, value, with);
		}

		public static string Uuid()
		{
			return Guid.NewGuid().ToString();
		}

		public static object Random(TemplateContext context, SourceSpan span, int minValue, int maxValue)
		{
			if (minValue > maxValue)
			{
				throw new ScriptRuntimeException(span, "minValue must be greater than maxValue");
			}
			Dictionary<object, object> tags = context.Tags;
			if (!tags.TryGetValue("random", out var value))
			{
				value = new Random();
				tags.Add("random", value);
			}
			return ((Random)value).Next(minValue, maxValue);
		}
	}
	public class ObjectFunctions : ScriptObject
	{
		private sealed class ReferenceEqualityComparer : IEqualityComparer<object>
		{
			internal static readonly ReferenceEqualityComparer Default = new ReferenceEqualityComparer();

			public new bool Equals(object? x, object? y)
			{
				return x == y;
			}

			public int GetHashCode(object obj)
			{
				return RuntimeHelpers.GetHashCode(obj);
			}
		}

		public static object? Default(object? value, object? @default)
		{
			if (value != null && (!(value is string value2) || !string.IsNullOrEmpty(value2)))
			{
				return value;
			}
			return @default;
		}

		public static object? Eval(TemplateContext context, SourceSpan span, object? value)
		{
			if (value == null)
			{
				return null;
			}
			if (value is string text)
			{
				try
				{
					Template template = Template.Parse(text, null, null, new LexerOptions
					{
						Lang = context.Language,
						Mode = ScriptMode.ScriptOnly
					});
					if (template.HasErrors)
					{
						throw new ScriptRuntimeException(span, template.Messages.ToString());
					}
					ScriptPage page = template.Page;
					if (page == null)
					{
						return null;
					}
					if (page.Body == null)
					{
						return null;
					}
					return (page.Body.Statements.Count == 1) ? context.Evaluate(page.Body.Statements[0]) : context.Evaluate(page);
				}
				catch (Exception ex)
				{
					throw new ArgumentException(ex.Message, "value");
				}
			}
			if (value is IScriptCustomFunction functionObject)
			{
				return ScriptFunctionCall.Call(context, context.CurrentNode, functionObject, processPipeArguments: false, null);
			}
			return value;
		}

		public static object? EvalTemplate(TemplateContext context, SourceSpan span, object? value)
		{
			if (value == null)
			{
				return null;
			}
			if (value is string text)
			{
				try
				{
					Template template = Template.Parse(text, null, null, new LexerOptions
					{
						Lang = context.Language,
						Mode = ScriptMode.Default
					});
					StringBuilderOutput stringBuilderOutput = new StringBuilderOutput();
					context.PushOutput(stringBuilderOutput);
					try
					{
						if (template.Page != null)
						{
							context.Evaluate(template.Page);
						}
					}
					finally
					{
						context.PopOutput();
					}
					return stringBuilderOutput.ToString();
				}
				catch (Exception ex)
				{
					throw new ArgumentException(ex.Message, "value");
				}
			}
			if (value is IScriptCustomFunction functionObject)
			{
				return ScriptFunctionCall.Call(context, context.CurrentNode, functionObject, processPipeArguments: false, null);
			}
			return value;
		}

		public static string Format(TemplateContext context, SourceSpan span, object? value, string? format, string? culture = null)
		{
			if (value == null)
			{
				return string.Empty;
			}
			format = format ?? string.Empty;
			return ((value as IFormattable) ?? throw new ScriptRuntimeException(span, $"Unexpected `{value}`. Must be a formattable object")).ToString(format, (culture != null) ? new CultureInfo(culture) : context.CurrentCulture);
		}

		public static bool HasKey(IDictionary<string, object?>? value, string? key)
		{
			if (value == null || key == null)
			{
				return false;
			}
			return value.ContainsKey(key);
		}

		public static bool HasValue(IDictionary<string, object?>? value, string? key)
		{
			if (value == null || key == null)
			{
				return false;
			}
			if (value.ContainsKey(key))
			{
				return value[key] != null;
			}
			return false;
		}

		public new static ScriptArray Keys(TemplateContext context, object? value)
		{
			if (value == null)
			{
				return new ScriptArray();
			}
			if (value is IDictionary dictionary)
			{
				return ToScriptArray(context, context.CurrentSpan, dictionary.Keys);
			}
			if (value is IDictionary<string, object> dictionary2)
			{
				return ToScriptArray(context, context.CurrentSpan, dictionary2.Keys);
			}
			if (value is IScriptObject scriptObject)
			{
				return ToScriptArray(context, context.CurrentSpan, scriptObject.GetMembers());
			}
			if (value is IScriptCustomFunction)
			{
				return new ScriptArray();
			}
			IObjectAccessor memberAccessor = context.GetMemberAccessor(value);
			return ToScriptArray(context, context.CurrentSpan, memberAccessor.GetMembers(context, context.CurrentSpan, value));
		}

		[ScriptMemberIgnore]
		public static int Size(object? value)
		{
			if (value == null)
			{
				return 0;
			}
			if (value is string)
			{
				return StringFunctions.Size((string)value);
			}
			if (value is IEnumerable)
			{
				return ArrayFunctions.Size((IEnumerable)value);
			}
			return 0;
		}

		public static int Size(TemplateContext context, SourceSpan span, object? value)
		{
			if (value == null)
			{
				return 0;
			}
			if (value is string)
			{
				return StringFunctions.Size((string)value);
			}
			if (value is IEnumerable)
			{
				return ArrayFunctions.Size(context, span, (IEnumerable)value);
			}
			return 0;
		}

		public static string? Typeof(object? value)
		{
			if (value == null)
			{
				return null;
			}
			Type type = value.GetType();
			Type c = type;
			if (type == typeof(string))
			{
				return "string";
			}
			if (type == typeof(bool))
			{
				return "boolean";
			}
			if (type.IsPrimitiveOrDecimal())
			{
				return "number";
			}
			if (typeof(ScriptRange).IsAssignableFrom(c))
			{
				return "iterator";
			}
			if (typeof(IList).IsAssignableFrom(c))
			{
				return "array";
			}
			if (!typeof(ScriptObject).IsAssignableFrom(c) && !typeof(IDictionary).IsAssignableFrom(c) && typeof(IEnumerable).IsAssignableFrom(c))
			{
				return "iterator";
			}
			return "object";
		}

		public static string? Kind(TemplateContext context, object? value)
		{
			if (value == null)
			{
				return null;
			}
			return context.GetTypeName(value);
		}

		public new static ScriptArray Values(TemplateContext context, object? value)
		{
			if (value == null)
			{
				return new ScriptArray();
			}
			if (value is IDictionary<string, object> dictionary)
			{
				ScriptArray scriptArray = new ScriptArray();
				int loopStep = 0;
				{
					foreach (object value3 in dictionary.Values)
					{
						context.StepLoop(context.CurrentSpan, ref loopStep);
						scriptArray.Add(value3);
					}
					return scriptArray;
				}
			}
			if (value is IScriptCustomFunction)
			{
				return new ScriptArray();
			}
			IObjectAccessor memberAccessor = context.GetMemberAccessor(value);
			ScriptArray scriptArray2 = new ScriptArray();
			int loopStep2 = 0;
			foreach (string member in memberAccessor.GetMembers(context, context.CurrentSpan, value))
			{
				context.StepLoop(context.CurrentSpan, ref loopStep2);
				memberAccessor.TryGetValue(context, context.CurrentSpan, value, member, out object value2);
				scriptArray2.Add(value2);
			}
			return scriptArray2;
		}

		private static ScriptArray ToScriptArray(TemplateContext context, SourceSpan span, IEnumerable values)
		{
			ScriptArray scriptArray = new ScriptArray();
			int loopStep = 0;
			TemplateContext.LoopType loopType = GetLoopType(values);
			foreach (object value in values)
			{
				context.StepLoop(span, ref loopStep, loopType);
				scriptArray.Add(value);
			}
			return scriptArray;
		}

		private static TemplateContext.LoopType GetLoopType(IEnumerable values)
		{
			if (!(values is IQueryable))
			{
				return TemplateContext.LoopType.Default;
			}
			return TemplateContext.LoopType.Queryable;
		}

		public static object? FromJson(TemplateContext context, string json)
		{
			using JsonDocument jsonDocument = JsonDocument.Parse(json);
			return jsonDocument.RootElement.Clone().ToScriban();
		}

		public static string ToJson(TemplateContext context, object? value)
		{
			if (value is IScriptCustomFunction)
			{
				throw new ArgumentOutOfRangeException("value", "Can not serialize functions to JSON.");
			}
			JsonWriterOptions options = new JsonWriterOptions
			{
				Indented = false
			};
			using (MemoryStream memoryStream = new MemoryStream())
			{
				Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options);
				HashSet<object> path = new HashSet<object>(ReferenceEqualityComparer.Default);
				WriteValue(context, utf8JsonWriter, value, 0, path);
				utf8JsonWriter.Flush();
				return Encoding.UTF8.GetString(memoryStream.ToArray());
			}
			static void WriteValue(TemplateContext templateContext, Utf8JsonWriter writer, object? obj, int depth, HashSet<object> hashSet)
			{
				try
				{
					RuntimeHelpers.EnsureSufficientExecutionStack();
				}
				catch (InsufficientExecutionStackException)
				{
					throw new InvalidOperationException("Structure is too deeply nested or contains reference loops.");
				}
				depth++;
				if (templateContext.ObjectRecursionLimit != 0 && depth > templateContext.ObjectRecursionLimit)
				{
					throw new InvalidOperationException("Structure is too deeply nested or contains reference loops.");
				}
				Type type = obj?.GetType() ?? typeof(object);
				bool num = obj != null && !type.IsValueType && !(obj is string);
				bool flag = false;
				if (num && obj != null)
				{
					flag = hashSet.Add(obj);
					if (!flag)
					{
						throw new InvalidOperationException("Structure is too deeply nested or contains reference loops.");
					}
				}
				try
				{
					if (obj == null || obj is string || obj is bool || type.IsPrimitiveOrDecimal() || obj is IFormattable)
					{
						JsonSerializer.Serialize(writer, obj, type);
					}
					else if (obj is IList || type.IsArray)
					{
						writer.WriteStartArray();
						IList list = templateContext.ToList(templateContext.CurrentSpan, obj);
						if (list != null)
						{
							foreach (object item in list)
							{
								WriteValue(templateContext, writer, item, depth, hashSet);
							}
						}
						writer.WriteEndArray();
					}
					else
					{
						writer.WriteStartObject();
						IObjectAccessor memberAccessor = templateContext.GetMemberAccessor(obj);
						foreach (string member in memberAccessor.GetMembers(templateContext, templateContext.CurrentSpan, obj))
						{
							if (memberAccessor.TryGetValue(templateContext, templateContext.CurrentSpan, obj, member, out object value2))
							{
								writer.WritePropertyName(member);
								WriteValue(templateContext, writer, value2, depth, hashSet);
							}
						}
						writer.WriteEndObject();
					}
				}
				finally
				{
					if (flag && obj != null)
					{
						hashSet.Remove(obj);
					}
				}
			}
		}
	}
	public class RegexFunctions : ScriptObject
	{
		public static string Escape(string pattern)
		{
			return Regex.Escape(pattern);
		}

		public static ScriptArray Match(TemplateContext context, string text, string pattern, string? options = null)
		{
			Match match = Regex.Match(text, pattern, GetOptions(options), context.RegexTimeOut);
			ScriptArray scriptArray = new ScriptArray();
			if (match.Success)
			{
				foreach (Group group in match.Groups)
				{
					scriptArray.Add(group.Value);
				}
			}
			return scriptArray;
		}

		public static ScriptArray Matches(TemplateContext context, string text, string pattern, string? options = null)
		{
			MatchCollection matchCollection = Regex.Matches(text, pattern, GetOptions(options), context.RegexTimeOut);
			ScriptArray scriptArray = new ScriptArray();
			foreach (Match item in matchCollection)
			{
				if (item.Success)
				{
					ScriptArray scriptArray2 = new ScriptArray();
					for (int i = 0; i < item.Groups.Count; i++)
					{
						Group obj = item.Groups[i];
						scriptArray2.Add(obj.Value);
					}
					scriptArray.Add(scriptArray2);
				}
			}
			return scriptArray;
		}

		public static string Replace(TemplateContext context, string text, string pattern, string replace, string? options = null)
		{
			return Regex.Replace(text, pattern, replace, GetOptions(options), context.RegexTimeOut);
		}

		public static ScriptArray Split(TemplateContext context, string text, string pattern, string? options = null)
		{
			return new ScriptArray(Regex.Split(text, pattern, GetOptions(options), context.RegexTimeOut));
		}

		public static string Unescape(string pattern)
		{
			return Regex.Unescape(pattern);
		}

		private static RegexOptions GetOptions(string? options)
		{
			if (options == null)
			{
				return RegexOptions.None;
			}
			RegexOptions regexOptions = RegexOptions.None;
			for (int i = 0; i < options.Length; i++)
			{
				switch (options[i])
				{
				case 'i':
					regexOptions |= RegexOptions.IgnoreCase;
					break;
				case 'm':
					regexOptions |= RegexOptions.Multiline;
					break;
				case 's':
					regexOptions |= RegexOptions.Singleline;
					break;
				case 'x':
					regexOptions |= RegexOptions.IgnorePatternWhitespace;
					break;
				}
			}
			return regexOptions;
		}
	}
	public class StringFunctions : ScriptObject
	{
		[ThreadStatic]
		private static StringBuilder? _tlsBuilder;

		private static StringBuilder GetTempStringBuilder()
		{
			StringBuilder stringBuilder = _tlsBuilder;
			if (stringBuilder == null)
			{
				stringBuilder = (_tlsBuilder = new StringBuilder(1024));
			}
			return stringBuilder;
		}

		private static void ReleaseBuilder(StringBuilder builder)
		{
			builder.Length = 0;
		}

		public static string? Escape(string? text)
		{
			if (text == null)
			{
				return text;
			}
			StringBuilder stringBuilder = null;
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (c < ' ' || c == '"' || c == '\\')
				{
					string value = c switch
					{
						'"' => "\\\"", 
						'\\' => "\\\\", 
						'\a' => "\\a", 
						'\b' => "\\b", 
						'\t' => "\\t", 
						'\r' => "\\r", 
						'\v' => "\\v", 
						'\f' => "\\f", 
						'\n' => "\\n", 
						_ => $"\\x{(int)c:x2}", 
					};
					if (stringBuilder == null)
					{
						stringBuilder = new StringBuilder(text.Length + 10);
						if (i > 0)
						{
							stringBuilder.Append(text, 0, i);
						}
					}
					stringBuilder.Append(value);
				}
				else
				{
					stringBuilder?.Append(c);
				}
			}
			if (stringBuilder == null)
			{
				return text;
			}
			return stringBuilder.ToString();
		}

		[ScriptMemberIgnore]
		public static string Append(string? text, string? with)
		{
			return (text ?? string.Empty) + (with ?? string.Empty);
		}

		public static string Append(TemplateContext context, string? text, string? with)
		{
			string text2 = text ?? string.Empty;
			string text3 = with ?? string.Empty;
			VerifyResultStringLength(context, (long)text2.Length + (long)text3.Length);
			return text2 + text3;
		}

		public static string Capitalize(string? text)
		{
			if (text == null || string.IsNullOrEmpty(text) || char.IsUpper(text[0]))
			{
				return text ?? string.Empty;
			}
			StringBuilder tempStringBuilder = GetTempStringBuilder();
			tempStringBuilder.Append(char.ToUpper(text[0]));
			if (text.Length > 1)
			{
				tempStringBuilder.Append(text, 1, text.Length - 1);
			}
			string result = tempStringBuilder.ToString();
			ReleaseBuilder(tempStringBuilder);
			return result;
		}

		public static string Capitalizewords(string? text)
		{
			if (text == null || text.Length == 0)
			{
				return string.Empty;
			}
			StringBuilder tempStringBuilder = GetTempStringBuilder();
			bool flag = true;
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (char.IsWhiteSpace(c))
				{
					flag = true;
				}
				else if (flag && char.IsLetter(c))
				{
					c = char.ToUpper(c);
					flag = false;
				}
				tempStringBuilder.Append(c);
			}
			string result = tempStringBuilder.ToString();
			ReleaseBuilder(tempStringBuilder);
			return result;
		}

		public static bool Contains(string? text, string? value)
		{
			if (text == null || text.Length == 0 || value == null || value.Length == 0)
			{
				return false;
			}
			return text.Contains(value);
		}

		public static bool Empty(string? text)
		{
			return string.IsNullOrEmpty(text);
		}

		public static bool Whitespace(string? text)
		{
			return string.IsNullOrWhiteSpace(text);
		}

		public static string? Downcase(string? text)
		{
			return text?.ToLowerInvariant();
		}

		public static bool EndsWith(string? text, string? value)
		{
			if (value == null || value.Length == 0 || text == null || text.Length == 0)
			{
				return false;
			}
			return text.EndsWith(value);
		}

		public static bool EqualsIgnoreCase(string? text, string? value)
		{
			return text?.Equals(value, StringComparison.InvariantCultureIgnoreCase) ?? false;
		}

		public static string Handleize(string text)
		{
			StringBuilder tempStringBuilder = GetTempStringBuilder();
			char c = '\0';
			foreach (char c2 in text)
			{
				if (char.IsLetterOrDigit(c2))
				{
					c = c2;
					tempStringBuilder.Append(char.ToLowerInvariant(c2));
				}
				else if (c != '-')
				{
					tempStringBuilder.Append('-');
					c = '-';
				}
			}
			if (tempStringBuilder.Length > 0 && tempStringBuilder[tempStringBuilder.Length - 1] == '-')
			{
				tempStringBuilder.Length--;
			}
			string result = tempStringBuilder.ToString();
			ReleaseBuilder(tempStringBuilder);
			return result;
		}

		public static string? Literal(string? text)
		{
			if (text != null)
			{
				return "\"" + Escape(text) + "\"";
			}
			return null;
		}

		public static string? LStrip(string? text)
		{
			return text?.TrimStart(Array.Empty<char>());
		}

		public static string Pluralize(int number, string singular, string plural)
		{
			if (number != 1)
			{
				return plural;
			}
			return singular;
		}

		[ScriptMemberIgnore]
		public static string Prepend(string? text, string? by)
		{
			return (by ?? string.Empty) + (text ?? string.Empty);
		}

		public static string Prepend(TemplateContext context, string? text, string? by)
		{
			string text2 = text ?? string.Empty;
			string text3 = by ?? string.Empty;
			VerifyResultStringLength(context, (long)text3.Length + (long)text2.Length);
			return text3 + text2;
		}

		public static string? Remove(string? text, string? remove)
		{
			if (text == null || text.Length == 0 || remove == null || remove.Length == 0)
			{
				return text;
			}
			return text.Replace(remove, string.Empty);
		}

		public static string? RemoveFirst(string? text, string? remove)
		{
			if (text == null || text.Length == 0 || remove == null || remove.Length == 0)
			{
				return text;
			}
			return ReplaceFirst(text, remove, string.Empty);
		}

		public static string? RemoveLast(string? text, string? remove)
		{
			if (text == null || text.Length == 0 || remove == null || remove.Length == 0)
			{
				return text;
			}
			return ReplaceFirst(text, remove, string.Empty, fromEnd: true);
		}

		[ScriptMemberIgnore]
		public static string Replace(string? text, string? match, string? replace)
		{
			if (text == null || text.Length == 0)
			{
				return string.Empty;
			}
			match = match ?? string.Empty;
			replace = replace ?? string.Empty;
			return text.Replace(match, replace);
		}

		public static string Replace(TemplateContext context, string? text, string? match, string? replace)
		{
			string text2 = Replace(text, match, replace);
			VerifyResultStringLength(context, text2.Length);
			return text2;
		}

		[ScriptMemberIgnore]
		public static string ReplaceFirst(string? text, string? match, string? replace, bool fromEnd = false)
		{
			if (text == null || text.Length == 0)
			{
				return string.Empty;
			}
			if (match == null || match.Length == 0)
			{
				return text;
			}
			string value = replace ?? string.Empty;
			int num = (fromEnd ? text.LastIndexOf(match, StringComparison.OrdinalIgnoreCase) : text.IndexOf(match, StringComparison.OrdinalIgnoreCase));
			if (num < 0)
			{
				return text;
			}
			StringBuilder tempStringBuilder = GetTempStringBuilder();
			tempStringBuilder.Append(text.Substring(0, num));
			tempStringBuilder.Append(value);
			tempStringBuilder.Append(text.Substring(num + match.Length));
			string result = tempStringBuilder.ToString();
			ReleaseBuilder(tempStringBuilder);
			return result;
		}

		public static string ReplaceFirst(TemplateContext context, string? text, string? match, string? replace, bool fromEnd = false)
		{
			string text2 = ReplaceFirst(text, match, replace, fromEnd);
			VerifyResultStringLength(context, text2.Length);
			return text2;
		}

		public static string? RStrip(string? text)
		{
			return text?.TrimEnd(Array.Empty<char>());
		}

		public static int Size(string? text)
		{
			return text?.Length ?? 0;
		}

		public static string Slice(string? text, int start, int? length = null)
		{
			if (text == null || text.Length == 0 || start >= text.Length)
			{
				return string.Empty;
			}
			if (start < 0)
			{
				start += text.Length;
			}
			if (!length.HasValue)
			{
				length = text.Length;
			}
			if (start < 0)
			{
				if (start + length <= 0)
				{
					return string.Empty;
				}
				length += start;
				start = 0;
			}
			if (start + length > text.Length)
			{
				length = text.Length - start;
			}
			return text.Substring(start, length.Value);
		}

		public static string Slice1(string? text, int start, int length = 1)
		{
			if (text == null || text.Length == 0 || start > text.Length || length <= 0)
			{
				return string.Empty;
			}
			if (start < 0)
			{
				start += text.Length;
			}
			if (start < 0)
			{
				length += start;
				start = 0;
			}
			if (start + length > text.Length)
			{
				length = text.Length - start;
			}
			return text.Substring(start, length);
		}

		public static IEnumerable Split(string? text, string? match)
		{
			if (text == null || text.Length == 0)
			{
				return new ScriptRange(Enumerable.Empty<string>());
			}
			if (match == null || match.Length == 0)
			{
				return new ScriptRange(new string[1] { text });
			}
			return new ScriptRange(text.Split(new string[1] { match }, StringSplitOptions.RemoveEmptyEntries));
		}

		public static bool StartsWith(string? text, string? value)
		{
			if (value == null || value.Length == 0 || text == null || text.Length == 0)
			{
				return false;
			}
			return text.StartsWith(value);
		}

		public static string? Strip(string? text)
		{
			return text?.Trim();
		}

		public static string StripNewlines(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			return Regex.Replace(text, "\\r\\n|\\r|\\n", string.Empty);
		}

		public static object? ToInt(TemplateContext context, string? text)
		{
			if (!int.TryParse(text, NumberStyles.Integer, context.CurrentCulture, out var result))
			{
				return null;
			}
			return result;
		}

		public static object? ToLong(TemplateContext context, string? text)
		{
			if (!long.TryParse(text, NumberStyles.Integer, context.CurrentCulture, out var result))
			{
				return null;
			}
			return result;
		}

		public static object? ToFloat(TemplateContext context, string? text)
		{
			if (!float.TryParse(text, NumberStyles.Float | NumberStyles.AllowThousands, context.CurrentCulture, out var result))
			{
				return null;
			}
			return result;
		}

		public static object? ToDouble(TemplateContext context, string? text)
		{
			if (!double.TryParse(text, NumberStyles.Float | NumberStyles.AllowThousands, context.CurrentCulture, out var result))
			{
				return null;
			}
			return result;
		}

		public static string Truncate(string? text, int length, string? ellipsis = null)
		{
			ellipsis = ellipsis ?? "...";
			if (text == null || text.Length == 0)
			{
				return string.Empty;
			}
			int num = length - ellipsis.Length;
			if (text.Length > length)
			{
				StringBuilder tempStringBuilder = GetTempStringBuilder();
				tempStringBuilder.Append(text, 0, (num >= 0) ? num : 0);
				tempStringBuilder.Append(ellipsis);
				text = tempStringBuilder.ToString();
				ReleaseBuilder(tempStringBuilder);
			}
			return text;
		}

		public static string Truncatewords(string? text, int count, string? ellipsis = null)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			StringBuilder tempStringBuilder = GetTempStringBuilder();
			bool flag = true;
			string[] array = Regex.Split(text, "\\s+");
			foreach (string value in array)
			{
				if (count <= 0)
				{
					break;
				}
				if (!flag)
				{
					tempStringBuilder.Append(' ');
				}
				tempStringBuilder.Append(value);
				flag = false;
				count--;
			}
			tempStringBuilder.Append("...");
			string result = tempStringBuilder.ToString();
			ReleaseBuilder(tempStringBuilder);
			return result;
		}

		public static string? Upcase(string? text)
		{
			return text?.ToUpperInvariant();
		}

		public static string Md5(string? text)
		{
			text = text ?? string.Empty;
			using MD5 algo = MD5.Create();
			return Hash(algo, text);
		}

		public static string Sha1(string? text)
		{
			using SHA1 algo = SHA1.Create();
			return Hash(algo, text);
		}

		public static string Sha256(string? text)
		{
			using SHA256 algo = SHA256.Create();
			return Hash(algo, text);
		}

		public static string Sha512(string? text)
		{
			using SHA512 algo = SHA512.Create();
			return Hash(algo, text);
		}

		public static string HmacSha1(string? text, string? secretKey)
		{
			using HMACSHA1 algo = new HMACSHA1(Encoding.UTF8.GetBytes(secretKey ?? string.Empty));
			return Hash(algo, text);
		}

		public static string HmacSha256(string? text, string? secretKey)
		{
			using HMACSHA256 algo = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey ?? string.Empty));
			return Hash(algo, text);
		}

		public static string HmacSha512(string? text, string? secretKey)
		{
			using HMACSHA512 algo = new HMACSHA512(Encoding.UTF8.GetBytes(secretKey ?? string.Empty));
			return Hash(algo, text);
		}

		private static string Hash(HashAlgorithm algo, string? text)
		{
			text = text ?? string.Empty;
			byte[] bytes = Encoding.UTF8.GetBytes(text);
			byte[] array = algo.ComputeHash(bytes);
			StringBuilder tempStringBuilder = GetTempStringBuilder();
			foreach (byte b in array)
			{
				tempStringBuilder.Append(b.ToString("x2"));
			}
			string result = tempStringBuilder.ToString();
			ReleaseBuilder(tempStringBuilder);
			return result;
		}

		[ScriptMemberIgnore]
		public static string PadLeft(string? text, int width)
		{
			return (text ?? string.Empty).PadLeft(width);
		}

		public static string PadLeft(TemplateContext context, string? text, int width)
		{
			VerifyPaddingWidth(context, width);
			return PadLeft(text, width);
		}

		[ScriptMemberIgnore]
		public static string PadRight(string? text, int width)
		{
			return (text ?? string.Empty).PadRight(width);
		}

		public static string PadRight(TemplateContext context, string? text, int width)
		{
			VerifyPaddingWidth(context, width);
			return PadRight(text, width);
		}

		private static void VerifyPaddingWidth(TemplateContext context, int width)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			if (context.LimitToString > 0 && width > context.LimitToString)
			{
				throw new ArgumentOutOfRangeException("width", $"Padding width `{width}` exceeds the configured LimitToString `{context.LimitToString}`.");
			}
		}

		private static void VerifyResultStringLength(TemplateContext context, long length)
		{
			if (context == null)
			{
				throw new ArgumentNullException("context");
			}
			if (context.LimitToString > 0 && length > context.LimitToString)
			{
				throw new InvalidOperationException($"The resulting string length exceeds the configured LimitToString `{context.LimitToString}`.");
			}
		}

		public static string Base64Encode(string? text)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(text ?? string.Empty));
		}

		public static string Base64Decode(string? text)
		{
			byte[] bytes = Convert.FromBase64String(text ?? string.Empty);
			return Encoding.UTF8.GetString(bytes);
		}

		public static int IndexOf(string text, string search, int? startIndex = null, int? count = null, string? stringComparison = null)
		{
			text = text ?? throw new ArgumentNullException("text");
			search = search ?? throw new ArgumentNullException("search");
			StringComparison comparison = GetComparison(stringComparison, StringComparison.CurrentCulture, throwExceptions: true);
			int valueOrDefault = startIndex.GetValueOrDefault();
			int count2 = count ?? (text.Length - valueOrDefault);
			return text.IndexOf(search, valueOrDefault, count2, comparison);
		}

		private static StringComparison GetComparison(string? stringComparison, StringComparison defaultValue, bool throwExceptions)
		{
			(string, bool) tuple = (stringComparison, throwExceptions);
			if (tuple.Item1 == null)
			{
				return defaultValue;
			}
			if (!Enum.TryParse<StringComparison>(stringComparison, out var result))
			{
				if (tuple.Item2)
				{
					throw new ArgumentException("'" + stringComparison + "' is not a valid stringComparison", "stringComparison");
				}
				return defaultValue;
			}
			return result;
		}
	}
	public class TimeSpanFunctions : ScriptObject
	{
		public static TimeSpan Zero => TimeSpan.Zero;

		public static TimeSpan FromDays(double days)
		{
			return TimeSpan.FromDays(days);
		}

		public static TimeSpan FromHours(double hours)
		{
			return TimeSpan.FromHours(hours);
		}

		public static TimeSpan FromMinutes(double minutes)
		{
			return TimeSpan.FromMinutes(minutes);
		}

		public static TimeSpan FromSeconds(double seconds)
		{
			return TimeSpan.FromSeconds(seconds);
		}

		public static TimeSpan FromMilliseconds(double millis)
		{
			return TimeSpan.FromMilliseconds(millis);
		}

		public static TimeSpan Parse(string text)
		{
			return TimeSpan.Parse(text);
		}
	}
}