@crossbind/core-embind-jsi 2.0.0-beta.50

package/cpp/src/emscripten/bind.h

@@ -0,0 +1,2880 @@
+/*
+ * Copyright 2012 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#if __cplusplus < 201103L
+#error Including <./bind.h> requires building with -std=c++11 or newer!
+#endif
+
+#include <cassert>
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "./em_macros.h"
+#include "./val.h"
+#include "./wire.h"
+
+#if __has_feature(leak_sanitizer) || __has_feature(address_sanitizer)
+#include <sanitizer/lsan_interface.h>
+#endif
+
+#include "jsi/jsi.h"
+
+// #include <android/log.h>
+// #define APPNAME "react-native-crossbind"
+
+namespace emscripten {
+    extern facebook::jsi::Runtime* jsRuntime;
+
+    enum class sharing_policy {
+        NONE = 0,
+        INTRUSIVE = 1,
+        BY_EMVAL = 2,
+    };
+
+    namespace internal {
+        EMSCRIPTEN_KEEPALIVE void _embind_initialize_bindings(facebook::jsi::Runtime& rt, std::string path);
+
+        typedef int32_t GenericEnumValue;
+
+        typedef void* GenericFunction;
+        typedef void (*VoidFunctionPtr)(void);
+
+// Implemented in JavaScript.  Don't call these directly.
+
+        void _embind_fatal_error(
+                const char* name,
+                const char* payload) __attribute__((__noreturn__));
+
+        void _embind_register_void(
+                TYPEID voidType,
+                const char* name);
+
+        void _embind_register_bool(
+                TYPEID boolType,
+                const char* name,
+                size_t size,
+                bool trueValue,
+                bool falseValue);
+
+        void _embind_register_integer(
+                TYPEID integerType,
+                const char* name,
+                size_t size,
+                int32_t minRange,
+                uint32_t maxRange);
+
+        void _embind_register_bigint(
+                TYPEID integerType,
+                const char* name,
+                size_t size,
+                int64_t minRange,
+                uint64_t maxRange);
+
+        void _embind_register_float(
+                TYPEID floatType,
+                const char* name,
+                size_t size);
+
+        void _embind_register_std_string(
+                TYPEID stringType,
+                const char* name);
+
+        void _embind_register_std_wstring(
+                TYPEID stringType,
+                size_t charSize,
+                const char* name);
+
+        void _embind_register_emval(
+                TYPEID emvalType,
+                const char* name);
+
+        void _embind_register_memory_view(
+                TYPEID memoryViewType,
+                unsigned typedArrayIndex,
+                const char* name);
+
+        void _embind_register_function(
+                const char* name,
+                unsigned argCount,
+                const TYPEID argTypes[],
+                const char* signature,
+                facebook::jsi::Function& invoker,
+                GenericFunction function,
+                bool isAsync);
+
+        void _embind_register_optional(
+                TYPEID optionalType,
+                TYPEID type);
+
+        void _embind_register_value_array(
+                TYPEID tupleType,
+                const char* name,
+                const char* constructorSignature,
+                facebook::jsi::Function& constructor,
+                const char* destructorSignature,
+                facebook::jsi::Function& destructor);
+
+        void _embind_register_value_array_element(
+                TYPEID tupleType,
+                TYPEID getterReturnType,
+                const char* getterSignature,
+                facebook::jsi::Function& getter,
+                void* getterContext,
+                TYPEID setterArgumentType,
+                const char* setterSignature,
+                facebook::jsi::Function& setter,
+                void* setterContext);
+
+        void _embind_finalize_value_array(TYPEID tupleType);
+
+        void _embind_register_value_object(
+                TYPEID structType,
+                const char* fieldName,
+                const char* constructorSignature,
+                facebook::jsi::Function& constructor,
+                const char* destructorSignature,
+                facebook::jsi::Function& destructor);
+
+        void _embind_register_value_object_field(
+                TYPEID structType,
+                const char* fieldName,
+                TYPEID getterReturnType,
+                const char* getterSignature,
+                facebook::jsi::Function& getter,
+                void* getterContext,
+                TYPEID setterArgumentType,
+                const char* setterSignature,
+                facebook::jsi::Function& setter,
+                void* setterContext);
+
+        void _embind_finalize_value_object(TYPEID structType);
+
+        void _embind_register_class(
+                TYPEID classType,
+                TYPEID pointerType,
+                TYPEID constPointerType,
+                TYPEID baseClassType,
+                const char* getActualTypeSignature,
+                facebook::jsi::Function& getActualType,
+                const char* upcastSignature,
+                facebook::jsi::Function& upcast,
+                const char* downcastSignature,
+                facebook::jsi::Function& downcast,
+                const char* className,
+                const char* destructorSignature,
+                facebook::jsi::Function& destructor);
+
+        void _embind_register_class_constructor(
+                TYPEID classType,
+                unsigned argCount,
+                const TYPEID argTypes[],
+                const char* invokerSignature,
+                facebook::jsi::Function& invoker,
+                GenericFunction constructor);
+
+        void _embind_register_class_function(
+                TYPEID classType,
+                const char* methodName,
+                unsigned argCount,
+                const TYPEID argTypes[],
+                const char* invokerSignature,
+                facebook::jsi::Function& invoker,
+                void* context,
+                unsigned isPureVirtual,
+                bool isAsync);
+
+        void _embind_register_class_property(
+                TYPEID classType,
+                const char* fieldName,
+                TYPEID getterReturnType,
+                const char* getterSignature,
+                facebook::jsi::Function& getter,
+                void* getterContext,
+                TYPEID setterArgumentType,
+                const char* setterSignature,
+                facebook::jsi::Function& setter,
+                void* setterContext);
+
+        void _embind_register_class_class_function(
+                TYPEID classType,
+                const char* methodName,
+                unsigned argCount,
+                const TYPEID argTypes[],
+                const char* invokerSignature,
+                facebook::jsi::Function& invoker,
+                GenericFunction method,
+                bool isAsync);
+
+        void _embind_register_class_class_property(
+                TYPEID classType,
+                const char* fieldName,
+                TYPEID fieldType,
+                void* fieldContext,
+                const char* getterSignature,
+                facebook::jsi::Function& getter,
+                const char* setterSignature,
+                facebook::jsi::Function& setter);
+
+        EM_VAL _embind_create_inheriting_constructor(
+                const char* constructorName,
+                TYPEID wrapperType,
+                EM_VAL properties);
+
+        void _embind_register_enum(
+                TYPEID enumType,
+                const char* name,
+                size_t size,
+                bool isSigned);
+
+        void _embind_register_smart_ptr(
+                TYPEID pointerType,
+                TYPEID pointeeType,
+                const char* pointerName,
+                sharing_policy sharingPolicy,
+                const char* getPointeeSignature,
+                facebook::jsi::Function& getPointee,
+                const char* constructorSignature,
+                facebook::jsi::Function& constructor,
+                const char* shareSignature,
+                facebook::jsi::Function& share,
+                const char* destructorSignature,
+                facebook::jsi::Function& destructor);
+
+        void _embind_register_enum_value(
+                TYPEID enumType,
+                const char* valueName,
+                GenericEnumValue value);
+
+        void _embind_register_constant(
+                const char* name,
+                TYPEID constantType,
+                const facebook::jsi::Value value);
+
+// Register an InitFunc in the global linked list of init functions.
+        void _embind_register_bindings(struct InitFunc* f);
+
+// Binding initialization functions registerd by EMSCRIPTEN_BINDINGS macro
+// below.  Stored as linked list of static data object avoiding std containers
+// to avoid static contructor ordering issues.
+        struct InitFunc {
+            InitFunc(void (*init_func)()) : init_func(init_func) {
+                // This the function immediately upon constructions, and also register
+                // it so that it can be called again on each worker that starts.
+                // init_func();
+                _embind_register_bindings(this);
+            }
+            void (*init_func)();
+            InitFunc* next = nullptr;
+        };
+
+
+    } // end namespace internal
+
+////////////////////////////////////////////////////////////////////////////////
+// POLICIES
+////////////////////////////////////////////////////////////////////////////////
+
+    template<int Index>
+    struct arg {
+        static constexpr int index = Index + 1;
+    };
+
+    struct ret_val {
+        static constexpr int index = 0;
+    };
+
+/*
+template<typename Slot>
+struct allow_raw_pointer {
+    template<typename InputType, int Index>
+    struct Transform {
+        typedef typename std::conditional<
+            Index == Slot::index,
+            internal::AllowedRawPointer<typename std::remove_pointer<InputType>::type>,
+            InputType
+        >::type type;
+    };
+};
+*/
+
+// allow all raw pointers
+    struct allow_raw_pointers {
+        template<typename InputType, int Index>
+        struct Transform {
+            typedef typename std::conditional<
+                    std::is_pointer<InputType>::value,
+                    internal::AllowedRawPointer<typename std::remove_pointer<InputType>::type>,
+                    InputType
+            >::type type;
+        };
+    };
+
+// this is temporary until arg policies are reworked
+    template<typename Slot>
+    struct allow_raw_pointer : public allow_raw_pointers {
+    };
+
+    struct async {
+        template<typename InputType, int Index>
+        struct Transform {
+            typedef InputType type;
+        };
+    };
+
+    namespace internal {
+
+        template<typename... Policies>
+        struct isAsync;
+
+        template<typename... Rest>
+        struct isAsync<async, Rest...> {
+            static constexpr bool value = true;
+        };
+
+        template<typename T, typename... Rest>
+        struct isAsync<T, Rest...> {
+            static constexpr bool value = isAsync<Rest...>::value;
+        };
+
+        template<>
+        struct isAsync<> {
+            static constexpr bool value = false;
+        };
+
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+// select_overload and select_const
+////////////////////////////////////////////////////////////////////////////////
+
+    template<typename Signature>
+    Signature* select_overload(Signature* fn) {
+        return fn;
+    }
+
+    template<typename Signature, typename ClassType>
+    auto select_overload(Signature (ClassType::*fn)) -> decltype(fn) {
+            return fn;
+    }
+
+    template<typename ClassType, typename ReturnType, typename... Args>
+    auto select_const(ReturnType (ClassType::*method)(Args...) const) -> decltype(method) {
+            return method;
+    }
+
+    namespace internal {
+// this should be in <type_traits>, but alas, it's not
+        template<typename T> struct remove_class;
+        template<typename C, typename R, typename... A>
+        struct remove_class<R(C::*)(A...)> { using type = R(A...); };
+        template<typename C, typename R, typename... A>
+        struct remove_class<R(C::*)(A...) const> { using type = R(A...); };
+        template<typename C, typename R, typename... A>
+        struct remove_class<R(C::*)(A...) volatile> { using type = R(A...); };
+        template<typename C, typename R, typename... A>
+        struct remove_class<R(C::*)(A...) const volatile> { using type = R(A...); };
+
+        template<typename LambdaType>
+        using LambdaSignature = typename remove_class<
+                decltype(&LambdaType::operator())
+        >::type;
+    } // end namespace internal
+
+// requires captureless lambda because implicitly coerces to function pointer
+    template<typename LambdaType>
+    internal::LambdaSignature<LambdaType>* optional_override(const LambdaType& fp) {
+        return fp;
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+// Invoker
+////////////////////////////////////////////////////////////////////////////////
+
+    namespace internal {
+
+        // C++ exceptions escaping a host function reach JS engine-dependently (often with
+        // the what() text dropped); rethrowing as JSError guarantees e.message everywhere.
+        template<typename F>
+        inline decltype(auto) rethrowAsJsError(facebook::jsi::Runtime& rt, F&& call) {
+            try {
+                return std::forward<F>(call)();
+            } catch (const facebook::jsi::JSError&) {
+                throw;
+            } catch (const std::exception& e) {
+                throw facebook::jsi::JSError(rt, std::string(e.what()));
+            }
+        }
+
+        template<typename ReturnType, typename... Args>
+        struct Invoker {
+            static typename internal::BindingType<ReturnType>::WireType invoke(
+                    ReturnType (*fn)(Args...),
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                return internal::BindingType<ReturnType>::toWireType(
+                        fn(
+                                internal::BindingType<Args>::fromWireType(args)...
+                        )
+                );
+            }
+
+            static typename internal::BindingType<ReturnType>::WireType2 invoke2(
+                    facebook::jsi::Runtime& rt,
+                    ReturnType (*fn)(Args...),
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                return rethrowAsJsError(rt, [&]() -> typename internal::BindingType<ReturnType>::WireType2 {
+                    return internal::BindingType<ReturnType>::toWireType2(rt,
+                                                                          fn(
+                                                                                  internal::BindingType<Args>::fromWireType2(rt, args)...
+                                                                          )
+                    );
+                });
+            }
+        };
+
+        template<typename... Args>
+        struct Invoker<void, Args...> {
+            static void invoke(
+                    void (*fn)(Args...),
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                return fn(
+                        internal::BindingType<Args>::fromWireType(args)...
+                );
+            }
+
+            static void invoke2(
+                    facebook::jsi::Runtime& rt,
+                    void (*fn)(Args...),
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                return rethrowAsJsError(rt, [&]() -> void {
+                    fn(
+                            internal::BindingType<Args>::fromWireType2(rt, args)...
+                    );
+                });
+            }
+        };
+
+        namespace async {
+
+            template<typename F, F f> struct Wrapper;
+            template<typename ReturnType, typename... Args, ReturnType(*f)(Args...)>
+            struct Wrapper<ReturnType(*)(Args...), f> {
+                EMSCRIPTEN_KEEPALIVE static ReturnType invoke(Args... args) {
+                    return f(args...);
+                }
+            };
+
+        } // end namespace async
+
+        template<typename T, typename... Policies>
+        using maybe_wrap_async = typename std::conditional<
+                isAsync<Policies...>::value,
+                async::Wrapper<decltype(&T::invoke2), &T::invoke2>,
+                T
+        >::type;
+
+        template<typename FunctorType, typename ReturnType, typename... Args>
+        struct FunctorInvoker {
+            static typename internal::BindingType<ReturnType>::WireType invoke(
+                    FunctorType& function,
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                return internal::BindingType<ReturnType>::toWireType(
+                        function(
+                                internal::BindingType<Args>::fromWireType(args)...)
+                );
+            }
+
+            static typename internal::BindingType<ReturnType>::WireType2 invoke2(
+                    facebook::jsi::Runtime& rt,
+                    FunctorType& function,
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                return rethrowAsJsError(rt, [&]() -> typename internal::BindingType<ReturnType>::WireType2 {
+                    return internal::BindingType<ReturnType>::toWireType2(
+                            rt,
+                            function(
+                                    internal::BindingType<Args>::fromWireType2(rt, args)...)
+                    );
+                });
+            }
+        };
+
+        template<typename FunctorType, typename... Args>
+        struct FunctorInvoker<FunctorType, void, Args...> {
+            static void invoke(
+                    FunctorType& function,
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                function(
+                        internal::BindingType<Args>::fromWireType(args)...);
+            }
+
+            static void invoke2(
+                    facebook::jsi::Runtime& rt,
+                    FunctorType& function,
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                rethrowAsJsError(rt, [&]() -> void {
+                    function(
+                            internal::BindingType<Args>::fromWireType2(rt, args)...);
+                });
+            }
+        };
+
+    } // end namespace internal
+
+////////////////////////////////////////////////////////////////////////////////
+// SignatureCode, SignatureString
+////////////////////////////////////////////////////////////////////////////////
+
+    namespace internal {
+
+        template<typename T>
+        struct SignatureCode {};
+
+        template<>
+        struct SignatureCode<int> {
+            static constexpr char get() {
+                return 'i';
+            }
+        };
+
+        template<>
+        struct SignatureCode<void> {
+            static constexpr char get() {
+                return 'v';
+            }
+        };
+
+        template<>
+        struct SignatureCode<float> {
+            static constexpr char get() {
+                return 'f';
+            }
+        };
+
+        template<>
+        struct SignatureCode<double> {
+            static constexpr char get() {
+                return 'd';
+            }
+        };
+
+#ifdef __wasm64__
+        // With wasm32 we can fallback to 'i' for pointer types but we need special
+// handling with wasm64.
+template<>
+struct SignatureCode<void*> {
+    static constexpr char get() {
+        return 'p';
+    }
+};
+template<>
+struct SignatureCode<size_t> {
+    static constexpr char get() {
+        return 'p';
+    }
+};
+#endif
+
+        template<typename... Args>
+        const char* getGenericSignature() {
+            static constexpr char signature[] = { SignatureCode<Args>::get()..., 0 };
+            return signature;
+        }
+
+        template<typename T> struct SignatureTranslator { using type = int; };
+        template<> struct SignatureTranslator<void> { using type = void; };
+        template<> struct SignatureTranslator<float> { using type = float; };
+        template<> struct SignatureTranslator<double> { using type = double; };
+#ifdef __wasm64__
+        template<> struct SignatureTranslator<size_t> { using type = size_t; };
+template<typename PtrType>
+struct SignatureTranslator<PtrType*> { using type = void*; };
+template<typename PtrType>
+struct SignatureTranslator<PtrType&> { using type = void*; };
+template<typename ReturnType, typename... Args>
+struct SignatureTranslator<ReturnType (*)(Args...)> { using type = void*; };
+#endif
+
+        template<typename... Args>
+        EMSCRIPTEN_ALWAYS_INLINE const char* getSpecificSignature() {
+            return getGenericSignature<typename SignatureTranslator<Args>::type...>();
+        }
+
+        template<typename Return, typename... Args>
+        EMSCRIPTEN_ALWAYS_INLINE const char* getSignature(Return (*)(Args...)) {
+            return getSpecificSignature<Return, Args...>();
+        }
+
+    } // end namespace internal
+
+////////////////////////////////////////////////////////////////////////////////
+// FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+#define call_invoke_4 ({return invoke(fn, args[0], args[1], args[2], args[3]);})
+#define call_invoke(count) (call_invoke_##count)
+
+#define callInvoke(count, invokeVar, fnVar) ({ \
+    if constexpr (count == 1) { return invokeVar(rt, fnVar, args[0]); }\
+    else if constexpr (count == 2) { return invokeVar(rt, fnVar, args[0], args[1]); }\
+    else if constexpr (count == 3) { return invokeVar(rt, fnVar, args[0], args[1], args[2]); }\
+    else if constexpr (count == 4) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3]); }\
+    else if constexpr (count == 5) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4]); }\
+    else if constexpr (count == 6) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5]); }\
+    else if constexpr (count == 7) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6]); }\
+    else if constexpr (count == 8) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]); }\
+    else if constexpr (count == 9) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]); }\
+    else if constexpr (count == 10) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]); }\
+    else if constexpr (count == 11) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10]); }\
+    else if constexpr (count == 12) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11]); }\
+    else if constexpr (count == 13) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12]); }\
+    else if constexpr (count == 14) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13]); }\
+    else if constexpr (count == 15) { return invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13], args[14]); }\
+    else { return invokeVar(rt, fnVar); }                                              \
+})
+
+#define callInvokeVoid(count, invokeVar, fnVar) ({ \
+    if constexpr (count == 1) { invokeVar(rt, fnVar, args[0]); }\
+    else if constexpr (count == 2) { invokeVar(rt, fnVar, args[0], args[1]); }\
+    else if constexpr (count == 3) { invokeVar(rt, fnVar, args[0], args[1], args[2]); }\
+    else if constexpr (count == 4) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3]); }\
+    else if constexpr (count == 5) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4]); }\
+    else if constexpr (count == 6) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5]); }\
+    else if constexpr (count == 7) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6]); }\
+    else if constexpr (count == 8) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]); }\
+    else if constexpr (count == 9) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]); }\
+    else if constexpr (count == 10) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]); }\
+    else if constexpr (count == 11) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10]); }\
+    else if constexpr (count == 12) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11]); }\
+    else if constexpr (count == 13) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12]); }\
+    else if constexpr (count == 14) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13]); }\
+    else if constexpr (count == 15) { invokeVar(rt, fnVar, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11], args[12], args[13], args[14]); }\
+    else { invokeVar(rt, fnVar); }                                              \
+})
+
+    template<typename ReturnType, typename... Args, typename... Policies>
+    void function(const char* name, ReturnType (*fn)(Args...), Policies...) {
+        using namespace internal;
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, Args...> args;
+        using OriginalInvoker = Invoker<ReturnType, Args...>;
+        auto invoke = &maybe_wrap_async<OriginalInvoker, Policies...>::invoke2;
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_"+getSignature(invoke)),
+                args.getCount(),
+                [invoke, fn](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                    callInvokeVoid(sizeof...(Args), invoke, fn);
+                    return nullptr;
+                } else {
+                    callInvoke(sizeof...(Args), invoke, fn);
+                }
+                });
+        _embind_register_function(
+                name,
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                reinterpret_cast<GenericFunction>(fn),
+                isAsync<Policies...>::value);
+    }
+
+    namespace internal {
+
+        template<typename ClassType, typename... Args>
+        ClassType* operator_new(Args&&... args) {
+            return new ClassType(std::forward<Args>(args)...);
+        }
+
+        template<typename WrapperType, typename ClassType, typename... Args>
+        WrapperType wrapped_new(Args&&... args) {
+            return WrapperType(new ClassType(std::forward<Args>(args)...));
+        }
+
+        template<typename ClassType, typename... Args>
+        ClassType* raw_constructor(
+                typename internal::BindingType<Args>::WireType2&... args
+        ) {
+            return new ClassType(
+                    internal::BindingType<Args>::fromWireType2(*jsRuntime, args)...
+            );
+        }
+
+        template<typename ClassType>
+        void raw_destructor(ClassType* ptr) {
+            delete ptr;
+        }
+
+        template<typename FunctionPointerType, typename ReturnType, typename ThisType, typename... Args>
+        struct FunctionInvoker {
+            static typename internal::BindingType<ReturnType>::WireType invoke(
+                    FunctionPointerType* function,
+                    typename internal::BindingType<ThisType>::WireType wireThis,
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                return internal::BindingType<ReturnType>::toWireType(
+                        (*function)(
+                                internal::BindingType<ThisType>::fromWireType(wireThis),
+                                internal::BindingType<Args>::fromWireType(args)...)
+                );
+            }
+
+            static typename internal::BindingType<ReturnType>::WireType2 invoke2(
+                    facebook::jsi::Runtime& rt,
+                    FunctionPointerType* function,
+                    typename internal::BindingType<ThisType>::WireType2& wireThis,
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                return rethrowAsJsError(rt, [&]() -> typename internal::BindingType<ReturnType>::WireType2 {
+                    return internal::BindingType<ReturnType>::toWireType2(
+                            rt,
+                            (*function)(
+                                    internal::BindingType<ThisType>::fromWireType2(rt, wireThis),
+                                    internal::BindingType<Args>::fromWireType2(rt, args)...)
+                    );
+                });
+            }
+        };
+
+        template<typename FunctionPointerType, typename ThisType, typename... Args>
+        struct FunctionInvoker<FunctionPointerType, void, ThisType, Args...> {
+            static void invoke(
+                    FunctionPointerType* function,
+                    typename internal::BindingType<ThisType>::WireType wireThis,
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                (*function)(
+                        internal::BindingType<ThisType>::fromWireType(wireThis),
+                        internal::BindingType<Args>::fromWireType(args)...);
+            }
+
+            static void invoke2(
+                    facebook::jsi::Runtime& rt,
+                    FunctionPointerType* function,
+                    typename internal::BindingType<ThisType>::WireType2& wireThis,
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                rethrowAsJsError(rt, [&]() -> void {
+                    (*function)(
+                            internal::BindingType<ThisType>::fromWireType2(rt, wireThis),
+                            internal::BindingType<Args>::fromWireType2(rt, args)...);
+                });
+            }
+        };
+
+        template<typename MemberPointer,
+                typename ReturnType,
+                typename ThisType,
+                typename... Args>
+        struct MethodInvoker {
+            static typename internal::BindingType<ReturnType>::WireType invoke(
+                    const MemberPointer& method,
+                    typename internal::BindingType<ThisType>::WireType wireThis,
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                return internal::BindingType<ReturnType>::toWireType(
+                        (internal::BindingType<ThisType>::fromWireType(wireThis)->*method)(
+                                internal::BindingType<Args>::fromWireType(args)...
+                        )
+                );
+            }
+
+            static typename internal::BindingType<ReturnType>::WireType2 invoke2(
+                    facebook::jsi::Runtime& rt,
+                    const MemberPointer& method,
+                    typename internal::BindingType<ThisType>::WireType2& wireThis,
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                return rethrowAsJsError(rt, [&]() -> typename internal::BindingType<ReturnType>::WireType2 {
+                    return internal::BindingType<ReturnType>::toWireType2(rt,
+                                                                          (internal::BindingType<ThisType>::fromWireType2(rt, wireThis)->*method)(
+                                                                                  internal::BindingType<Args>::fromWireType2(rt, args)...
+                                                                          )
+                    );
+                });
+            }
+        };
+
+        template<typename MemberPointer,
+                typename ThisType,
+                typename... Args>
+        struct MethodInvoker<MemberPointer, void, ThisType, Args...> {
+            static void invoke(
+                    const MemberPointer& method,
+                    typename internal::BindingType<ThisType>::WireType wireThis,
+                    typename internal::BindingType<Args>::WireType... args
+            ) {
+                return (internal::BindingType<ThisType>::fromWireType(wireThis)->*method)(
+                        internal::BindingType<Args>::fromWireType(args)...
+                );
+            }
+
+            static void invoke2(
+                    facebook::jsi::Runtime& rt,
+                    const MemberPointer& method,
+                    typename internal::BindingType<ThisType>::WireType2& wireThis,
+                    typename internal::BindingType<Args>::WireType2&... args
+            ) {
+                rethrowAsJsError(rt, [&]() -> void {
+                    (internal::BindingType<ThisType>::fromWireType2(rt, wireThis)->*method)(
+                            internal::BindingType<Args>::fromWireType2(rt, args)...
+                    );
+                });
+            }
+        };
+
+        template<typename InstanceType, typename MemberType>
+        struct MemberAccess {
+            typedef MemberType InstanceType::*MemberPointer;
+            typedef internal::BindingType<MemberType> MemberBinding;
+            typedef typename MemberBinding::WireType WireType;
+            typedef typename MemberBinding::WireType2 WireType2;
+
+            template<typename ClassType>
+            static WireType getWire(
+                    const MemberPointer& field,
+                    const ClassType& ptr
+            ) {
+                return MemberBinding::toWireType(ptr.*field);
+            }
+
+            template<typename ClassType>
+            static void setWire(
+                    const MemberPointer& field,
+                    ClassType& ptr,
+                    WireType value
+            ) {
+                ptr.*field = MemberBinding::fromWireType(value);
+            }
+
+            template<typename ClassType>
+            static WireType2 getWire2(
+                    const MemberPointer& field,
+                    const ClassType& ptr
+            ) {
+                return MemberBinding::toWireType2(*jsRuntime, ptr.*field);
+            }
+
+            template<typename ClassType>
+            static void setWire2(
+                    const MemberPointer& field,
+                    ClassType& ptr,
+                    WireType2& value
+            ) {
+                ptr.*field = MemberBinding::fromWireType2(*jsRuntime, value);
+            }
+        };
+
+        template<typename FieldType>
+        struct GlobalAccess {
+            typedef internal::BindingType<FieldType> MemberBinding;
+            typedef typename MemberBinding::WireType WireType;
+            typedef typename MemberBinding::WireType2 WireType2;
+
+            static WireType get(FieldType* context) {
+                return MemberBinding::toWireType(*context);
+            }
+
+            static void set(FieldType* context, WireType value) {
+                *context = MemberBinding::fromWireType(value);
+            }
+
+            static WireType2 get2(FieldType* context) {
+                return MemberBinding::toWireType2(*jsRuntime, *context);
+            }
+
+            static void set2(FieldType* context, WireType2& value) {
+                *context = MemberBinding::fromWireType2(*jsRuntime, value);
+            }
+        };
+
+// TODO: This could do a reinterpret-cast if sizeof(T) === sizeof(void*)
+        template<typename T>
+        inline T* getContext(const T& t) {
+            // not a leak because this is called once per binding
+            auto* ret = new T(t);
+#if __has_feature(leak_sanitizer) || __has_feature(address_sanitizer)
+            __lsan_ignore_object(ret);
+#endif
+            return ret;
+        }
+
+        template<typename Accessor, typename ValueType>
+        struct PropertyTag {};
+
+        template<typename T>
+        struct GetterPolicy;
+
+        template<typename GetterReturnType, typename GetterThisType>
+        struct GetterPolicy<GetterReturnType (GetterThisType::*)() const> {
+            typedef GetterReturnType ReturnType;
+            typedef GetterReturnType (GetterThisType::*Context)() const;
+
+            typedef internal::BindingType<ReturnType> Binding;
+            typedef typename Binding::WireType WireType;
+            typedef typename Binding::WireType2 WireType2;
+
+            template<typename ClassType>
+            static WireType get(const Context& context, const ClassType& ptr) {
+                return Binding::toWireType((ptr.*context)());
+            }
+
+            template<typename ClassType>
+            static WireType2 get2(const Context& context, const ClassType& ptr) {
+                return Binding::toWireType2(*jsRuntime, (ptr.*context)());
+            }
+
+            static void* getContext(Context context) {
+                return internal::getContext(context);
+            }
+        };
+
+#ifdef __cpp_noexcept_function_type
+        template<typename GetterReturnType, typename GetterThisType>
+struct GetterPolicy<GetterReturnType (GetterThisType::*)() const noexcept>
+     : GetterPolicy<GetterReturnType (GetterThisType::*)() const> {};
+#endif
+
+        template<typename GetterReturnType, typename GetterThisType>
+        struct GetterPolicy<GetterReturnType (*)(const GetterThisType&)> {
+            typedef GetterReturnType ReturnType;
+            typedef GetterReturnType (*Context)(const GetterThisType&);
+
+            typedef internal::BindingType<ReturnType> Binding;
+            typedef typename Binding::WireType WireType;
+            typedef typename Binding::WireType2 WireType2;
+
+            template<typename ClassType>
+            static WireType get(const Context& context, const ClassType& ptr) {
+                return Binding::toWireType(context(ptr));
+            }
+
+            template<typename ClassType>
+            static WireType2 get2(const Context& context, const ClassType& ptr) {
+                return Binding::toWireType2(*jsRuntime, context(ptr));
+            }
+
+            static void* getContext(Context context) {
+                return internal::getContext(context);
+            }
+        };
+
+        template<typename GetterReturnType, typename GetterThisType>
+        struct GetterPolicy<std::function<GetterReturnType(const GetterThisType&)>> {
+        typedef GetterReturnType ReturnType;
+        typedef std::function<GetterReturnType(const GetterThisType&)> Context;
+
+        typedef internal::BindingType<ReturnType> Binding;
+        typedef typename Binding::WireType WireType;
+        typedef typename Binding::WireType2 WireType2;
+
+        template<typename ClassType>
+        static WireType get(const Context& context, const ClassType& ptr) {
+            return Binding::toWireType(context(ptr));
+        }
+
+        template<typename ClassType>
+        static WireType2 get2(const Context& context, const ClassType& ptr) {
+            return Binding::toWireType2(*jsRuntime, context(ptr));
+        }
+
+        static void* getContext(const Context& context) {
+            return internal::getContext(context);
+        }
+    };
+
+    template<typename Getter, typename GetterReturnType>
+    struct GetterPolicy<PropertyTag<Getter, GetterReturnType>> {
+    typedef GetterReturnType ReturnType;
+    typedef Getter Context;
+
+    typedef internal::BindingType<ReturnType> Binding;
+    typedef typename Binding::WireType WireType;
+    typedef typename Binding::WireType2 WireType2;
+
+    template<typename ClassType>
+    static WireType get(const Context& context, const ClassType& ptr) {
+        return Binding::toWireType(context(ptr));
+    }
+
+    template<typename ClassType>
+    static WireType2 get2(const Context& context, const ClassType& ptr) {
+        return Binding::toWireType2(*jsRuntime, context(ptr));
+    }
+
+    static void* getContext(const Context& context) {
+        return internal::getContext(context);
+    }
+};
+
+template<typename T>
+struct SetterPolicy;
+
+template<typename SetterReturnType, typename SetterThisType, typename SetterArgumentType>
+struct SetterPolicy<SetterReturnType (SetterThisType::*)(SetterArgumentType)> {
+    typedef SetterArgumentType ArgumentType;
+    typedef SetterReturnType (SetterThisType::*Context)(SetterArgumentType);
+
+    typedef internal::BindingType<SetterArgumentType> Binding;
+    typedef typename Binding::WireType WireType;
+    typedef typename Binding::WireType2 WireType2;
+
+    template<typename ClassType>
+    static void set(const Context& context, ClassType& ptr, WireType wt) {
+        (ptr.*context)(Binding::fromWireType(wt));
+    }
+
+    template<typename ClassType>
+    static void set2(const Context& context, ClassType& ptr, WireType2& wt) {
+        (ptr.*context)(Binding::fromWireType2(*jsRuntime, wt));
+    }
+
+    static void* getContext(Context context) {
+        return internal::getContext(context);
+    }
+};
+
+#ifdef __cpp_noexcept_function_type
+template<typename SetterReturnType, typename SetterThisType, typename SetterArgumentType>
+struct SetterPolicy<SetterReturnType (SetterThisType::*)(SetterArgumentType) noexcept>
+     : SetterPolicy<SetterReturnType (SetterThisType::*)(SetterArgumentType)> {};
+#endif
+
+template<typename SetterReturnType, typename SetterThisType, typename SetterArgumentType>
+struct SetterPolicy<SetterReturnType (*)(SetterThisType&, SetterArgumentType)> {
+    typedef SetterArgumentType ArgumentType;
+    typedef SetterReturnType (*Context)(SetterThisType&, SetterArgumentType);
+
+    typedef internal::BindingType<SetterArgumentType> Binding;
+    typedef typename Binding::WireType WireType;
+    typedef typename Binding::WireType2 WireType2;
+
+    template<typename ClassType>
+    static void set(const Context& context, ClassType& ptr, WireType wt) {
+        context(ptr, Binding::fromWireType(wt));
+    }
+
+    template<typename ClassType>
+    static void set2(const Context& context, ClassType& ptr, WireType2& wt) {
+        context(ptr, Binding::fromWireType2(*jsRuntime, wt));
+    }
+
+    static void* getContext(Context context) {
+        return internal::getContext(context);
+    }
+};
+
+template<typename SetterReturnType, typename SetterThisType, typename SetterArgumentType>
+struct SetterPolicy<std::function<SetterReturnType(SetterThisType&, SetterArgumentType)>> {
+typedef SetterArgumentType ArgumentType;
+typedef std::function<SetterReturnType(SetterThisType&, SetterArgumentType)> Context;
+
+typedef internal::BindingType<SetterArgumentType> Binding;
+typedef typename Binding::WireType WireType;
+typedef typename Binding::WireType2 WireType2;
+
+template<typename ClassType>
+static void set(const Context& context, ClassType& ptr, WireType wt) {
+    context(ptr, Binding::fromWireType(wt));
+}
+
+template<typename ClassType>
+static void set2(const Context& context, ClassType& ptr, WireType2& wt) {
+    context(ptr, Binding::fromWireType2(*jsRuntime, wt));
+}
+
+static void* getContext(const Context& context) {
+    return internal::getContext(context);
+}
+};
+
+template<typename Setter, typename SetterArgumentType>
+struct SetterPolicy<PropertyTag<Setter, SetterArgumentType>> {
+typedef SetterArgumentType ArgumentType;
+typedef Setter Context;
+
+typedef internal::BindingType<SetterArgumentType> Binding;
+typedef typename Binding::WireType WireType;
+typedef typename Binding::WireType2 WireType2;
+
+template<typename ClassType>
+static void set(const Context& context, ClassType& ptr, WireType wt) {
+    context(ptr, Binding::fromWireType(wt));
+}
+
+template<typename ClassType>
+static void set2(const Context& context, ClassType& ptr, WireType2& wt) {
+    context(ptr, Binding::fromWireType2(*jsRuntime, wt));
+}
+
+static void* getContext(const Context& context) {
+    return internal::getContext(context);
+}
+};
+
+class noncopyable {
+protected:
+    noncopyable() {}
+    ~noncopyable() {}
+private:
+    noncopyable(const noncopyable&) = delete;
+    const noncopyable& operator=(const noncopyable&) = delete;
+};
+
+template<typename ClassType, typename ElementType>
+typename BindingType<ElementType>::WireType2 get_by_index(int index, ClassType& ptr) {
+    return BindingType<ElementType>::toWireType2(*jsRuntime, ptr[index]);
+}
+
+template<typename ClassType, typename ElementType>
+void set_by_index(int index, ClassType& ptr, typename BindingType<ElementType>::WireType2& wt) {
+    ptr[index] = BindingType<ElementType>::fromWireType2(*jsRuntime, wt);
+}
+
+} // end namespace internal
+
+template<int Index>
+struct index {
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// VALUE TUPLES
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename ClassType>
+class value_array : public internal::noncopyable {
+public:
+    typedef ClassType class_type;
+
+    value_array(const char* name) {
+        using namespace internal;
+
+        auto constructor = &raw_constructor<ClassType>;
+        auto destructor = &raw_destructor<ClassType>;
+
+        facebook::jsi::Function constructorJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_constructor"),
+                0,
+                [constructor](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t = constructor();
+                    return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(t));
+                });
+
+        facebook::jsi::Function destructorJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_constructor"),
+                1,
+                [destructor](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t = reinterpret_cast<ClassType*>(args[0].asBigInt(rt).asUint64(rt));
+                    destructor(t);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_array(
+                TypeID<ClassType>::get(),
+                name,
+                getSignature(constructor),
+                constructorJSIFunc,
+                getSignature(destructor),
+                destructorJSIFunc);
+    }
+
+    ~value_array() {
+        using namespace internal;
+        _embind_finalize_value_array(TypeID<ClassType>::get());
+    }
+
+    template<typename InstanceType, typename ElementType>
+    value_array& element(ElementType InstanceType::*field) {
+        using namespace internal;
+
+        auto getter = &MemberAccess<InstanceType, ElementType>
+        ::template getWire2<ClassType>;
+        auto setter = &MemberAccess<InstanceType, ElementType>
+        ::template setWire2<ClassType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_array_element_gter1"),
+                2,
+                [getter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return getter(field, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_array_element_ster1"),
+                3,
+                [setter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    setter(field, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_array_element(
+                TypeID<ClassType>::get(),
+                TypeID<ElementType>::get(),
+                getSignature(getter),
+                getterJSIFunc,
+                getContext(field),
+                TypeID<ElementType>::get(),
+                getSignature(setter),
+                setterJSIFunc,
+                getContext(field));
+        return *this;
+    }
+
+    template<typename Getter, typename Setter>
+    value_array& element(Getter getter, Setter setter) {
+        using namespace internal;
+        typedef GetterPolicy<Getter> GP;
+        typedef SetterPolicy<Setter> SP;
+
+        auto g = &GP::template get2<ClassType>;
+        auto s = &SP::template set2<ClassType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_array_element_gter2"),
+                2,
+                [g, getter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    Getter* t = reinterpret_cast<Getter*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return g(getter, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_array_element_ster2"),
+                3,
+                [s](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    Setter* t = reinterpret_cast<Setter*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    s(*t, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_array_element(
+                TypeID<ClassType>::get(),
+                TypeID<typename GP::ReturnType>::get(),
+                getSignature(g),
+                getterJSIFunc,
+                GP::getContext(getter),
+                TypeID<typename SP::ArgumentType>::get(),
+                getSignature(s),
+                setterJSIFunc,
+                SP::getContext(setter));
+        return *this;
+    }
+
+    template<int Index>
+    value_array& element(index<Index>) {
+        using namespace internal;
+        ClassType* null = 0;
+        typedef typename std::remove_reference<decltype((*null)[Index])>::type ElementType;
+        auto getter = &internal::get_by_index<ClassType, ElementType>;
+        auto setter = &internal::set_by_index<ClassType, ElementType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_array_element_gter3"),
+                2,
+                [getter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    int t1 = static_cast<int>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return getter(t1, *t2);
+                });
+
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_array_element_ster3"),
+                3,
+                [setter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    int t1 = static_cast<int>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    setter(t1, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_array_element(
+                TypeID<ClassType>::get(),
+                TypeID<ElementType>::get(),
+                getSignature(getter),
+                getterJSIFunc,
+                reinterpret_cast<void*>(Index),
+                TypeID<ElementType>::get(),
+                getSignature(setter),
+                setterJSIFunc,
+                reinterpret_cast<void*>(Index));
+        return *this;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// VALUE STRUCTS
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename ClassType>
+class value_object : public internal::noncopyable {
+public:
+    typedef ClassType class_type;
+
+    value_object(const char* name) {
+        using namespace internal;
+
+        auto ctor = &raw_constructor<ClassType>;
+        auto dtor = &raw_destructor<ClassType>;
+
+        facebook::jsi::Function constructorJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_constructor"),
+                0,
+                [ctor](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t = ctor();
+                    return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(t));
+                });
+
+        facebook::jsi::Function destructorJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_constructor"),
+                1,
+                [dtor](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t = reinterpret_cast<ClassType*>(args[0].asBigInt(rt).asUint64(rt));
+                    dtor(t);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_object(
+                TypeID<ClassType>::get(),
+                name,
+                getSignature(ctor),
+                constructorJSIFunc,
+                getSignature(dtor),
+                destructorJSIFunc);
+    }
+
+    ~value_object() {
+        using namespace internal;
+        _embind_finalize_value_object(internal::TypeID<ClassType>::get());
+    }
+
+    template<typename InstanceType, typename FieldType>
+    value_object& field(const char* fieldName, FieldType InstanceType::*field) {
+        using namespace internal;
+
+        auto getter = &MemberAccess<InstanceType, FieldType>
+        ::template getWire2<ClassType>;
+        auto setter = &MemberAccess<InstanceType, FieldType>
+        ::template setWire2<ClassType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_gter1"),
+                2,
+                [getter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return getter(field, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_ster1"),
+                3,
+                [setter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    setter(field, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_object_field(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<FieldType>::get(),
+                getSignature(getter),
+                getterJSIFunc,
+                getContext(field),
+                TypeID<FieldType>::get(),
+                getSignature(setter),
+                setterJSIFunc,
+                getContext(field));
+        return *this;
+    }
+
+    template<typename InstanceType, typename ElementType, int N>
+    value_object& field(const char* fieldName, ElementType (InstanceType::*field)[N]) {
+        using namespace internal;
+
+        typedef std::array<ElementType, N> FieldType;
+        static_assert(sizeof(FieldType) == sizeof(ElementType[N]));
+
+        auto getter = &MemberAccess<InstanceType, FieldType>
+        ::template getWire2<ClassType>;
+        auto setter = &MemberAccess<InstanceType, FieldType>
+        ::template setWire2<ClassType>;
+
+        typedef FieldType InstanceType::*MemberPointer;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_gter1"),
+                2,
+                [getter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    const MemberPointer* t1 = reinterpret_cast<MemberPointer*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return getter(*t1, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_ster1"),
+                3,
+                [setter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    const MemberPointer* t1 = reinterpret_cast<MemberPointer*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    setter(*t1, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_object_field(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<FieldType>::get(),
+                getSignature(getter),
+                getterJSIFunc,
+                getContext(field),
+                TypeID<FieldType>::get(),
+                getSignature(setter),
+                setterJSIFunc,
+                getContext(field));
+        return *this;
+    }
+
+    template<typename Getter, typename Setter>
+    value_object& field(
+            const char* fieldName,
+            Getter getter,
+            Setter setter
+    ) {
+        using namespace internal;
+        typedef GetterPolicy<Getter> GP;
+        typedef SetterPolicy<Setter> SP;
+
+        auto g = &GP::template get2<ClassType>;
+        auto s = &SP::template set2<ClassType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_gter2"),
+                2,
+                [g, getter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    Getter* t = reinterpret_cast<Getter*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return g(getter, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_ster2"),
+                3,
+                [s](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    Setter* t = reinterpret_cast<Setter*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    s(*t, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_object_field(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<typename GP::ReturnType>::get(),
+                getSignature(g),
+                getterJSIFunc,
+                GP::getContext(getter),
+                TypeID<typename SP::ArgumentType>::get(),
+                getSignature(s),
+                setterJSIFunc,
+                SP::getContext(setter));
+        return *this;
+    }
+
+    template<int Index>
+    value_object& field(const char* fieldName, index<Index>) {
+        using namespace internal;
+        ClassType* null = 0;
+        typedef typename std::remove_reference<decltype((*null)[Index])>::type ElementType;
+
+        auto getter = &internal::get_by_index<ClassType, ElementType>;
+        auto setter = &internal::set_by_index<ClassType, ElementType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_gter3"),
+                2,
+                [getter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    int t1 = static_cast<int>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return getter(t1, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, "value_object_element_ster3"),
+                3,
+                [setter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    int t1 = static_cast<int>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    setter(t1, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_value_object_field(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<ElementType>::get(),
+                getSignature(getter),
+                getterJSIFunc,
+                reinterpret_cast<void*>(Index),
+                TypeID<ElementType>::get(),
+                getSignature(setter),
+                setterJSIFunc,
+                reinterpret_cast<void*>(Index));
+        return *this;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// SMART POINTERS
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename PointerType>
+struct default_smart_ptr_trait {
+    static sharing_policy get_sharing_policy() {
+        return sharing_policy::NONE;
+    }
+
+    static void* share(void* v) {
+        return 0; // no sharing
+    }
+
+    static PointerType* construct_null() {
+        return new PointerType;
+    }
+};
+
+// specialize if you have a different pointer type
+template<typename PointerType>
+struct smart_ptr_trait : public default_smart_ptr_trait<PointerType> {
+    typedef typename PointerType::element_type element_type;
+
+    static element_type* get(const PointerType& ptr) {
+        return ptr.get();
+    }
+};
+
+template<typename PointeeType>
+struct smart_ptr_trait<std::shared_ptr<PointeeType>> {
+typedef std::shared_ptr<PointeeType> PointerType;
+typedef typename PointerType::element_type element_type;
+
+static element_type* get(const PointerType& ptr) {
+    return ptr.get();
+}
+
+static sharing_policy get_sharing_policy() {
+    return sharing_policy::BY_EMVAL;
+}
+
+static std::shared_ptr<PointeeType>* share(PointeeType* p, EM_VAL v) {
+    return new std::shared_ptr<PointeeType>(
+            p,
+            val_deleter(val::take_ownership(v)));
+}
+
+static PointerType* construct_null() {
+    return new PointerType;
+}
+
+private:
+class val_deleter {
+public:
+    val_deleter() = delete;
+    explicit val_deleter(val v)
+            : v(v)
+    {}
+    void operator()(void const*) {
+        v();
+        // eventually we'll need to support emptied out val
+        v = val::undefined();
+    }
+private:
+    val v;
+};
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+// CLASSES
+////////////////////////////////////////////////////////////////////////////////
+
+namespace internal {
+
+    class WrapperBase {
+    public:
+        void setNotifyJSOnDestruction(bool notify) {
+            notifyJSOnDestruction = notify;
+        }
+
+    protected:
+        bool notifyJSOnDestruction = false;
+    };
+
+} // end namespace internal
+
+// abstract classes
+template<typename T>
+class wrapper : public T, public internal::WrapperBase {
+public:
+    typedef T class_type;
+
+    template<typename... Args>
+    explicit wrapper(val&& wrapped, Args&&... args)
+            : T(std::forward<Args>(args)...)
+            , wrapped(std::forward<val>(wrapped))
+    {}
+
+    ~wrapper() {
+        if (notifyJSOnDestruction) {
+            call<void>("__destruct");
+        }
+    }
+
+    template<typename ReturnType, typename... Args>
+    ReturnType call(const char* name, Args&&... args) const {
+        return wrapped.call<ReturnType>(name, std::forward<Args>(args)...);
+    }
+
+private:
+    val wrapped;
+};
+
+#define EMSCRIPTEN_WRAPPER(T)                                           \
+template<typename... Args>                                          \
+T(::emscripten::val&& v, Args&&... args)                            \
+    : wrapper(std::forward<::emscripten::val>(v), std::forward<Args>(args)...) \
+{}
+
+namespace internal {
+
+    struct NoBaseClass {
+        template<typename ClassType>
+        static void verify() {
+        }
+
+        static TYPEID get() {
+            return nullptr;
+        }
+
+        template<typename ClassType>
+        static VoidFunctionPtr getUpcaster() {
+            return nullptr;
+        }
+
+        template<typename ClassType>
+        static VoidFunctionPtr getDowncaster() {
+            return nullptr;
+        }
+    };
+
+// NOTE: this returns the class type, not the pointer type
+    template<typename T>
+    inline TYPEID getActualType(T* ptr) {
+        return getLightTypeID(*ptr);
+    };
+
+} // end namespace internal
+
+template<typename BaseClass>
+struct base {
+    typedef BaseClass class_type;
+
+    template<typename ClassType>
+    static void verify() {
+        static_assert(!std::is_same<ClassType, BaseClass>::value, "Base must not have same type as class");
+        static_assert(std::is_base_of<BaseClass, ClassType>::value, "Derived class must derive from base");
+    }
+
+    static internal::TYPEID get() {
+        return internal::TypeID<BaseClass>::get();
+    }
+
+    template<typename ClassType>
+    using Upcaster = BaseClass* (*)(ClassType*);
+
+    template<typename ClassType>
+    using Downcaster = ClassType* (*)(BaseClass*);
+
+    template<typename ClassType>
+    static Upcaster<ClassType> getUpcaster() {
+        return &convertPointer<ClassType, BaseClass>;
+    }
+
+    template<typename ClassType>
+    static Downcaster<ClassType> getDowncaster() {
+        return &convertPointer<BaseClass, ClassType>;
+    }
+
+    template<typename From, typename To>
+    static To* convertPointer(From* ptr) {
+        return static_cast<To*>(ptr);
+    }
+};
+
+namespace internal {
+
+    template<typename WrapperType>
+    val wrapped_extend(const std::string& name, const val& properties) {
+        return val::take_ownership(_embind_create_inheriting_constructor(
+                name.c_str(),
+                TypeID<WrapperType>::get(),
+                properties.as_handle()));
+    }
+
+} // end namespace internal
+
+struct pure_virtual {
+    template<typename InputType, int Index>
+    struct Transform {
+        typedef InputType type;
+    };
+};
+
+namespace internal {
+
+    template<typename... Policies>
+    struct isPureVirtual;
+
+    template<typename... Rest>
+    struct isPureVirtual<pure_virtual, Rest...> {
+        static constexpr bool value = true;
+    };
+
+    template<typename T, typename... Rest>
+    struct isPureVirtual<T, Rest...> {
+        static constexpr bool value = isPureVirtual<Rest...>::value;
+    };
+
+    template<>
+    struct isPureVirtual<> {
+        static constexpr bool value = false;
+    };
+
+    struct DeduceArgumentsTag {};
+
+////////////////////////////////////////////////////////////////////////////
+// RegisterClassConstructor
+////////////////////////////////////////////////////////////////////////////
+
+    template <typename T>
+    struct RegisterClassConstructor;
+
+    template<typename ReturnType, typename... Args>
+    struct RegisterClassConstructor<ReturnType (*)(Args...)> {
+
+        template <typename ClassType, typename... Policies>
+        static void invoke(ReturnType (*factory)(Args...)) {
+            typename WithPolicies<allow_raw_pointers, Policies...>::template ArgTypeList<ReturnType, Args...> args;
+            auto invoke = &Invoker<ReturnType, Args...>::invoke2;
+
+            facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                    *jsRuntime,
+                    facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string("RegisterClassConstructor_invoke_")+getSignature(invoke)),
+                    args.getCount() - 1,
+                    [invoke, factory](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                        if constexpr (std::is_same<ReturnType, void>::value) {
+                        callInvokeVoid(sizeof...(Args), invoke, factory);
+                        return nullptr;
+                    } else {
+                        callInvoke(sizeof...(Args), invoke, factory);
+                    }
+                    });
+
+            _embind_register_class_constructor(
+                    TypeID<ClassType>::get(),
+                    args.getCount(),
+                    args.getTypes(),
+                    getSignature(invoke),
+                    invokeJSIFunc,
+                    reinterpret_cast<GenericFunction>(factory));
+        }
+    };
+
+    template<typename ReturnType, typename... Args>
+    struct RegisterClassConstructor<std::function<ReturnType (Args...)>> {
+
+    template <typename ClassType, typename... Policies>
+    static void invoke(std::function<ReturnType (Args...)> factory) {
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, Args...> args;
+        auto invoke = &FunctorInvoker<decltype(factory), ReturnType, Args...>::invoke2;
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string("RegisterClassConstructor_invoke_")+getSignature(invoke)),
+                args.getCount() - 1,
+                [invoke, factory](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                        callInvokeVoid(sizeof...(Args), invoke, factory);
+                        return nullptr;
+                    } else {
+                        callInvoke(sizeof...(Args), invoke, factory);
+                    }
+                });
+
+        _embind_register_class_constructor(
+                TypeID<ClassType>::get(),
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                reinterpret_cast<GenericFunction>(getContext(factory)));
+    }
+};
+
+template<typename ReturnType, typename... Args>
+struct RegisterClassConstructor<ReturnType (Args...)> {
+
+    template <typename ClassType, typename Callable, typename... Policies>
+    static void invoke(Callable& factory) {
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, Args...> args;
+        auto invoke = &FunctorInvoker<decltype(factory), ReturnType, Args...>::invoke2;
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string("RegisterClassConstructor_invoke_")+getSignature(invoke)),
+                args.getCount() - 1,
+                [invoke, factory](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                        callInvokeVoid(sizeof...(Args), invoke, getContext(factory));
+                        return nullptr;
+                    } else {
+                        callInvoke(sizeof...(Args), invoke, getContext(factory));
+                    }
+                });
+
+        _embind_register_class_constructor(
+                TypeID<ClassType>::get(),
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                reinterpret_cast<GenericFunction>(getContext(factory)));
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////
+// RegisterClassMethod
+////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+struct RegisterClassMethod;
+
+template<typename ClassType, typename ReturnType, typename... Args>
+struct RegisterClassMethod<ReturnType (ClassType::*)(Args...)> {
+
+    template <typename CT, typename... Policies>
+    static void invoke(facebook::jsi::Runtime* rt, const char* methodName,
+                       ReturnType (ClassType::*memberFunction)(Args...)) {
+        using OriginalInvoker = MethodInvoker<decltype(memberFunction), ReturnType, ClassType*, Args...>;
+        auto invoke = &maybe_wrap_async<OriginalInvoker, Policies...>::invoke2;
+
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, AllowedRawPointer<ClassType>, Args...> args;
+        auto a = getContext(memberFunction);
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *rt,
+                facebook::jsi::PropNameID::forAscii(*rt, std::string(methodName)+"_"+getSignature(invoke)),
+                args.getCount() + 1,
+                [invoke, a, memberFunction](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                    callInvokeVoid(sizeof...(Args) + 1, invoke, memberFunction);
+                    return nullptr;
+                } else {
+                    callInvoke(sizeof...(Args) + 1, invoke, memberFunction);
+                }
+                });
+
+        _embind_register_class_function(
+                TypeID<ClassType>::get(),
+                methodName,
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                getContext(memberFunction),
+                isPureVirtual<Policies...>::value,
+                isAsync<Policies...>::value);
+    }
+};
+
+#ifdef __cpp_noexcept_function_type
+template<typename ClassType, typename ReturnType, typename... Args>
+struct RegisterClassMethod<ReturnType (ClassType::*)(Args...) noexcept>
+     : RegisterClassMethod<ReturnType (ClassType::*)(Args...)> {};
+#endif
+
+template<typename ClassType, typename ReturnType, typename... Args>
+struct RegisterClassMethod<ReturnType (ClassType::*)(Args...) const> {
+
+    template <typename CT, typename... Policies>
+    static void invoke(facebook::jsi::Runtime* rt, const char* methodName,
+                       ReturnType (ClassType::*memberFunction)(Args...) const)  {
+        using OriginalInvoker = MethodInvoker<decltype(memberFunction), ReturnType, const ClassType*, Args...>;
+        auto invoke = &maybe_wrap_async<OriginalInvoker, Policies...>::invoke2;
+
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, AllowedRawPointer<const ClassType>, Args...> args;
+        auto a = getContext(memberFunction);
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *rt,
+                facebook::jsi::PropNameID::forAscii(*rt, std::string(methodName)+"_"+getSignature(invoke)),
+                args.getCount() + 1,
+                [invoke, a, memberFunction](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                    callInvokeVoid(sizeof...(Args) + 1, invoke, memberFunction);
+                    return nullptr;
+                } else {
+                    callInvoke(sizeof...(Args) + 1, invoke, memberFunction);
+                }
+                });
+
+        _embind_register_class_function(
+                TypeID<ClassType>::get(),
+                methodName,
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                getContext(memberFunction),
+                isPureVirtual<Policies...>::value,
+                isAsync<Policies...>::value);
+    }
+};
+
+#ifdef __cpp_noexcept_function_type
+template<typename ClassType, typename ReturnType, typename... Args>
+struct RegisterClassMethod<ReturnType (ClassType::*)(Args...) const noexcept>
+     : RegisterClassMethod<ReturnType (ClassType::*)(Args...) const> {};
+#endif
+
+template<typename ReturnType, typename ThisType, typename... Args>
+struct RegisterClassMethod<ReturnType (*)(ThisType, Args...)> {
+
+    template <typename ClassType, typename... Policies>
+    static void invoke(facebook::jsi::Runtime* rt, const char* methodName,
+                       ReturnType (*function)(ThisType, Args...)) {
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, ThisType, Args...> args;
+        using OriginalInvoker = FunctionInvoker<decltype(function), ReturnType, ThisType, Args...>;
+        auto invoke = &maybe_wrap_async<OriginalInvoker, Policies...>::invoke2;
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *rt,
+                facebook::jsi::PropNameID::forAscii(*rt, std::string(methodName)+"_"+getSignature(invoke)),
+                args.getCount() + 1,
+                [invoke, function](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                        callInvokeVoid(sizeof...(Args) + 1, invoke, getContext(function));
+                        return nullptr;
+                    } else {
+                        callInvoke(sizeof...(Args) + 1, invoke, getContext(function));
+                    }
+                });
+
+        _embind_register_class_function(
+                TypeID<ClassType>::get(),
+                methodName,
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                getContext(function),
+                false,
+                isAsync<Policies...>::value);
+    }
+};
+
+#ifdef __cpp_noexcept_function_type
+template<typename ReturnType, typename ThisType, typename... Args>
+struct RegisterClassMethod<ReturnType (*)(ThisType, Args...) noexcept>
+     : RegisterClassMethod<ReturnType (*)(ThisType, Args...)> {};
+#endif
+
+template<typename ReturnType, typename ThisType, typename... Args>
+struct RegisterClassMethod<std::function<ReturnType (ThisType, Args...)>> {
+
+template <typename ClassType, typename... Policies>
+static void invoke(facebook::jsi::Runtime* rt, const char* methodName,
+                   std::function<ReturnType (ThisType, Args...)> function) {
+    typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, ThisType, Args...> args;
+    using OriginalInvoker = FunctorInvoker<decltype(function), ReturnType, ThisType, Args...>;
+    auto invoke = &maybe_wrap_async<OriginalInvoker, Policies...>::invoke2;
+
+    facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+            *rt,
+            facebook::jsi::PropNameID::forAscii(*rt, std::string(methodName)+"_"+getSignature(invoke)),
+            args.getCount() + 1,
+            [invoke, function](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                if constexpr (std::is_same<ReturnType, void>::value) {
+                callInvokeVoid(sizeof...(Args) + 1, invoke, function);
+                return nullptr;
+            } else {
+                callInvoke(sizeof...(Args) + 1, invoke, function);
+            }
+            });
+
+    _embind_register_class_function(
+            TypeID<ClassType>::get(),
+            methodName,
+            args.getCount(),
+            args.getTypes(),
+            getSignature(invoke),
+            invokeJSIFunc,
+            getContext(function),
+            false,
+            isAsync<Policies...>::value);
+}
+};
+
+template<typename ReturnType, typename ThisType, typename... Args>
+struct RegisterClassMethod<ReturnType (ThisType, Args...)> {
+
+    template <typename ClassType, typename Callable, typename... Policies>
+    static void invoke(facebook::jsi::Runtime* rt, const char* methodName,
+                       Callable& callable) {
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, ThisType, Args...> args;
+        using OriginalInvoker = FunctorInvoker<decltype(callable), ReturnType, ThisType, Args...>;
+        auto invoke = &maybe_wrap_async<OriginalInvoker, Policies...>::invoke2;
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *rt,
+                facebook::jsi::PropNameID::forAscii(*rt, std::string(methodName)+"_"+getSignature(invoke)),
+                args.getCount() + 1,
+                [invoke, callable](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                    callInvokeVoid(sizeof...(Args) + 1, invoke, callable);
+                    return nullptr;
+                } else {
+                    callInvoke(sizeof...(Args) + 1, invoke, callable);
+                }
+                });
+
+        _embind_register_class_function(
+                TypeID<ClassType>::get(),
+                methodName,
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                getContext(callable),
+                false,
+                isAsync<Policies...>::value);
+    }
+};
+
+} // end namespace internal
+
+template<typename... ConstructorArgs>
+struct constructor {
+};
+
+template<typename ClassType, typename BaseSpecifier>
+facebook::jsi::Value dsadsa(facebook::jsi::Runtime& rt, ClassType* rawValue, BaseSpecifier*);
+
+template<typename ClassType, typename BaseSpecifier>
+facebook::jsi::Value dsadsa(facebook::jsi::Runtime& rt, ClassType* rawValue, BaseSpecifier*) {
+    auto upcast   = BaseSpecifier::template getUpcaster<ClassType>();
+    auto r = upcast(rawValue);
+    return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(r));
+}
+
+template<typename ClassType, typename BaseSpecifier>
+facebook::jsi::Value dsadsa(facebook::jsi::Runtime& rt, ClassType* rawValue, internal::NoBaseClass*) {
+    return facebook::jsi::Value::undefined();
+}
+
+
+template<typename ClassType, typename BaseSpecifier>
+facebook::jsi::Value downcastHelper(facebook::jsi::Runtime& rt, ClassType* rawValue, BaseSpecifier*);
+
+template<typename ClassType, typename BaseSpecifier>
+facebook::jsi::Value downcastHelper(facebook::jsi::Runtime& rt, ClassType* rawValue, BaseSpecifier*) {
+    auto downcast = BaseSpecifier::template getDowncaster<ClassType>();
+    auto r = downcast(rawValue);
+    return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(r));
+}
+
+template<typename ClassType, typename BaseSpecifier>
+facebook::jsi::Value downcastHelper(facebook::jsi::Runtime& rt, ClassType* rawValue, internal::NoBaseClass*) {
+    return facebook::jsi::Value::undefined();
+}
+
+template<typename ClassType, typename BaseSpecifier = internal::NoBaseClass>
+class class_ {
+public:
+    typedef ClassType class_type;
+    typedef BaseSpecifier base_specifier;
+
+    class_() = delete;
+
+    EMSCRIPTEN_ALWAYS_INLINE explicit class_(const char* name) {
+        using namespace internal;
+
+        BaseSpecifier::template verify<ClassType>();
+
+        auto _getActualType = &getActualType<ClassType>;
+        auto upcast   = BaseSpecifier::template getUpcaster<ClassType>();
+        auto downcast = BaseSpecifier::template getDowncaster<ClassType>();
+        auto destructor = &raw_destructor<ClassType>;
+
+        facebook::jsi::Function _getActualTypeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"__getActualType"),
+                1,
+                [_getActualType](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    auto returnValue = _getActualType(reinterpret_cast<ClassType*>(args[0].asBigInt(rt).asUint64(rt)));
+                    return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(returnValue));
+                });
+
+        facebook::jsi::Function upcastJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_upcast"),
+                1,
+                [upcast](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t = reinterpret_cast<ClassType*>(args[0].asBigInt(rt).asUint64(rt));
+                    BaseSpecifier* a = nullptr;
+                    return dsadsa<ClassType, BaseSpecifier>(rt, t, a);
+                });
+
+        facebook::jsi::Function downcastJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_downcast"),
+                1,
+                [downcast](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t = reinterpret_cast<ClassType*>(args[0].asBigInt(rt).asUint64(rt));
+                    BaseSpecifier* a = nullptr;
+                    return downcastHelper<ClassType, BaseSpecifier>(rt, t, a);
+                });
+
+        facebook::jsi::Function destructorJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_destructor"),
+                1,
+                [destructor](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    destructor(reinterpret_cast<ClassType*>(args[0].asBigInt(rt).asUint64(rt)));
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_class(
+                TypeID<ClassType>::get(),
+                TypeID<AllowedRawPointer<ClassType>>::get(),
+                TypeID<AllowedRawPointer<const ClassType>>::get(),
+                BaseSpecifier::get(),
+                getSignature(_getActualType),
+                _getActualTypeJSIFunc,
+                getSignature(upcast),
+                upcastJSIFunc,
+                getSignature(downcast),
+                downcastJSIFunc,
+                name,
+                getSignature(destructor),
+                destructorJSIFunc);
+    }
+
+    template<typename PointerType>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& smart_ptr(const char* name) const {
+        using namespace internal;
+
+        typedef smart_ptr_trait<PointerType> PointerTrait;
+        typedef typename PointerTrait::element_type PointeeType;
+
+        static_assert(std::is_same<ClassType, typename std::remove_cv<PointeeType>::type>::value, "smart pointer must point to this class");
+
+        auto get = &PointerTrait::get;
+        auto construct_null = &PointerTrait::construct_null;
+        auto share = &PointerTrait::share;
+        auto destructor = &raw_destructor<PointerType>;
+
+        facebook::jsi::Function getJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_get"),
+                1,
+                [get](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    uint64_t ptrNumber = args[0].asBigInt(rt).asUint64(rt);
+                    auto b = *reinterpret_cast<PointerType*>(ptrNumber);
+                    auto a = get(b);
+                    return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(a));
+                });
+
+        facebook::jsi::Function construct_nullJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_construct_null"),
+                1,
+                [construct_null](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    auto a = construct_null();
+                    return facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(a));
+                });
+
+        facebook::jsi::Function shareJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_share"),
+                2,
+                [share](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    uint64_t pNumber = args[0].asBigInt(rt).asUint64(rt);
+                    auto p = reinterpret_cast<PointeeType*>(pNumber);
+                    // uint64_t vNumber = (uint64_t) args[1].getNumber();
+                    uint64_t vNumber = args[1].asBigInt(rt).asUint64(rt);
+                    EM_VAL v = reinterpret_cast<EM_VAL>(vNumber);
+                    auto a = share(p, v);
+                    auto e = facebook::jsi::BigInt::fromUint64(rt, reinterpret_cast<uint64_t>(a));
+                    return e;
+                });
+
+        facebook::jsi::Function destructorJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_destructor"),
+                1,
+                [destructor](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    uint64_t ptrNumber = args[0].asBigInt(rt).asUint64(rt);
+                    auto b = reinterpret_cast<PointerType*>(ptrNumber);
+                    destructor(b);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_smart_ptr(
+                TypeID<PointerType>::get(),
+                TypeID<PointeeType>::get(),
+                name,
+                PointerTrait::get_sharing_policy(),
+                getSignature(get),
+                getJSIFunc,
+                getSignature(construct_null),
+                construct_nullJSIFunc,
+                getSignature(share),
+                shareJSIFunc,
+                getSignature(destructor),
+                destructorJSIFunc);
+        return *this;
+    };
+
+    template<typename... ConstructorArgs, typename... Policies>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& constructor(Policies... policies) const {
+        return constructor(
+                &internal::operator_new<ClassType, ConstructorArgs...>,
+                policies...);
+    }
+
+    template<typename Signature = internal::DeduceArgumentsTag, typename Callable, typename... Policies>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& constructor(Callable callable, Policies...) const {
+
+        using invoker = internal::RegisterClassConstructor<
+                typename std::conditional<std::is_same<Signature, internal::DeduceArgumentsTag>::value,
+                        Callable,
+                        Signature>::type>;
+
+        invoker::template invoke<ClassType, Policies...>(callable);
+        return *this;
+    }
+
+    template<typename SmartPtr, typename... Args, typename... Policies>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& smart_ptr_constructor(const char* smartPtrName, SmartPtr (*factory)(Args...), Policies...) const {
+        using namespace internal;
+
+        // smart_ptr<SmartPtr>(smartPtrName);
+
+        typename WithPolicies<Policies...>::template ArgTypeList<SmartPtr, Args...> args;
+        auto invoke = &Invoker<SmartPtr, Args...>::invoke2;
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(smartPtrName)+"_"+getSignature(invoke)),
+                args.getCount() - 1,
+                [invoke, factory](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    callInvoke(sizeof...(Args), invoke, factory);
+                });
+
+        _embind_register_class_constructor(
+                TypeID<ClassType>::get(),
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                reinterpret_cast<GenericFunction>(factory));
+        return *this;
+    }
+
+    template<typename WrapperType, typename... ConstructorArgs>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
+            const char* wrapperClassName,
+            ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>()
+    ) const {
+        using namespace internal;
+
+        auto cls = class_<WrapperType, base<ClassType>>(wrapperClassName)
+                .function("notifyOnDestruction", select_overload<void(WrapperType&)>([](WrapperType& wrapper) {
+                    wrapper.setNotifyJSOnDestruction(true);
+                }))
+        ;
+
+        return
+                class_function(
+                        "implement",
+                        &wrapped_new<WrapperType*, WrapperType, val, ConstructorArgs...>,
+                        allow_raw_pointer<ret_val>())
+        .class_function(
+                "extend",
+                &wrapped_extend<WrapperType>)
+                ;
+    }
+
+    template<typename WrapperType, typename PointerType, typename... ConstructorArgs>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
+            const char* wrapperClassName,
+            const char* pointerName,
+            ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>()
+    ) const {
+        using namespace internal;
+
+        auto cls = class_<WrapperType, base<ClassType>>(wrapperClassName)
+                .function("notifyOnDestruction", select_overload<void(WrapperType&)>([](WrapperType& wrapper) {
+                    wrapper.setNotifyJSOnDestruction(true);
+                }))
+                .template smart_ptr<PointerType>(pointerName)
+        ;
+
+        return
+                class_function(
+                        "implement",
+                        &wrapped_new<PointerType, WrapperType, val, ConstructorArgs...>,
+                        allow_raw_pointer<ret_val>())
+        .class_function(
+                "extend",
+                &wrapped_extend<WrapperType>)
+                ;
+    }
+
+    template<typename Signature = internal::DeduceArgumentsTag, typename Callable, typename... Policies>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& function(const char* methodName, Callable callable, Policies...) const {
+        using invoker = internal::RegisterClassMethod<
+                typename std::conditional<std::is_same<Signature, internal::DeduceArgumentsTag>::value,
+                        Callable,
+                        Signature>::type>;
+
+        invoker::template invoke<ClassType, Policies...>(jsRuntime, methodName, callable);
+        return *this;
+    }
+
+    template<typename FieldType, typename = typename std::enable_if<!std::is_function<FieldType>::value>::type>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, const FieldType ClassType::*field) const {
+        using namespace internal;
+
+        auto getter = &MemberAccess<ClassType, FieldType>::template getWire2<ClassType>;
+        FieldType ClassType::* a = const_cast<FieldType ClassType::*>(field);
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName)+"_gter"),
+                2,
+                [getter, a](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return getter(a, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName)+"_ster"),
+                0,
+                [](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_class_property(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<FieldType>::get(),
+                getSignature(getter),
+                getterJSIFunc,
+                getContext(field),
+                0,
+                "",
+                setterJSIFunc,
+                0);
+        return *this;
+    }
+
+    template<typename FieldType, typename = typename std::enable_if<!std::is_function<FieldType>::value>::type>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, FieldType ClassType::*field) const {
+        using namespace internal;
+
+        auto getter = &MemberAccess<ClassType, FieldType>::template getWire2<ClassType>;
+        auto setter = &MemberAccess<ClassType, FieldType>::template setWire2<ClassType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName)+"_gter"),
+                2,
+                [getter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    FieldType* t = reinterpret_cast<FieldType*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return getter(field, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName)+"_ster"),
+                3,
+                [setter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    FieldType* t = reinterpret_cast<FieldType*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    setter(field, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_class_property(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<FieldType>::get(),
+                getSignature(getter),
+                getterJSIFunc,
+                getContext(field),
+                TypeID<FieldType>::get(),
+                getSignature(setter),
+                setterJSIFunc,
+                getContext(field));
+        return *this;
+    }
+
+    template<typename PropertyType = internal::DeduceArgumentsTag, typename Getter>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, Getter getter) const {
+        using namespace internal;
+
+        typedef GetterPolicy<
+                typename std::conditional<std::is_same<PropertyType, internal::DeduceArgumentsTag>::value,
+                        Getter,
+        PropertyTag<Getter, PropertyType>>::type> GP;
+
+        auto gter = &GP::template get2<ClassType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName) + "_gter"),
+                2,
+                [gter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    Getter* t = reinterpret_cast<Getter*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return gter(*t, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName)+"_ster"),
+                3,
+                [](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_class_property(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<typename GP::ReturnType>::get(),
+                getSignature(gter),
+                getterJSIFunc,
+                GP::getContext(getter),
+                0,
+                "",
+                setterJSIFunc,
+                0);
+        return *this;
+    }
+
+    template<typename PropertyType = internal::DeduceArgumentsTag, typename Getter, typename Setter>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, Getter getter, Setter setter) const {
+        using namespace internal;
+
+        typedef GetterPolicy<
+                typename std::conditional<std::is_same<PropertyType, internal::DeduceArgumentsTag>::value,
+                        Getter,
+        PropertyTag<Getter, PropertyType>>::type> GP;
+        typedef SetterPolicy<
+                typename std::conditional<std::is_same<PropertyType, internal::DeduceArgumentsTag>::value,
+                        Setter,
+        PropertyTag<Setter, PropertyType>>::type> SP;
+
+
+        auto gter = &GP::template get2<ClassType>;
+        auto ster = &SP::template set2<ClassType>;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName)+"_gter"),
+                2,
+                [gter](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    Getter* t = reinterpret_cast<Getter*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    return gter(*t, *t2);
+                });
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(fieldName)+"_ster"),
+                3,
+                [ster](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    Setter* t = reinterpret_cast<Setter*>(args[0].asBigInt(rt).asUint64(rt));
+                    ClassType* t2 = reinterpret_cast<ClassType*>(args[1].asBigInt(rt).asUint64(rt));
+                    ster(*t, *t2, args[2]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_class_property(
+                TypeID<ClassType>::get(),
+                fieldName,
+                TypeID<typename GP::ReturnType>::get(),
+                getSignature(gter),
+                getterJSIFunc,
+                GP::getContext(getter),
+                TypeID<typename SP::ArgumentType>::get(),
+                getSignature(ster),
+                setterJSIFunc,
+                SP::getContext(setter));
+        return *this;
+    }
+
+    template<typename ReturnType, typename... Args, typename... Policies>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& class_function(const char* methodName, ReturnType (*classMethod)(Args...), Policies...) const {
+        using namespace internal;
+
+        typename WithPolicies<Policies...>::template ArgTypeList<ReturnType, Args...> args;
+        using OriginalInvoker = internal::Invoker<ReturnType, Args...>;
+        auto invoke = &maybe_wrap_async<OriginalInvoker, Policies...>::invoke2;
+
+        facebook::jsi::Function invokeJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(methodName)+"_"+getSignature(invoke)),
+                args.getCount() - 1,
+                [invoke, classMethod](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    if constexpr (std::is_same<ReturnType, void>::value) {
+                    callInvokeVoid(sizeof...(Args), invoke, classMethod);
+                    return nullptr;
+                } else {
+                    callInvoke(sizeof...(Args), invoke, classMethod);
+                }
+                });
+
+        _embind_register_class_class_function(
+                TypeID<ClassType>::get(),
+                methodName,
+                args.getCount(),
+                args.getTypes(),
+                getSignature(invoke),
+                invokeJSIFunc,
+                reinterpret_cast<GenericFunction>(classMethod),
+                isAsync<Policies...>::value);
+        return *this;
+    }
+
+    template<typename FieldType>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& class_property(const char* name, const FieldType* field) const {
+        using namespace internal;
+
+        auto getter = &GlobalAccess<FieldType>::get2;
+
+        FieldType* a = const_cast<FieldType*>(field);
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_"+getSignature(getter)),
+                1,
+                [getter, a](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    return getter(a);
+                });
+
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_null_setter"),
+                2,
+                [](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_class_class_property(
+                TypeID<ClassType>::get(),
+                name,
+                TypeID<FieldType>::get(),
+                a,
+                getSignature(getter),
+                getterJSIFunc,
+                "",
+                setterJSIFunc);
+        return *this;
+    }
+
+    template<typename FieldType>
+    EMSCRIPTEN_ALWAYS_INLINE const class_& class_property(const char* name, FieldType* field) const {
+        using namespace internal;
+
+        auto getter = &GlobalAccess<FieldType>::get2;
+        auto setter = &GlobalAccess<FieldType>::set2;
+
+        facebook::jsi::Function getterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_"+getSignature(getter)),
+                1,
+                [getter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    return getter(field);
+                });
+
+
+        facebook::jsi::Function setterJSIFunc = facebook::jsi::Function::createFromHostFunction(
+                *jsRuntime,
+                facebook::jsi::PropNameID::forAscii(*jsRuntime, std::string(name)+"_"+getSignature(setter)),
+                2,
+                [setter, field](facebook::jsi::Runtime& rt, const facebook::jsi::Value& thisVal, const facebook::jsi::Value* args, size_t count) {
+                    setter(field, args[1]);
+                    return facebook::jsi::Value::undefined();
+                });
+
+        _embind_register_class_class_property(
+                TypeID<ClassType>::get(),
+                name,
+                TypeID<FieldType>::get(),
+                field,
+                getSignature(getter),
+                getterJSIFunc,
+                getSignature(setter),
+                setterJSIFunc);
+        return *this;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// VECTORS
+////////////////////////////////////////////////////////////////////////////////
+
+namespace internal {
+
+    template<typename VectorType, typename Type>
+    struct VectorAccess {
+        static val get(
+                const VectorType& v,
+                int index
+        ) {
+            if (index < v.size()) {
+                return val(v[index]);
+            } else {
+                return val::undefined();
+            }
+        }
+
+        static bool set(
+                VectorType& v,
+                int index,
+                const typename VectorType::value_type& value
+        ) {
+            v[index] = value;
+            return true;
+        }
+
+        static int size(VectorType& v) {
+            return (int) v.size();
+        }
+    };
+
+} // end namespace internal
+
+template<typename T>
+void register_optional() {
+    // Mirrors upstream embind: the optional<T> TYPEID resolves to a JS converter that
+    // delegates to T's converter, with no-value crossing as undefined.
+    internal::_embind_register_optional(
+            internal::TypeID<std::optional<T>>::get(),
+            internal::TypeID<T>::get());
+}
+
+template<typename T>
+class_<std::vector<T>> register_vector(const char* name) {
+    typedef std::vector<T> VecType;
+    // Upstream registers the element's optional alongside the vector; matching it keeps
+    // optional<T> usable wherever a vector of T is registered (the common bridge case).
+    register_optional<T>();
+
+    void (VecType::*push_back)(const T&) = &VecType::push_back;
+    void (VecType::*resize)(const size_t, const T&) = &VecType::resize;
+    // size_t (VecType::*size)() const = &VecType::size;
+    return class_<std::vector<T>>(name)
+            .template constructor<>()
+            .function("push_back", push_back)
+            .function("resize", resize)
+            .function("size", &internal::VectorAccess<VecType, T>::size)
+            .function("get", &internal::VectorAccess<VecType, T>::get)
+            .function("set", &internal::VectorAccess<VecType, T>::set)
+            ;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// MAPS
+////////////////////////////////////////////////////////////////////////////////
+
+namespace internal {
+
+    template<typename MapType>
+    struct MapAccess {
+        static val get(
+                const MapType& m,
+                const typename MapType::key_type& k
+        ) {
+            auto i = m.find(k);
+            if (i == m.end()) {
+                return val::undefined();
+            } else {
+                return val(i->second);
+            }
+        }
+
+        static void set(
+                MapType& m,
+                const typename MapType::key_type& k,
+                const typename MapType::mapped_type& v
+        ) {
+            m[k] = v;
+        }
+
+        static std::vector<typename MapType::key_type> keys(
+                const MapType& m
+        ) {
+            std::vector<typename MapType::key_type> keys;
+            keys.reserve(m.size());
+            for (const auto& pair : m) {
+                keys.push_back(pair.first);
+            }
+            return keys;
+        }
+    };
+
+} // end namespace internal
+
+template<typename K, typename V>
+class_<std::map<K, V>> register_map(const char* name) {
+    typedef std::map<K,V> MapType;
+
+    size_t (MapType::*size)() const = &MapType::size;
+    return class_<MapType>(name)
+            .template constructor<>()
+            .function("size", size)
+            .function("get", internal::MapAccess<MapType>::get)
+            .function("set", internal::MapAccess<MapType>::set)
+            .function("keys", internal::MapAccess<MapType>::keys)
+            ;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// ENUMS
+////////////////////////////////////////////////////////////////////////////////
+
+template<typename EnumType>
+class enum_ {
+public:
+    typedef EnumType enum_type;
+
+    enum_(const char* name) {
+        using namespace internal;
+        _embind_register_enum(
+                internal::TypeID<EnumType>::get(),
+                name,
+                sizeof(EnumType),
+                std::is_signed<typename std::underlying_type<EnumType>::type>::value);
+    }
+
+    enum_& value(const char* name, EnumType value) {
+        using namespace internal;
+        // TODO: there's still an issue here.
+        // if EnumType is an unsigned long, then JS may receive it as a signed long
+        static_assert(sizeof(value) <= sizeof(internal::GenericEnumValue), "enum type must fit in a GenericEnumValue");
+
+        _embind_register_enum_value(
+                internal::TypeID<EnumType>::get(),
+                name,
+                static_cast<internal::GenericEnumValue>(value));
+        return *this;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// CONSTANTS
+////////////////////////////////////////////////////////////////////////////////
+
+namespace internal {
+
+    template<typename T> double asGenericValue(T t) {
+        return static_cast<double>(t);
+    }
+
+    template<typename T> uint64_t asGenericValue(T* p) {
+        return reinterpret_cast<uint64_t>(p);
+    }
+
+    template<typename T> std::string asGenericValue(std::string p) {
+        return p;
+    }
+
+}
+
+template<typename ConstantType>
+void constant(const char* name, const ConstantType& v) {
+    using namespace internal;
+    typedef BindingType<const ConstantType&> BT;
+    _embind_register_constant(
+            name,
+            TypeID<const ConstantType&>::get(),
+            BT::toWireType2(*jsRuntime, v)
+            );
+}
+
+// EMSCRIPTEN_BINDINGS creates a static struct to initialize the binding which
+// will get included in the program if the translation unit in which it is
+// defined gets linked into the program. Using a C++ constructor here ensures it
+// occurs after any other C++ constructors in this file, which is not true for
+// __attribute__((constructor)) (they run before C++ constructors in the same
+// file).
+#define EMSCRIPTEN_BINDINGS(name)                                              \
+  static void embind_init_##name();                                            \
+  static struct EmBindInit_##name : emscripten::internal::InitFunc {           \
+    EmBindInit_##name() : InitFunc(embind_init_##name) {}                      \
+  } EmBindInit_##name##_instance;                                              \
+  static void embind_init_##name()
+
+} // end namespace emscripten
+
+class Crossbind {
+public:
+    static int setEnv(std::string key, std::string value, bool overwrite);
+    static std::string getEnv(std::string key);
+};