//экспортируемая функция
int SomeFunc(bool arg1, int arg2)
{
    //код
}

//shim function
//Указатель на shim передаётся движку v8 (то есть его сигнатура фиксированная и менять её нельзя).
void SomeFuncShim(const FunctionCallbackInfo<Value>& info)
{
    //проверка совпадения кол-ва параметром с ожидаемым
    auto argsCnt = info.Length();
    if (argsCnt != 2)
    {
        //ругаемся матом и прекращаем выполнение скрипта, код пропущен
        return;
    }

    //достаём аргументы

    //первый
    Local<Value> arg1 = info[0];
    //распаковываем в нужный тип
    bool arg1Val = arg1->Value();

    //второй
    Local<Value> arg2 = info[1];
    int arg2Val = arg2->Value();

    //прочие элементарные типы обрабатываются аналогично, за исключением строк - для них отдельный код распаковки

    //распаковываем указатель на целевую функцию
    auto funcPtr = static_cast<int(*)(bool arg1, int arg2)>(wrap->Value());

    //вызываем собственно функцию
    int result = funcPtr(arg1Val, arg2Val);


    //упаковываем результат и устанавливаем возвращаемое значение
    info.GetReturnValue().Set(result);
}

template<typename T> T UnpackParameter(const Local<Value>& val)
{
    throw std::exception("no specialization exist");
}

template<> int UnpackParameter(const Local<Value>& val)
{
    auto arg = val->ToInt32();
    return arg->Value();
}

template<> bool UnpackParameter(const Local<Value>& val)
{
    auto arg = val->ToBoolean();
    return arg->Value();
}
//и т.п. для других типов
//использовать так:
auto arg1 = UnpackParameter<bool>(info[0]);

template <typename _Ty> struct VariantConverter
{
};

template<> struct VariantConverter<int>
{
    static int FromVariant(const Local<Value> &val)
    {
        auto arg = val->ToInt32();
        return arg->Value();
    }

    static Local<Value> ToVariant(Isolate * isolate, int val)
    {
        return Int32::New(isolate, val);
    }
};

template<> struct VariantConverter<bool>
{
    static bool FromVariant(const Local<Value> &val)
    {
        auto arg = val->ToBoolean();
        return arg->Value();
    }

    static Local<Value> ToVariant(Isolate * isolate, bool val)
    {
        return Boolean::New(isolate, val);
    }
};

template<> struct VariantConverter<std::wstring>
{
    static std::wstring FromVariant(const Local<Value> &val)
    {
        Local<String> str = val->ToString();
        auto len = str->Length();
        auto buf = new wchar_t[len + 1];
        str->Write(reinterpret_cast<uint16_t*>(buf));
        std::wstring result = buf;
        delete[]buf;
        return result;
    }

    static Local<Value> ToVariant(Isolate * isolate, std::wstring val)
    {
        return String::NewFromTwoByte(isolate, (const uint16_t*)val.c_str());
    }
};



class IInvokable
{
public:
    virtual Local<Value> Invoke(Isolate * isolate, const std::vector<Local<Value>> &variants) = 0;
    virtual void (*GetShim())(const FunctionCallbackInfo<Value>& info) = 0;
    virtual ~IInvokable(){}
};

template<typename _Result, typename... _Args> class Invoker : public IInvokable
{
private:
    _Result(*m_pFunc)(_Args...);

private:
    template <typename _Ty, size_t _Index> int GetArg(const std::vector<Local<Value>> &variants)
    {
        return VariantConverter<_Ty>::FromVariant(variants[_Index]);
    }

    template <size_t... _Indicies> Local<Value> DoInvoke(Isolate * isolate, const std::vector<Local<Value>> &variants, std::_Arg_idx<_Indicies...>)
    {
        auto result = m_pFunc((GetArg<_Args, _Indicies>(variants))...);
        return VariantConverter<_Result>::ToVariant(isolate, result);
    }

public:
    Invoker(_Result(*pFunc)(_Args...))
        : m_pFunc(pFunc)
    {
    }

    Local<Value> Invoke(Isolate * isolate, const std::vector<Local<Value>> &variants)
    {
        return DoInvoke(isolate, variants, std::_Make_arg_idx<_Args...>::type());
    }

    static void ShimFunc(const FunctionCallbackInfo<Value>& info)
    {
        auto argsCountRequired = sizeof...(_Args);
        auto argsCountPassed = info.Length();
        if (argsCountRequired != argsCountPassed)
        {
            info.GetIsolate()->ThrowException(String::NewFromUtf8(info.GetIsolate(), "Bad parameters"));
            return;
        }
        std::vector<Local<Value>> args;
        for (auto i = 0U; i < argsCountRequired; ++i)
        {
            args.push_back(info[i]);
        }
        
        auto invokerData = info.Data();
        auto wrap = Local<External>::Cast(invokerData);
        void* invokerVoid = wrap->Value();
        auto invoker = static_cast<IInvokable*>(invokerVoid);
        auto result = invoker->Invoke(info.GetIsolate(), args);
        info.GetReturnValue().Set(result);
    }

    void (*GetShim())(const FunctionCallbackInfo<Value>& info)
    {
        return ShimFunc;
    }
};

template<typename _Result, typename... _Args> Invoker<_Result, _Args...> *CreateInvoker(_Result(*pFunc)(_Args...))
{
    return new Invoker<_Result, _Args...>(pFunc);
}

1>Scripting\v8\V8ScriptingEngine.cpp(210): warning C4800: 'int' : forcing value to bool 'true' or 'false' (performance warning)
1> Scripting\v8\V8ScriptingEngine.cpp(222) : see reference to function template instantiation 'v8::Local<v8::Value> Invoker<int,bool,int>::DoInvoke<0x00,0x01>(v8::Isolate *,const std::vector<v8::Local<v8::Value>,std::allocator<_Ty>> &,std::_Arg_idx<0x00,0x01>)' being compiled
1> with
1> [
1> _Ty=v8::Local<v8::Value>
1> ]
1> Scripting\v8\V8ScriptingEngine.cpp(222) : see reference to function template instantiation 'v8::Local<v8::Value> Invoker<int,bool,int>::DoInvoke<0x00,0x01>(v8::Isolate *,const std::vector<v8::Local<v8::Value>,std::allocator<_Ty>> &,std::_Arg_idx<0x00,0x01>)' being compiled
1> with
1> [
1> _Ty=v8::Local<v8::Value>
1> ]
1> Scripting\v8\V8ScriptingEngine.cpp(221) : while compiling class template member function 'v8::Local<v8::Value> Invoker<int,bool,int>::Invoke(v8::Isolate *,const std::vector<v8::Local<v8::Value>,std::allocator<_Ty>> &)'
1> with
1> [
1> _Ty=v8::Local<v8::Value>
1> ]
1> Scripting\v8\V8ScriptingEngine.cpp(390) : see reference to class template instantiation 'Invoker<int,bool,int>' being compiled