private static IDynamic HasOwnProperty(IEnvironment environment, IArgs args)
 {
     if (args.IsEmpty) return environment.False;
     var obj = environment.Context.ThisBinding.ConvertToObject();
     var desc = obj.GetOwnProperty(args[0].ConvertToString().BaseValue);
     return environment.CreateBoolean(desc != null);
 }

        public virtual IDynamic Call(IEnvironment environment, IDynamic thisBinding, IArgs args)
        {
            var oldContext = environment.Context;
            var newEnvironment = Scope.NewDeclarativeEnvironment();
            using (var newContext = environment.EnterContext())
            {
                newContext.LexicalEnviroment = newEnvironment;
                newContext.VariableEnviroment = newEnvironment;
                newContext.Strict = ExecutableCode.Strict;
                if (ExecutableCode.Strict)
                {
                    newContext.ThisBinding = thisBinding;
                }
                else
                {
                    switch (thisBinding.TypeCode)
                    {
                        case LanguageTypeCode.Undefined:
                        case LanguageTypeCode.Null:
                            newContext.ThisBinding = Environment.GlobalObject;
                            break;
                        default:
                            newContext.ThisBinding = thisBinding.ConvertToObject();
                            break;
                    }
                }

                BindFormalParameters(args);
                Environment.BindFunctionDeclarations(ExecutableCode.FunctionDeclarations, ExecutableCode.Strict, true);
                BindArgumentsObject(args);
                Environment.BindVariableDeclarations(ExecutableCode.VariableDeclarations, ExecutableCode.Strict, true);
                return ExecutableCode.Code(environment, args);
            }
        }

 public override IDynamic CreateIterator(IEnvironment environment, IArgs args)
 {
     var scope = Scope.NewDeclarativeEnvironment();
     var generator = new Generator(new GeneratorSteps(Steps));
     var iterator = new HGeneratorIterator(environment, generator, VariableDeclarations, scope);
     return iterator;
 }

 internal static IDynamic Stringify(IEnvironment environment, IArgs args)
 {
     var value = args[0];
     var replacer = args[1];
     var space = args[2];
     return Machete.Compiler.JsonParser.Stringify(environment, value, replacer, space);
 }

        internal static IDynamic IsArray(IEnvironment environment, IArgs args)
        {
            // 15.4.3.2 Array.isArray ( arg )

            var arg = args[0] as IObject;
            return environment.CreateBoolean(arg != null && arg.Class == "Array");
        }

 protected override sealed IDynamic Call(IEnvironment environment, IArgs args)
 {
     if (args.Count > 0)
     {
         return args[0].ConvertToString();
     }
     return environment.CreateString("");
 }

 protected override sealed IDynamic Call(IEnvironment environment, IArgs args)
 {
     if (args.Count > 0)
     {
         return args[0].ConvertToNumber();
     }
     return environment.CreateNumber(0.0);
 }

 public IDynamic Call(IEnvironment environment, IDynamic thisBinding, IArgs args)
 {
     using (var newContext = environment.EnterContext())
     {
         Environment.Context.ThisBinding = thisBinding;
         return _code(environment, args);
     }
 }

 public override IObject Construct(IEnvironment environment, IArgs args)
 {
     var func = TargetFunction as NFunction;
     if (func == null)
     {
         throw Environment.CreateTypeError("");
     }
     return func.Construct(environment, environment.ConcatArgs(BoundArguments, args));
 }

 public override IObject Construct(IEnvironment environment, IArgs args)
 {
     var obj = new NBoolean(environment);
     obj.Class = "Boolean";
     obj.Extensible = true;
     obj.PrimitiveValue = args[0].ConvertToBoolean();
     obj.Prototype = environment.BooleanPrototype;
     return obj;
 }

 protected override sealed IDynamic Call(IEnvironment environment, IArgs args)
 {
     var patternObject = args[0] as IObject;
     if (patternObject != null && patternObject.Class == "RegExp")
     {
         return patternObject;
     }
     return Construct(environment, args);
 }

 internal static IDynamic FromCharCode(IEnvironment environment, IArgs args)
 {
     var sb = new StringBuilder(args.Count);
     foreach (var arg in args)
     {
         sb.Append((char)arg.ConvertToUInt16().BaseValue);
     }
     return environment.CreateString(sb.ToString());
 }

 internal static IDynamic Filter(IEnvironment environment, IArgs args)
 {
     if (args.Count < 2)
         throw environment.CreateTypeError("The arguments 'iterable' and 'predicate' are required.");
     var iterable = args[1].ConvertToObject();
     var predicate = args[0].ConvertToObject() as ICallable;
     if (predicate == null)
         throw environment.CreateTypeError("The argument 'predicate' must be a callable function.");
     return new HFilterIterable(environment, iterable, predicate);
 }

 internal static IDynamic Assert(IEnvironment environment, IArgs args)
 {
     var condition = args[0].ConvertToBoolean().BaseValue;
     if (!condition)
     {
         var message = args[1].ConvertToString().BaseValue;
         throw environment.CreateError(message);
     }
     return environment.Undefined;
 }

 public override IDynamic Next(IEnvironment environment, IArgs args)
 {
     if (_complete)
         return environment.False;
     _initialized = true;
     if (++_index < _length)
         return environment.True;
     _complete = true;
     return environment.False;
 }

 internal static IDynamic Asin(IEnvironment environment, IArgs args)
 {
     double x = args[0].ConvertToNumber().BaseValue;
     if (double.IsNaN(x))
         return environment.CreateNumber(double.NaN);
     if (x > 1.0 || x < -1.0)
         return environment.CreateNumber(double.NaN);
     if (x == 0.0)
         return environment.CreateNumber(x);
     return environment.CreateNumber(Math.Asin(x));
 }

 internal static IDynamic Abs(IEnvironment environment, IArgs args)
 {
     double x = args[0].ConvertToNumber().BaseValue;
     if (double.IsNaN(x))
         return environment.CreateNumber(double.NaN);
     if (IsNegativeZero(x))
         return environment.CreateNumber(0.0);
     if (double.IsNegativeInfinity(x))
         return environment.CreateNumber(double.PositiveInfinity);
     return environment.CreateNumber(Math.Abs(x));
 }

        public override sealed IObject Construct(IEnvironment environment, IArgs args)
        {
            var patternArg = args[0];
            var flagsArg = args[1];
            var pattern = "";
            var flags = "";
            bool global, ignoreCase, multiline;

            var patternObject = patternArg as IObject;
            if (patternObject != null && patternObject.Class == "RegExp")
            {
                if (flagsArg.TypeCode != LanguageTypeCode.Undefined)
                {
                    throw environment.CreateTypeError("");
                }
                global = ((IBoolean)patternObject.Get("global")).BaseValue;
                ignoreCase = ((IBoolean)patternObject.Get("ignoreCase")).BaseValue;
                multiline = ((IBoolean)patternObject.Get("multiline")).BaseValue;
                pattern = ((IString)patternObject.Get("source")).BaseValue;
                if (global) flags += "g";
                if (ignoreCase) flags += "i";
                if (multiline) flags += "m";
            }
            else
            {
                if (patternArg.TypeCode != LanguageTypeCode.Undefined)
                {
                    pattern = patternArg.ConvertToString().BaseValue;
                }
                if (flagsArg.TypeCode != LanguageTypeCode.Undefined)
                {
                    flags = flagsArg.ConvertToString().BaseValue;
                }
                global = flags.Contains("g");
                ignoreCase = flags.Contains("i");
                multiline = flags.Contains("m");
            }

            var regExpObj = new NRegExp(environment);
            regExpObj.Class = "RegExp";
            regExpObj.Extensible = true;
            regExpObj.Prototype = environment.RegExpPrototype;
            regExpObj.Body = pattern;
            regExpObj.Flags = flags;
            regExpObj.RegExpMatcher = Machete.Compiler.RegExpParser.Parse(Environment, pattern, flags);
            regExpObj.DefineOwnProperty("source", environment.CreateDataDescriptor(environment.CreateString(pattern), false, false, false), false);
            regExpObj.DefineOwnProperty("global", environment.CreateDataDescriptor(environment.CreateBoolean(global), false, false, false), false);
            regExpObj.DefineOwnProperty("ignoreCase", environment.CreateDataDescriptor(environment.CreateBoolean(ignoreCase), false, false, false), false);
            regExpObj.DefineOwnProperty("multiline", environment.CreateDataDescriptor(environment.CreateBoolean(multiline), false, false, false), false);
            regExpObj.DefineOwnProperty("lastIndex", environment.CreateDataDescriptor(environment.CreateNumber(0.0), true, false, false), false);
            return regExpObj;
        }

 internal static IDynamic Iterate(IEnvironment environment, IArgs args)
 {
     var iterator = new Iterator(environment, args[1]);
     var callback = args[0] as ICallable;
     if (callback == null)
         throw environment.CreateTypeError("The argument 'callback' must be a callable function.");
     while (iterator.Next())
     {
         var callArgs = environment.CreateArgs(new[] { iterator.Current });
         callback.Call(environment, environment.Undefined, callArgs);
     }
     return environment.Undefined;
 }

        public override IObject Construct(IEnvironment environment, IArgs args)
        {
            var r = new NDate(environment);
            r.Class = "Date";
            r.Extensible = true;
            r.Prototype = environment.DatePrototype;

            var argCount = args.Count;
            double timeValue = 0.0;
            if (argCount == 0)
            {
                timeValue = (DateTime.UtcNow - _utcStart).TotalMilliseconds;
            }
            else if (argCount == 1)
            {
                var value = args[0].ConvertToPrimitive(null);
                if (value.TypeCode == LanguageTypeCode.String)
                {
                    timeValue = Parse(environment, args).ConvertToNumber().BaseValue;
                }
                else
                {
                    timeValue = value.ConvertToNumber().BaseValue;
                }
            }
            else
            {
                var year = args[0].ConvertToNumber().ConvertToInteger().BaseValue;
                var month = args[1].ConvertToNumber().BaseValue;
                var date = argCount > 2 ? args[2].ConvertToNumber().BaseValue : 1.0;
                var hours = argCount > 3 ? args[3].ConvertToNumber().BaseValue : 0.0;
                var minutes = argCount > 4 ? args[4].ConvertToNumber().BaseValue : 0.0;
                var seconds = argCount > 5 ? args[5].ConvertToNumber().BaseValue : 0.0;
                var ms = argCount > 6 ? args[6].ConvertToNumber().BaseValue : 0.0;

                if (!double.IsNaN(year) && year >= 0.0 && year <= 99)
                {
                    year = 1900.0 + year;
                }

                var dayPortion = PDate.MakeDay(year, month, date);
                var timePortion = PDate.MakeTime(hours, minutes, seconds, ms);
                var dateValue = PDate.MakeDate(dayPortion, timePortion);

                timeValue = PDate.TimeClip(PDate.UTC(dateValue));
            }

            r.PrimitiveValue = environment.CreateNumber(PDate.TimeClip(timeValue));
            return r;
        }