Binding a callback (std::function) causes runtime error about quickjspp HOT 11 OPEN

// c++
void Listener::listen( std::function<void(void)> callback ){
    _callback = callback;
}

// quickjspp
module.class_<Listener>( "Listener" )
    .constructor<>()
    .fun<&Listener::listen>( "listen" );

class MyListener extends Listener {
    constructor() {
        super(); // init listenere
        listen( test ); // Both of these calls to 'listen' (either of them) results in an exception 
        listen( methodTest );
    }
    methodTest() {
        console.log("method test");
    }
}

// c++
class Listener {
public:
    listen( std::function<bool(int)> callback ){ // Callback contains only non-custom types
        auto res = callback( 1234 );
        cout << "result " << res << endl; // This is fine. Prints "result 1"
    }
};

// quickjspp
module.class_<Listener>( "Listener" )
    .constructor<>()
    .fun<&Listener::listen>( "listen" );

// js
class MyClass extends Listener {
    constructor() {
        super();
        this.listen( this.exampleCallback );
    }
    exampleCallback( v ) {
        console.log( v ); // This is fine. Prints "1234"
        return true;
    }
}

// c++
class Event {
public:
    int type = 0;
}
class Listener {
public:
    listen( std::function<bool(Event*)> callback ){ // Callback passes event by pointer
        Event* event = new Event();
        event->type = 1234;
        auto res = callback( event );
        delete event;
        cout << "result " << res << endl; // This is fine. Prints "result 1"
    }
};

// quickjspp
module.class_<Event>( "Event" )
    .constructor<>()
    .fun<&Event::type>( "type" );

module.class_<Listener>( "Listener" )
    .constructor<>()
    .fun<&Listener::listen>( "listen" );

// js
class MyClass extends Listener {
    constructor() {
        super();
        this.listen( this.exampleCallback );
    }
    exampleCallback( evt ) {
        console.log( evt.type ); // This is wrong. Prints garbage.
                                 // Dumping properties shows evt is actually an empty object { }
        return true;
    }
}

// c++
class Event {
public:
    int type = 0;
}
class Listener {
public:
    listen( std::function<bool(Event)> callback ){ // Callback passes event object
        Event event;
        event.type = 1234;
        auto res = callback( event );
        cout << "result " << res << endl; // This is fine. Prints "result 1"
    }
};

// quickjspp
module.class_<Event>( "Event" )
    .constructor<>()
    .fun<&Event::type>( "type" );

module.class_<Listener>( "Listener" )
    .constructor<>()
    .fun<&Listener::listen>( "listen" );

// Compile error
undefined symbol: public: static unsigned __int64 __cdecl qjs::js_traits<class Event, void>::wrap(struct JSContext *, class Event)

class Event {
public:
    virtual ~Event(){}
    int type = 0;
};

// c++
event->type = 105;

// Javascript
log( event.type ); // log: 5.2e-322
// 5.2e-322 is the double representation of the binary number 105 (taking the binary bits)

// c++
class Event {
public:
    virtual ~Event(){}
    int type = 0;
    int getType() { return type; }
};

// quickjspp
module.class_<Event>( "Event" )
    .constructor<>()
    .property<&Event::getType>( "type" );

class Event {
public:
    virtual ~Event(){}
    bool cancelled = true;  // Now this is mangled
    int type = 0; // But this is ok
};

class Event {
public:
    virtual ~Event(){}
    bool _ignore; // Never use this
    bool cancelled = true;  // Now this is ok
    int type = 0; // And this is ok
};