emnapi 1.11.0 → 2.0.0-alpha.2

package/emnapi.gyp

@@ -144,6 +144,43 @@
           }],
         ]
       },
+    },
+    {
+      'target_name': 'v8',
+      'type': 'static_library',
+      'sources': [
+        'array.cc',
+        'external.cc',
+        'exception.cc',
+        'date.cc',
+        'function.cc',
+        'handle_scope.cc',
+        'internal.cc',
+        'isolate.cc',
+        'json.cc',
+        'object.cc',
+        'string.cc',
+        'value.cc',
+        'boolean.cc',
+        'number.cc',
+        'template.cc',
+        'try_catch.cc',
+        'node.cc',
+        'script.cc'
+      ],
+      'defines': [
+        'V8_ENABLE_DIRECT_LOCAL'
+      ],
+      'link_settings': {
+        'target_conditions': [
+          ['_type == "executable" and OS == "emscripten"', {
+            'libraries': [
+              '--js-library=<(emnapi_js_library)',
+              '--js-library=<(v8_js_library)',
+            ]
+          }],
+        ]
+      },
     }
   ]
 }

package/include/node/emnapi.h

@@ -5,8 +5,8 @@
 #include "js_native_api_types.h"
 #include "emnapi_common.h"
 
-#define EMNAPI_MAJOR_VERSION 1
-#define EMNAPI_MINOR_VERSION 11
+#define EMNAPI_MAJOR_VERSION 2
+#define EMNAPI_MINOR_VERSION 0
 #define EMNAPI_PATCH_VERSION 0
 
 typedef enum {
@@ -82,6 +82,14 @@ napi_status emnapi_get_memory_address(napi_env env,
                                       emnapi_ownership* ownership,
                                       bool* runtime_allocated);
 
+EMNAPI_EXTERN void emnapi_debug(
+  const char* file,
+  int lineno,
+  const char* str,
+  void* value,
+  int type
+);
+
 /**
  * Get the handle for an external SharedArrayBuffer.
  * This function must be called on the emnapi main thread.
@@ -107,6 +115,9 @@ void emnapi_acquire_external_sharedarraybuffer(void* handle);
 EMNAPI_EXTERN
 void emnapi_release_external_sharedarraybuffer(void* handle);
 
+#define DEBUGGER_LOG(str, value, type) \
+  emnapi_debug(__FILE__, __LINE__, str, value, type)
+
 EXTERN_C_END
 
 #endif

package/include/node/js_native_api_types.h

@@ -241,4 +241,26 @@ typedef struct {
 } napi_type_tag;
 #endif  // NAPI_VERSION >= 8
 
+#ifndef EMNAPI_UNMODIFIED_UPSTREAM
+// Sentinel format: "NODE_VT" (7 bytes) + marker byte.
+// Marker byte = (version << 1) | 1
+//   - Bit 0 is always 1: ensures the sentinel can never match a C++ vtable
+//     pointer (which is always pointer-aligned, thus bit 0 = 0).
+//   - Bits 1-7: struct version number (0-127).
+#define NODE_API_VT_SENTINEL_VERSION 0
+#define NODE_API_VT_SENTINEL_MAKE(version)                                     \
+  (0x4E4F44455F565400ULL | (((version) << 1) | 1))
+#define NODE_API_VT_SENTINEL                                                   \
+  NODE_API_VT_SENTINEL_MAKE(NODE_API_VT_SENTINEL_VERSION)
+
+#define EMNAPI_NAPI_ENV_FIELDS                        \
+  uint64_t sentinel;                                  \
+  const struct node_api_js_vtable* js_vtable;         \
+  const struct node_api_module_vtable* module_vtable;
+
+struct napi_env__ {
+  EMNAPI_NAPI_ENV_FIELDS
+};
+#endif
+
 #endif  // SRC_JS_NATIVE_API_TYPES_H_

package/include/node/node.h

@@ -0,0 +1,198 @@
+#ifndef SRC_NODE_H_
+#define SRC_NODE_H_
+
+#if !defined(NODE_EXTERN)
+#define NODE_EXTERN __attribute__((__import_module__("env")))
+#endif
+
+#include "v8.h"
+#include "v8-platform.h"
+#include "node_version.h"
+#include "node_api_types.h"
+
+// Forward-declare libuv loop
+struct uv_loop_s;
+struct napi_module;
+
+namespace node {
+
+inline void NODE_SET_METHOD(v8::Local<v8::Object> recv,
+                            const char* name,
+                            v8::FunctionCallback callback) {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate,
+                                                                callback);
+  v8::Local<v8::Function> fn = t->GetFunction(context).ToLocalChecked();
+  v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name,
+      v8::NewStringType::kInternalized).ToLocalChecked();
+  fn->SetName(fn_name);
+  recv->Set(context, fn_name, fn).Check();
+}
+#define NODE_SET_METHOD node::NODE_SET_METHOD
+
+#ifdef _WIN32
+# define NODE_MODULE_EXPORT __declspec(dllexport)
+#else
+#ifdef __EMSCRIPTEN__
+#define NODE_MODULE_EXPORT                                                     \
+  __attribute__((visibility("default"))) __attribute__((used))
+#else
+# define NODE_MODULE_EXPORT __attribute__((visibility("default")))
+#endif
+#endif
+
+#define NODE_DEPRECATED(message, declarator) declarator
+
+typedef void (*addon_register_func)(
+    v8::Local<v8::Object> exports,
+    v8::Local<v8::Value> module,
+    void* priv);
+
+// BINARY is a deprecated alias of LATIN1.
+// BASE64URL is not currently exposed to the JavaScript side.
+enum encoding {
+  ASCII,
+  UTF8,
+  BASE64,
+  UCS2,
+  BINARY,
+  HEX,
+  BUFFER,
+  BASE64URL,
+  LATIN1 = BINARY
+};
+
+NODE_EXTERN v8::Local<v8::Value> ErrnoException(v8::Isolate* isolate,
+                                                int errorno,
+                                                const char* syscall = nullptr,
+                                                const char* message = nullptr,
+                                                const char* path = nullptr);
+NODE_EXTERN v8::Local<v8::Value> UVException(v8::Isolate* isolate,
+                                             int errorno,
+                                             const char* syscall = nullptr,
+                                             const char* message = nullptr,
+                                             const char* path = nullptr,
+                                             const char* dest = nullptr);
+
+NODE_DEPRECATED("Use ErrnoException(isolate, ...)",
+                inline v8::Local<v8::Value> ErrnoException(
+      int errorno,
+      const char* syscall = nullptr,
+      const char* message = nullptr,
+      const char* path = nullptr) {
+  return ErrnoException(v8::Isolate::GetCurrent(),
+                        errorno,
+                        syscall,
+                        message,
+                        path);
+})
+
+NODE_DEPRECATED("Use UVException(isolate, ...)",
+                inline v8::Local<v8::Value> UVException(int errorno,
+                                        const char* syscall = nullptr,
+                                        const char* message = nullptr,
+                                        const char* path = nullptr) {
+  return UVException(v8::Isolate::GetCurrent(),
+                     errorno,
+                     syscall,
+                     message,
+                     path);
+})
+
+NODE_EXTERN struct uv_loop_s* GetCurrentEventLoop(v8::Isolate* isolate);
+
+typedef double async_id;
+struct async_context {
+  ::node::async_id async_id;
+  ::node::async_id trigger_async_id;
+};
+
+NODE_EXTERN async_context EmitAsyncInit(v8::Isolate* isolate,
+                                        v8::Local<v8::Object> resource,
+                                        const char* name,
+                                        async_id trigger_async_id = -1);
+
+NODE_EXTERN async_context EmitAsyncInit(v8::Isolate* isolate,
+                                        v8::Local<v8::Object> resource,
+                                        v8::Local<v8::String> name,
+                                        async_id trigger_async_id = -1);
+
+NODE_EXTERN void EmitAsyncDestroy(v8::Isolate* isolate,
+                                  async_context asyncContext);
+
+NODE_EXTERN void FatalException(v8::Isolate* isolate,
+                                const v8::TryCatch& try_catch);
+
+NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                                        const char* buf,
+                                        size_t len,
+                                        enum encoding encoding = LATIN1);
+
+// Warning: This reverses endianness on Big Endian platforms, even though the
+// signature using uint16_t implies that it should not.
+NODE_EXTERN v8::Local<v8::Value> Encode(v8::Isolate* isolate,
+                                        const uint16_t* buf,
+                                        size_t len);
+
+// Returns -1 if the handle was not valid for decoding
+NODE_EXTERN ssize_t DecodeBytes(v8::Isolate* isolate,
+                                v8::Local<v8::Value>,
+                                enum encoding encoding = LATIN1);
+// returns bytes written.
+NODE_EXTERN ssize_t DecodeWrite(v8::Isolate* isolate,
+                                char* buf,
+                                size_t buflen,
+                                v8::Local<v8::Value>,
+                                enum encoding encoding = LATIN1);
+
+#define NODE_MODULE(modname, regfunc)                                 \
+  NODE_MODULE_INIT() { ((node::addon_register_func)regfunc)(exports, module, NULL); }
+
+#define NODE_MODULE_VERSION 127
+
+#define NODE_MODULE_INITIALIZER_BASE node_register_module_v
+
+#define NODE_MODULE_INITIALIZER_X(base, version)                      \
+    NODE_MODULE_INITIALIZER_X_HELPER(base, version)
+
+#define NODE_MODULE_INITIALIZER_X_HELPER(base, version) base##version
+
+#define NODE_MODULE_INITIALIZER                                       \
+  NODE_MODULE_INITIALIZER_X(NODE_MODULE_INITIALIZER_BASE,             \
+      NODE_MODULE_VERSION)
+
+#define NODE_MODULE_INIT()                                            \
+  extern "C" NODE_MODULE_EXPORT void                                  \
+  NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports,              \
+                          v8::Local<v8::Value> module,                \
+                          v8::Local<v8::Context> context);            \
+  void NODE_MODULE_INITIALIZER(v8::Local<v8::Object> exports,         \
+                               v8::Local<v8::Value> module,           \
+                               v8::Local<v8::Context> context)
+
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::Function> callback,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       const char* method,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::String> symbol,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext);
+}  // namespace node
+
+#endif

package/include/node/node_api.h

@@ -1,16 +1,6 @@
 #ifndef SRC_NODE_API_H_
 #define SRC_NODE_API_H_
 
-#ifndef EMNAPI_UNMODIFIED_UPSTREAM
-#ifndef BUILDING_NODE_EXTENSION
-#define BUILDING_NODE_EXTENSION
-#endif
-
-#if !defined(NAPI_EXTERN) && defined(__EMSCRIPTEN__)
-#define NAPI_EXTERN __attribute__((__import_module__("env")))
-#endif
-#endif
-
 #if defined(BUILDING_NODE_EXTENSION) && !defined(NAPI_EXTERN)
 #ifdef _WIN32
 // Building native addon against node

package/include/node/node_buffer.h

@@ -0,0 +1,92 @@
+// 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_BUFFER_H_
+#define SRC_NODE_BUFFER_H_
+
+#include "node.h"
+#include "v8.h"
+
+namespace node {
+
+namespace Buffer {
+
+static const size_t kMaxLength = v8::Uint8Array::kMaxLength;
+
+typedef void (*FreeCallback)(char* data, void* hint);
+
+NODE_EXTERN bool HasInstance(v8::Local<v8::Value> val);
+NODE_EXTERN bool HasInstance(v8::Local<v8::Object> val);
+NODE_EXTERN char* Data(v8::Local<v8::Value> val);
+NODE_EXTERN char* Data(v8::Local<v8::Object> val);
+NODE_EXTERN size_t Length(v8::Local<v8::Value> val);
+NODE_EXTERN size_t Length(v8::Local<v8::Object> val);
+
+// public constructor - data is copied
+NODE_EXTERN v8::MaybeLocal<v8::Object> Copy(v8::Isolate* isolate,
+                                            const char* data,
+                                            size_t len);
+
+// public constructor
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, size_t length);
+
+// public constructor from string
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           v8::Local<v8::String> string,
+                                           enum encoding enc = UTF8);
+
+// public constructor - data is used, callback is passed data on object gc
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           char* data,
+                                           size_t length,
+                                           FreeCallback callback,
+                                           void* hint);
+
+// public constructor - data is used.
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
+                                           char* data,
+                                           size_t len);
+
+// Creates a Buffer instance over an existing ArrayBuffer.
+NODE_EXTERN v8::MaybeLocal<v8::Uint8Array> New(v8::Isolate* isolate,
+                                               v8::Local<v8::ArrayBuffer> ab,
+                                               size_t byte_offset,
+                                               size_t length);
+
+// This is verbose to be explicit with inline commenting
+static inline bool IsWithinBounds(size_t off, size_t len, size_t max) {
+  // Asking to seek too far into the buffer
+  // check to avoid wrapping in subsequent subtraction
+  if (off > max)
+    return false;
+
+  // Asking for more than is left over in the buffer
+  if (max - off < len)
+    return false;
+
+  // Otherwise we're in bounds
+  return true;
+}
+
+}  // namespace Buffer
+}  // namespace node
+
+#endif  // SRC_NODE_BUFFER_H_

package/include/node/node_object_wrap.h

@@ -0,0 +1,132 @@
+// 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_OBJECT_WRAP_H_
+#define SRC_NODE_OBJECT_WRAP_H_
+
+#include "v8.h"
+#include <cassert>
+
+
+namespace node {
+
+class ObjectWrap {
+ public:
+  ObjectWrap() {
+    refs_ = 0;
+  }
+
+
+  virtual ~ObjectWrap() {
+    if (persistent().IsEmpty())
+      return;
+    persistent().ClearWeak();
+    persistent().Reset();
+  }
+
+
+  template <class T>
+  static inline T* Unwrap(v8::Local<v8::Object> handle) {
+    assert(!handle.IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    // Cast to ObjectWrap before casting to T.  A direct cast from void
+    // to T won't work right when T has more than one base class.
+    void* ptr = handle->GetAlignedPointerFromInternalField(0);
+    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
+    return static_cast<T*>(wrap);
+  }
+
+
+  inline v8::Local<v8::Object> handle() {
+    return handle(v8::Isolate::GetCurrent());
+  }
+
+
+  inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
+    return v8::Local<v8::Object>::New(isolate, persistent());
+  }
+
+
+  // NOLINTNEXTLINE(runtime/v8_persistent)
+  inline v8::Persistent<v8::Object>& persistent() {
+    return handle_;
+  }
+
+
+ protected:
+  inline void Wrap(v8::Local<v8::Object> handle) {
+    assert(persistent().IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    handle->SetAlignedPointerInInternalField(0, this);
+    persistent().Reset(v8::Isolate::GetCurrent(), handle);
+    MakeWeak();
+  }
+
+
+  inline void MakeWeak() {
+    persistent().SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
+  }
+
+  /* Ref() marks the object as being attached to an event loop.
+   * Refed objects will not be garbage collected, even if
+   * all references are lost.
+   */
+  virtual void Ref() {
+    assert(!persistent().IsEmpty());
+    persistent().ClearWeak();
+    refs_++;
+  }
+
+  /* Unref() marks an object as detached from the event loop.  This is its
+   * default state.  When an object with a "weak" reference changes from
+   * attached to detached state it will be freed. Be careful not to access
+   * the object after making this call as it might be gone!
+   * (A "weak reference" means an object that only has a
+   * persistent handle.)
+   *
+   * DO NOT CALL THIS FROM DESTRUCTOR
+   */
+  virtual void Unref() {
+    assert(!persistent().IsEmpty());
+    assert(!persistent().IsWeak());
+    assert(refs_ > 0);
+    if (--refs_ == 0)
+      MakeWeak();
+  }
+
+  int refs_;  // ro
+
+ private:
+  static void WeakCallback(
+      const v8::WeakCallbackInfo<ObjectWrap>& data) {
+    ObjectWrap* wrap = data.GetParameter();
+    assert(wrap->refs_ == 0);
+    wrap->handle_.Reset();
+    delete wrap;
+  }
+
+  // NOLINTNEXTLINE(runtime/v8_persistent)
+  v8::Persistent<v8::Object> handle_;
+};
+
+}  // namespace node
+
+#endif  // SRC_NODE_OBJECT_WRAP_H_

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