emnapi 1.9.2 → 2.0.0-alpha.1

package/include/node/node_version.h

@@ -0,0 +1,110 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_NODE_VERSION_H_
+#define SRC_NODE_VERSION_H_
+
+#define NODE_MAJOR_VERSION 22
+#define NODE_MINOR_VERSION 15
+#define NODE_PATCH_VERSION 0
+
+#define NODE_VERSION_IS_LTS 1
+#define NODE_VERSION_LTS_CODENAME "Jod"
+
+#define NODE_VERSION_IS_RELEASE 1
+
+#ifndef NODE_STRINGIFY
+#define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)
+#define NODE_STRINGIFY_HELPER(n) #n
+#endif
+
+#ifndef NODE_RELEASE
+#define NODE_RELEASE "node"
+#endif
+
+#ifndef NODE_TAG
+# if NODE_VERSION_IS_RELEASE
+#  define NODE_TAG ""
+# else
+#  define NODE_TAG "-pre"
+# endif
+#else
+// NODE_TAG is passed without quotes when rc.exe is run from msbuild
+# define NODE_EXE_VERSION NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                          NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                          NODE_STRINGIFY(NODE_PATCH_VERSION)     \
+                          NODE_STRINGIFY(NODE_TAG)
+#endif
+
+# define NODE_VERSION_STRING  NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_PATCH_VERSION)     \
+                              NODE_TAG
+#ifndef NODE_EXE_VERSION
+# define NODE_EXE_VERSION NODE_VERSION_STRING
+#endif
+
+#define NODE_VERSION "v" NODE_VERSION_STRING
+
+
+#define NODE_VERSION_AT_LEAST(major, minor, patch) \
+  (( (major) < NODE_MAJOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && (minor) < NODE_MINOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && \
+      (minor) == NODE_MINOR_VERSION && (patch) <= NODE_PATCH_VERSION))
+
+/**
+ * Node.js will refuse to load modules that weren't compiled against its own
+ * module ABI number, exposed as the process.versions.modules property.
+ *
+ * Node.js will refuse to load modules with a non-matching ABI version. The
+ * version number here should be changed whenever an ABI-incompatible API change
+ * is made in the C++ side, including in V8 or other dependencies.
+ *
+ * Node.js will not change the module version during a Major release line
+ * We will, at times update the version of V8 shipped in the release line
+ * if it can be made ABI compatible with the previous version.
+ *
+ * Embedders building Node.js can define NODE_EMBEDDER_MODULE_VERSION to
+ * override the default value of NODE_MODULE_VERSION.
+ *
+ * The registry of used NODE_MODULE_VERSION numbers is located at
+ *   https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json
+ * Extenders, embedders and other consumers of Node.js that require ABI
+ * version matching should open a pull request to reserve a number in this
+ * registry.
+ */
+#if defined(NODE_EMBEDDER_MODULE_VERSION)
+#define NODE_MODULE_VERSION NODE_EMBEDDER_MODULE_VERSION
+#else
+#define NODE_MODULE_VERSION 127
+#endif
+
+// The NAPI_VERSION supported by the runtime. This is the inclusive range of
+// versions which the Node.js binary being built supports.
+#define NODE_API_SUPPORTED_VERSION_MAX 10
+#define NODE_API_SUPPORTED_VERSION_MIN 1
+
+// Node API modules use NAPI_VERSION 8 by default if it is not explicitly
+// specified. It must be always 8.
+#define NODE_API_DEFAULT_MODULE_API_VERSION 8
+
+#endif  // SRC_NODE_VERSION_H_

package/include/node/uv/unix.h

@@ -15,6 +15,7 @@ typedef pthread_t uv_thread_t;
 typedef pthread_mutex_t uv_mutex_t;
 typedef sem_t uv_sem_t;
 typedef pthread_cond_t uv_cond_t;
+typedef pthread_key_t uv_key_t;
 
 #endif
 

package/include/node/uv/version.h

@@ -0,0 +1,43 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_VERSION_H
+#define UV_VERSION_H
+
+ /*
+ * Versions with the same major number are ABI stable. API is allowed to
+ * evolve between minor releases, but only in a backwards compatible way.
+ * Make sure you update the -soname directives in configure.ac
+ * whenever you bump UV_VERSION_MAJOR or UV_VERSION_MINOR (but
+ * not UV_VERSION_PATCH.)
+ */
+
+#define UV_VERSION_MAJOR 1
+#define UV_VERSION_MINOR 48
+#define UV_VERSION_PATCH 0
+#define UV_VERSION_IS_RELEASE 1
+#define UV_VERSION_SUFFIX ""
+
+#define UV_VERSION_HEX  ((UV_VERSION_MAJOR << 16) | \
+                         (UV_VERSION_MINOR <<  8) | \
+                         (UV_VERSION_PATCH))
+
+#endif /* UV_VERSION_H */

package/include/node/uv.h

@@ -7,6 +7,7 @@
 extern "C" {
 #endif
 
+#include "uv/version.h"
 #include <stddef.h>
 #include <stdint.h>
 
@@ -80,6 +81,11 @@ UV_EXTERN void uv_cond_destroy(uv_cond_t* cond);
 
 UV_EXTERN void uv_once(uv_once_t* guard, void (*callback)(void));
 
+UV_EXTERN int uv_key_create(uv_key_t* key);
+UV_EXTERN void uv_key_delete(uv_key_t* key);
+UV_EXTERN void* uv_key_get(uv_key_t* key);
+UV_EXTERN void uv_key_set(uv_key_t* key, void* value);
+
 struct uv_work_s {
   UV_REQ_FIELDS
   uv_loop_t* loop;

package/index.js

@@ -34,17 +34,21 @@ exports.requiredConfig = {
     settings: {
       WASM_BIGINT: '1',
       ALLOW_MEMORY_GROWTH: '1',
+      ALLOW_TABLE_GROWTH: '1',
       MIN_CHROME_VERSION: '85',
       EXPORTED_RUNTIME_METHODS: [
-        'emnapiInit'
+        'emnapiInit',
       ],
       EXPORTED_FUNCTIONS: [
         '_malloc',
         '_free',
         '_napi_register_wasm_v1',
-        '_node_api_module_get_api_version_v1'
-      ]
-    }
+        '_node_api_module_get_api_version_v1',
+        '_emnapi_create_env',
+        '_emnapi_delete_env',
+        '_uv_library_shutdown'
+      ],
+    },
   },
   clang: {
     target: 'wasm32-wasip1-threads',
@@ -54,13 +58,17 @@ exports.requiredConfig = {
       '--import-memory',
       '--shared-memory',
       '--export-table',
+      '--growable-table',
       '--export=malloc',
       '--export=free',
       '--export=napi_register_wasm_v1',
       '--export-if-defined=node_api_module_get_api_version_v1',
       '--export=emnapi_thread_crashed',
       '--export-if-defined=emnapi_async_worker_create',
-      '--export-if-defined=emnapi_async_worker_init'
-    ]
-  }
+      '--export-if-defined=emnapi_async_worker_init',
+      '--export-if-defined=uv_library_shutdown',
+      '--export=emnapi_create_env',
+      '--export=emnapi_delete_env',
+    ],
+  },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "1.9.2",
+  "version": "2.0.0-alpha.1",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "gypfile": false,

package/src/async_cleanup_hook.c

@@ -8,7 +8,7 @@ EXTERN_C_START
 typedef void (*async_cleanup_hook)(void* arg, void(*)(void*), void*);
 
 struct async_cleanup_hook_info {
-  napi_env env;
+  node_api_basic_env env;
   async_cleanup_hook fun;
   void* arg;
   bool started;
@@ -16,7 +16,7 @@ struct async_cleanup_hook_info {
 
 struct napi_async_cleanup_hook_handle__ {
   struct async_cleanup_hook_info* handle_;
-  napi_env env_;
+  node_api_basic_env env_;
   napi_async_cleanup_hook user_hook_;
   void* user_data_;
   void (*done_cb_)(void*);
@@ -46,7 +46,7 @@ static void _emnapi_run_async_cleanup_hook(void* arg) {
 }
 
 static struct async_cleanup_hook_info*
-_emnapi_add_async_environment_cleanup_hook(napi_env env,
+_emnapi_add_async_environment_cleanup_hook(node_api_basic_env env,
                                            async_cleanup_hook fun,
                                            void* arg) {
   struct async_cleanup_hook_info* info =
@@ -68,7 +68,7 @@ static void _emnapi_remove_async_environment_cleanup_hook(
 }
 
 static napi_async_cleanup_hook_handle
-_emnapi_ach_handle_create(napi_env env,
+_emnapi_ach_handle_create(node_api_basic_env env,
                           napi_async_cleanup_hook user_hook,
                           void* user_data) {
   napi_async_cleanup_hook_handle handle =
@@ -83,7 +83,7 @@ _emnapi_ach_handle_create(napi_env env,
 }
 
 static void _emnapi_ach_handle_env_unref(void* arg) {
-  napi_env env = (napi_env) arg;
+  node_api_basic_env env = (node_api_basic_env) arg;
   _emnapi_env_unref(env);
 }
 
@@ -92,7 +92,7 @@ _emnapi_ach_handle_delete(napi_async_cleanup_hook_handle handle) {
   _emnapi_remove_async_environment_cleanup_hook(handle->handle_);
   if (handle->done_cb_ != NULL) handle->done_cb_(handle->done_data_);
 
-  _emnapi_set_immediate(_emnapi_ach_handle_env_unref, handle->env_);
+  _emnapi_set_immediate(_emnapi_ach_handle_env_unref, (void*) handle->env_);
 
   free(handle->handle_);
   free(handle);

package/src/emnapi_internal.h

@@ -75,12 +75,6 @@ EXTERN_C_END
 
 EXTERN_C_START
 
-EMNAPI_INTERNAL_EXTERN napi_status napi_set_last_error(node_api_basic_env env,
-                                       napi_status error_code,
-                                       uint32_t engine_error_code,
-                                       void* engine_reserved);
-EMNAPI_INTERNAL_EXTERN napi_status napi_clear_last_error(node_api_basic_env env);
-
 #ifdef __EMSCRIPTEN__
 #if __EMSCRIPTEN_major__ * 10000 + __EMSCRIPTEN_minor__ * 100 + __EMSCRIPTEN_tiny__ >= 30114  // NOLINT
 #define EMNAPI_KEEPALIVE_PUSH emscripten_runtime_keepalive_push
@@ -103,8 +97,8 @@ EMNAPI_INTERNAL_EXTERN void _emnapi_runtime_keepalive_pop();
 
 EMNAPI_INTERNAL_EXTERN napi_handle_scope _emnapi_open_handle_scope();
 EMNAPI_INTERNAL_EXTERN void _emnapi_close_handle_scope(napi_handle_scope scope);
-EMNAPI_INTERNAL_EXTERN void _emnapi_env_ref(napi_env env);
-EMNAPI_INTERNAL_EXTERN void _emnapi_env_unref(napi_env env);
+EMNAPI_INTERNAL_EXTERN void _emnapi_env_ref(node_api_basic_env env);
+EMNAPI_INTERNAL_EXTERN void _emnapi_env_unref(node_api_basic_env env);
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_increase_waiting_request_counter();
 EMNAPI_INTERNAL_EXTERN void _emnapi_ctx_decrease_waiting_request_counter();
 
@@ -113,8 +107,7 @@ EMNAPI_INTERNAL_EXTERN int _emnapi_is_main_runtime_thread();
 EMNAPI_INTERNAL_EXTERN double _emnapi_get_now();
 EMNAPI_INTERNAL_EXTERN void _emnapi_unwind();
 EMNAPI_INTERNAL_EXTERN void _emnapi_set_immediate(void (*callback)(void*), void* data);
-EMNAPI_INTERNAL_EXTERN napi_status _emnapi_create_function(napi_env env,
-                                                           const char* utf8name,
+EMNAPI_INTERNAL_EXTERN napi_status _emnapi_create_function(const char* utf8name,
                                                            size_t length,
                                                            napi_callback cb,
                                                            void* data,
@@ -197,4 +190,6 @@ void _emnapi_env_check_gc_access(napi_env env);
 
 EXTERN_C_END
 
+#include "js_native_api_internal.h"
+
 #endif

package/src/js_native_api.c

@@ -2,6 +2,34 @@
 
 EXTERN_C_START
 
+struct node_api_base_env__vtable node_api_base_env__vtable_instance = {
+  .offset_to_top = offsetof(node_api_base_env__, vptr),
+  .type_info = NULL,
+  .cdtor = node_api_base_env__cdtor,
+  .ddtor = node_api_base_env__ddtor,
+};
+
+__attribute__((visibility("default")))
+node_api_base_env__* emnapi_create_env() {
+  node_api_base_env__* env = (node_api_base_env__*) calloc(1, sizeof(node_api_base_env__));
+  node_api_base_env__ctor(env);
+  return env;
+}
+
+__attribute__((visibility("default")))
+void emnapi_delete_env(node_api_base_env__* env) {
+  node_api_base_env__ddtor(env);
+}
+
+node_api_base_env__* node_api_base_env__cdtor(node_api_base_env__* self) {
+  return self;
+}
+
+void node_api_base_env__ddtor(node_api_base_env__* self) {
+  node_api_base_env__cdtor(self);
+  free(self);
+}
+
 static const char* emnapi_error_messages[] = {
   NULL,
   "Invalid argument",
@@ -29,17 +57,12 @@ static const char* emnapi_error_messages[] = {
   "Cannot run JavaScript",
 };
 
-EMNAPI_INTERNAL_EXTERN void _emnapi_get_last_error_info(napi_env env,
-                                        napi_status* error_code,
-                                        uint32_t* engine_error_code,
-                                        void** engine_reserved);
-
+__attribute__((visibility("default")))
 napi_status napi_get_last_error_info(
     node_api_basic_env basic_env, const napi_extended_error_info** result) {
-  static napi_extended_error_info last_error;
-  napi_env env = (napi_env) basic_env;
-  CHECK_ENV(env);
-  CHECK_ARG(env, result);
+  CHECK_ENV(basic_env);
+  CHECK_ARG(basic_env, result);
+  node_api_base_env__* env = EMNAPI_AS_NODE_API_BASE_ENV(basic_env);
 
   const int last_status = napi_cannot_run_js;
 
@@ -48,21 +71,14 @@ napi_status napi_get_last_error_info(
                 "Count of error messages must match count of error values");
 #endif
 
-  _emnapi_get_last_error_info(env,
-                              &last_error.error_code,
-                              &last_error.engine_error_code,
-                              &last_error.engine_reserved);
-
-  CHECK_LE(last_error.error_code, last_status);
+  CHECK_LE(env->last_error.error_code, last_status);
 
-  last_error.error_message = emnapi_error_messages[last_error.error_code];
+  env->last_error.error_message = emnapi_error_messages[env->last_error.error_code];
 
-  if (last_error.error_code == napi_ok) {
-    napi_clear_last_error(env);
-    last_error.engine_error_code = 0;
-    last_error.engine_reserved = NULL;
+  if (env->last_error.error_code == napi_ok) {
+    napi_clear_last_error(basic_env);
   }
-  *result = &last_error;
+  *result = &(env->last_error);
   return napi_ok;
 }
 

package/src/js_native_api_internal.h

@@ -0,0 +1,66 @@
+#ifndef SRC_JS_NATIVE_API_INTERNAL_H_
+#define SRC_JS_NATIVE_API_INTERNAL_H_
+
+#include "js_native_api_types.h"
+
+typedef struct node_api_base_env__ {
+  void* vptr;
+  EMNAPI_NAPI_ENV_FIELDS;
+  uint32_t id;
+  napi_extended_error_info last_error;
+} node_api_base_env__;
+
+#define EMNAPI_AS_NODE_API_BASE_ENV(env) \
+  ((node_api_base_env__*)((char*)(env) - offsetof(node_api_base_env__, sentinel)))
+
+struct node_api_base_env__vtable {
+  size_t offset_to_top;
+  void* type_info;
+  node_api_base_env__* (*cdtor)(node_api_base_env__* self);
+  void (*ddtor)(node_api_base_env__* self);
+};
+
+EXTERN_C_START
+
+extern struct node_api_base_env__vtable node_api_base_env__vtable_instance;
+
+// EMNAPI_INTERNAL_EXTERN
+// const struct node_api_js_vtable* _emnapi_get_node_api_js_vtable();
+
+// EMNAPI_INTERNAL_EXTERN
+// const struct node_api_module_vtable* _emnapi_get_node_api_module_vtable();
+
+node_api_base_env__* node_api_base_env__cdtor(node_api_base_env__* self);
+void node_api_base_env__ddtor(node_api_base_env__* self);
+
+static inline
+node_api_base_env__* node_api_base_env__ctor(node_api_base_env__* self) {
+  self->vptr = &node_api_base_env__vtable_instance.cdtor;
+  self->sentinel = NODE_API_VT_SENTINEL;
+  return self;
+}
+
+static inline napi_status napi_clear_last_error(node_api_basic_env basic_env) {
+  node_api_base_env__* env = EMNAPI_AS_NODE_API_BASE_ENV(basic_env);
+  env->last_error.error_code = napi_ok;
+  env->last_error.engine_error_code = 0;
+  env->last_error.engine_reserved = NULL;
+  env->last_error.error_message = NULL;
+  return napi_ok;
+}
+
+static inline napi_status
+napi_set_last_error(node_api_basic_env basic_env,
+                    napi_status error_code,
+                    uint32_t engine_error_code,
+                    void* engine_reserved) {
+  node_api_base_env__* env = EMNAPI_AS_NODE_API_BASE_ENV(basic_env);
+  env->last_error.error_code = error_code;
+  env->last_error.engine_error_code = engine_error_code;
+  env->last_error.engine_reserved = engine_reserved;
+  return error_code;
+}
+
+EXTERN_C_END
+
+#endif

package/src/node_api.c

@@ -36,7 +36,7 @@ napi_status napi_get_uv_event_loop(node_api_basic_env env,
   return napi_clear_last_error(env);
 }
 
-EMNAPI_INTERNAL_EXTERN int _emnapi_get_filename(napi_env env, char* buf, int len);
+EMNAPI_INTERNAL_EXTERN int _emnapi_get_filename(node_api_basic_env env, char* buf, int len);
 
 napi_status node_api_get_module_file_name(node_api_basic_env env,
                                           const char** result) {

package/src/threadsafe_function.c

@@ -215,7 +215,7 @@ static void _emnapi_tsfn_finalize(napi_threadsafe_function func) {
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
       EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->async_resource.resource_, &resource));
-      EMNAPI_ASSERT_CALL(_emnapi_create_function(func->env, NULL, 0, _emnapi_tsfn_finalize_in_callback_scope, func, &cb));
+      EMNAPI_ASSERT_CALL(_emnapi_create_function(NULL, 0, _emnapi_tsfn_finalize_in_callback_scope, func, &cb));
       _emnapi_node_make_callback(func->env,
                                 resource,
                                 cb,
@@ -337,7 +337,7 @@ static bool _emnapi_tsfn_dispatch_one(napi_threadsafe_function func) {
     if (emnapi_is_node_binding_available()) {
       napi_value resource, cb;
       EMNAPI_ASSERT_CALL(napi_get_reference_value(func->env, func->async_resource.resource_, &resource));
-      EMNAPI_ASSERT_CALL(_emnapi_create_function(func->env, NULL, 0, _emnapi_tsfn_call_js_cb_in_callback_scope, jscb_data, &cb));
+      EMNAPI_ASSERT_CALL(_emnapi_create_function(NULL, 0, _emnapi_tsfn_call_js_cb_in_callback_scope, jscb_data, &cb));
       _emnapi_node_make_callback(func->env,
                                 resource,
                                 cb,

package/src/uv/unix/thread.c

@@ -188,4 +188,25 @@ int uv_thread_join(uv_thread_t *tid) {
   return pthread_join(*tid, NULL);
 }
 
+int uv_key_create(uv_key_t* key) {
+  return pthread_key_create(key, NULL);
+}
+
+
+void uv_key_delete(uv_key_t* key) {
+  if (pthread_key_delete(*key))
+    abort();
+}
+
+
+void* uv_key_get(uv_key_t* key) {
+  return pthread_getspecific(*key);
+}
+
+
+void uv_key_set(uv_key_t* key, void* value) {
+  if (pthread_setspecific(*key, value))
+    abort();
+}
+
 #endif

package/src/v8/array.cc

@@ -0,0 +1,19 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_array_new(Isolate* isolate, int length);
+  V8_EXTERN uint32_t _v8_array_length(const Array* array);
+}
+
+Local<Array> Array::New(Isolate* isolate, int length) {
+  auto n = _v8_array_new(isolate, length);
+  return v8impl::V8LocalValueFromAddress(n).As<Array>();
+}
+
+uint32_t Array::Length() const {
+  return _v8_array_length(this);
+}
+
+}

package/src/v8/boolean.cc

@@ -0,0 +1,26 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN bool _v8_boolean_value(const Boolean*);
+  V8_EXTERN int _v8_boolean_object_value_of(const BooleanObject*);
+  V8_EXTERN internal::Address _v8_boolean_object_new(Isolate* isolate, int value);
+}
+
+void Boolean::CheckCast(v8::Data*) {}
+
+bool Boolean::Value() const {
+  return _v8_boolean_value(this);
+}
+
+Local<Value> BooleanObject::New(Isolate* isolate, bool value) {
+  auto n = _v8_boolean_object_new(isolate, static_cast<int>(value));
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
+bool BooleanObject::ValueOf() const {
+  return static_cast<bool>(_v8_boolean_object_value_of(this));
+}
+
+}

package/src/v8/date.cc

@@ -0,0 +1,15 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_date_new(Context* context, double value);
+}
+
+MaybeLocal<Value> Date::New(Local<Context> context, double time) {
+  auto n = _v8_date_new(*context, time);
+  if (!n) return MaybeLocal<Value>();
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
+}

package/src/v8/exception.cc

@@ -0,0 +1,48 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_exception_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_type_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_range_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_reference_error(internal::Address message, internal::Address options);
+  V8_EXTERN internal::Address _v8_exception_syntax_error(internal::Address message, internal::Address options);
+}
+
+Local<Value> Exception::Error(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::TypeError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_type_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::RangeError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_range_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::ReferenceError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_reference_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+Local<Value> Exception::SyntaxError(Local<String> message, Local<Value> options) {
+  return v8impl::V8LocalValueFromAddress(
+      _v8_exception_syntax_error(
+          v8impl::AddressFromV8LocalValue(message),
+          v8impl::AddressFromV8LocalValue(options)));
+}
+
+}