DefaultScripts.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using ServiceStack.Text;
using ServiceStack.Text.Json;

namespace ServiceStack.Script
{
    // ReSharper disable InconsistentNaming
    
    public partial class DefaultScripts : ScriptMethods, IConfigureScriptContext
    {
        public static readonly DefaultScripts Instance = new DefaultScripts();
        
        public static List<string> RemoveNewLinesFor { get; } = new List<string> {
            nameof(to),
            nameof(toGlobal),
            nameof(assignTo),
            nameof(assignToGlobal),
            nameof(assignError),
            nameof(addTo),
            nameof(addToGlobal),
            nameof(addToStart),
            nameof(addToStartGlobal),
            nameof(appendTo),
            nameof(appendToGlobal),
            nameof(prependTo),
            nameof(prependToGlobal),
            nameof(forEach),
            nameof(@do),
            nameof(end),
            nameof(@throw),
            nameof(ifThrow),
            nameof(throwIf),
            nameof(throwIf),
            nameof(ifThrowArgumentException),
            nameof(ifThrowArgumentNullException),
            nameof(throwArgumentNullExceptionIf),
            nameof(throwArgumentException),
            nameof(throwArgumentNullException),
            nameof(throwNotSupportedException),
            nameof(throwNotImplementedException),
            nameof(throwUnauthorizedAccessException),
            nameof(throwFileNotFoundException),
            nameof(throwOptimisticConcurrencyException),
            nameof(throwNotSupportedException),
            nameof(ifError),
            nameof(skipExecutingFiltersOnError),
            nameof(continueExecutingFiltersOnError),
        };
        
        public static List<string> EvaluateWhenSkippingFilterExecution = new List<string> {
            nameof(ifError),
            nameof(lastError),
        };

        public void Configure(ScriptContext context)
        {
            RemoveNewLinesFor.Each(name => context.RemoveNewLineAfterFiltersNamed.Add(name));
            EvaluateWhenSkippingFilterExecution.Each(name => context.OnlyEvaluateFiltersWhenSkippingPageFilterExecution.Add(name));
        }

        // methods without arguments can be used in bindings, e.g. {{ now |> dateFormat }}
        public DateTime now() => DateTime.Now;
        public DateTime utcNow() => DateTime.UtcNow;

        public DateTimeOffset nowOffset() => DateTimeOffset.Now;
        public DateTimeOffset utcNowOffset() => DateTimeOffset.UtcNow;

        public Guid nguid() => Guid.NewGuid();

        public DateTime addTicks(DateTime target, int count) => target.AddTicks(count);
        public DateTime addMilliseconds(DateTime target, int count) => target.AddMilliseconds(count);
        public DateTime addSeconds(DateTime target, int count) => target.AddSeconds(count);
        public DateTime addMinutes(DateTime target, int count) => target.AddMinutes(count);
        public DateTime addHours(DateTime target, int count) => target.AddHours(count);
        public DateTime addDays(DateTime target, int count) => target.AddDays(count);
        public DateTime addMonths(DateTime target, int count) => target.AddMonths(count);
        public DateTime addYears(DateTime target, int count) => target.AddYears(count);

        public List<object> itemsOf(int count, object target)
        {
            AssertWithinMaxQuota(count);
            var to = new List<object>();
            for (var i = 0; i < count; i++)
            {
                to.Add(target);
            }
            return to;
        }

        public List<int> times(int count) => AssertWithinMaxQuota(count).Times().ToList();
        public IEnumerable<int> range(int count) => Enumerable.Range(0, AssertWithinMaxQuota(count));
        public IEnumerable<int> range(int start, int count) => Enumerable.Range(start, AssertWithinMaxQuota(count));

        public bool isEven(int value) => value % 2 == 0;
        public bool isOdd(int value) => !isEven(value);

        public static bool isTrue(object target) => target is bool b && b;

        public static bool isTruthy(object target) => !isFalsy(target);
        public static bool isFalsy(object target)
        {
            if (target == null || target == JsNull.Value)
                return true;
            if (target is string s)
                return string.IsNullOrEmpty(s);
            if (target is bool b)
                return !b;
            if (target is int i)
                return i == 0;
            if (target is long l)
                return l == 0;
            if (target is double d)
                return d == 0 || double.IsNaN(d);

            return false;
        }

        public object iif(object test, object ifTrue, object ifFalse) => isTrue(test) ? ifTrue : ifFalse;
        public object when(object returnTarget, object test) => @if(returnTarget, test);     //alias

        public object ifNot(object returnTarget, object test) => !isTrue(test) ? returnTarget : StopExecution.Value;
        public object unless(object returnTarget, object test) => ifNot(returnTarget, test); //alias

        public object otherwise(object returnTarget, object elseReturn) => returnTarget ?? elseReturn;
        
        public object ifElse(object returnTarget, object test, object defaultValue) => test is bool b && b ? returnTarget : defaultValue;
        public object ifNotElse(object returnTarget, object test, object defaultValue) => !isTrue(test) ? returnTarget : defaultValue;
        public object unlessElse(object returnTarget, object test, object defaultValue) => ifNotElse(returnTarget, test, defaultValue); //alias

        public object ifFalsy(object returnTarget, object test) => isFalsy(test) ? returnTarget : StopExecution.Value;
        public object ifTruthy(object returnTarget, object test) => !isFalsy(test) ? returnTarget : StopExecution.Value;
        public object falsy(object test, object returnIfFalsy) => isFalsy(test) ? returnIfFalsy : null;
        public object truthy(object test, object returnIfTruthy) => !isFalsy(test) ? returnIfTruthy : null;

        public bool isNull(object test) => ViewUtils.IsNull(test);
        public bool isNotNull(object test) => !isNull(test);
        public bool exists(object test) => !isNull(test);

        public bool isZero(double value) => value.Equals(0d);
        public bool isPositive(double value) => value > 0;
        public bool isNegative(double value) => value < 0;
        public bool isNaN(double value) => double.IsNaN(value);
        public bool isInfinity(double value) => double.IsInfinity(value);

        public object ifExists(object target) => target;
        public object ifExists(object returnTarget, object test) => !isNull(test) ? returnTarget : StopExecution.Value;
        public object ifNotExists(object returnTarget, object test) => isNull(test) ? returnTarget : StopExecution.Value;
        public object ifNo(object returnTarget, object target) => target == null ? returnTarget : StopExecution.Value;
        public object ifNotEmpty(object target) => isEmpty(target) ? StopExecution.Value : target;
        public object ifNotEmpty(object returnTarget, object test) => isEmpty(test) ? StopExecution.Value : returnTarget;
        public object ifEmpty(object returnTarget, object test) => isEmpty(test) ? returnTarget : StopExecution.Value;
        public object ifTrue(object returnTarget, object test) => isTrue(test) ? returnTarget : StopExecution.Value;
        public object ifFalse(object returnTarget, object test) => !isTrue(test) ? returnTarget : StopExecution.Value;

        public bool isEmpty(object target)
        {
            if (isNull(target))
                return true;

            if (target is string s)
                return s == string.Empty;

            if (target is IEnumerable e)
                return !e.GetEnumerator().MoveNext();

            return false;
        }

        public bool IsNullOrWhiteSpace(object target) => target == null || target is string s && string.IsNullOrWhiteSpace(s);
        
        public bool isEnum(Enum source, object value) => value is string strEnum
            ? Equals(source, Enum.Parse(source.GetType(), strEnum, ignoreCase: true))
            : value is Enum enumValue
                ? Equals(source, enumValue)
                : Equals(source, Enum.ToObject(source.GetType(), value));

        public bool hasFlag(Enum source, object value) => value is string strEnum
            ? source.HasFlag((Enum) Enum.Parse(source.GetType(), strEnum, ignoreCase: true))
            : value is Enum enumValue
                ? source.HasFlag(enumValue)
                : source.HasFlag((Enum) Enum.ToObject(source.GetType(), value));

        public StopExecution end() => StopExecution.Value;
        public Task end(ScriptScopeContext scope, object ignore) => TypeConstants.EmptyTask;
        public StopExecution end(object ignore) => StopExecution.Value;

        public object endIfNull(object target) => isNull(target) ? StopExecution.Value : target;
        public object endIfNull(object ignoreTarget, object target) => isNull(target) ? StopExecution.Value : target;
        public object endIfNotNull(object target) => !isNull(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIfNotNull(object ignoreTarget, object target) => !isNull(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIfExists(object target) => !isNull(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIfExists(object ignoreTarget, object target) => !isNull(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIfEmpty(object target) => isEmpty(target) ? StopExecution.Value : target;
        public object endIfEmpty(object ignoreTarget, object target) => isEmpty(target) ? StopExecution.Value : target;
        public object endIfNotEmpty(object target) => !isEmpty(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIfNotEmpty(object ignoreTarget, object target) => !isEmpty(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIfFalsy(object target) => isFalsy(target) ? (object) StopExecution.Value : target;
        public object endIfFalsy(object ignoreTarget, object target) => isFalsy(target) ? (object) StopExecution.Value : target;
        public object endIfTruthy(object target) => !isFalsy(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIfTruthy(object ignoreTarget, object target) => !isFalsy(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object endIf(object test) => isTrue(test) ? (object)StopExecution.Value : IgnoreResult.Value;

        public object endIf(object returnTarget, bool test) => test ? StopExecution.Value : returnTarget;
        public object endIfAny(ScriptScopeContext scope, object target, object expression) => any(scope, target, expression) ? StopExecution.Value : target;
        public object endIfAll(ScriptScopeContext scope, object target, object expression) => all(scope, target, expression) ? StopExecution.Value : target;
        public object endWhere(ScriptScopeContext scope, object target, object expression) => endWhere(scope, target, expression, null);

        public object endWhere(ScriptScopeContext scope, object target, object expression, object scopeOptions)
        {
            var literal = scope.AssertExpression(nameof(count), expression);
            var scopedParams = scope.GetParamsWithItemBinding(nameof(count), scopeOptions, out string itemBinding);

            var expr = literal.GetCachedJsExpression(scope);
            scope = scope.Clone();
            scope.AddItemToScope(itemBinding, target);
            var result = expr.EvaluateToBool(scope);

            return result
                ? StopExecution.Value
                : target;
        }
        
        public object ifEnd(bool test) => test ? (object)StopExecution.Value : IgnoreResult.Value;
        public object ifEnd(object ignoreTarget, bool test) => test ? (object)StopExecution.Value : IgnoreResult.Value;
        public object ifNotEnd(bool test) => !test ? (object)StopExecution.Value : IgnoreResult.Value;
        public object ifNotEnd(object ignoreTarget, bool test) => !test ? (object)StopExecution.Value : IgnoreResult.Value;
        
        public object onlyIfNull(object target) => !isNull(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object onlyIfNull(object ignoreTarget, object target) => !isNull(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object onlyIfNotNull(object target) => isNull(target) ? StopExecution.Value : target;
        public object onlyIfNotNull(object ignoreTarget, object target) => isNull(target) ? StopExecution.Value : target;
        public object onlyIfExists(object target) => isNull(target) ? (object) StopExecution.Value : target;
        public object onlyIfExists(object ignoreTarget, object target) => isNull(target) ? (object) StopExecution.Value : target;
        public object onlyIfEmpty(object target) => !isEmpty(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object onlyIfEmpty(object ignoreTarget, object target) => !isEmpty(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object onlyIfNotEmpty(object target) => isEmpty(target) ? (object) StopExecution.Value : target;
        public object onlyIfNotEmpty(object ignoreTarget, object target) => isEmpty(target) ? (object) StopExecution.Value : target;
        public object onlyIfFalsy(object target) => !isFalsy(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object onlyIfFalsy(object ignoreTarget, object target) => !isFalsy(target) ? (object) StopExecution.Value : IgnoreResult.Value;
        public object onlyIfTruthy(object target) => isFalsy(target) ? (object) StopExecution.Value : target;
        public object onlyIfTruthy(object ignoreTarget, object target) => isFalsy(target) ? (object) StopExecution.Value : target;
        public object onlyIf(object test) => !isTrue(test) ? (object)StopExecution.Value : IgnoreResult.Value;

        public object onlyIf(object returnTarget, bool test) => !test ? StopExecution.Value : returnTarget;
        public object onlyIfAny(ScriptScopeContext scope, object target, object expression) => !any(scope, target, expression) ? StopExecution.Value : target;
        public object onlyIfAll(ScriptScopeContext scope, object target, object expression) => !all(scope, target, expression) ? StopExecution.Value : target;
        public object onlyWhere(ScriptScopeContext scope, object target, object expression) => onlyWhere(scope, target, expression, null);

        public object onlyIfDebug(object returnTarget) => !Context.DebugMode ? StopExecution.Value : returnTarget;
        public object endIfDebug(object returnTarget) => Context.DebugMode ? StopExecution.Value : returnTarget;

        public object onlyWhere(ScriptScopeContext scope, object target, object expression, object scopeOptions)
        {
            var literal = scope.AssertExpression(nameof(count), expression);
            var scopedParams = scope.GetParamsWithItemBinding(nameof(count), scopeOptions, out string itemBinding);

            var expr = literal.GetCachedJsExpression(scope);
            scope = scope.Clone();
            scope.AddItemToScope(itemBinding, target);
            var result = expr.EvaluateToBool(scope);

            return result
                ? target
                : StopExecution.Value;
        }
        
        public object ifOnly(bool test) => !test ? (object)StopExecution.Value : IgnoreResult.Value;
        public object ifOnly(object ignoreTarget, bool test) => !test ? (object)StopExecution.Value : IgnoreResult.Value;
        public object ifNotOnly(bool test) => test ? (object)StopExecution.Value : IgnoreResult.Value;
        public object ifNotOnly(object ignoreTarget, bool test) => test ? (object)StopExecution.Value : IgnoreResult.Value;


        public object ifDo(object test) => isTrue(test) ? (object)IgnoreResult.Value : StopExecution.Value;
        public object ifDo(object ignoreTarget, object test) => isTrue(test) ? (object)IgnoreResult.Value : StopExecution.Value;
        public object doIf(object test) => isTrue(test) ? (object)IgnoreResult.Value : StopExecution.Value;
        public object doIf(object ignoreTarget, object test) => isTrue(test) ? (object)IgnoreResult.Value : StopExecution.Value;

        public object ifUse(object test, object useValue) => isTrue(test) ? useValue : StopExecution.Value;
        public object ifShow(object test, object useValue) => isTrue(test) ? useValue : StopExecution.Value;
        public object ifShowRaw(object test, object useValue) => isTrue(test) ? (object) raw(useValue) : StopExecution.Value;

        public object useIf(object useValue, object test) => isTrue(test) ? useValue : StopExecution.Value;
        public object showIf(object useValue, object test) => isTrue(test) ? useValue : StopExecution.Value;
        public object showIfExists(object useValue, object test) => !isNull(test) ? useValue : StopExecution.Value;

        public object use(object ignoreTarget, object useValue) => useValue;
        public object show(object ignoreTarget, object useValue) => useValue;
        public IRawString showRaw(object ignoreTarget, string content) => content.ToRawString();

        public object useFmt(object ignoreTarget, string format, object arg) => fmt(format, arg);
        public object useFmt(object ignoreTarget, string format, object arg1, object arg2) => fmt(format, arg1, arg2);
        public object useFmt(object ignoreTarget, string format, object arg1, object arg2, object arg3) => fmt(format, arg1, arg2, arg3);
        public object useFormat(object ignoreTarget, object arg, string fmt) => format(arg, fmt);

        public object showFmt(object ignoreTarget, string format, object arg) => fmt(format, arg);
        public object showFmt(object ignoreTarget, string format, object arg1, object arg2) => fmt(format, arg1, arg2);
        public object showFmt(object ignoreTarget, string format, object arg1, object arg2, object arg3) => fmt(format, arg1, arg2, arg3);
        public object showFormat(object ignoreTarget, object arg, string fmt) => format(arg, fmt);

        public IRawString showFmtRaw(object ignoreTarget, string format, object arg) => raw(fmt(format, arg));
        public IRawString showFmtRaw(object ignoreTarget, string format, object arg1, object arg2) => raw(fmt(format, arg1, arg2));
        public IRawString showFmtRaw(object ignoreTarget, string format, object arg1, object arg2, object arg3) => raw(fmt(format, arg1, arg2, arg3));

        public bool isString(object target) => target is string;
        public bool isInt(object target) => target is int;
        public bool isLong(object target) => target is long;
        public bool isInteger(object target) => target?.GetType()?.IsIntegerType() == true;
        public bool isDouble(object target) => target is double;
        public bool isFloat(object target) => target is float;
        public bool isDecimal(object target) => target is decimal;
        public bool isBool(object target) => target is bool;
        public bool isList(object target) => target is IEnumerable && !(target is IDictionary) && !(target is string);
        public bool isEnumerable(object target) => target is IEnumerable;
        public bool isDictionary(object target) => target is IDictionary;
        public bool isChar(object target) => target is char;
        public bool isChars(object target) => target is char[];
        public bool isByte(object target) => target is byte;
        public bool isBytes(object target) => target is byte[];
        public bool isObjectDictionary(object target) => target is IDictionary<string, object>;
        public bool isStringDictionary(object target) => target is IDictionary<string, string>;

        public bool isType(object target, string typeName) => typeName.EqualsIgnoreCase(target?.GetType()?.Name);
        public bool isNumber(object target) => target?.GetType().IsNumericType() == true;
        public bool isRealNumber(object target) => target?.GetType().IsRealNumberType() == true;
        public bool isEnum(object target) => target?.GetType().IsEnum == true;
        public bool isArray(object target) => target?.GetType().IsArray == true;
        public bool isAnonObject(object target) => target?.GetType().IsAnonymousType() == true;
        public bool isClass(object target) => target?.GetType().IsClass == true;
        public bool isValueType(object target) => target?.GetType().IsValueType == true;
        public bool isDto(object target) => target?.GetType().IsDto() == true;
        public bool isTuple(object target) => target?.GetType().IsTuple() == true;
        public bool isKeyValuePair(object target) => "KeyValuePair`2".Equals(target?.GetType().Name);

        public bool instanceOf(object target, object type)
        {
            if (target == null || type == null)
                return target == type;
            
            Type t = null;
            if (type is string typeName)
            {
                var protectedScripts = Context.ProtectedMethods;
                if (protectedScripts != null)
                    t = protectedScripts.assertTypeOf(typeName);
                else
                    return target.GetType().Name == typeName;
            }
            if (t == null)
            {
                t = type as Type
                    ?? throw new NotSupportedException($"{nameof(instanceOf)} expects Type or Type Name but was {type.GetType().Name}");
            }

            return t.IsInstanceOfType(target);
        }

        public int length(object target) => target is IEnumerable e ? e.Cast<object>().Count() : 0;

        public bool hasMinCount(object target, int minCount) => target is IEnumerable e && e.Cast<object>().Count() >= minCount;
        public bool hasMaxCount(object target, int maxCount) => target is IEnumerable e && e.Cast<object>().Count() <= maxCount;

        public bool OR(object lhs, object rhs) => isTrue(lhs) || isTrue(rhs);
        public bool AND(object lhs, object rhs) => isTrue(lhs) && isTrue(rhs);

        public bool equals(object target, object other) =>
            target == null || other == null
                ? target == other
                : target.GetType() == other.GetType()
                    ? target.Equals(other)
                    : target.Equals(other.ConvertTo(target.GetType()));

        public bool notEquals(object target, object other) => !equals(target, other);

        public bool greaterThan(object target, object other) => compareTo(target, other, i => i > 0);
        public bool greaterThanEqual(object target, object other) => compareTo(target, other, i => i >= 0);
        public bool lessThan(object target, object other) => compareTo(target, other, i => i < 0);
        public bool lessThanEqual(object target, object other) => compareTo(target, other, i => i <= 0);

        //aliases
        public bool not(bool target) => !target;
        public bool eq(object target, object other) => equals(target, other);
        public bool not(object target, object other) => notEquals(target, other);
        public bool gt(object target, object other) => greaterThan(target, other);
        public bool gte(object target, object other) => greaterThanEqual(target, other);
        public bool lt(object target, object other) => lessThan(target, other);
        public bool lte(object target, object other) => lessThanEqual(target, other);

        internal static bool compareTo(object target, object other, Func<int, bool> fn)
        {
            if (target == null || target == JsNull.Value)
                throw new ArgumentNullException(nameof(target));
            if (other == null)
                throw new ArgumentNullException(nameof(other));

            if (target is IComparable c)
            {
                return target.GetType() == other?.GetType()
                    ? fn(c.CompareTo(other))
                    : fn(c.CompareTo(other.ConvertTo(target.GetType())));
            }

            throw new NotSupportedException($"{target} is not IComparable");
        }

        public object echo(object value) => value;
        public IRawString pass(string target) => ("{{ " + target + " }}").ToRawString();

        public IEnumerable join(IEnumerable<object> values) => join(values, ",");
        public IEnumerable joinln(IEnumerable<object> values) => join(values, "\n");
        public IEnumerable join(IEnumerable<object> values, string delimiter) => values.Map(x => x.AsString()).Join(delimiter);

        public IEnumerable<object> reverse(ScriptScopeContext scope, IEnumerable<object> original) => original.Reverse();

        public KeyValuePair<string, object> keyValuePair(string key, object value) => new KeyValuePair<string, object>(key, value);

        public IgnoreResult prependTo(ScriptScopeContext scope, string value, object argExpr) =>
            prependToArgs(scope, nameof(prependTo), value, argExpr, scope.ScopedParams);

        public IgnoreResult prependToGlobal(ScriptScopeContext scope, string value, object argExpr) =>
            prependToArgs(scope, nameof(prependToGlobal), value, argExpr, scope.PageResult.Args);

        private IgnoreResult prependToArgs(ScriptScopeContext scope, string filterName, string value, object argExpr, Dictionary<string, object> args)
        {
            if (value == null)
                return IgnoreResult.Value;

            var varName = GetVarNameFromStringOrArrowExpression(filterName, argExpr);

            if (args.TryGetValue(varName, out object oString))
            {
                if (oString is string s)
                {
                    args[varName] = value + s;
                }
            }
            else
            {
                args[varName] = value;
            }
            
            return IgnoreResult.Value;
        }

        public IgnoreResult appendTo(ScriptScopeContext scope, string value, object argExpr) =>
            appendToArgs(scope, nameof(appendTo), value, argExpr, scope.ScopedParams);

        public IgnoreResult appendToGlobal(ScriptScopeContext scope, string value, object argExpr) =>
            appendToArgs(scope, nameof(appendToGlobal), value, argExpr, scope.PageResult.Args);

        private IgnoreResult appendToArgs(ScriptScopeContext scope, string filterName, string value, object argExpr, Dictionary<string,object> args)
        {
            if (value == null)
                return IgnoreResult.Value;

            var varName = GetVarNameFromStringOrArrowExpression(filterName, argExpr);

            if (args.TryGetValue(varName, out object oString))
            {
                if (oString is string s)
                {
                    args[varName] = s + value;
                }
            }
            else
            {
                args[varName] = value;
            }
            
            return IgnoreResult.Value;
        }

        public IgnoreResult addToStart(ScriptScopeContext scope, object value, object argExpr) =>
            addToStartArgs(scope, nameof(addToStart), value, argExpr, scope.ScopedParams);

        public IgnoreResult addToStartGlobal(ScriptScopeContext scope, object value, object argExpr) =>
            addToStartArgs(scope, nameof(addToStartGlobal), value, argExpr, scope.PageResult.Args);

        private IgnoreResult addToStartArgs(ScriptScopeContext scope, string filterName, object value, object argExpr, Dictionary<string,object> args)
        {
            if (value == null)
                return IgnoreResult.Value;

            var varName = GetVarNameFromStringOrArrowExpression(filterName, argExpr);

            if (args.TryGetValue(varName, out object collection))
            {
                if (collection is IList l)
                {
                    l.Insert(0, value);
                }                
                else if (collection is IEnumerable e && !(collection is string))
                {
                    var to = new List<object> { value };
                    foreach (var item in e)
                    {
                        to.Add(item);
                    }
                    args[varName] = to;
                }
                else throw new NotSupportedException(nameof(addToStart) + " can only add to an IEnumerable not a " + collection.GetType().Name);
            }
            else
            {
                if (value is IEnumerable && !(value is string))
                    args[varName] = value;
                else
                    args[varName] = new List<object> { value };
            }
            
            return IgnoreResult.Value;
        }

        public IgnoreResult addTo(ScriptScopeContext scope, object value, object argExpr) =>
            addToArgs(scope, nameof(addTo), value, argExpr, scope.ScopedParams);

        public IgnoreResult addToGlobal(ScriptScopeContext scope, object value, object argExpr) =>
            addToArgs(scope, nameof(addToGlobal), value, argExpr, scope.PageResult.Args);

        private IgnoreResult addToArgs(ScriptScopeContext scope, string filterName, object value, object argExprOrCollection, Dictionary<string, object> args)
        {
            if (value == null)
                return IgnoreResult.Value;

            var varName = GetVarNameFromStringOrArrowExpression(filterName, argExprOrCollection);
            if (args.TryGetValue(varName, out object collection))
            {
                if (TryAddToCollection(collection, value)) {}
                else if (collection is IEnumerable e && !(collection is string))
                {
                    var to = new List<object>();
                    foreach (var item in e)
                    {
                        to.Add(item);
                    }
                    if (value is IEnumerable eValues && !(value is string))
                    {
                        foreach (var item in eValues)
                        {
                            to.Add(item);
                        }
                    }
                    else
                    {
                        to.Add(value);
                    }
                    args[varName] = to;
                }
                else throw new NotSupportedException(filterName + " can only add to an IEnumerable not a " + collection.GetType().Name);
            }
            else
            {
                if (value is IEnumerable && !(value is string || value is IDictionary))
                    args[varName] = value;
                else
                    args[varName] = new List<object> { value };
            }
            
            return IgnoreResult.Value;
        }

        public object addItem(object collection, object value)
        {
            if (collection == null)
                return null;
            
            if (!TryAddToCollection(collection, value))
                throw new NotSupportedException($"{nameof(addItem)} can only add to an ICollection not a '{collection.GetType().Name}'");

            return collection;
        }

        /// <summary>
        /// Puts value in dictionary at key  
        /// </summary>
        /// <returns>value</returns>
        public object putItem(IDictionary dictionary, object key, object value)
        {
            if (dictionary == null)
                return null;

            dictionary[key] = value;

            return value;
        }

        private static bool TryAddToCollection(object collection, object value)
        {
            if (collection is IList l)
            {
                if (value is IEnumerable e && !(value is string || value is IDictionary))
                {
                    foreach (var item in e)
                    {
                        l.Add(item);
                    }
                }
                else
                {
                    l.Add(value);
                }
            }
            else if (collection is IDictionary d)
            {
                if (value is KeyValuePair<string, object> kvp)
                {
                    d[kvp.Key] = kvp.Value;
                }
                else if (value is IEnumerable<KeyValuePair<string, object>> kvps)
                {
                    foreach (var entry in kvps)
                    {
                        d[entry.Key] = entry.Value;
                    }
                }
                else if (value is IDictionary dValue)
                {
                    foreach (var key in dValue.Keys)
                    {
                        d[key] = dValue[key];
                    }
                }
            }
            else if (collection is NameValueCollection nvc)
            {
                if (value is KeyValuePair<string, object> kvp)
                {
                    nvc[kvp.Key] = kvp.Value?.ToString();
                }
                else if (value is IEnumerable<KeyValuePair<string, object>> kvps)
                {
                    foreach (var entry in kvps)
                    {
                        nvc[entry.Key] = entry.Value?.ToString();
                    }
                }
                else if (value is IDictionary dValue)
                {
                    foreach (string key in dValue.Keys)
                    {
                        nvc[key] = dValue[key]?.ToString();
                    }
                }
            }
            else return false;
            return true;
        }

        public object resolveArg(ScriptScopeContext scope, string name) => scope.GetValue(name);
        public object resolveGlobal(ScriptScopeContext scope, string name) => resolvePageArg(scope, name);
        public object resolvePageArg(ScriptScopeContext scope, string name) => scope.PageResult.Args.TryGetValue(name, out var value)
            ? value
            : null;
        public object resolveContextArg(ScriptScopeContext scope, string name) => scope.Context.Args.TryGetValue(name, out var value)
            ? value
            : null;
        
        public object assign(ScriptScopeContext scope, string argExpr, object value) =>
            assignArgs(scope, argExpr, value, scope.ScopedParams);

        public object assignGlobal(ScriptScopeContext scope, string argExpr, object value) =>
            assignArgs(scope, argExpr, value, scope.PageResult.Args);

        private object assignArgs(ScriptScopeContext scope, string argExpr, object value, Dictionary<string,object> args) //from filter
        {
            var targetEndPos = argExpr.IndexOfAny(new[] { '.', '[' });
            if (targetEndPos == -1)
            {
                args[argExpr] = value;
            }
            else
            {
                var targetName = argExpr.Substring(0, targetEndPos);
                if (!args.TryGetValue(targetName, out object target))
                    throw new NotSupportedException($"Cannot assign to non-existing '{targetName}' in {argExpr}");

                scope.InvokeAssignExpression(argExpr, target, value);
            }

            return value;
        }

        // Shorter Alias for assignTo:
        public IgnoreResult to(ScriptScopeContext scope, object value, object argExpr)
        {
            var varName = GetVarNameFromStringOrArrowExpression(nameof(to), argExpr);
            
            scope.ScopedParams[varName] = value;
            return IgnoreResult.Value;
        }
        
        public IgnoreResult assignTo(ScriptScopeContext scope, object value, object argExpr)
        {
            var varName = GetVarNameFromStringOrArrowExpression(nameof(assignTo), argExpr);
            
            scope.ScopedParams[varName] = value;
            return IgnoreResult.Value;
        }

        // Shorter Alias for assignToGlobal:
        public IgnoreResult toGlobal(ScriptScopeContext scope, object value, object argExpr)
        {
            var varName = GetVarNameFromStringOrArrowExpression(nameof(toGlobal), argExpr);
            
            scope.PageResult.Args[varName] = value;
            return IgnoreResult.Value;
        }

        public IgnoreResult assignToGlobal(ScriptScopeContext scope, object value, object argExpr)
        {
            var varName = GetVarNameFromStringOrArrowExpression(nameof(assignToGlobal), argExpr);
            
            scope.PageResult.Args[varName] = value;
            return IgnoreResult.Value;
        }

        // Shorter Alias for assignTo:
        public Task to(ScriptScopeContext scope, object argExpr) =>
            assignToArgs(scope, nameof(to), argExpr, scope.ScopedParams);

        public Task assignTo(ScriptScopeContext scope, object argExpr) =>
            assignToArgs(scope, nameof(assignTo), argExpr, scope.ScopedParams);

        // Shorter Alias for assignToGlobal:
        public Task toGlobal(ScriptScopeContext scope, object argExpr) =>
            assignToArgs(scope, nameof(toGlobal), argExpr, scope.PageResult.Args);

        public Task assignToGlobal(ScriptScopeContext scope, object argExpr) =>
            assignToArgs(scope, nameof(assignToGlobal), argExpr, scope.PageResult.Args);

        private Task assignToArgs(ScriptScopeContext scope, string filterName, object argExpr, Dictionary<string, object> args) //from context filter
        {
            var varName = GetVarNameFromStringOrArrowExpression(nameof(assignToGlobal), argExpr);

            var ms = (MemoryStream)scope.OutputStream;
            var value = ms.ReadToEnd();
            scope.ScopedParams[varName] = value;
            ms.SetLength(0); //just capture output, don't write anything to the ResponseStream
            return TypeConstants.EmptyTask;
        }

        public static string GetVarNameFromStringOrArrowExpression(string filterName, object argExpr)
        {
            if (argExpr == null)
                throw new ArgumentNullException(filterName);
            
            if (argExpr is JsArrowFunctionExpression arrowExpr)
            {
                if (!(arrowExpr.Body is JsIdentifier identifier))
                    throw new NotSupportedException($"{filterName} expression must return an identifer");

                return identifier.Name;
            }

            if (argExpr is string varName)
                return varName;

            throw new NotSupportedException($"{filterName} requires a string or expression identifier but was instead '{argExpr.GetType().Name}'");
        }

        public Task buffer(ScriptScopeContext scope, object target)
        {
            var ms = (MemoryStream)scope.OutputStream;
            return TypeConstants.EmptyTask;
        }

        public Task partial(ScriptScopeContext scope, object target) => partial(scope, target, null);
        public async Task partial(ScriptScopeContext scope, object target, object scopedParams)
        {
            var pageName = target.ToString();
            var pageParams = scope.AssertOptions(nameof(partial), scopedParams);

            if (!scope.TryGetPage(pageName, out var page, out var codePage))
            {
                //Allow partials starting with '_{name}-partial' to be referenced without boilerplate
                if (pageName[0] != '_')
                {
                    if (!scope.TryGetPage('_' + pageName + "-partial", out page, out codePage))
                        throw new FileNotFoundException($"Partial was not found: '{pageName}'");            
                }
            }
            
            if (page != null)
                await page.Init();

            if (page is SharpPartialPage) // make partial block args available in scope
            {
                foreach (var pageArg in page.Args)
                {
                    pageParams[pageArg.Key] = pageArg.Value;
                }
            }

            pageParams[ScriptConstants.It] = pageParams;
            pageParams[ScriptConstants.PartialArg] = page;

            await scope.WritePageAsync(page, codePage, pageParams);
        }

        public Task selectEach(ScriptScopeContext scope, object target, object items) => selectEach(scope, target, items, null);
        public async Task selectEach(ScriptScopeContext scope, object target, object items, object scopeOptions)
        {
            if (items is IEnumerable objs)
            {
                var scopedParams = scope.GetParamsWithItemBinding(nameof(select), scopeOptions, out string itemBinding);

                var i = 0;
                var itemScope = scope.CreateScopedContext(target.ToString(), scopedParams);
                foreach (var item in objs)
                {
                    itemScope.AddItemToScope(itemBinding, item, i++);
                    await itemScope.WritePageAsync();
                }
            }
            else if (items != null)
            {
                throw new ArgumentException($"{nameof(selectEach)} in '{scope.Page.VirtualPath}' requires an IEnumerable, but received a '{items.GetType().Name}' instead");
            }
        }

        public string toString(object target) => target?.ToString();
        public string asString(object target) => target.AsString();
        public List<object> toList(IEnumerable target) => target.Map(x => x);
        public List<string> toStringList(IEnumerable target) => ViewUtils.ToStringList(target);
        public object[] toArray(IEnumerable target) => target.Map(x => x).ToArray();

        public char fromCharCode(int charCode) => Convert.ToChar(charCode);
        public char toChar(object target) => target is string s && s.Length == 1 ? s[0] : target.ConvertTo<char>();
        public char[] toChars(object target) => target is string s
            ? s.ToCharArray()
            : target is IEnumerable<object> objects
                ? objects.Where(x => x != null).Select(x => x.ToString()[0]).ToArray()
                : target.ConvertTo<char[]>();

        public int toCharCode(object target) => toChar(target);

        public byte[] toUtf8Bytes(string target) => target.ToUtf8Bytes();
        public string fromUtf8Bytes(byte[] target) => target.FromUtf8Bytes();

        public byte toByte(object target) => target.ConvertTo<byte>();
        public int toInt(object target) => target.ConvertTo<int>();
        public long toLong(object target) => target.ConvertTo<long>();
        public float toFloat(object target) => target.ConvertTo<float>();
        public double toDouble(object target) => target.ConvertTo<double>();
        public decimal toDecimal(object target) => target.ConvertTo<decimal>();
        public bool toBool(object target) => target.ConvertTo<bool>();
        public DateTime toDateTime(object target) => target.ConvertTo<DateTime>();
        public DateTime date(int year, int month, int day) => new DateTime(year, month, day);
        public DateTime date(int year, int month, int day, int hour, int min, int secs) => new DateTime(year, month, day, hour, min, secs);
        public TimeSpan toTimeSpan(object target) => target.ConvertTo<TimeSpan>();
        public TimeSpan time(int hours, int mins, int secs) => new TimeSpan(0, hours, mins, secs);
        public TimeSpan time(int days, int hours, int mins, int secs) => new TimeSpan(days, hours, mins, secs);
        
        public KeyValuePair<string, object> pair(string key, object value) => new KeyValuePair<string, object>(key, value);

        public List<string> toKeys(object target)
        {
            if (target == null)
                return null;
            
            if (target is IDictionary<string, object> objDictionary)
                return objDictionary.Keys.ToList();
            if (target is IDictionary dictionary)
                return dictionary.Keys.Map(x => x.ToString());

            if (target is IEnumerable<KeyValuePair<string, object>> kvps)
            {
                var to = new List<string>();
                foreach (var kvp in kvps)
                {
                    to.Add(kvp.Key);
                }
                return to;
            }
            if (target is IEnumerable<KeyValuePair<string, string>> stringKvps)
            {
                var to = new List<string>();
                foreach (var kvp in stringKvps)
                {
                    to.Add(kvp.Key);
                }
                return to;
            }
            throw new NotSupportedException(nameof(toKeys) + " expects an IDictionary or List of KeyValuePairs but received: " + target.GetType().Name);
        }

        public List<object> toValues(object target)
        {
            if (target == null)
                return null;
            
            if (target is IDictionary<string, object> objDictionary)
                return objDictionary.Values.ToList();
            if (target is IDictionary dictionary)
                return dictionary.Values.Map(x => x);

            if (target is IEnumerable<KeyValuePair<string, object>> kvps)
            {
                var to = new List<object>();
                foreach (var kvp in kvps)
                {
                    to.Add(kvp.Value);
                }
                return to;
            }
            if (target is IEnumerable<KeyValuePair<string, string>> stringKvps)
            {
                var to = new List<object>();
                foreach (var kvp in stringKvps)
                {
                    to.Add(kvp.Value);
                }
                return to;
            }
            throw new NotSupportedException(nameof(toValues) + " expects an IDictionary or List of KeyValuePairs but received: " + target.GetType().Name);
        }

        public Dictionary<string, object> toObjectDictionary(object target) => target.ToObjectDictionary();
        public Dictionary<string, string> toStringDictionary(IDictionary map)
        {
            if (isNull(map))
                return null;

            var to = new Dictionary<string, string>();
            foreach (var key in map.Keys)
            {
                var value = map[key];
                to[key.ToString()] = value?.ToString();
            }
            return to;
        }
        
        public List<string> splitStringList(IEnumerable strings) => ViewUtils.SplitStringList(strings);

        public List<string> toVarNames(IEnumerable names) => ViewUtils.SplitStringList(names);

        public int AssertWithinMaxQuota(int value)
        {
            var maxQuota = Context.MaxQuota;
            if (value > maxQuota)
                throw new NotSupportedException($"{value} exceeds Max Quota of {maxQuota}. \nMaxQuota can be changed in `ScriptContext.MaxQuota`.");

            return value;
        }

        public Dictionary<object, object> toDictionary(ScriptScopeContext scope, object target, object expression) => toDictionary(scope, target, expression, null);
        public Dictionary<object, object> toDictionary(ScriptScopeContext scope, object target, object expression, object scopeOptions)
        {
            var items = target.AssertEnumerable(nameof(toDictionary));
            var token = scope.AssertExpression(nameof(map), expression, scopeOptions, out var itemBinding);

            scope = scope.Clone();
            return items.ToDictionary(item => token.Evaluate(scope.AddItemToScope(itemBinding, item)));
        }

        public IRawString typeName(object target) => (target?.GetType().Name ?? "null").ToRawString();
        public IRawString typeFullName(object target) => 
            (target != null ? Context.ProtectedMethods.typeQualifiedName(target.GetType()) : "null").ToRawString();

        public IEnumerable of(ScriptScopeContext scope, IEnumerable target, object scopeOptions)
        {
            var items = target.AssertEnumerable(nameof(of));
            var scopedParams = scope.GetParamsWithItemBinding(nameof(of), scopeOptions, out string itemBinding);

            if (scopedParams.TryGetValue("type", out object oType))
            {
                if (oType is string typeName)
                    return items.Where(x => x?.GetType()?.Name == typeName);
                if (oType is Type type)
                    return items.Where(x => x?.GetType() == type);
            }

            return items;
        }

        public object @do(ScriptScopeContext scope, object expression)
        {
            var token = scope.AssertExpression(nameof(@do), expression, scopeOptions:null, out var itemBinding);
            var result = token.Evaluate(scope);

            return IgnoreResult.Value;
        }

        public Task @do(ScriptScopeContext scope, object target, object expression) => @do(scope, target, expression, null);
        public Task @do(ScriptScopeContext scope, object target, object expression, object scopeOptions)
        {
            if (isNull(target) || target is bool b && !b)
                return TypeConstants.EmptyTask;

            var token = scope.AssertExpression(nameof(@do), expression, scopeOptions, out var itemBinding);

            if (target is IEnumerable objs && !(target is IDictionary) && !(target is string))
            {
                var items = target.AssertEnumerable(nameof(@do));