/// <summary>
        /// Creates a new JavaScript function
        /// </summary>
        /// <remarks>
        /// Requires an active script context.
        /// </remarks>
        /// <param name="function">The method to call when the function is invoked</param>
        /// <param name="callbackData">Data to be provided to all function callbacks</param>
        /// <returns>The new function object</returns>
        public static EdgeJsValue CreateFunction(EdgeJsNativeFunction function, IntPtr callbackData)
        {
            EdgeJsValue reference;

            EdgeJsErrorHelpers.ThrowIfError(EdgeNativeMethods.JsCreateFunction(function, callbackData, out reference));

            return(reference);
        }
        private EdgeJsValue CreateFunctionFromDelegate(Delegate value)
        {
            EdgeJsNativeFunction nativeFunction = (callee, isConstructCall, args, argCount, callbackData) =>
            {
                object[]        processedArgs  = MapToHostType(args.Skip(1).ToArray());
                ParameterInfo[] parameters     = value.GetMethodInfo().GetParameters();
                EdgeJsValue     undefinedValue = EdgeJsValue.Undefined;

                ReflectionHelpers.FixArgumentTypes(ref processedArgs, parameters);

                object result;

                try
                {
                    result = value.DynamicInvoke(processedArgs);
                }
                catch (Exception e)
                {
                    EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateError(
                        string.Format(NetCoreStrings.Runtime_HostDelegateInvocationFailed, e.Message));
                    EdgeJsErrorHelpers.SetException(errorValue);

                    return(undefinedValue);
                }

                EdgeJsValue resultValue = MapToScriptType(result);

                return(resultValue);
            };

            _nativeFunctions.Add(nativeFunction);

            EdgeJsValue functionValue = EdgeJsValue.CreateFunction(nativeFunction);

            return(functionValue);
        }
		internal static extern JsErrorCode JsCreateFunction(EdgeJsNativeFunction nativeFunction, IntPtr externalData, out EdgeJsValue function);
        /// <summary>
        /// Creates a new JavaScript function
        /// </summary>
        /// <remarks>
        /// Requires an active script context.
        /// </remarks>
        /// <param name="function">The method to call when the function is invoked</param>
        /// <param name="callbackData">Data to be provided to all function callbacks</param>
        /// <returns>The new function object</returns>
        public static EdgeJsValue CreateFunction(EdgeJsNativeFunction function, IntPtr callbackData)
        {
            EdgeJsValue reference;
            EdgeJsErrorHelpers.ThrowIfError(EdgeNativeMethods.JsCreateFunction(function, callbackData, out reference));

            return reference;
        }
        private void ProjectMethods(EdgeJsValue target, Type type, bool instance)
        {
            string       typeName            = type.FullName;
            BindingFlags defaultBindingFlags = ReflectionHelpers.GetDefaultBindingFlags(instance);

            MethodInfo[] methods = type.GetMethods(defaultBindingFlags);
            IEnumerable <IGrouping <string, MethodInfo> > methodGroups = methods.GroupBy(m => m.Name);

            foreach (IGrouping <string, MethodInfo> methodGroup in methodGroups)
            {
                string       methodName       = methodGroup.Key;
                MethodInfo[] methodCandidates = methodGroup.ToArray();

                EdgeJsNativeFunction nativeFunction = (callee, isConstructCall, args, argCount, callbackData) =>
                {
                    EdgeJsValue thisValue      = args[0];
                    EdgeJsValue undefinedValue = EdgeJsValue.Undefined;

                    object thisObj = null;

                    if (instance)
                    {
                        if (!thisValue.HasExternalData)
                        {
                            EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateTypeError(
                                string.Format(NetCoreStrings.Runtime_InvalidThisContextForHostObjectMethod, methodName));
                            EdgeJsErrorHelpers.SetException(errorValue);

                            return(undefinedValue);
                        }

                        thisObj = MapToHostType(thisValue);
                    }

                    object[] processedArgs = MapToHostType(args.Skip(1).ToArray());

                    var bestFitMethod = (MethodInfo)ReflectionHelpers.GetBestFitMethod(
                        methodCandidates, processedArgs);
                    if (bestFitMethod == null)
                    {
                        EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateReferenceError(
                            string.Format(NetCoreStrings.Runtime_SuitableMethodOfHostObjectNotFound, methodName));
                        EdgeJsErrorHelpers.SetException(errorValue);

                        return(undefinedValue);
                    }

                    ReflectionHelpers.FixArgumentTypes(ref processedArgs, bestFitMethod.GetParameters());

                    object result;

                    try
                    {
                        result = bestFitMethod.Invoke(thisObj, processedArgs);
                    }
                    catch (Exception e)
                    {
                        string errorMessage = instance ?
                                              string.Format(
                            NetCoreStrings.Runtime_HostObjectMethodInvocationFailed, methodName, e.Message)
                                                        :
                                              string.Format(
                            NetCoreStrings.Runtime_HostTypeMethodInvocationFailed, methodName, typeName, e.Message)
                        ;

                        EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateError(errorMessage);
                        EdgeJsErrorHelpers.SetException(errorValue);

                        return(undefinedValue);
                    }

                    EdgeJsValue resultValue = MapToScriptType(result);

                    return(resultValue);
                };
                _nativeFunctions.Add(nativeFunction);

                EdgeJsValue methodValue = EdgeJsValue.CreateFunction(nativeFunction);
                target.SetProperty(methodName, methodValue, true);
            }
        }
        private void ProjectProperties(EdgeJsValue target, Type type, bool instance)
        {
            string       typeName            = type.FullName;
            BindingFlags defaultBindingFlags = ReflectionHelpers.GetDefaultBindingFlags(instance);

            PropertyInfo[] properties = type.GetProperties(defaultBindingFlags);

            foreach (PropertyInfo property in properties)
            {
                string propertyName = property.Name;

                EdgeJsValue descriptorValue = EdgeJsValue.CreateObject();
                descriptorValue.SetProperty("enumerable", EdgeJsValue.True, true);

                if (property.GetGetMethod() != null)
                {
                    EdgeJsNativeFunction nativeFunction = (callee, isConstructCall, args, argCount, callbackData) =>
                    {
                        EdgeJsValue thisValue      = args[0];
                        EdgeJsValue undefinedValue = EdgeJsValue.Undefined;

                        object thisObj = null;

                        if (instance)
                        {
                            if (!thisValue.HasExternalData)
                            {
                                EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateTypeError(
                                    string.Format(NetCoreStrings.Runtime_InvalidThisContextForHostObjectProperty, propertyName));
                                EdgeJsErrorHelpers.SetException(errorValue);

                                return(undefinedValue);
                            }

                            thisObj = MapToHostType(thisValue);
                        }

                        object result;

                        try
                        {
                            result = property.GetValue(thisObj, new object[0]);
                        }
                        catch (Exception e)
                        {
                            string errorMessage = instance ?
                                                  string.Format(
                                NetCoreStrings.Runtime_HostObjectPropertyGettingFailed, propertyName, e.Message)
                                                                :
                                                  string.Format(
                                NetCoreStrings.Runtime_HostTypePropertyGettingFailed, propertyName, typeName, e.Message)
                            ;

                            EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateError(errorMessage);
                            EdgeJsErrorHelpers.SetException(errorValue);

                            return(undefinedValue);
                        }

                        EdgeJsValue resultValue = MapToScriptType(result);

                        return(resultValue);
                    };
                    _nativeFunctions.Add(nativeFunction);

                    EdgeJsValue getMethodValue = EdgeJsValue.CreateFunction(nativeFunction);
                    descriptorValue.SetProperty("get", getMethodValue, true);
                }

                if (property.GetSetMethod() != null)
                {
                    EdgeJsNativeFunction nativeFunction = (callee, isConstructCall, args, argCount, callbackData) =>
                    {
                        EdgeJsValue thisValue      = args[0];
                        EdgeJsValue undefinedValue = EdgeJsValue.Undefined;

                        object thisObj = null;

                        if (instance)
                        {
                            if (!thisValue.HasExternalData)
                            {
                                EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateTypeError(
                                    string.Format(NetCoreStrings.Runtime_InvalidThisContextForHostObjectProperty, propertyName));
                                EdgeJsErrorHelpers.SetException(errorValue);

                                return(undefinedValue);
                            }

                            thisObj = MapToHostType(thisValue);
                        }

                        object value = MapToHostType(args.Skip(1).First());
                        ReflectionHelpers.FixPropertyValueType(ref value, property);

                        try
                        {
                            property.SetValue(thisObj, value, new object[0]);
                        }
                        catch (Exception e)
                        {
                            string errorMessage = instance ?
                                                  string.Format(
                                NetCoreStrings.Runtime_HostObjectPropertySettingFailed, propertyName, e.Message)
                                                                :
                                                  string.Format(
                                NetCoreStrings.Runtime_HostTypePropertySettingFailed, propertyName, typeName, e.Message)
                            ;

                            EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateError(errorMessage);
                            EdgeJsErrorHelpers.SetException(errorValue);

                            return(undefinedValue);
                        }

                        return(undefinedValue);
                    };
                    _nativeFunctions.Add(nativeFunction);

                    EdgeJsValue setMethodValue = EdgeJsValue.CreateFunction(nativeFunction);
                    descriptorValue.SetProperty("set", setMethodValue, true);
                }

                target.DefineProperty(propertyName, descriptorValue);
            }
        }
        private EdgeJsValue CreateConstructor(Type type)
        {
            TypeInfo     typeInfo            = type.GetTypeInfo();
            string       typeName            = type.FullName;
            BindingFlags defaultBindingFlags = ReflectionHelpers.GetDefaultBindingFlags(true);

            ConstructorInfo[] constructors = type.GetConstructors(defaultBindingFlags);

            EdgeJsNativeFunction nativeFunction = (callee, isConstructCall, args, argCount, callbackData) =>
            {
                EdgeJsValue resultValue;
                EdgeJsValue undefinedValue = EdgeJsValue.Undefined;

                object[] processedArgs = MapToHostType(args.Skip(1).ToArray());
                object   result;

                if (processedArgs.Length == 0 && typeInfo.IsValueType)
                {
                    result      = Activator.CreateInstance(type);
                    resultValue = MapToScriptType(result);

                    return(resultValue);
                }

                if (constructors.Length == 0)
                {
                    EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateError(
                        string.Format(NetCoreStrings.Runtime_HostTypeConstructorNotFound, typeName));
                    EdgeJsErrorHelpers.SetException(errorValue);

                    return(undefinedValue);
                }

                var bestFitConstructor = (ConstructorInfo)ReflectionHelpers.GetBestFitMethod(
                    constructors, processedArgs);
                if (bestFitConstructor == null)
                {
                    EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateReferenceError(
                        string.Format(NetCoreStrings.Runtime_SuitableConstructorOfHostTypeNotFound, typeName));
                    EdgeJsErrorHelpers.SetException(errorValue);

                    return(undefinedValue);
                }

                ReflectionHelpers.FixArgumentTypes(ref processedArgs, bestFitConstructor.GetParameters());

                try
                {
                    result = bestFitConstructor.Invoke(processedArgs);
                }
                catch (Exception e)
                {
                    EdgeJsValue errorValue = EdgeJsErrorHelpers.CreateError(
                        string.Format(NetCoreStrings.Runtime_HostTypeConstructorInvocationFailed, typeName, e.Message));
                    EdgeJsErrorHelpers.SetException(errorValue);

                    return(undefinedValue);
                }

                resultValue = MapToScriptType(result);

                return(resultValue);
            };

            _nativeFunctions.Add(nativeFunction);

            EdgeJsValue constructorValue = EdgeJsValue.CreateFunction(nativeFunction);

            return(constructorValue);
        }
 internal static extern JsErrorCode JsCreateFunction(EdgeJsNativeFunction nativeFunction,
                                                     IntPtr externalData, out EdgeJsValue function);