From df3a406f7542693b674278912f451e3bae363b5e Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 8 May 2015 02:18:56 +0300
Subject: [PATCH 01/84] Remove deprecated functions

---
 nan.h | 481 ----------------------------------------------------------
 1 file changed, 481 deletions(-)

diff --git a/nan.h b/nan.h
index c059429a..8cc1e335 100644
--- a/nan.h
+++ b/nan.h
@@ -219,91 +219,6 @@ inline void nauv_key_set(nauv_key_t* key, void* value) {
 #endif
 #endif
 
-// some generic helpers
-
-namespace Nan { namespace imp {
-template<typename T> NAN_INLINE bool NanSetPointerSafe(
-    T *var
-  , T val
-) {
-  if (var) {
-    *var = val;
-    return true;
-  } else {
-    return false;
-  }
-}
-
-template<typename T> NAN_INLINE T NanGetPointerSafe(
-    T *var
-  , T fallback = reinterpret_cast<T>(0)
-) {
-  if (var) {
-    return *var;
-  } else {
-    return fallback;
-  }
-}
-
-NAN_INLINE bool NanBooleanOptionValue(
-    v8::Local<v8::Object> optionsObj
-  , v8::Handle<v8::String> opt, bool def
-) {
-  if (def) {
-    return optionsObj.IsEmpty()
-      || !optionsObj->Has(opt)
-      || optionsObj->Get(opt)->BooleanValue();
-  } else {
-    return !optionsObj.IsEmpty()
-      && optionsObj->Has(opt)
-      && optionsObj->Get(opt)->BooleanValue();
-  }
-}
-
-}  // end of namespace imp
-}  // end of namespace Nan
-
-template<typename T> NAN_DEPRECATED NAN_INLINE bool NanSetPointerSafe(
-    T *var
-  , T val
-) {
-  return Nan::imp::NanSetPointerSafe<T>(var, val);
-}
-
-template<typename T> NAN_DEPRECATED NAN_INLINE T NanGetPointerSafe(
-    T *var
-  , T fallback = reinterpret_cast<T>(0)
-) {
-  return Nan::imp::NanGetPointerSafe(var, fallback);
-}
-
-
-NAN_DEPRECATED NAN_INLINE bool NanBooleanOptionValue(
-    v8::Local<v8::Object> optionsObj
-  , v8::Handle<v8::String> opt, bool def
-) {
-  return Nan::imp::NanBooleanOptionValue(optionsObj, opt, def);
-}
-
-NAN_DEPRECATED NAN_INLINE bool NanBooleanOptionValue(
-    v8::Local<v8::Object> optionsObj
-  , v8::Handle<v8::String> opt
-) {
-  return Nan::imp::NanBooleanOptionValue(optionsObj, opt, false);
-}
-
-NAN_DEPRECATED NAN_INLINE uint32_t NanUInt32OptionValue(
-    v8::Local<v8::Object> optionsObj
-  , v8::Handle<v8::String> opt
-  , uint32_t def
-) {
-  return !optionsObj.IsEmpty()
-    && optionsObj->Has(opt)
-    && optionsObj->Get(opt)->IsNumber()
-      ? optionsObj->Get(opt)->Uint32Value()
-      : def;
-}
-
 template<typename T>
 v8::Local<T> NanNew(v8::Handle<T>);
 
@@ -583,11 +498,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
     v8::Isolate::GetCurrent()->GetHeapStatistics(heap_statistics);
   }
 
-  NAN_DEPRECATED NAN_INLINE v8::Local<v8::String> NanSymbol(
-      const char* data, int length = -1) {
-    return NanNew<v8::String>(data, length);
-  }
-
   template<typename T>
   NAN_INLINE void NanAssignPersistent(
       v8::Persistent<T>& handle
@@ -647,9 +557,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       return info_;
     }
 
-    NAN_DEPRECATED NAN_INLINE void Dispose() const {
-    }
-
    private:
     _NanWeakCallbackInfo<T, P>* info_;
   };
@@ -786,18 +693,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
     return NanNew(function_template)->HasInstance(value);
   }
 
-  NAN_DEPRECATED NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
-      v8::ExtensionConfiguration* extensions = NULL
-    , v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
-    , v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
-  ) {
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    return v8::Local<v8::Context>::New(
-        isolate
-      , v8::Context::New(isolate, extensions, tmpl, obj)
-    );
-  }
-
   NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
@@ -889,10 +784,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       size = toStr->WriteOneByte(reinterpret_cast<unsigned char*>(buf));
     }
 
-    NAN_DEPRECATED NAN_INLINE int Size() const {
-      return size;
-    }
-
     NAN_INLINE int length() const {
       return size;
     }
@@ -921,10 +812,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       toStr->WriteUtf8(buf);
     }
 
-    NAN_DEPRECATED NAN_INLINE int Size() const {
-      return size;
-    }
-
     NAN_INLINE int length() const {
       return size;
     }
@@ -952,10 +839,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       toStr->Write(buf);
     }
 
-    NAN_DEPRECATED NAN_INLINE int Size() const {
-      return size;
-    }
-
     NAN_INLINE int length() const {
       return size;
     }
@@ -1029,11 +912,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
 # define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args
 # define _NAN_INDEX_QUERY_RETURN_TYPE v8::Handle<v8::Integer>
 
-  NAN_DEPRECATED NAN_INLINE v8::Local<v8::String> NanSymbol(
-      const char* data, int length = -1) {
-    return v8::String::NewSymbol(data, length);
-  }
-
 # define NanScope() v8::HandleScope scope
 # define NanEscapableScope() v8::HandleScope scope
 # define NanEscapeScope(val) scope.Close(val)
@@ -1188,9 +1066,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       return info_;
     }
 
-    NAN_DEPRECATED NAN_INLINE void Dispose() const {
-    }
-
    private:
     _NanWeakCallbackInfo<T, P>* info_;
   };
@@ -1347,17 +1222,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
     return function_template->HasInstance(value);
   }
 
-  NAN_DEPRECATED NAN_INLINE v8::Local<v8::Context> NanNewContextHandle(
-      v8::ExtensionConfiguration* extensions = NULL
-    , v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
-    , v8::Handle<v8::Value> obj = v8::Handle<v8::Value>()
-  ) {
-    v8::Persistent<v8::Context> ctx = v8::Context::New(extensions, tmpl, obj);
-    v8::Local<v8::Context> lctx = NanNew(ctx);
-    ctx.Dispose();
-    return lctx;
-  }
-
   NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
@@ -1454,10 +1318,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       size = toStr->WriteAscii(buf);
     }
 
-    NAN_DEPRECATED NAN_INLINE int Size() const {
-      return size;
-    }
-
     NAN_INLINE int length() const {
       return size;
     }
@@ -1486,10 +1346,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       toStr->WriteUtf8(buf);
     }
 
-    NAN_DEPRECATED NAN_INLINE int Size() const {
-      return size;
-    }
-
     NAN_INLINE int length() const {
       return size;
     }
@@ -1517,10 +1373,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       toStr->Write(buf);
     }
 
-    NAN_DEPRECATED NAN_INLINE int Size() const {
-      return size;
-    }
-
     NAN_INLINE int length() const {
       return size;
     }
@@ -1952,134 +1804,6 @@ NAN_INLINE void NanAsyncQueueWorker (NanAsyncWorker* worker) {
   );
 }
 
-//// Base 64 ////
-
-#define _nan_base64_encoded_size(size) ((size + 2 - ((size + 2) % 3)) / 3 * 4)
-
-// Doesn't check for padding at the end.  Can be 1-2 bytes over.
-NAN_INLINE size_t _nan_base64_decoded_size_fast(size_t size) {
-  size_t remainder = size % 4;
-
-  size = (size / 4) * 3;
-  if (remainder) {
-    if (size == 0 && remainder == 1) {
-      // special case: 1-byte input cannot be decoded
-      size = 0;
-    } else {
-      // non-padded input, add 1 or 2 extra bytes
-      size += 1 + (remainder == 3);
-    }
-  }
-
-  return size;
-}
-
-template<typename T>
-NAN_INLINE size_t _nan_base64_decoded_size(
-    const T* src
-  , size_t size
-) {
-  if (size == 0)
-    return 0;
-
-  if (src[size - 1] == '=')
-    size--;
-  if (size > 0 && src[size - 1] == '=')
-    size--;
-
-  return _nan_base64_decoded_size_fast(size);
-}
-
-// supports regular and URL-safe base64
-static const int _nan_unbase64_table[] = {
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -1, -1, -2, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63
-  , 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1
-  , -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14
-  , 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63
-  , -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40
-  , 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-  , -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-};
-
-#define _nan_unbase64(x) _nan_unbase64_table[(uint8_t)(x)]
-
-template<typename T> static size_t _nan_base64_decode(
-    char* buf
-  , size_t len
-  , const T* src
-  , const size_t srcLen
-) {
-  char* dst = buf;
-  char* dstEnd = buf + len;
-  const T* srcEnd = src + srcLen;
-
-  while (src < srcEnd && dst < dstEnd) {
-    ptrdiff_t remaining = srcEnd - src;
-    char a, b, c, d;
-
-    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
-    if (remaining == 0 || *src == '=') break;
-    a = _nan_unbase64(*src++);
-
-    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
-    if (remaining <= 1 || *src == '=') break;
-    b = _nan_unbase64(*src++);
-
-    *dst++ = (a << 2) | ((b & 0x30) >> 4);
-    if (dst == dstEnd) break;
-
-    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
-    if (remaining <= 2 || *src == '=') break;
-    c = _nan_unbase64(*src++);
-
-    *dst++ = ((b & 0x0F) << 4) | ((c & 0x3C) >> 2);
-    if (dst == dstEnd) break;
-
-    while (_nan_unbase64(*src) < 0 && src < srcEnd) src++, remaining--;
-    if (remaining <= 3 || *src == '=') break;
-    d = _nan_unbase64(*src++);
-
-    *dst++ = ((c & 0x03) << 6) | (d & 0x3F);
-  }
-
-  return dst - buf;
-}
-
-//// HEX ////
-
-template<typename T> unsigned _nan_hex2bin(T c) {
-  if (c >= '0' && c <= '9') return c - '0';
-  if (c >= 'A' && c <= 'F') return 10 + (c - 'A');
-  if (c >= 'a' && c <= 'f') return 10 + (c - 'a');
-  return static_cast<unsigned>(-1);
-}
-
-template<typename T> static size_t _nan_hex_decode(
-    char* buf
-  , size_t len
-  , const T* src
-  , const size_t srcLen
-) {
-  size_t i;
-  for (i = 0; i < len && i * 2 + 1 < srcLen; ++i) {
-    unsigned a = _nan_hex2bin(src[i * 2 + 0]);
-    unsigned b = _nan_hex2bin(src[i * 2 + 1]);
-    if (!~a || !~b) return i;
-    buf[i] = a * 16 + b;
-  }
-
-  return i;
-}
-
 namespace Nan { namespace imp {
 
 inline
@@ -2105,39 +1829,6 @@ IsExternal(v8::Local<v8::String> str) {
 }  // end of namespace imp
 }  // end of namespace Nan
 
-static bool _NanGetExternalParts(
-    v8::Handle<v8::Value> val
-  , const char** data
-  , size_t* len
-) {
-  if (node::Buffer::HasInstance(val)) {
-    *data = node::Buffer::Data(val.As<v8::Object>());
-    *len = node::Buffer::Length(val.As<v8::Object>());
-    return true;
-  }
-
-  assert(val->IsString());
-  v8::Local<v8::String> str = NanNew(val.As<v8::String>());
-
-  if (Nan::imp::IsExternal(str)) {
-    const NanExternalOneByteStringResource* ext;
-    ext = Nan::imp::GetExternalResource(str);
-    *data = ext->data();
-    *len = ext->length();
-    return true;
-  }
-
-  if (str->IsExternal()) {
-    const v8::String::ExternalStringResource* ext;
-    ext = str->GetExternalStringResource();
-    *data = reinterpret_cast<const char*>(ext->data());
-    *len = ext->length();
-    return true;
-  }
-
-  return false;
-}
-
 namespace Nan {
   enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
 }
@@ -2221,178 +1912,6 @@ NAN_INLINE ssize_t NanDecodeWrite(
 #endif
 }
 
-/* NAN_DEPRECATED */ NAN_INLINE void* _NanRawString(
-    v8::Handle<v8::Value> from
-  , enum Nan::Encoding encoding
-  , size_t *datalen
-  , void *buf
-  , size_t buflen
-  , int flags
-) {
-  NanScope();
-
-  size_t sz_;
-  size_t term_len = !(flags & v8::String::NO_NULL_TERMINATION);
-  char *data = NULL;
-  size_t len;
-  bool is_extern = _NanGetExternalParts(
-      from
-    , const_cast<const char**>(&data)
-    , &len);
-
-  if (is_extern && !term_len) {
-    Nan::imp::NanSetPointerSafe(datalen, len);
-    return data;
-  }
-
-  v8::Local<v8::String> toStr = from->ToString();
-
-  char *to = static_cast<char *>(buf);
-
-  switch (encoding) {
-    case Nan::ASCII:
-#if NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION
-      sz_ = toStr->Length();
-      if (to == NULL) {
-        to = new char[sz_ + term_len];
-      } else {
-        assert(buflen >= sz_ + term_len && "too small buffer");
-      }
-      Nan::imp::NanSetPointerSafe<size_t>(
-          datalen
-        , toStr->WriteAscii(to, 0, static_cast<int>(sz_ + term_len), flags));
-      return to;
-#endif
-    case Nan::BINARY:
-    case Nan::BUFFER:
-      sz_ = toStr->Length();
-      if (to == NULL) {
-        to = new char[sz_ + term_len];
-      } else {
-        assert(buflen >= sz_ + term_len && "too small buffer");
-      }
-#if NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION
-      {
-        uint16_t* twobytebuf = new uint16_t[sz_ + term_len];
-
-        size_t somelen = toStr->Write(twobytebuf, 0,
-          static_cast<int>(sz_ + term_len), flags);
-
-        for (size_t i = 0; i < sz_ + term_len && i < somelen + term_len; i++) {
-          unsigned char *b = reinterpret_cast<unsigned char*>(&twobytebuf[i]);
-          to[i] = *b;
-        }
-
-        Nan::imp::NanSetPointerSafe<size_t>(datalen, somelen);
-
-        delete[] twobytebuf;
-        return to;
-      }
-#else
-      Nan::imp::NanSetPointerSafe<size_t>(
-        datalen,
-        toStr->WriteOneByte(
-            reinterpret_cast<uint8_t *>(to)
-          , 0
-          , static_cast<int>(sz_ + term_len)
-          , flags));
-      return to;
-#endif
-    case Nan::UTF8:
-      sz_ = toStr->Utf8Length();
-      if (to == NULL) {
-        to = new char[sz_ + term_len];
-      } else {
-        assert(buflen >= sz_ + term_len && "too small buffer");
-      }
-      Nan::imp::NanSetPointerSafe<size_t>(
-          datalen
-        , toStr->WriteUtf8(to, static_cast<int>(sz_ + term_len)
-            , NULL, flags)
-          - term_len);
-      return to;
-    case Nan::BASE64:
-      {
-        v8::String::Value value(toStr);
-        sz_ = _nan_base64_decoded_size(*value, value.length());
-        if (to == NULL) {
-          to = new char[sz_ + term_len];
-        } else {
-          assert(buflen >= sz_ + term_len);
-        }
-        Nan::imp::NanSetPointerSafe<size_t>(
-            datalen
-          , _nan_base64_decode(to, sz_, *value, value.length()));
-        if (term_len) {
-          to[sz_] = '\0';
-        }
-        return to;
-      }
-    case Nan::UCS2:
-      {
-        sz_ = toStr->Length();
-        if (to == NULL) {
-          to = new char[(sz_ + term_len) * 2];
-        } else {
-          assert(buflen >= (sz_ + term_len) * 2 && "too small buffer");
-        }
-
-        int bc = 2 * toStr->Write(
-            reinterpret_cast<uint16_t *>(to)
-          , 0
-          , static_cast<int>(sz_ + term_len)
-          , flags);
-        Nan::imp::NanSetPointerSafe<size_t>(datalen, bc);
-        return to;
-      }
-    case Nan::HEX:
-      {
-        v8::String::Value value(toStr);
-        sz_ = value.length();
-        assert(!(sz_ & 1) && "bad hex data");
-        if (to == NULL) {
-          to = new char[sz_ / 2 + term_len];
-        } else {
-          assert(buflen >= sz_ / 2 + term_len && "too small buffer");
-        }
-        Nan::imp::NanSetPointerSafe<size_t>(
-            datalen
-          , _nan_hex_decode(to, sz_ / 2, *value, value.length()));
-      }
-      if (term_len) {
-        to[sz_ / 2] = '\0';
-      }
-      return to;
-    default:
-      assert(0 && "unknown encoding");
-  }
-  return to;
-}
-
-NAN_DEPRECATED NAN_INLINE void* NanRawString(
-    v8::Handle<v8::Value> from
-  , enum Nan::Encoding encoding
-  , size_t *datalen
-  , void *buf
-  , size_t buflen
-  , int flags
-) {
-  return _NanRawString(from, encoding, datalen, buf, buflen, flags);
-}
-
-
-NAN_DEPRECATED NAN_INLINE char* NanCString(
-    v8::Handle<v8::Value> from
-  , size_t *datalen
-  , char *buf = NULL
-  , size_t buflen = 0
-  , int flags = v8::String::NO_OPTIONS
-) {
-    return static_cast<char *>(
-      _NanRawString(from, Nan::UTF8, datalen, buf, buflen, flags)
-    );
-}
-
 NAN_INLINE void NanSetPrototypeTemplate(
     v8::Local<v8::FunctionTemplate> templ
   , const char *name

From 058fae8bad524e9c53c340e7a70d0a92188ec11c Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 8 May 2015 22:11:31 +0300
Subject: [PATCH 02/84] Remove remnants of 0.6 compatibility

---
 nan.h | 27 +--------------------------
 1 file changed, 1 insertion(+), 26 deletions(-)

diff --git a/nan.h b/nan.h
index 8cc1e335..a438a138 100644
--- a/nan.h
+++ b/nan.h
@@ -1244,16 +1244,7 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
     , v8::Handle<v8::Function> func
     , int argc
     , v8::Handle<v8::Value>* argv) {
-# if NODE_VERSION_AT_LEAST(0, 8, 0)
     return NanNew(node::MakeCallback(target, func, argc, argv));
-# else
-    v8::TryCatch try_catch;
-    v8::Local<v8::Value> result = func->Call(target, argc, argv);
-    if (try_catch.HasCaught()) {
-        node::FatalException(try_catch);
-    }
-    return result;
-# endif
   }
 
   NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
@@ -1261,12 +1252,7 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
     , v8::Handle<v8::String> symbol
     , int argc
     , v8::Handle<v8::Value>* argv) {
-# if NODE_VERSION_AT_LEAST(0, 8, 0)
     return NanNew(node::MakeCallback(target, symbol, argc, argv));
-# else
-    v8::Local<v8::Function> callback = target->Get(symbol).As<v8::Function>();
-    return NanMakeCallback(target, callback, argc, argv);
-# endif
   }
 
   NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
@@ -1274,11 +1260,7 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
     , const char* method
     , int argc
     , v8::Handle<v8::Value>* argv) {
-# if NODE_VERSION_AT_LEAST(0, 8, 0)
     return NanNew(node::MakeCallback(target, method, argc, argv));
-# else
-    return NanMakeCallback(target, NanNew(method), argc, argv);
-# endif
   }
 
   NAN_INLINE void NanFatalException(const v8::TryCatch& try_catch) {
@@ -1553,7 +1535,6 @@ class NanCallback {
                            , v8::Handle<v8::Value> argv[]) const {
     NanEscapableScope();
 
-#if NODE_VERSION_AT_LEAST(0, 8, 0)
     v8::Local<v8::Function> callback = handle->
         Get(kCallbackIndex).As<v8::Function>();
     return NanEscapeScope(NanNew(node::MakeCallback(
@@ -1561,13 +1542,7 @@ class NanCallback {
       , callback
       , argc
       , argv
-    )));
-#else
-    v8::Local<v8::Function> callback = handle->
-        Get(kCallbackIndex).As<v8::Function>();
-    return NanEscapeScope(NanMakeCallback(
-        target, callback, argc, argv));
-#endif
+    ));
   }
 #endif
 };

From 4cf44af6d90321c5ea007790531960ce0076d2c5 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 8 May 2015 22:15:44 +0300
Subject: [PATCH 03/84] Remove 0.11 compatibility

---
 nan.h | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/nan.h b/nan.h
index a438a138..2f00aceb 100644
--- a/nan.h
+++ b/nan.h
@@ -267,9 +267,8 @@ namespace Nan { namespace imp {
 }  // end of namespace imp
 }  // end of namespace Nan
 
-/* io.js 1.0  */
-#if NODE_MODULE_VERSION >= IOJS_1_0_MODULE_VERSION \
-  || NODE_VERSION_AT_LEAST(0, 11, 15)
+/* node 0.12  */
+#if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
   NAN_INLINE
   void NanSetCounterFunction(v8::CounterLookupCallback cb) {
     v8::Isolate::GetCurrent()->SetCounterFunction(cb);
@@ -1808,7 +1807,7 @@ namespace Nan {
   enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
 }
 
-#if !NODE_VERSION_AT_LEAST(0, 10, 0)
+#if NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION
 # include "nan_string_bytes.h"  // NOLINT(build/include)
 #endif
 
@@ -1836,7 +1835,7 @@ NAN_INLINE v8::Local<v8::Value> NanEncode(
     , buf, len
     , static_cast<node::encoding>(encoding));
 #else
-# if NODE_VERSION_AT_LEAST(0, 10, 0)
+# if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION
   return node::Encode(buf, len, static_cast<node::encoding>(encoding));
 # else
   return Nan::imp::Encode(reinterpret_cast<const char*>(buf), len, encoding);

From ba9986d92f70225ac02bd1cebbdd5b7d6841eab8 Mon Sep 17 00:00:00 2001
From: David Siegel <david.siegel@artcom.de>
Date: Sat, 8 Nov 2014 21:14:28 +0100
Subject: [PATCH 04/84] WeakPersistent redesign

---
 nan.h             | 272 ++++++++++++++++++----------------------------
 test/cpp/weak.cpp |   8 +-
 2 files changed, 110 insertions(+), 170 deletions(-)

diff --git a/nan.h b/nan.h
index 2f00aceb..3131ec51 100644
--- a/nan.h
+++ b/nan.h
@@ -511,86 +511,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       handle.Reset(v8::Isolate::GetCurrent(), obj);
   }
 
-  template<typename T, typename P>
-  class _NanWeakCallbackData;
-
-  template<typename T, typename P>
-  struct _NanWeakCallbackInfo {
-    typedef void (*Callback)(const _NanWeakCallbackData<T, P>& data);
-    NAN_INLINE _NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb)
-      : parameter(param), callback(cb) {
-       NanAssignPersistent(persistent, handle);
-    }
-
-    NAN_INLINE ~_NanWeakCallbackInfo() {
-      persistent.Reset();
-    }
-
-    P* const parameter;
-    Callback const callback;
-    v8::Persistent<T> persistent;
-
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(_NanWeakCallbackInfo)
-  };
-
-  template<typename T, typename P>
-  class _NanWeakCallbackData {
-   public:
-    NAN_INLINE _NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
-      : info_(info) { }
-
-    NAN_INLINE v8::Local<T> GetValue() const {
-      return NanNew(info_->persistent);
-    }
-
-    NAN_INLINE P* GetParameter() const { return info_->parameter; }
-
-    NAN_INLINE bool IsNearDeath() const {
-      return info_->persistent.IsNearDeath();
-    }
-
-    NAN_INLINE void Revive() const;
-
-    NAN_INLINE _NanWeakCallbackInfo<T, P>* GetCallbackInfo() const {
-      return info_;
-    }
-
-   private:
-    _NanWeakCallbackInfo<T, P>* info_;
-  };
-
-  template<typename T, typename P>
-  static void _NanWeakCallbackDispatcher(
-    const v8::WeakCallbackData<T, _NanWeakCallbackInfo<T, P> > &data) {
-      _NanWeakCallbackInfo<T, P> *info = data.GetParameter();
-      _NanWeakCallbackData<T, P> wcbd(info);
-      info->callback(wcbd);
-      if (wcbd.IsNearDeath()) {
-        delete wcbd.GetCallbackInfo();
-      }
-  }
-
-  template<typename T, typename P>
-  NAN_INLINE void _NanWeakCallbackData<T, P>::Revive() const {
-      info_->persistent.SetWeak(info_, &_NanWeakCallbackDispatcher<T, P>);
-  }
-
-  template<typename T, typename P>
-  NAN_INLINE _NanWeakCallbackInfo<T, P>* NanMakeWeakPersistent(
-      v8::Handle<T> handle
-    , P* parameter
-    , typename _NanWeakCallbackInfo<T, P>::Callback callback) {
-      _NanWeakCallbackInfo<T, P> *cbinfo =
-       new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
-      cbinfo->persistent.SetWeak(cbinfo, &_NanWeakCallbackDispatcher<T, P>);
-      return cbinfo;
-  }
-
-# define NAN_WEAK_CALLBACK(name)                                               \
-    template<typename T, typename P>                                           \
-    static void name(const _NanWeakCallbackData<T, P> &data)
-
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
       NanEscapableScope();                                                     \
@@ -1019,93 +939,6 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
       handle = v8::Persistent<T>::New(obj);
   }
 
-  template<typename T, typename P>
-  class _NanWeakCallbackData;
-
-  template<typename T, typename P>
-  struct _NanWeakCallbackInfo {
-    typedef void (*Callback)(const _NanWeakCallbackData<T, P> &data);
-    NAN_INLINE _NanWeakCallbackInfo(v8::Handle<T> handle, P* param, Callback cb)
-      : parameter(param)
-      , callback(cb)
-      , persistent(v8::Persistent<T>::New(handle)) { }
-
-    NAN_INLINE ~_NanWeakCallbackInfo() {
-      persistent.Dispose();
-      persistent.Clear();
-    }
-
-    P* const parameter;
-    Callback const callback;
-    v8::Persistent<T> persistent;
-
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(_NanWeakCallbackInfo)
-  };
-
-  template<typename T, typename P>
-  class _NanWeakCallbackData {
-   public:
-    NAN_INLINE _NanWeakCallbackData(_NanWeakCallbackInfo<T, P> *info)
-      : info_(info) { }
-
-    NAN_INLINE v8::Local<T> GetValue() const {
-      return NanNew(info_->persistent);
-    }
-
-    NAN_INLINE P* GetParameter() const { return info_->parameter; }
-
-    NAN_INLINE bool IsNearDeath() const {
-      return info_->persistent.IsNearDeath();
-    }
-
-    NAN_INLINE void Revive() const;
-
-    NAN_INLINE _NanWeakCallbackInfo<T, P>* GetCallbackInfo() const {
-      return info_;
-    }
-
-   private:
-    _NanWeakCallbackInfo<T, P>* info_;
-  };
-
-  template<typename T, typename P>
-  static void _NanWeakPersistentDispatcher(
-      v8::Persistent<v8::Value> object, void *data) {
-    (void) object;  // unused
-    _NanWeakCallbackInfo<T, P>* info =
-        static_cast<_NanWeakCallbackInfo<T, P>*>(data);
-    _NanWeakCallbackData<T, P> wcbd(info);
-    info->callback(wcbd);
-    if (wcbd.IsNearDeath()) {
-      delete wcbd.GetCallbackInfo();
-    }
-  }
-
-  template<typename T, typename P>
-  NAN_INLINE void _NanWeakCallbackData<T, P>::Revive() const {
-      info_->persistent.MakeWeak(
-          info_
-        , &_NanWeakPersistentDispatcher<T, P>);
-  }
-
-  template<typename T, typename P>
-  NAN_INLINE _NanWeakCallbackInfo<T, P>* NanMakeWeakPersistent(
-    v8::Handle<T> handle
-  , P* parameter
-  , typename _NanWeakCallbackInfo<T, P>::Callback callback) {
-      _NanWeakCallbackInfo<T, P> *cbinfo =
-        new _NanWeakCallbackInfo<T, P>(handle, parameter, callback);
-      cbinfo->persistent.MakeWeak(
-          cbinfo
-        , &_NanWeakPersistentDispatcher<T, P>);
-      return cbinfo;
-  }
-
-# define NAN_WEAK_CALLBACK(name)                                               \
-    template<typename T, typename P>                                           \
-    static void name(const _NanWeakCallbackData<T, P> &data)
-
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
       NanEscapableScope();                                                     \
@@ -1920,6 +1753,111 @@ NAN_INLINE void NanSetInstanceTemplate(
   NanSetTemplate(templ->InstanceTemplate(), name, value, attributes);
 }
 
+//=== Weak Persistent Handling =================================================
+
+#if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
+# define NAN_WEAK_CALLBACK_DATA_TYPE_ \
+    v8::WeakCallbackData<T, NanWeakCallbackData<T, P> > const&
+# define NAN_WEAK_CALLBACK_SIG_ NAN_WEAK_CALLBACK_DATA_TYPE_
+#else
+# define NAN_WEAK_CALLBACK_DATA_TYPE_ void *
+# define NAN_WEAK_CALLBACK_SIG_ \
+    v8::Persistent<v8::Value>, NAN_WEAK_CALLBACK_DATA_TYPE_
+#endif
+
+template <typename T, typename P>
+class NanWeakCallbackData {
+ public:  // constructors
+  typedef void (*Callback)(
+      NanWeakCallbackData & data  // NOLINT(runtime/references)
+      );
+  NanWeakCallbackData(v8::Handle<T> handle, P* param, Callback cb)
+    : parameter(param), callback(cb) {
+    NanAssignPersistent(persistent, handle);
+    Revive();
+  }
+  inline ~NanWeakCallbackData();
+
+ public:  // member functions
+  v8::Local<T> GetValue() const { return NanNew(persistent); }
+  v8::Persistent<T> &GetPersistent() const { return persistent; }
+  P* GetParameter() const { return parameter; }
+  bool IsNearDeath() const { return persistent.IsNearDeath(); }
+  inline void Revive();
+
+ private:  // constructors
+  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanWeakCallbackData)
+
+ private:  // static member functions
+  static
+  void
+  invoke(NAN_WEAK_CALLBACK_SIG_ data) {
+    NanWeakCallbackData * wcbd = unwrap(data);
+    wcbd->callback(*wcbd);
+    if (wcbd->IsNearDeath()) {
+      delete wcbd;
+    }
+  }
+
+  static inline
+  NanWeakCallbackData *
+  unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
+
+ private:  // data members
+  P* const parameter;
+  Callback const callback;
+  v8::Persistent<T> persistent;
+};
+
+#undef NAN_WEAK_CALLBACK_DATA_TYPE_
+#undef NAN_WEAK_CALLBACK_SIG_
+
+#if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
+
+template <typename T, typename P>
+NanWeakCallbackData<T, P>::~NanWeakCallbackData() { persistent.Reset(); }
+
+template <typename T, typename P>
+void
+NanWeakCallbackData<T, P>::Revive() { persistent.SetWeak(this, &invoke); }
+
+template <typename T, typename P>
+NanWeakCallbackData<T, P> *
+NanWeakCallbackData<T, P>::unwrap(
+    v8::WeakCallbackData<T, NanWeakCallbackData> const& data) {
+  return data.GetParameter();
+}
+
+#else
+
+template <typename T, typename P>
+NanWeakCallbackData<T, P>::~NanWeakCallbackData() {
+  persistent.Dispose();
+  persistent.Clear();
+}
+
+template <typename T, typename P>
+void
+NanWeakCallbackData<T, P>::Revive() { persistent.MakeWeak(this, &invoke); }
+
+template <typename T, typename P>
+NanWeakCallbackData<T, P> *
+NanWeakCallbackData<T, P>::unwrap(void * data) {
+  return static_cast<NanWeakCallbackData*>(data);
+}
+
+#endif
+
+template<typename T, typename P>
+inline
+NanWeakCallbackData<T, P>*
+NanMakeWeakPersistent(
+    v8::Handle<T> handle
+  , P* parameter
+  , typename NanWeakCallbackData<T, P>::Callback callback) {
+  return new NanWeakCallbackData<T, P>(handle, parameter, callback);
+}
+
 //=== Export ==================================================================
 
 inline
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index b156d8ec..69f47e96 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -8,7 +8,8 @@
 
 #include <nan.h>
 
-NAN_WEAK_CALLBACK(weakCallback) {
+void weakCallback(
+NanWeakCallbackData<v8::Function, int> & data) {  // NOLINT(runtime/references)
   int *parameter = data.GetParameter();
   NanMakeCallback(NanGetCurrentContext()->Global(), data.GetValue(), 0, NULL);
   if ((*parameter)++ == 0) {
@@ -19,10 +20,11 @@ NAN_WEAK_CALLBACK(weakCallback) {
 }
 
 v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
+  NanEscapableScope();
   v8::Local<v8::String> lstring = NanNew<v8::String>("result");
   int *parameter = new int(0);
-  NanMakeWeakPersistent(func, parameter, &weakCallback);
-  return lstring;
+  NanMakeWeakPersistent(func, parameter, weakCallback);
+  return NanEscapeScope(lstring);
 }
 
 NAN_METHOD(Hustle) {

From b5932b42fdb6edc064b9f2e097de56a10c17e07f Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 1 May 2015 17:19:11 +0300
Subject: [PATCH 05/84] Renamed identifiers with leading underscores

---
 nan.h | 230 ++++++++++++++++++++++++++--------------------------------
 1 file changed, 101 insertions(+), 129 deletions(-)

diff --git a/nan.h b/nan.h
index 3131ec51..91f3ea77 100644
--- a/nan.h
+++ b/nan.h
@@ -324,71 +324,53 @@ namespace Nan { namespace imp {
   }
 #endif
 
-#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
-// Node 0.11+ (0.11.12 and below won't compile with these)
-
-# define _NAN_METHOD_ARGS_TYPE const v8::FunctionCallbackInfo<v8::Value>&
-# define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args
-# define _NAN_METHOD_RETURN_TYPE void
-
-# define _NAN_GETTER_ARGS_TYPE const v8::PropertyCallbackInfo<v8::Value>&
-# define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args
-# define _NAN_GETTER_RETURN_TYPE void
-
-# define _NAN_SETTER_ARGS_TYPE const v8::PropertyCallbackInfo<void>&
-# define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args
-# define _NAN_SETTER_RETURN_TYPE void
-
-# define _NAN_PROPERTY_GETTER_ARGS_TYPE                                        \
-    const v8::PropertyCallbackInfo<v8::Value>&
-# define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args
-# define _NAN_PROPERTY_GETTER_RETURN_TYPE void
-
-# define _NAN_PROPERTY_SETTER_ARGS_TYPE                                        \
-    const v8::PropertyCallbackInfo<v8::Value>&
-# define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args
-# define _NAN_PROPERTY_SETTER_RETURN_TYPE void
-
-# define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE                                    \
-    const v8::PropertyCallbackInfo<v8::Array>&
-# define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args
-# define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE void
-
-# define _NAN_PROPERTY_DELETER_ARGS_TYPE                                       \
-    const v8::PropertyCallbackInfo<v8::Boolean>&
-# define _NAN_PROPERTY_DELETER_ARGS                                            \
-    _NAN_PROPERTY_DELETER_ARGS_TYPE args
-# define _NAN_PROPERTY_DELETER_RETURN_TYPE void
-
-# define _NAN_PROPERTY_QUERY_ARGS_TYPE                                         \
-    const v8::PropertyCallbackInfo<v8::Integer>&
-# define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args
-# define _NAN_PROPERTY_QUERY_RETURN_TYPE void
-
-# define _NAN_INDEX_GETTER_ARGS_TYPE                                           \
-    const v8::PropertyCallbackInfo<v8::Value>&
-# define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args
-# define _NAN_INDEX_GETTER_RETURN_TYPE void
-
-# define _NAN_INDEX_SETTER_ARGS_TYPE                                           \
-    const v8::PropertyCallbackInfo<v8::Value>&
-# define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args
-# define _NAN_INDEX_SETTER_RETURN_TYPE void
-
-# define _NAN_INDEX_ENUMERATOR_ARGS_TYPE                                       \
-    const v8::PropertyCallbackInfo<v8::Array>&
-# define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args
-# define _NAN_INDEX_ENUMERATOR_RETURN_TYPE void
-
-# define _NAN_INDEX_DELETER_ARGS_TYPE                                          \
-    const v8::PropertyCallbackInfo<v8::Boolean>&
-# define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args
-# define _NAN_INDEX_DELETER_RETURN_TYPE void
-
-# define _NAN_INDEX_QUERY_ARGS_TYPE                                            \
-    const v8::PropertyCallbackInfo<v8::Integer>&
-# define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args
-# define _NAN_INDEX_QUERY_RETURN_TYPE void
+#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)  // Node 0.12
+  typedef const v8::FunctionCallbackInfo<v8::Value>& NAN_METHOD_ARGS_TYPE;
+  typedef void NAN_METHOD_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Value>& NAN_GETTER_ARGS_TYPE;
+  typedef void NAN_GETTER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<void>& NAN_SETTER_ARGS_TYPE;
+  typedef void NAN_SETTER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Value>&
+      NAN_PROPERTY_GETTER_ARGS_TYPE;
+  typedef void NAN_PROPERTY_GETTER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Value>&
+      NAN_PROPERTY_SETTER_ARGS_TYPE;
+  typedef void NAN_PROPERTY_SETTER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Array>&
+      NAN_PROPERTY_ENUMERATOR_ARGS_TYPE;
+  typedef void NAN_PROPERTY_ENUMERATOR_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Boolean>&
+      NAN_PROPERTY_DELETER_ARGS_TYPE;
+  typedef void NAN_PROPERTY_DELETER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Integer>&
+      NAN_PROPERTY_QUERY_ARGS_TYPE;
+  typedef void NAN_PROPERTY_QUERY_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Value>& NAN_INDEX_GETTER_ARGS_TYPE;
+  typedef void NAN_INDEX_GETTER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Value>& NAN_INDEX_SETTER_ARGS_TYPE;
+  typedef void NAN_INDEX_SETTER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Array>&
+      NAN_INDEX_ENUMERATOR_ARGS_TYPE;
+  typedef void NAN_INDEX_ENUMERATOR_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Boolean>&
+      NAN_INDEX_DELETER_ARGS_TYPE;
+  typedef void NAN_INDEX_DELETER_RETURN_TYPE;
+
+  typedef const v8::PropertyCallbackInfo<v8::Integer>&
+      NAN_INDEX_QUERY_ARGS_TYPE;
+  typedef void NAN_INDEX_QUERY_RETURN_TYPE;
 
 # define NanScope() v8::HandleScope scope(v8::Isolate::GetCurrent())
 # define NanEscapableScope()                                                   \
@@ -398,7 +380,7 @@ namespace Nan { namespace imp {
 # define NanLocker() v8::Locker locker(v8::Isolate::GetCurrent())
 # define NanUnlocker() v8::Unlocker unlocker(v8::Isolate::GetCurrent())
 # define NanReturnValue(value)                                                 \
-return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
+  return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
 # define NanReturnUndefined() return
 # define NanReturnHolder() NanReturnValue(args.Holder())
 # define NanReturnThis() NanReturnValue(args.This())
@@ -776,60 +758,45 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
     int size;
   };
 
-#else
-// Node 0.8 and 0.10
-
-# define _NAN_METHOD_ARGS_TYPE const v8::Arguments&
-# define _NAN_METHOD_ARGS _NAN_METHOD_ARGS_TYPE args
-# define _NAN_METHOD_RETURN_TYPE v8::Handle<v8::Value>
+#else  // Node 0.8 and 0.10
+  typedef const v8::Arguments& NAN_METHOD_ARGS_TYPE;
+  typedef v8::Handle<v8::Value> NAN_METHOD_RETURN_TYPE;
 
-# define _NAN_GETTER_ARGS_TYPE const v8::AccessorInfo &
-# define _NAN_GETTER_ARGS _NAN_GETTER_ARGS_TYPE args
-# define _NAN_GETTER_RETURN_TYPE v8::Handle<v8::Value>
+  typedef const v8::AccessorInfo & NAN_GETTER_ARGS_TYPE;
+  typedef v8::Handle<v8::Value> NAN_GETTER_RETURN_TYPE;
 
-# define _NAN_SETTER_ARGS_TYPE const v8::AccessorInfo &
-# define _NAN_SETTER_ARGS _NAN_SETTER_ARGS_TYPE args
-# define _NAN_SETTER_RETURN_TYPE void
+  typedef const v8::AccessorInfo & NAN_SETTER_ARGS_TYPE;
+  typedef void NAN_SETTER_RETURN_TYPE;
 
-# define _NAN_PROPERTY_GETTER_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_PROPERTY_GETTER_ARGS _NAN_PROPERTY_GETTER_ARGS_TYPE args
-# define _NAN_PROPERTY_GETTER_RETURN_TYPE v8::Handle<v8::Value>
+  typedef const v8::AccessorInfo& NAN_PROPERTY_GETTER_ARGS_TYPE;
+  typedef v8::Handle<v8::Value> NAN_PROPERTY_GETTER_RETURN_TYPE;
 
-# define _NAN_PROPERTY_SETTER_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_PROPERTY_SETTER_ARGS _NAN_PROPERTY_SETTER_ARGS_TYPE args
-# define _NAN_PROPERTY_SETTER_RETURN_TYPE v8::Handle<v8::Value>
+  typedef const v8::AccessorInfo& NAN_PROPERTY_SETTER_ARGS_TYPE;
+  typedef v8::Handle<v8::Value> NAN_PROPERTY_SETTER_RETURN_TYPE;
 
-# define _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_PROPERTY_ENUMERATOR_ARGS _NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args
-# define _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array>
+  typedef const v8::AccessorInfo& NAN_PROPERTY_ENUMERATOR_ARGS_TYPE;
+  typedef v8::Handle<v8::Array> NAN_PROPERTY_ENUMERATOR_RETURN_TYPE;
 
-# define _NAN_PROPERTY_DELETER_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_PROPERTY_DELETER_ARGS _NAN_PROPERTY_DELETER_ARGS_TYPE args
-# define _NAN_PROPERTY_DELETER_RETURN_TYPE v8::Handle<v8::Boolean>
+  typedef const v8::AccessorInfo& NAN_PROPERTY_DELETER_ARGS_TYPE;
+  typedef v8::Handle<v8::Boolean> NAN_PROPERTY_DELETER_RETURN_TYPE;
 
-# define _NAN_PROPERTY_QUERY_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_PROPERTY_QUERY_ARGS _NAN_PROPERTY_QUERY_ARGS_TYPE args
-# define _NAN_PROPERTY_QUERY_RETURN_TYPE v8::Handle<v8::Integer>
+  typedef const v8::AccessorInfo& NAN_PROPERTY_QUERY_ARGS_TYPE;
+  typedef v8::Handle<v8::Integer> NAN_PROPERTY_QUERY_RETURN_TYPE;
 
-# define _NAN_INDEX_GETTER_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_INDEX_GETTER_ARGS _NAN_INDEX_GETTER_ARGS_TYPE args
-# define _NAN_INDEX_GETTER_RETURN_TYPE v8::Handle<v8::Value>
+  typedef const v8::AccessorInfo& NAN_INDEX_GETTER_ARGS_TYPE;
+  typedef v8::Handle<v8::Value> NAN_INDEX_GETTER_RETURN_TYPE;
 
-# define _NAN_INDEX_SETTER_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_INDEX_SETTER_ARGS _NAN_INDEX_SETTER_ARGS_TYPE args
-# define _NAN_INDEX_SETTER_RETURN_TYPE v8::Handle<v8::Value>
+  typedef const v8::AccessorInfo& NAN_INDEX_SETTER_ARGS_TYPE;
+  typedef v8::Handle<v8::Value> NAN_INDEX_SETTER_RETURN_TYPE;
 
-# define _NAN_INDEX_ENUMERATOR_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_INDEX_ENUMERATOR_ARGS _NAN_INDEX_ENUMERATOR_ARGS_TYPE args
-# define _NAN_INDEX_ENUMERATOR_RETURN_TYPE v8::Handle<v8::Array>
+  typedef const v8::AccessorInfo& NAN_INDEX_ENUMERATOR_ARGS_TYPE;
+  typedef v8::Handle<v8::Array> NAN_INDEX_ENUMERATOR_RETURN_TYPE;
 
-# define _NAN_INDEX_DELETER_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_INDEX_DELETER_ARGS _NAN_INDEX_DELETER_ARGS_TYPE args
-# define _NAN_INDEX_DELETER_RETURN_TYPE v8::Handle<v8::Boolean>
+  typedef const v8::AccessorInfo& NAN_INDEX_DELETER_ARGS_TYPE;
+  typedef v8::Handle<v8::Boolean> NAN_INDEX_DELETER_RETURN_TYPE;
 
-# define _NAN_INDEX_QUERY_ARGS_TYPE const v8::AccessorInfo&
-# define _NAN_INDEX_QUERY_ARGS _NAN_INDEX_QUERY_ARGS_TYPE args
-# define _NAN_INDEX_QUERY_RETURN_TYPE v8::Handle<v8::Integer>
+  typedef const v8::AccessorInfo& NAN_INDEX_QUERY_ARGS_TYPE;
+  typedef v8::Handle<v8::Integer> NAN_INDEX_QUERY_RETURN_TYPE;
 
 # define NanScope() v8::HandleScope scope
 # define NanEscapableScope() v8::HandleScope scope
@@ -1209,50 +1176,55 @@ return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
 
 typedef void (*NanFreeCallback)(char *data, void *hint);
 
-#define NAN_METHOD(name) _NAN_METHOD_RETURN_TYPE name(_NAN_METHOD_ARGS)
+#define NAN_METHOD(name) NAN_METHOD_RETURN_TYPE name(NAN_METHOD_ARGS_TYPE args)
 #define NAN_GETTER(name)                                                       \
-    _NAN_GETTER_RETURN_TYPE name(                                              \
+    NAN_GETTER_RETURN_TYPE name(                                               \
         v8::Local<v8::String> property                                         \
-      , _NAN_GETTER_ARGS)
+      , NAN_GETTER_ARGS_TYPE args)
 #define NAN_SETTER(name)                                                       \
-    _NAN_SETTER_RETURN_TYPE name(                                              \
+    NAN_SETTER_RETURN_TYPE name(                                               \
         v8::Local<v8::String> property                                         \
       , v8::Local<v8::Value> value                                             \
-      , _NAN_SETTER_ARGS)
+      , NAN_SETTER_ARGS_TYPE args)
 #define NAN_PROPERTY_GETTER(name)                                              \
-    _NAN_PROPERTY_GETTER_RETURN_TYPE name(                                     \
+    NAN_PROPERTY_GETTER_RETURN_TYPE name(                                      \
         v8::Local<v8::String> property                                         \
-      , _NAN_PROPERTY_GETTER_ARGS)
+      , NAN_PROPERTY_GETTER_ARGS_TYPE args)
 #define NAN_PROPERTY_SETTER(name)                                              \
-    _NAN_PROPERTY_SETTER_RETURN_TYPE name(                                     \
+    NAN_PROPERTY_SETTER_RETURN_TYPE name(                                      \
         v8::Local<v8::String> property                                         \
       , v8::Local<v8::Value> value                                             \
-      , _NAN_PROPERTY_SETTER_ARGS)
+      , NAN_PROPERTY_SETTER_ARGS_TYPE args)
 #define NAN_PROPERTY_ENUMERATOR(name)                                          \
-    _NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(_NAN_PROPERTY_ENUMERATOR_ARGS)
+    NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(                                  \
+        NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args)
 #define NAN_PROPERTY_DELETER(name)                                             \
-    _NAN_PROPERTY_DELETER_RETURN_TYPE name(                                    \
+    NAN_PROPERTY_DELETER_RETURN_TYPE name(                                     \
         v8::Local<v8::String> property                                         \
-      , _NAN_PROPERTY_DELETER_ARGS)
+      , NAN_PROPERTY_DELETER_ARGS_TYPE args)
 #define NAN_PROPERTY_QUERY(name)                                               \
-    _NAN_PROPERTY_QUERY_RETURN_TYPE name(                                      \
+    NAN_PROPERTY_QUERY_RETURN_TYPE name(                                       \
         v8::Local<v8::String> property                                         \
-      , _NAN_PROPERTY_QUERY_ARGS)
+      , NAN_PROPERTY_QUERY_ARGS_TYPE args)
 # define NAN_INDEX_GETTER(name)                                                \
-    _NAN_INDEX_GETTER_RETURN_TYPE name(uint32_t index, _NAN_INDEX_GETTER_ARGS)
+    NAN_INDEX_GETTER_RETURN_TYPE name(                                         \
+        uint32_t index                                                         \
+      , NAN_INDEX_GETTER_ARGS_TYPE args)
 #define NAN_INDEX_SETTER(name)                                                 \
-    _NAN_INDEX_SETTER_RETURN_TYPE name(                                        \
+    NAN_INDEX_SETTER_RETURN_TYPE name(                                         \
         uint32_t index                                                         \
       , v8::Local<v8::Value> value                                             \
-      , _NAN_INDEX_SETTER_ARGS)
+      , NAN_INDEX_SETTER_ARGS_TYPE args)
 #define NAN_INDEX_ENUMERATOR(name)                                             \
-    _NAN_INDEX_ENUMERATOR_RETURN_TYPE name(_NAN_INDEX_ENUMERATOR_ARGS)
+    NAN_INDEX_ENUMERATOR_RETURN_TYPE name(NAN_INDEX_ENUMERATOR_ARGS_TYPE args)
 #define NAN_INDEX_DELETER(name)                                                \
-    _NAN_INDEX_DELETER_RETURN_TYPE name(                                       \
+    NAN_INDEX_DELETER_RETURN_TYPE name(                                        \
         uint32_t index                                                         \
-      , _NAN_INDEX_DELETER_ARGS)
+      , NAN_INDEX_DELETER_ARGS_TYPE args)
 #define NAN_INDEX_QUERY(name)                                                  \
-    _NAN_INDEX_QUERY_RETURN_TYPE name(uint32_t index, _NAN_INDEX_QUERY_ARGS)
+    NAN_INDEX_QUERY_RETURN_TYPE name(                                          \
+        uint32_t index                                                         \
+      , NAN_INDEX_QUERY_ARGS_TYPE args)
 
 class NanCallback {
  public:

From f77b7e7eafce44503dce381c30fe53c329892aee Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Wed, 11 Feb 2015 00:43:32 +0200
Subject: [PATCH 06/84] Disconnect NanScope and NanReturnValue

---
 README.md                           | 18 +-----------------
 examples/async_pi_estimate/async.cc |  2 --
 examples/async_pi_estimate/sync.cc  |  2 --
 nan.h                               |  2 +-
 test/cpp/asyncprogressworker.cpp    |  1 -
 test/cpp/asyncworker.cpp            |  1 -
 test/cpp/asyncworkererror.cpp       |  1 -
 test/cpp/bufferworkerpersistent.cpp |  5 -----
 test/cpp/gc.cpp                     |  2 --
 test/cpp/isolatedata.cpp            |  2 --
 test/cpp/makecallback.cpp           | 20 ++++++++------------
 test/cpp/morenews.cpp               |  8 --------
 test/cpp/multifile2.cpp             |  1 -
 test/cpp/nancallback.cpp            | 13 -------------
 test/cpp/nannew.cpp                 | 27 ---------------------------
 test/cpp/news.cpp                   | 27 ---------------------------
 test/cpp/objectwraphandle.cpp       |  4 ----
 test/cpp/persistent.cpp             | 14 --------------
 test/cpp/returnemptystring.cpp      |  1 -
 test/cpp/returnnull.cpp             |  1 -
 test/cpp/returnundefined.cpp        |  1 -
 test/cpp/returnvalue.cpp            |  4 ----
 test/cpp/settemplate.cpp            |  4 ----
 test/cpp/settergetter.cpp           | 14 ++------------
 test/cpp/strings.cpp                |  8 --------
 test/cpp/threadlocal.cpp            |  2 +-
 test/cpp/weak.cpp                   |  1 -
 27 files changed, 13 insertions(+), 173 deletions(-)

diff --git a/README.md b/README.md
index 8e155dcc..6cb0acc3 100644
--- a/README.md
+++ b/README.md
@@ -178,8 +178,6 @@ using v8::Number;
 
 // Simple synchronous access to the `Estimate()` function
 NAN_METHOD(CalculateSync) {
-  NanScope();
-
   // expect a number as the first argument
   int points = args[0]->Uint32Value();
   double est = Estimate(points);
@@ -245,8 +243,6 @@ class PiWorker : public NanAsyncWorker {
 
 // Asynchronous access to the `Estimate()` function
 NAN_METHOD(CalculateAsync) {
-  NanScope();
-
   int points = args[0]->Uint32Value();
   NanCallback *callback = new NanCallback(args[1].As<Function>());
 
@@ -461,7 +457,6 @@ NAN_GC_CALLBACK(gcPrologueCallback) {
 }
 
 NAN_METHOD(Hook) {
-  NanScope();
   NanAssignPersistent(callback, args[0].As<Function>());
   NanAddGCPrologueCallback(gcPrologueCallback);
   NanReturnValue(args.Holder());
@@ -635,12 +630,10 @@ NAN_METHOD(Foo::Baz) {
 <a name="api_nan_scope"></a>
 ### NanScope()
 
-The introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanScope()` necessary, use it in place of `HandleScope scope` when you do not wish to return handles (`Handle` or `Local`) to the surrounding scope (or in functions directly exposed to V8, as they do not return values in the normal sense):
+The introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanScope()` necessary, use it in place of `HandleScope scope` when you do not wish to return handles (`Handle` or `Local`) to the surrounding scope (or in functions directly exposed to V8, as they do not return values in the normal sense). V8-exposed methods (NAN_METHOD, etc.) have implicit handle scopes and do not need extra scopes:
 
 ```c++
 NAN_METHOD(Foo::Bar) {
-  NanScope();
-
   NanReturnValue(NanNew<String>("FooBar!"));
 }
 ```
@@ -815,7 +808,6 @@ Convert a `String` to zero-terminated, sort-of Ascii-encoded `char *`. The under
 
 ```c++
 NAN_METHOD(foo) {
-  NanScope();
   NanReturnValue(NanNew(*NanAsciiString(arg[0])));
 }
 ```
@@ -826,7 +818,6 @@ the buffer `str` points to has been freed when `baz` was destroyed:
 static char *str;
 
 NAN_METHOD(bar) {
-  NanScope();
   NanAsciiString baz(arg[0]);
 
   str = *baz;
@@ -843,7 +834,6 @@ printf(str); // use-after-free error
 static NanAsciiString *str;
 
 NAN_METHOD(bar) {
-  NanScope();
   str = new NanAsciiString(arg[0]);
   NanReturnUndefined();
 }
@@ -861,7 +851,6 @@ Convert a `String` to zero-terminated, Utf8-encoded `char *`. The underlying buf
 
 ```c++
 NAN_METHOD(foo) {
-  NanScope();
   NanReturnValue(NanNew(*NanUtf8String(arg[0])));
 }
 ```
@@ -872,7 +861,6 @@ the buffer `str` points to has been freed when `baz` was destroyed:
 static char *str;
 
 NAN_METHOD(bar) {
-  NanScope();
   NanUtf8String baz(arg[0]);
 
   str = *baz;
@@ -889,7 +877,6 @@ printf(str); // use-after-free error
 static NanUtf8String *str;
 
 NAN_METHOD(bar) {
-  NanScope();
   str = new NanUtf8String(arg[0]);
   NanReturnUndefined();
 }
@@ -908,7 +895,6 @@ Convert a `String` to zero-terminated, Ucs2-encoded `uint16_t *`. The underlying
 
 ```c++
 NAN_METHOD(foo) {
-  NanScope();
   NanReturnValue(NanNew(*NanUcs2String(arg[0])));
 }
 ```
@@ -919,7 +905,6 @@ the buffer `str` points to has been freed when `baz` was destroyed:
 static char *str;
 
 NAN_METHOD(bar) {
-  NanScope();
   NanUcs2String baz(arg[0]);
 
   str = *baz;
@@ -936,7 +921,6 @@ printf(str); // use-after-free error
 static NanUcs2String *str;
 
 NAN_METHOD(bar) {
-  NanScope();
   str = new NanUcs2String(arg[0]);
   NanReturnUndefined();
 }
diff --git a/examples/async_pi_estimate/async.cc b/examples/async_pi_estimate/async.cc
index d6b2982c..8ce559c8 100644
--- a/examples/async_pi_estimate/async.cc
+++ b/examples/async_pi_estimate/async.cc
@@ -51,8 +51,6 @@ class PiWorker : public NanAsyncWorker {
 
 // Asynchronous access to the `Estimate()` function
 NAN_METHOD(CalculateAsync) {
-  NanScope();
-
   int points = args[0]->Uint32Value();
   NanCallback *callback = new NanCallback(args[1].As<Function>());
 
diff --git a/examples/async_pi_estimate/sync.cc b/examples/async_pi_estimate/sync.cc
index d46380a2..b2e7ba6c 100644
--- a/examples/async_pi_estimate/sync.cc
+++ b/examples/async_pi_estimate/sync.cc
@@ -14,8 +14,6 @@ using v8::Number;
 
 // Simple synchronous access to the `Estimate()` function
 NAN_METHOD(CalculateSync) {
-  NanScope();
-
   // expect a number as the first argument
   int points = args[0]->Uint32Value();
   double est = Estimate(points);
diff --git a/nan.h b/nan.h
index 91f3ea77..b9928928 100644
--- a/nan.h
+++ b/nan.h
@@ -804,7 +804,7 @@ namespace Nan { namespace imp {
 # define NanLocker() v8::Locker locker
 # define NanUnlocker() v8::Unlocker unlocker
 # define NanReturnValue(value)                                                 \
-    return scope.Close(Nan::imp::NanEnsureHandleOrPersistent(value))
+    return Nan::imp::NanEnsureHandleOrPersistent(value)
 # define NanReturnHolder() NanReturnValue(args.Holder())
 # define NanReturnThis() NanReturnValue(args.This())
 # define NanReturnUndefined() return v8::Undefined()
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index 92afd389..68c4a5aa 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -46,7 +46,6 @@ class ProgressWorker : public NanAsyncProgressWorker {
 };
 
 NAN_METHOD(DoProgress) {
-  NanScope();
   NanCallback *progress = new NanCallback(args[2].As<v8::Function>());
   NanCallback *callback = new NanCallback(args[3].As<v8::Function>());
   NanAsyncQueueWorker(new ProgressWorker(
diff --git a/test/cpp/asyncworker.cpp b/test/cpp/asyncworker.cpp
index 39ee0156..f11b489a 100644
--- a/test/cpp/asyncworker.cpp
+++ b/test/cpp/asyncworker.cpp
@@ -27,7 +27,6 @@ class SleepWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(DoSleep) {
-  NanScope();
   NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
   NanAsyncQueueWorker(new SleepWorker(callback, args[0]->Uint32Value()));
   NanReturnUndefined();
diff --git a/test/cpp/asyncworkererror.cpp b/test/cpp/asyncworkererror.cpp
index 089f6442..6b26a65b 100644
--- a/test/cpp/asyncworkererror.cpp
+++ b/test/cpp/asyncworkererror.cpp
@@ -19,7 +19,6 @@ class ErrorWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(Work) {
-  NanScope();
   NanCallback *callback = new NanCallback(args[0].As<v8::Function>());
   NanAsyncQueueWorker(new ErrorWorker(callback));
   NanReturnUndefined();
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index 188e0713..88be47a4 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -20,10 +20,6 @@ class BufferWorker : public NanAsyncWorker {
         , v8::Local<v8::Object> &bufferHandle
       )
     : NanAsyncWorker(callback), milliseconds(milliseconds) {
-
-      NanScope();
-
-     /* test them all */
       SaveToPersistent("buffer", bufferHandle);
       SaveToPersistent(NanNew("puffer"), bufferHandle);
       SaveToPersistent(0u, bufferHandle);
@@ -53,7 +49,6 @@ class BufferWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(DoSleep) {
-  NanScope();
   v8::Local<v8::Object> bufferHandle = args[1].As<v8::Object>();
   NanCallback *callback = new NanCallback(args[2].As<v8::Function>());
   assert(!callback->IsEmpty() && "Callback shoud not be empty");
diff --git a/test/cpp/gc.cpp b/test/cpp/gc.cpp
index a5a62450..c046f5a6 100644
--- a/test/cpp/gc.cpp
+++ b/test/cpp/gc.cpp
@@ -20,14 +20,12 @@ NAN_GC_CALLBACK(gcEpilogueCallback) {
 }
 
 NAN_METHOD(Hook) {
-  NanScope();
   NanAddGCPrologueCallback(gcPrologueCallback);
   NanAddGCEpilogueCallback(gcEpilogueCallback);
   NanReturnUndefined();
 }
 
 NAN_METHOD(Check) {
-  NanScope();
   NanReturnValue(NanNew(prologue_called && epilogue_called));
 }
 
diff --git a/test/cpp/isolatedata.cpp b/test/cpp/isolatedata.cpp
index 32808053..a97a8ee5 100644
--- a/test/cpp/isolatedata.cpp
+++ b/test/cpp/isolatedata.cpp
@@ -13,8 +13,6 @@ struct Dummy {
 };
 
 NAN_METHOD(SetAndGet) {
-  NanScope();
-
   Dummy *d0 = new Dummy;
   Dummy *d1 = NULL;
 
diff --git a/test/cpp/makecallback.cpp b/test/cpp/makecallback.cpp
index 6abe7710..b54c1608 100644
--- a/test/cpp/makecallback.cpp
+++ b/test/cpp/makecallback.cpp
@@ -30,8 +30,6 @@ MyObject::~MyObject() {
 }
 
 void MyObject::Init(v8::Handle<v8::Object> exports) {
-  NanScope();
-
   // Prepare constructor template
   v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
   tpl->SetClassName(NanNew<v8::String>("MyObject"));
@@ -44,22 +42,20 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
 }
 
 NAN_METHOD(MyObject::New) {
-  NanScope();
-
   if (args.IsConstructCall()) {
-    MyObject* obj = new MyObject();
-    obj->Wrap(args.This());
-    NanReturnValue(args.This());
-  } else {
-    v8::Local<v8::Function> cons = NanNew<v8::Function>(constructor);
-    NanReturnValue(cons->NewInstance());
+      MyObject* obj = new MyObject();
+      obj->Wrap(args.This());
+      NanReturnValue(args.This());
+  }
+  else {
+      v8::Local<v8::Function> cons = NanNew<v8::Function>(constructor);
+      NanReturnValue(cons->NewInstance());
   }
 }
 
 NAN_METHOD(MyObject::CallEmit) {
-  NanScope();
   v8::Handle<v8::Value> argv[1] = {
-    NanNew("event"),  // event name
+      NanNew("event"), // event name
   };
 
   NanMakeCallback(args.This(), "emit", 1, argv);
diff --git a/test/cpp/morenews.cpp b/test/cpp/morenews.cpp
index 3290a3c6..86983da6 100644
--- a/test/cpp/morenews.cpp
+++ b/test/cpp/morenews.cpp
@@ -9,34 +9,28 @@
 #include <nan.h>
 
 NAN_METHOD(NewNumber) {
-  NanScope();
   NanReturnValue(NanNew(0.5));
 }
 
 NAN_METHOD(NewNegativeInteger) {
-  NanScope();
   NanReturnValue(NanNew(-1));
 }
 
 NAN_METHOD(NewPositiveInteger) {
-  NanScope();
   NanReturnValue(NanNew(1));
 }
 
 NAN_METHOD(NewUtf8String) {
-  NanScope();
   const char s[] = "strïng";
   NanReturnValue(NanNew(s));
 }
 
 NAN_METHOD(NewLatin1String) {
-  NanScope();
   const uint8_t s[] = "str\xefng";
   NanReturnValue(NanNew(s));
 }
 
 NAN_METHOD(NewUcs2String) {
-  NanScope();
   uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
   NanReturnValue(NanNew(s));
 }
@@ -60,13 +54,11 @@ class ExtAsciiString : public NanExternalOneByteStringResource {
 };
 
 NAN_METHOD(NewExternalStringResource) {
-  NanScope();
   v8::Local<v8::String> ext = NanNew(new ExtString());
   NanReturnValue(ext);
 }
 
 NAN_METHOD(NewExternalAsciiStringResource) {
-  NanScope();
   v8::Local<v8::String> ext = NanNew(new ExtAsciiString());
   NanReturnValue(ext);
 }
diff --git a/test/cpp/multifile2.cpp b/test/cpp/multifile2.cpp
index a5ec0271..7f0c0c51 100644
--- a/test/cpp/multifile2.cpp
+++ b/test/cpp/multifile2.cpp
@@ -9,7 +9,6 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnString) {
-  NanScope();
   v8::Local<v8::String> s = NanNew<v8::String>(*NanUtf8String(args[0]));
   NanReturnValue(s);
 }
diff --git a/test/cpp/nancallback.cpp b/test/cpp/nancallback.cpp
index b99d2cbb..4b418149 100644
--- a/test/cpp/nancallback.cpp
+++ b/test/cpp/nancallback.cpp
@@ -8,33 +8,24 @@
 
 #include <nan.h>
 
-
 NAN_METHOD(GlobalContext) {
-  NanScope();
-
   NanCallback(args[0].As<v8::Function>()).Call(0, NULL);
   NanReturnUndefined();
 }
 
 NAN_METHOD(SpecificContext) {
-  NanScope();
-
   NanCallback cb(args[0].As<v8::Function>());
   cb.Call(NanGetCurrentContext()->Global(), 0, NULL);
   NanReturnUndefined();
 }
 
 NAN_METHOD(CustomReceiver) {
-  NanScope();
-
   NanCallback cb(args[0].As<v8::Function>());
   cb.Call(args[1].As<v8::Object>(), 0, NULL);
   NanReturnUndefined();
 }
 
 NAN_METHOD(CompareCallbacks) {
-  NanScope();
-
   NanCallback cb1(args[0].As<v8::Function>());
   NanCallback cb2(args[1].As<v8::Function>());
   NanCallback cb3(args[2].As<v8::Function>());
@@ -43,8 +34,6 @@ NAN_METHOD(CompareCallbacks) {
 }
 
 NAN_METHOD(CallDirect) {
-  NanScope();
-
   NanCallback cb(args[0].As<v8::Function>());
   (*cb)->Call(NanGetCurrentContext()->Global(), 0, NULL);
 
@@ -52,8 +41,6 @@ NAN_METHOD(CallDirect) {
 }
 
 NAN_METHOD(CallAsFunction) {
-  NanScope();
-
   NanCallback(args[0].As<v8::Function>())();
 
   NanReturnUndefined();
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index bd106df1..1c3932a0 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -52,7 +52,6 @@ stringMatches(Local<Value> value, const char * match) {
 #define _(e) NAN_TEST_EXPRESSION(e)
 
 NAN_METHOD(testArray) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(3);
@@ -65,7 +64,6 @@ NAN_METHOD(testArray) {
 }
 
 NAN_METHOD(testBoolean) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(6);
@@ -87,7 +85,6 @@ NAN_METHOD(testBoolean) {
 # define V(x) x->ValueOf()
 #endif
 NAN_METHOD(testBooleanObject) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(3);
@@ -101,7 +98,6 @@ NAN_METHOD(testBooleanObject) {
 #undef V
 
 NAN_METHOD(testContext) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(5);
@@ -121,7 +117,6 @@ NAN_METHOD(testContext) {
 }
 
 NAN_METHOD(testDate) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(1);
@@ -134,7 +129,6 @@ NAN_METHOD(testDate) {
 int ttt = 23;
 
 NAN_METHOD(testExternal) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(2);
@@ -146,7 +140,6 @@ NAN_METHOD(testExternal) {
 }
 
 NAN_METHOD(testFunction) {
-  NanScope();
   NanTap t(args[0]);
   t.plan(2);
 
@@ -158,7 +151,6 @@ NAN_METHOD(testFunction) {
 }
 
 NAN_METHOD(testFunctionTemplate) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(4);
@@ -179,7 +171,6 @@ NAN_METHOD(testFunctionTemplate) {
 const double epsilon = 1e-9;
 
 NAN_METHOD(testNumber) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(17);
@@ -214,7 +205,6 @@ NAN_METHOD(testNumber) {
 }
 
 NAN_METHOD(testNumberObject) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(2);
@@ -226,7 +216,6 @@ NAN_METHOD(testNumberObject) {
 }
 
 NAN_METHOD(testObject) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(1);
@@ -237,7 +226,6 @@ NAN_METHOD(testObject) {
 }
 
 NAN_METHOD(testObjectTemplate) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(1);
@@ -248,7 +236,6 @@ NAN_METHOD(testObjectTemplate) {
 }
 
 NAN_METHOD(testScript) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(6);
@@ -272,7 +259,6 @@ NAN_METHOD(testScript) {
 }
 
 NAN_METHOD(testSignature) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(3);
@@ -289,7 +275,6 @@ NAN_METHOD(testSignature) {
 }
 
 NAN_METHOD(testString) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(14);
@@ -328,7 +313,6 @@ NAN_METHOD(testString) {
 # define V(x) x->ValueOf()
 #endif
 NAN_METHOD(testStringObject) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(2);
@@ -345,7 +329,6 @@ NAN_METHOD(testStringObject) {
 
 template <typename T> Handle<T> asHandle(Local<T> l) { return l; }
 NAN_METHOD(testHandles) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(2);
@@ -357,7 +340,6 @@ NAN_METHOD(testHandles) {
 }
 
 NAN_METHOD(testPersistents) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(1);
@@ -377,7 +359,6 @@ NAN_METHOD(testPersistents) {
 
 // See https://github.com/nodejs/nan/issues/212
 NAN_METHOD(testRegression212) {
-  NanScope();
   NanTap t(args[0]);
 
   t.plan(1);
@@ -407,7 +388,6 @@ NAN_METHOD(overloaded) {
 }
 
 NAN_METHOD(testRegression242) {
-  NanScope();
   NanTap t(args[0]);
 
   // These lines must *compile*. Not much to test at runtime.
@@ -429,37 +409,30 @@ NAN_METHOD(testRegression242) {
 //==============================================================================
 
 NAN_METHOD(newIntegerWithValue) {
-  NanScope();
   return_NanValue(NanNew<Integer>(args[0]->Int32Value()));
 }
 
 NAN_METHOD(newNumberWithValue) {
-  NanScope();
   return_NanValue(NanNew<Number>(args[0]->NumberValue()));
 }
 
 NAN_METHOD(newUint32WithValue) {
-  NanScope();
   return_NanValue(NanNew<Uint32>(args[0]->Uint32Value()));
 }
 
 NAN_METHOD(newStringFromChars) {
-  NanScope();
   return_NanValue(NanNew<String>("hello?"));
 }
 
 NAN_METHOD(newStringFromCharsWithLength) {
-  NanScope();
   return_NanValue(NanNew<String>("hello?", 4));
 }
 
 NAN_METHOD(newStringFromStdString) {
-  NanScope();
   return_NanValue(NanNew<String>(std::string("hello!")));
 }
 
 NAN_METHOD(newExternal) {
-  NanScope();
   return_NanValue(NanNew<External>(&ttt));
 }
 
diff --git a/test/cpp/news.cpp b/test/cpp/news.cpp
index 1af4a9ee..04519ff1 100644
--- a/test/cpp/news.cpp
+++ b/test/cpp/news.cpp
@@ -19,98 +19,80 @@
 static int magic = 1337;
 
 NAN_METHOD(NewNumber) {
-  NanScope();
   NanReturnValue(NanNew<v8::Number>(0.5));
 }
 
 NAN_METHOD(NewNegativeInteger) {
-  NanScope();
   NanReturnValue(NanNew<v8::Integer>(-1));
 }
 
 NAN_METHOD(NewPositiveInteger) {
-  NanScope();
   NanReturnValue(NanNew<v8::Integer>(1));
 }
 
 NAN_METHOD(NewUnsignedInteger) {
-  NanScope();
   NanReturnValue(NanNew<v8::Integer>(0xFFFFFFFFu));
 }
 
 NAN_METHOD(NewInt32FromPositive) {
-  NanScope();
   NanReturnValue(NanNew<v8::Int32>(0xFFFFFFFF));
 }
 
 NAN_METHOD(NewInt32FromNegative) {
-  NanScope();
   NanReturnValue(NanNew<v8::Int32>(-1));
 }
 
 NAN_METHOD(NewUint32FromPositive) {
-  NanScope();
   NanReturnValue(NanNew<v8::Uint32>(0xFFFFFFFF));
 }
 
 NAN_METHOD(NewUint32FromNegative) {
-  NanScope();
   NanReturnValue(NanNew<v8::Uint32>(-1));
 }
 
 NAN_METHOD(NewUtf8String) {
-  NanScope();
   const char s[] = "strïng";
   NanReturnValue(NanNew<v8::String>(s));
 }
 
 NAN_METHOD(NewLatin1String) {
-  NanScope();
   const uint8_t s[] = "str\xefng";
   NanReturnValue(NanNew<v8::String>(s));
 }
 
 NAN_METHOD(NewUcs2String) {
-  NanScope();
   const uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
   NanReturnValue(NanNew(s));
 }
 
 NAN_METHOD(NewStdString) {
-  NanScope();
   const std::string s = "strïng";
   NanReturnValue(NanNew<v8::String>(s));
 }
 
 NAN_METHOD(NewRegExp) {
-  NanScope();
   NanReturnValue(NanNew<v8::RegExp>(NanNew("foo"), v8::RegExp::kNone));
 }
 
 NAN_METHOD(NewStringObject) {
-  NanScope();
   NanReturnValue(NanNew<v8::StringObject>(NanNew<v8::String>("foo")));
 }
 
 NAN_METHOD(NewNumberObject) {
-  NanScope();
   NanReturnValue(NanNew<v8::NumberObject>(0.5));
 }
 
 NAN_METHOD(NewBooleanObject) {
-  NanScope();
   NanReturnValue(NanNew<v8::BooleanObject>(true));
 }
 
 NAN_METHOD(NewExternal) {
-  NanScope();
   v8::Local<v8::External> ext = NanNew<v8::External>(&magic);
   assert(*static_cast<int *>(ext->Value()) == 1337);
   NanReturnValue(NanNew<v8::String>("passed"));
 }
 
 NAN_METHOD(NewSignature) {
-  NanScope();
   v8::Local<v8::FunctionTemplate> tmpl =
       NanNew<v8::FunctionTemplate>(NewSignature);
   v8::Local<v8::Signature> sig = NanNew<v8::Signature>(tmpl);
@@ -120,13 +102,11 @@ NAN_METHOD(NewSignature) {
 }
 
 NAN_METHOD(NewScript) {
-  NanScope();
   v8::Local<NanUnboundScript> script = NanNew<NanUnboundScript>(NanNew("2+4"));
   NanReturnValue(NanRunScript(script)->ToInt32());
 }
 
 NAN_METHOD(NewScript2) {
-  NanScope();
   v8::ScriptOrigin origin(NanNew<v8::String>("x"));
   v8::Local<NanUnboundScript> script =
       NanNew<NanUnboundScript>(NanNew("2+4"), origin);
@@ -134,37 +114,30 @@ NAN_METHOD(NewScript2) {
 }
 
 NAN_METHOD(CompileScript) {
-  NanScope();
   v8::Local<NanBoundScript> script = NanCompileScript(NanNew("2+4"));
   NanReturnValue(NanRunScript(script)->ToInt32());
 }
 
 NAN_METHOD(CompileScript2) {
-  NanScope();
   v8::ScriptOrigin origin(NanNew<v8::String>("x"));
   v8::Local<NanBoundScript> script = NanCompileScript(NanNew("2+4"), origin);
   NanReturnValue(NanRunScript(script)->ToInt32());
 }
 
 NAN_METHOD(NewDate) {
-  NanScope();
   NanReturnValue(NanNew<v8::Date>(1337));
 }
 
 NAN_METHOD(NewArray) {
-  NanScope();
   NanReturnValue(NanNew<v8::Array>());
 }
 
 NAN_METHOD(NewBoolean) {
-  NanScope();
   NanReturnValue(NanNew<v8::Boolean>(true));
 }
 
 // #212
 NAN_METHOD(NewBoolean2) {
-  NanScope();
-
 #if defined(_MSC_VER)
 # pragma warning( push )
 # pragma warning( disable : 4800 )
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index da25bc25..7f9fc54f 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -11,7 +11,6 @@
 class MyObject : public node::ObjectWrap {
  public:
   static void Init(v8::Handle<v8::Object> exports) {
-    NanScope();
     v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
     tpl->SetClassName(NanNew("MyObject"));
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
@@ -27,8 +26,6 @@ class MyObject : public node::ObjectWrap {
   ~MyObject() {}
 
   static NAN_METHOD(New) {
-    NanScope();
-
     if (args.IsConstructCall()) {
       double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
       MyObject *obj = new MyObject(value);
@@ -43,7 +40,6 @@ class MyObject : public node::ObjectWrap {
   }
 
   static NAN_METHOD(GetHandle) {
-    NanScope();
     MyObject* obj = node::ObjectWrap::Unwrap<MyObject>(args.This());
     NanReturnValue(NanObjectWrapHandle(obj));
   }
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index 6d4b3f1c..92a1d24e 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -12,48 +12,34 @@
 static v8::Persistent<v8::String> persistentTest1;
 
 NAN_METHOD(Save1) {
-  NanScope();
-
   NanAssignPersistent(persistentTest1, args[0].As<v8::String>());
-
   NanReturnUndefined();
 }
 
 NAN_METHOD(Get1) {
-  NanScope();
-
   NanReturnValue(NanNew(persistentTest1));
 }
 
 NAN_METHOD(Dispose1) {
-  NanScope();
-
   NanDisposePersistent(persistentTest1);
-
   NanReturnUndefined();
 }
 
 NAN_METHOD(ToPersistentAndBackAgain) {
-  NanScope();
-
   v8::Persistent<v8::Object> persistent;
   NanAssignPersistent(persistent, args[0].As<v8::Object>());
   v8::Local<v8::Object> object = NanNew(persistent);
   NanDisposePersistent(persistent);
   memset(&persistent, -1, sizeof(persistent));  // Clobber it good.
-
   NanReturnValue(object);
 }
 
 NAN_METHOD(PersistentToPersistent) {
-  NanScope();
-
   v8::Persistent<v8::String> persistent;
   NanAssignPersistent(persistent, args[0].As<v8::String>());
   NanAssignPersistent(persistentTest1, persistent);
   NanDisposePersistent(persistent);
   NanDisposePersistent(persistentTest1);
-
   NanReturnUndefined();
 }
 
diff --git a/test/cpp/returnemptystring.cpp b/test/cpp/returnemptystring.cpp
index 8b1cca08..1f37033c 100644
--- a/test/cpp/returnemptystring.cpp
+++ b/test/cpp/returnemptystring.cpp
@@ -9,7 +9,6 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnEmptyString) {
-  NanScope();
   NanReturnEmptyString();
 }
 
diff --git a/test/cpp/returnnull.cpp b/test/cpp/returnnull.cpp
index 2c774c3e..c283cd5a 100644
--- a/test/cpp/returnnull.cpp
+++ b/test/cpp/returnnull.cpp
@@ -9,7 +9,6 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnNull) {
-  NanScope();
   NanReturnNull();
 }
 
diff --git a/test/cpp/returnundefined.cpp b/test/cpp/returnundefined.cpp
index 38721ce5..2463f2de 100644
--- a/test/cpp/returnundefined.cpp
+++ b/test/cpp/returnundefined.cpp
@@ -9,7 +9,6 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnUndefined) {
-  NanScope();
   NanReturnUndefined();
 }
 
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index 5cc6be23..69874845 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -11,7 +11,6 @@
 v8::Persistent<v8::Boolean> persistent;
 
 NAN_METHOD(ReturnValue) {
-  NanScope();
   if (args.Length() == 1) {
     NanReturnValue(args[0]);
   } else {
@@ -20,17 +19,14 @@ NAN_METHOD(ReturnValue) {
 }
 
 NAN_METHOD(ReturnPrimitive) {
-  NanScope();
   NanReturnValue(true);
 }
 
 NAN_METHOD(ReturnString) {
-  NanScope();
   NanReturnValue("yes, it works");
 }
 
 NAN_METHOD(ReturnPersistent) {
-  NanScope();
   NanReturnValue(persistent);
 }
 
diff --git a/test/cpp/settemplate.cpp b/test/cpp/settemplate.cpp
index 32fc30b3..79a87880 100644
--- a/test/cpp/settemplate.cpp
+++ b/test/cpp/settemplate.cpp
@@ -29,8 +29,6 @@ MyObject::~MyObject() {
 }
 
 void MyObject::Init(v8::Handle<v8::Object> exports) {
-  NanScope();
-
   // Prepare constructor template
   v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
   tpl->SetClassName(NanNew<v8::String>("MyObject"));
@@ -55,8 +53,6 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
 }
 
 NAN_METHOD(MyObject::New) {
-  NanScope();
-
   if (args.IsConstructCall()) {
     MyObject* obj = new MyObject();
     obj->Wrap(args.This());
diff --git a/test/cpp/settergetter.cpp b/test/cpp/settergetter.cpp
index 1b1e6470..833a990f 100644
--- a/test/cpp/settergetter.cpp
+++ b/test/cpp/settergetter.cpp
@@ -29,7 +29,6 @@ class SetterGetter : public node::ObjectWrap {
 static v8::Persistent<v8::FunctionTemplate> settergetter_constructor;
 
 NAN_METHOD(CreateNew) {
-  NanScope();
   NanReturnValue(SetterGetter::NewInstance());
 }
 
@@ -61,16 +60,15 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
 }
 
 v8::Handle<v8::Value> SetterGetter::NewInstance () {
+  NanEscapableScope();
   v8::Local<v8::FunctionTemplate> constructorHandle =
       NanNew(settergetter_constructor);
   v8::Local<v8::Object> instance =
     constructorHandle->GetFunction()->NewInstance(0, NULL);
-  return instance;
+  return NanEscapeScope(instance);
 }
 
 NAN_METHOD(SetterGetter::New) {
-  NanScope();
-
   SetterGetter* settergetter = new SetterGetter();
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
   strncat(
@@ -83,8 +81,6 @@ NAN_METHOD(SetterGetter::New) {
 }
 
 NAN_GETTER(SetterGetter::GetProp1) {
-  NanScope();
-
   SetterGetter* settergetter =
     node::ObjectWrap::Unwrap<SetterGetter>(args.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
@@ -107,8 +103,6 @@ NAN_GETTER(SetterGetter::GetProp1) {
 }
 
 NAN_GETTER(SetterGetter::GetProp2) {
-  NanScope();
-
   SetterGetter* settergetter =
     node::ObjectWrap::Unwrap<SetterGetter>(args.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
@@ -131,8 +125,6 @@ NAN_GETTER(SetterGetter::GetProp2) {
 }
 
 NAN_SETTER(SetterGetter::SetProp2) {
-  NanScope();
-
   SetterGetter* settergetter =
       node::ObjectWrap::Unwrap<SetterGetter>(args.This());
   strncpy(
@@ -158,8 +150,6 @@ NAN_SETTER(SetterGetter::SetProp2) {
 }
 
 NAN_METHOD(SetterGetter::Log) {
-  NanScope();
-
   SetterGetter* settergetter =
     node::ObjectWrap::Unwrap<SetterGetter>(args.This());
 
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index 4a1f6e07..305aee63 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -9,22 +9,18 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnAsciiString) {
-  NanScope();
   NanReturnValue(NanNew(*NanAsciiString(args[0])));
 }
 
 NAN_METHOD(ReturnUtf8String) {
-  NanScope();
   NanReturnValue(NanNew(*NanUtf8String(args[0])));
 }
 
 NAN_METHOD(ReturnUcs2String) {
-  NanScope();
   NanReturnValue(NanNew(*NanUcs2String(args[0])));
 }
 
 NAN_METHOD(HeapString) {
-  NanScope();
   NanUcs2String *s = new NanUcs2String(args[0]);
   v8::Local<v8::String> res = NanNew(**s);
   delete s;
@@ -32,12 +28,10 @@ NAN_METHOD(HeapString) {
 }
 
 NAN_METHOD(EncodeHex) {
-  NanScope();
   NanReturnValue(NanEncode("hello", 5, Nan::HEX));
 }
 
 NAN_METHOD(EncodeUCS2) {
-  NanScope();
   NanReturnValue(NanEncode("h\0e\0l\0l\0o\0", 10, Nan::UCS2));
 }
 
@@ -49,8 +43,6 @@ v8::Persistent<v8::FunctionTemplate> encodeHex_persistent;
 v8::Persistent<v8::FunctionTemplate> encodeUCS2_persistent;
 
 void Init (v8::Handle<v8::Object> target) {
-  NanScope();
-
   v8::Local<v8::FunctionTemplate> returnAsciiString =
     NanNew<v8::FunctionTemplate>(ReturnAsciiString);
 
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index e0d63794..466e7bb7 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -16,6 +16,7 @@ class TlsTest : public NanAsyncWorker {
  public:
   explicit TlsTest(NanTap *t) : NanAsyncWorker(NULL), t(t), i(0) {
     NanScope();
+
     t->plan(7);
     t->ok(_(0 == nauv_key_create(&tls_key)));
     t->ok(_(NULL == nauv_key_get(&tls_key)));
@@ -53,7 +54,6 @@ class TlsTest : public NanAsyncWorker {
 };
 
 NAN_METHOD(thread_local_storage) {
-  NanScope();
   NanTap *t = new NanTap(args[0]);
   NanAsyncQueueWorker(new TlsTest(t));
   return_NanUndefined();
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index 69f47e96..f202e132 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -28,7 +28,6 @@ v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
 }
 
 NAN_METHOD(Hustle) {
-  NanScope();
   NanReturnValue(wrap(args[0].As<v8::Function>()));
 }
 

From 464f1e17fdf7d016c7a9e781e1caabf2b53ce866 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 9 May 2015 16:57:13 +0300
Subject: [PATCH 07/84] Replaced NanObjectWrapHandle with class NanObjectWrap

---
 nan.h                         | 20 ++++++++++----------
 test/cpp/objectwraphandle.cpp |  6 +++---
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/nan.h b/nan.h
index b9928928..caf22bdd 100644
--- a/nan.h
+++ b/nan.h
@@ -387,11 +387,6 @@ namespace Nan { namespace imp {
 # define NanReturnNull() return args.GetReturnValue().SetNull()
 # define NanReturnEmptyString() return args.GetReturnValue().SetEmptyString()
 
-  NAN_INLINE
-  v8::Local<v8::Object> NanObjectWrapHandle(const node::ObjectWrap *obj) {
-    return const_cast<node::ObjectWrap*>(obj)->handle();
-  }
-
   NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
     NanEscapableScope();
     return NanEscapeScope(NanNew(v8::Undefined(v8::Isolate::GetCurrent())));
@@ -811,11 +806,6 @@ namespace Nan { namespace imp {
 # define NanReturnNull() return v8::Null()
 # define NanReturnEmptyString() return v8::String::Empty()
 
-  NAN_INLINE
-  v8::Local<v8::Object> NanObjectWrapHandle(const node::ObjectWrap *obj) {
-    return v8::Local<v8::Object>::New(obj->handle_);
-  }
-
   NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
     NanEscapableScope();
     return NanEscapeScope(NanNew(v8::Undefined()));
@@ -1725,6 +1715,16 @@ NAN_INLINE void NanSetInstanceTemplate(
   NanSetTemplate(templ->InstanceTemplate(), name, value, attributes);
 }
 
+//=== ObjectWrap ===============================================================
+
+class NanObjectWrap : public node::ObjectWrap {
+#if NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION
+ public:
+  inline v8::Local<v8::Object> handle() { return NanNew(handle_); }
+  inline v8::Persistent<v8::Object> &persistent() { return handle_; }
+#endif
+};
+
 //=== Weak Persistent Handling =================================================
 
 #if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index 7f9fc54f..a2b33897 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -8,7 +8,7 @@
 
 #include <nan.h>
 
-class MyObject : public node::ObjectWrap {
+class MyObject : public NanObjectWrap {
  public:
   static void Init(v8::Handle<v8::Object> exports) {
     v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
@@ -40,8 +40,8 @@ class MyObject : public node::ObjectWrap {
   }
 
   static NAN_METHOD(GetHandle) {
-    MyObject* obj = node::ObjectWrap::Unwrap<MyObject>(args.This());
-    NanReturnValue(NanObjectWrapHandle(obj));
+    MyObject* obj = NanObjectWrap::Unwrap<MyObject>(args.This());
+    NanReturnValue(obj->handle());
   }
 
   static v8::Persistent<v8::Function> constructor;

From 47751c4f904e2f1e13244a8cd86d63ee427a69af Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 9 May 2015 18:27:38 +0300
Subject: [PATCH 08/84] Replace NanScope and NanEscpableScope macros with
 classes

---
 nan.h                               | 250 ++++++++++++++--------------
 test/cpp/asyncprogressworker.cpp    |   2 +-
 test/cpp/bufferworkerpersistent.cpp |   2 +-
 test/cpp/settergetter.cpp           |   4 +-
 test/cpp/threadlocal.cpp            |   2 +-
 test/cpp/weak.cpp                   |   4 +-
 6 files changed, 136 insertions(+), 128 deletions(-)

diff --git a/nan.h b/nan.h
index caf22bdd..caca5458 100644
--- a/nan.h
+++ b/nan.h
@@ -267,6 +267,74 @@ namespace Nan { namespace imp {
 }  // end of namespace imp
 }  // end of namespace Nan
 
+//=== HandleScope ==============================================================
+
+class NanScope {
+  v8::HandleScope scope;
+
+ public:
+#if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+  inline NanScope() : scope(v8::Isolate::GetCurrent()) {}
+  inline static int NumberOfHandles() {
+    return v8::HandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
+  }
+#else
+  inline NanScope() : scope() {}
+  inline static int NumberOfHandles() {
+    return v8::HandleScope::NumberOfHandles();
+  }
+#endif
+
+ private:
+  // Make it hard to create heap-allocated or illegal handle scopes by
+  // disallowing certain operations.
+  NanScope(const NanScope &);
+  void operator=(const NanScope &);
+  void *operator new(size_t size);
+  void operator delete(void *, size_t);
+};
+
+class NanEscapableScope {
+ public:
+#if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+  inline NanEscapableScope() : scope(v8::Isolate::GetCurrent()) {}
+
+  inline static int NumberOfHandles() {
+    return v8::EscapableHandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
+  }
+
+  template<typename T>
+  inline v8::Local<T> Escape(v8::Local<T> value) {
+    return scope.Escape(value);
+  }
+
+ private:
+  v8::EscapableHandleScope scope;
+#else
+  inline NanEscapableScope() : scope() {}
+
+  inline static int NumberOfHandles() {
+    return v8::HandleScope::NumberOfHandles();
+  }
+
+  template<typename T>
+  inline v8::Local<T> Escape(v8::Local<T> value) {
+    return scope.Close(value);
+  }
+
+ private:
+  v8::HandleScope scope;
+#endif
+
+ private:
+  // Make it hard to create heap-allocated or illegal handle scopes by
+  // disallowing certain operations.
+  NanEscapableScope(const NanEscapableScope &);
+  void operator=(const NanEscapableScope &);
+  void *operator new(size_t size);
+  void operator delete(void *, size_t);
+};
+
 /* node 0.12  */
 #if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
   NAN_INLINE
@@ -372,11 +440,6 @@ namespace Nan { namespace imp {
       NAN_INDEX_QUERY_ARGS_TYPE;
   typedef void NAN_INDEX_QUERY_RETURN_TYPE;
 
-# define NanScope() v8::HandleScope scope(v8::Isolate::GetCurrent())
-# define NanEscapableScope()                                                   \
-  v8::EscapableHandleScope scope(v8::Isolate::GetCurrent())
-
-# define NanEscapeScope(val) scope.Escape(Nan::imp::NanEnsureLocal(val))
 # define NanLocker() v8::Locker locker(v8::Isolate::GetCurrent())
 # define NanUnlocker() v8::Unlocker unlocker(v8::Isolate::GetCurrent())
 # define NanReturnValue(value)                                                 \
@@ -388,23 +451,23 @@ namespace Nan { namespace imp {
 # define NanReturnEmptyString() return args.GetReturnValue().SetEmptyString()
 
   NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::Undefined(v8::Isolate::GetCurrent())));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::Undefined(v8::Isolate::GetCurrent())));
   }
 
   NAN_INLINE v8::Local<v8::Primitive> NanNull() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::Null(v8::Isolate::GetCurrent())));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::Null(v8::Isolate::GetCurrent())));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> NanTrue() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::True(v8::Isolate::GetCurrent())));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::True(v8::Isolate::GetCurrent())));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> NanFalse() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::False(v8::Isolate::GetCurrent())));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::False(v8::Isolate::GetCurrent())));
   }
 
   NAN_INLINE int NanAdjustExternalMemory(int bc) {
@@ -490,8 +553,8 @@ namespace Nan { namespace imp {
 
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
-      NanEscapableScope();                                                     \
-      return NanEscapeScope(v8::Exception::NAME(NanNew(errmsg)));              \
+      NanEscapableScope scope;                                                 \
+      return scope.Escape(v8::Exception::NAME(NanNew(errmsg)));                \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
@@ -500,13 +563,13 @@ namespace Nan { namespace imp {
     }                                                                          \
                                                                                \
     NAN_INLINE void NanThrow ## NAME(const char *errmsg) {                     \
-      NanScope();                                                              \
+      NanScope scope;                                                          \
       v8::Isolate::GetCurrent()->ThrowException(                               \
           v8::Exception::NAME(NanNew(errmsg)));                                \
     }                                                                          \
                                                                                \
     NAN_INLINE void NanThrow ## NAME(v8::Handle<v8::String> errmsg) {          \
-      NanScope();                                                              \
+      NanScope scope;                                                          \
       v8::Isolate::GetCurrent()->ThrowException(                               \
           v8::Exception::NAME(NanNew(errmsg)));                                \
     }
@@ -523,31 +586,6 @@ namespace Nan { namespace imp {
     v8::Isolate::GetCurrent()->ThrowException(error);
   }
 
-  namespace Nan { namespace imp {
-    NAN_INLINE v8::Local<v8::Value> E(const char *msg, const int errorNumber) {
-      NanEscapableScope();
-      v8::Local<v8::Value> err = v8::Exception::Error(NanNew<v8::String>(msg));
-      v8::Local<v8::Object> obj = err.As<v8::Object>();
-      obj->Set(NanNew<v8::String>("code"), NanNew<v8::Int32>(errorNumber));
-      return NanEscapeScope(err);
-    }
-  }  // end of namespace imp
-  }  // end of namespace Nan
-
-  NAN_DEPRECATED NAN_INLINE v8::Local<v8::Value> NanError(
-      const char *msg
-    , const int errorNumber
-  ) {
-    return Nan::imp::E(msg, errorNumber);
-  }
-
-  NAN_DEPRECATED NAN_INLINE void NanThrowError(
-      const char *msg
-    , const int errorNumber
-  ) {
-    NanThrowError(Nan::imp::E(msg, errorNumber));
-  }
-
   template<typename T> NAN_INLINE void NanDisposePersistent(
       v8::Persistent<T> &handle
   ) {
@@ -793,9 +831,6 @@ namespace Nan { namespace imp {
   typedef const v8::AccessorInfo& NAN_INDEX_QUERY_ARGS_TYPE;
   typedef v8::Handle<v8::Integer> NAN_INDEX_QUERY_RETURN_TYPE;
 
-# define NanScope() v8::HandleScope scope
-# define NanEscapableScope() v8::HandleScope scope
-# define NanEscapeScope(val) scope.Close(val)
 # define NanLocker() v8::Locker locker
 # define NanUnlocker() v8::Unlocker unlocker
 # define NanReturnValue(value)                                                 \
@@ -807,23 +842,23 @@ namespace Nan { namespace imp {
 # define NanReturnEmptyString() return v8::String::Empty()
 
   NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::Undefined()));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::Undefined()));
   }
 
   NAN_INLINE v8::Local<v8::Primitive> NanNull() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::Null()));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::Null()));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> NanTrue() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::True()));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::True()));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> NanFalse() {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(v8::False()));
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(v8::False()));
   }
 
   NAN_INLINE int NanAdjustExternalMemory(int bc) {
@@ -898,8 +933,8 @@ namespace Nan { namespace imp {
 
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
-      NanEscapableScope();                                                     \
-      return NanEscapeScope(v8::Exception::NAME(NanNew(errmsg)));              \
+      NanEscapableScope scope;                                                 \
+      return scope.Escape(v8::Exception::NAME(NanNew(errmsg)));                \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
@@ -908,15 +943,15 @@ namespace Nan { namespace imp {
     }                                                                          \
                                                                                \
     NAN_INLINE v8::Local<v8::Value> NanThrow ## NAME(const char *errmsg) {     \
-      NanEscapableScope();                                                     \
-      return NanEscapeScope(NanNew(v8::ThrowException(                         \
+      NanEscapableScope scope;                                                 \
+      return scope.Escape(NanNew(v8::ThrowException(                           \
           v8::Exception::NAME(NanNew(errmsg)))));                              \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
     v8::Local<v8::Value> NanThrow ## NAME(v8::Handle<v8::String> errmsg) {     \
-      NanEscapableScope();                                                     \
-      return NanEscapeScope(NanNew(v8::ThrowException(                         \
+      NanEscapableScope scope;                                                 \
+      return scope.Escape(NanNew(v8::ThrowException(                           \
           v8::Exception::NAME(errmsg))));                                      \
     }
 
@@ -929,33 +964,8 @@ namespace Nan { namespace imp {
 # undef X
 
   NAN_INLINE v8::Local<v8::Value> NanThrowError(v8::Handle<v8::Value> error) {
-    NanEscapableScope();
-    return NanEscapeScope(v8::Local<v8::Value>::New(v8::ThrowException(error)));
-  }
-
-  namespace Nan { namespace imp {
-    NAN_INLINE v8::Local<v8::Value> E(const char *msg, const int errorNumber) {
-      NanEscapableScope();
-      v8::Local<v8::Value> err = v8::Exception::Error(NanNew<v8::String>(msg));
-      v8::Local<v8::Object> obj = err.As<v8::Object>();
-      obj->Set(NanNew<v8::String>("code"), NanNew<v8::Int32>(errorNumber));
-      return NanEscapeScope(err);
-    }
-  }  // end of namespace imp
-  }  // end of namespace Nan
-
-  NAN_DEPRECATED NAN_INLINE v8::Local<v8::Value> NanError(
-      const char *msg
-    , const int errorNumber
-  ) {
-    return Nan::imp::E(msg, errorNumber);
-  }
-
-  NAN_DEPRECATED NAN_INLINE v8::Local<v8::Value> NanThrowError(
-      const char *msg
-    , const int errorNumber
-  ) {
-    return NanThrowError(Nan::imp::E(msg, errorNumber));
+    NanEscapableScope scope;
+    return scope.Escape(v8::Local<v8::Value>::New(v8::ThrowException(error)));
   }
 
   template<typename T>
@@ -1219,13 +1229,13 @@ typedef void (*NanFreeCallback)(char *data, void *hint);
 class NanCallback {
  public:
   NanCallback() {
-    NanScope();
+    NanScope scope;
     v8::Local<v8::Object> obj = NanNew<v8::Object>();
     NanAssignPersistent(handle, obj);
   }
 
   explicit NanCallback(const v8::Handle<v8::Function> &fn) {
-    NanScope();
+    NanScope scope;
     v8::Local<v8::Object> obj = NanNew<v8::Object>();
     NanAssignPersistent(handle, obj);
     SetFunction(fn);
@@ -1237,7 +1247,7 @@ class NanCallback {
   }
 
   bool operator==(const NanCallback &other) const {
-    NanScope();
+    NanScope scope;
     v8::Local<v8::Value> a = NanNew(handle)->Get(kCallbackIndex);
     v8::Local<v8::Value> b = NanNew(other.handle)->Get(kCallbackIndex);
     return a->StrictEquals(b);
@@ -1264,18 +1274,18 @@ class NanCallback {
   }
 
   NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
-    NanScope();
+    NanScope scope;
     NanNew(handle)->Set(kCallbackIndex, fn);
   }
 
   NAN_INLINE v8::Local<v8::Function> GetFunction() const {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(handle)->Get(kCallbackIndex)
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(handle)->Get(kCallbackIndex)
         .As<v8::Function>());
   }
 
   NAN_INLINE bool IsEmpty() const {
-    NanScope();
+    NanScope scope;
     return NanNew(handle)->Get(kCallbackIndex)->IsUndefined();
   }
 
@@ -1311,11 +1321,11 @@ class NanCallback {
                            , v8::Handle<v8::Object> target
                            , int argc
                            , v8::Handle<v8::Value> argv[]) const {
-    NanEscapableScope();
+    NanEscapableScope scope;
 
     v8::Local<v8::Function> callback = NanNew(handle)->
         Get(kCallbackIndex).As<v8::Function>();
-    return NanEscapeScope(NanNew(node::MakeCallback(
+    return scope.Escape(Nan::imp::NanEnsureLocal(node::MakeCallback(
         isolate
       , target
       , callback
@@ -1327,16 +1337,16 @@ class NanCallback {
   v8::Local<v8::Value> Call_(v8::Handle<v8::Object> target
                            , int argc
                            , v8::Handle<v8::Value> argv[]) const {
-    NanEscapableScope();
+    NanEscapableScope scope;
 
     v8::Local<v8::Function> callback = handle->
         Get(kCallbackIndex).As<v8::Function>();
-    return NanEscapeScope(NanNew(node::MakeCallback(
+    return scope.Escape(Nan::imp::NanEnsureLocal(node::MakeCallback(
         target
       , callback
       , argc
       , argv
-    ));
+    )));
   }
 #endif
 };
@@ -1347,13 +1357,13 @@ class NanCallback {
       : callback(callback_), errmsg_(NULL) {
     request.data = this;
 
-    NanScope();
+    NanScope scope;
     v8::Local<v8::Object> obj = NanNew<v8::Object>();
     NanAssignPersistent(persistentHandle, obj);
   }
 
   virtual ~NanAsyncWorker() {
-    NanScope();
+    NanScope scope;
 
     if (!persistentHandle.IsEmpty())
       NanDisposePersistent(persistentHandle);
@@ -1364,7 +1374,7 @@ class NanCallback {
   }
 
   virtual void WorkComplete() {
-    NanScope();
+    NanScope scope;
 
     if (errmsg_ == NULL)
       HandleOKCallback();
@@ -1375,39 +1385,37 @@ class NanCallback {
   }
 
   NAN_INLINE void SaveToPersistent(
-      const char *key, const v8::Local<v8::Object> &obj) {
-    NanScope();
-    NanNew(persistentHandle)->Set(NanNew(key), obj);
+      const char *key, const v8::Local<v8::Value> &value) {
+    NanScope scope;
+    NanNew(persistentHandle)->Set(NanNew(key), value);
   }
 
   NAN_INLINE void SaveToPersistent(
-      const v8::Handle<v8::String> &key, const v8::Local<v8::Object> &obj) {
-    NanScope();
-    NanNew(persistentHandle)->Set(key, obj);
+      const v8::Handle<v8::String> &key, const v8::Local<v8::Value> &value) {
+    NanScope scope;
+    NanNew(persistentHandle)->Set(key, value);
   }
 
   NAN_INLINE void SaveToPersistent(
-      uint32_t index, const v8::Local<v8::Object> &obj) {
-    NanScope();
-    NanNew(persistentHandle)->Set(index, obj);
+      uint32_t index, const v8::Local<v8::Value> &value) {
+    NanScope scope;
+    NanNew(persistentHandle)->Set(index, value);
   }
 
-  NAN_INLINE v8::Local<v8::Object> GetFromPersistent(const char *key) const {
-    NanEscapableScope();
-    return NanEscapeScope(
-        NanNew(persistentHandle)->Get(NanNew(key)).As<v8::Object>());
+  NAN_INLINE v8::Local<v8::Value> GetFromPersistent(const char *key) const {
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(persistentHandle)->Get(NanNew(key)));
   }
 
   NAN_INLINE v8::Local<v8::Object>
   GetFromPersistent(const v8::Local<v8::String> &key) const {
-    NanEscapableScope();
-    return NanEscapeScope(NanNew(persistentHandle)->Get(key).As<v8::Object>());
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(persistentHandle)->Get(key));
   }
 
-  NAN_INLINE v8::Local<v8::Object> GetFromPersistent(uint32_t index) const {
-    NanEscapableScope();
-    return NanEscapeScope(
-        NanNew(persistentHandle)->Get(index).As<v8::Object>());
+  NAN_INLINE v8::Local<v8::Value> GetFromPersistent(uint32_t index) const {
+    NanEscapableScope scope;
+    return scope.Escape(NanNew(persistentHandle)->Get(index));
   }
 
   virtual void Execute() = 0;
@@ -1427,7 +1435,7 @@ class NanCallback {
   }
 
   virtual void HandleErrorCallback() {
-    NanScope();
+    NanScope scope;
 
     v8::Local<v8::Value> argv[] = {
         v8::Exception::Error(NanNew<v8::String>(ErrorMessage()))
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index 68c4a5aa..0639aac8 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -31,7 +31,7 @@ class ProgressWorker : public NanAsyncProgressWorker {
   }
 
   void HandleProgressCallback(const char *data, size_t size) {
-    NanScope();
+    NanScope scope;
 
     v8::Local<v8::Value> argv[] = {
         NanNew<v8::Integer>(*reinterpret_cast<int*>(const_cast<char*>(data)))
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index 88be47a4..9fe5a46c 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -32,7 +32,7 @@ class BufferWorker : public NanAsyncWorker {
   }
 
   void HandleOKCallback () {
-    NanScope();
+    NanScope scope;
 
     v8::Local<v8::Value> handle = GetFromPersistent("buffer");
     callback->Call(1, &handle);
diff --git a/test/cpp/settergetter.cpp b/test/cpp/settergetter.cpp
index 833a990f..875db98c 100644
--- a/test/cpp/settergetter.cpp
+++ b/test/cpp/settergetter.cpp
@@ -60,12 +60,12 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
 }
 
 v8::Handle<v8::Value> SetterGetter::NewInstance () {
-  NanEscapableScope();
+  NanEscapableScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       NanNew(settergetter_constructor);
   v8::Local<v8::Object> instance =
     constructorHandle->GetFunction()->NewInstance(0, NULL);
-  return NanEscapeScope(instance);
+  return scope.Escape(instance);
 }
 
 NAN_METHOD(SetterGetter::New) {
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index 466e7bb7..1680e0bf 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -31,7 +31,7 @@ class TlsTest : public NanAsyncWorker {
     ok(_(NULL == nauv_key_get(&tls_key)));
   }
   void WorkComplete() {
-    NanScope();
+    NanScope scope;
     for (unsigned j = 0; j < i; ++j)
       t->ok(res[j].ok, res[j].msg);
     nauv_key_delete(&tls_key);
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index f202e132..fc4248e3 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -20,11 +20,11 @@ NanWeakCallbackData<v8::Function, int> & data) {  // NOLINT(runtime/references)
 }
 
 v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
-  NanEscapableScope();
+  NanEscapableScope scope;
   v8::Local<v8::String> lstring = NanNew<v8::String>("result");
   int *parameter = new int(0);
   NanMakeWeakPersistent(func, parameter, weakCallback);
-  return NanEscapeScope(lstring);
+  return scope.Escape(lstring);
 }
 
 NAN_METHOD(Hustle) {

From dd6e4013914bb8f6b6bb650e4f0eba48b0864116 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 9 May 2015 18:49:48 +0300
Subject: [PATCH 09/84] Remove NanLocker and NanUnlocker

---
 README.md | 28 ----------------------------
 nan.h     |  4 ----
 2 files changed, 32 deletions(-)

diff --git a/README.md b/README.md
index 6cb0acc3..5d24595b 100644
--- a/README.md
+++ b/README.md
@@ -285,8 +285,6 @@ NAN_METHOD(CalculateAsync) {
  * <a href="#api_nan_scope"><b><code>NanScope</code></b></a>
  * <a href="#api_nan_escapable_scope"><b><code>NanEscapableScope</code></b></a>
  * <a href="#api_nan_escape_scope"><b><code>NanEscapeScope</code></b></a>
- * <a href="#api_nan_locker"><b><code>NanLocker</code></b></a>
- * <a href="#api_nan_unlocker"><b><code>NanUnlocker</code></b></a>
  * <a href="#api_nan_get_internal_field_pointer"><b><code>NanGetInternalFieldPointer</code></b></a>
  * <a href="#api_nan_set_internal_field_pointer"><b><code>NanSetInternalFieldPointer</code></b></a>
  * <a href="#api_nan_object_wrap_handle"><b><code>NanObjectWrapHandle</code></b></a>
@@ -667,32 +665,6 @@ Handle<String> Foo::Bar() {
 ### Local&lt;T&gt; NanEscapeScope(Handle&lt;T&gt; value);
 Use together with `NanEscapableScope` to escape the scope. Corresponds to `HandleScope::Close` or `EscapableHandleScope::Escape`.
 
-<a name="api_nan_locker"></a>
-### NanLocker()
-
-The introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanLocker()` necessary, use it in place of `Locker locker`:
-
-```c++
-NAN_METHOD(Foo::Bar) {
-  NanLocker();
-  ...
-  NanUnlocker();
-}
-```
-
-<a name="api_nan_unlocker"></a>
-### NanUnlocker()
-
-The introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanUnlocker()` necessary, use it in place of `Unlocker unlocker`:
-
-```c++
-NAN_METHOD(Foo::Bar) {
-  NanLocker();
-  ...
-  NanUnlocker();
-}
-```
-
 <a name="api_nan_get_internal_field_pointer"></a>
 ### void * NanGetInternalFieldPointer(Handle&lt;Object&gt;, int)
 
diff --git a/nan.h b/nan.h
index caca5458..7dbd6faf 100644
--- a/nan.h
+++ b/nan.h
@@ -440,8 +440,6 @@ class NanEscapableScope {
       NAN_INDEX_QUERY_ARGS_TYPE;
   typedef void NAN_INDEX_QUERY_RETURN_TYPE;
 
-# define NanLocker() v8::Locker locker(v8::Isolate::GetCurrent())
-# define NanUnlocker() v8::Unlocker unlocker(v8::Isolate::GetCurrent())
 # define NanReturnValue(value)                                                 \
   return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
 # define NanReturnUndefined() return
@@ -831,8 +829,6 @@ class NanEscapableScope {
   typedef const v8::AccessorInfo& NAN_INDEX_QUERY_ARGS_TYPE;
   typedef v8::Handle<v8::Integer> NAN_INDEX_QUERY_RETURN_TYPE;
 
-# define NanLocker() v8::Locker locker
-# define NanUnlocker() v8::Unlocker unlocker
 # define NanReturnValue(value)                                                 \
     return Nan::imp::NanEnsureHandleOrPersistent(value)
 # define NanReturnHolder() NanReturnValue(args.Holder())

From b5d00a9147f25c87fad6f2813bfca04b0471f4d8 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Tue, 26 May 2015 13:34:01 +0300
Subject: [PATCH 10/84] Remove string converters, except NanUtf8String, which
 now follows node::Utf8Value

---
 nan.h                   | 37 ++++++++++++++++++++++++++-----------
 test/cpp/strings.cpp    | 38 +-------------------------------------
 test/js/strings-test.js | 14 ++++----------
 3 files changed, 31 insertions(+), 58 deletions(-)

diff --git a/nan.h b/nan.h
index 7dbd6faf..dd53fe7c 100644
--- a/nan.h
+++ b/nan.h
@@ -737,29 +737,44 @@ class NanEscapableScope {
 
   class NanUtf8String {
    public:
-    NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) {
-      v8::Local<v8::String> toStr = from->ToString();
-      size = toStr->Utf8Length();
-      buf = new char[size + 1];
-      toStr->WriteUtf8(buf);
+    NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) :
+        length_(0), str_(str_st_) {
+      if (!from.IsEmpty()) {
+        v8::Local<v8::String> string = from->ToString();
+        if (!string.IsEmpty()) {
+          size_t len = 3 * string->Length() + 1;
+          assert(len <= INT_MAX);
+          if (len > sizeof (str_st_)) {
+            str_ = static_cast<char*>(malloc(len));
+            assert(str_ != 0);
+          }
+          const int flags = v8::String::NO_NULL_TERMINATION |
+                            v8::String::REPLACE_INVALID_UTF8;
+          length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
+          str_[length_] = '\0';
+        }
+      }
     }
 
     NAN_INLINE int length() const {
-      return size;
+      return length_;
     }
 
-    NAN_INLINE char* operator*() { return buf; }
-    NAN_INLINE const char* operator*() const { return buf; }
+    NAN_INLINE char* operator*() { return str_; }
+    NAN_INLINE const char* operator*() const { return str_; }
 
     NAN_INLINE ~NanUtf8String() {
-      delete[] buf;
+      if (str_ != str_st_) {
+        free(str_);
+      }
     }
 
    private:
     NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUtf8String)
 
-    char *buf;
-    int size;
+    int length_;
+    char *str_;
+    char str_st_[1024];
   };
 
   class NanUcs2String {
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index 305aee63..62fc213b 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -8,20 +8,12 @@
 
 #include <nan.h>
 
-NAN_METHOD(ReturnAsciiString) {
-  NanReturnValue(NanNew(*NanAsciiString(args[0])));
-}
-
 NAN_METHOD(ReturnUtf8String) {
   NanReturnValue(NanNew(*NanUtf8String(args[0])));
 }
 
-NAN_METHOD(ReturnUcs2String) {
-  NanReturnValue(NanNew(*NanUcs2String(args[0])));
-}
-
 NAN_METHOD(HeapString) {
-  NanUcs2String *s = new NanUcs2String(args[0]);
+  NanUtf8String *s = new NanUtf8String(args[0]);
   v8::Local<v8::String> res = NanNew(**s);
   delete s;
   NanReturnValue(res);
@@ -35,27 +27,12 @@ NAN_METHOD(EncodeUCS2) {
   NanReturnValue(NanEncode("h\0e\0l\0l\0o\0", 10, Nan::UCS2));
 }
 
-v8::Persistent<v8::FunctionTemplate> returnAsciiString_persistent;
 v8::Persistent<v8::FunctionTemplate> returnUtf8String_persistent;
-v8::Persistent<v8::FunctionTemplate> returnUcs2String_persistent;
 v8::Persistent<v8::FunctionTemplate> heapString_persistent;
 v8::Persistent<v8::FunctionTemplate> encodeHex_persistent;
 v8::Persistent<v8::FunctionTemplate> encodeUCS2_persistent;
 
 void Init (v8::Handle<v8::Object> target) {
-  v8::Local<v8::FunctionTemplate> returnAsciiString =
-    NanNew<v8::FunctionTemplate>(ReturnAsciiString);
-
-  NanAssignPersistent(
-    returnAsciiString_persistent
-  , returnAsciiString
-  );
-
-  target->Set(
-      NanNew("returnAsciiString")
-    , returnAsciiString->GetFunction()
-  );
-
   v8::Local<v8::FunctionTemplate> returnUtf8String =
     NanNew<v8::FunctionTemplate>(ReturnUtf8String);
 
@@ -69,19 +46,6 @@ void Init (v8::Handle<v8::Object> target) {
     , returnUtf8String->GetFunction()
   );
 
-  v8::Local<v8::FunctionTemplate> returnUcs2String =
-    NanNew<v8::FunctionTemplate>(ReturnUcs2String);
-
-  NanAssignPersistent(
-    returnUcs2String_persistent
-  , returnUcs2String
-  );
-
-  target->Set(
-      NanNew("returnUcs2String")
-    , returnUcs2String->GetFunction()
-  );
-
   v8::Local<v8::FunctionTemplate> heapString =
     NanNew<v8::FunctionTemplate>(HeapString);
 
diff --git a/test/js/strings-test.js b/test/js/strings-test.js
index 334e61bc..c0f5c592 100644
--- a/test/js/strings-test.js
+++ b/test/js/strings-test.js
@@ -12,22 +12,16 @@ const test     = require('tap').test
 
 
 test('FromV8String', function (t) {
-  t.plan(10);
+  t.plan(6);
 
-  var a = bindings.returnAsciiString;
-  var b = bindings.returnUtf8String;
-  var c = bindings.returnUcs2String;
-  var d = bindings.heapString;
+  var a = bindings.returnUtf8String;
+  var b = bindings.heapString;
 
   t.type(a, 'function');
   t.type(b, 'function');
-  t.type(c, 'function');
-  t.type(d, 'function');
 
-  t.equal(a('an ascii string'), 'an ascii string');
+  t.equal(a('an utf8 strïng'), 'an utf8 strïng');
   t.equal(b('an utf8 strïng'), 'an utf8 strïng');
-  t.equal(c('an ucs2 strïng'), 'an ucs2 strïng');
-  t.equal(d('an utf8 strïng'), 'an utf8 strïng');
 
   t.equal(bindings.encodeHex(), new Buffer('hello').toString('hex'));
   t.equal(bindings.encodeUCS2(), 'hello');

From 7fed69696bd9811d508bb775eaf8bf8206537ec1 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 11 May 2015 02:48:05 +0300
Subject: [PATCH 11/84] Introduce NanPersistent

---
 Makefile                        |  10 +-
 nan.h                           | 215 +++++------------
 nan_implementation_12_inl.h     |   9 +-
 nan_implementation_pre_12_inl.h |   5 +
 nan_new.h                       |   7 +
 nan_persistent_12_inl.h         |  58 +++++
 nan_persistent_pre_12_inl.h     | 180 ++++++++++++++
 nan_weak.h                      | 414 ++++++++++++++++++++++++++++++++
 test/binding.gyp                |   4 +
 test/cpp/makecallback.cpp       |   6 +-
 test/cpp/nannew.cpp             |   6 +-
 test/cpp/objectwraphandle.cpp   |   6 +-
 test/cpp/persistent.cpp         |  30 ++-
 test/cpp/returnvalue.cpp        |   4 +-
 test/cpp/settemplate.cpp        |   6 +-
 test/cpp/settergetter.cpp       |   4 +-
 test/cpp/strings.cpp            |  28 +--
 test/cpp/weak.cpp               |  20 +-
 test/cpp/weak2.cpp              |  48 ++++
 test/js/persistent-test.js      |  29 ++-
 test/js/weak-test.js            |  19 +-
 test/js/weak2-test.js           |  36 +++
 22 files changed, 910 insertions(+), 234 deletions(-)
 create mode 100644 nan_persistent_12_inl.h
 create mode 100644 nan_persistent_pre_12_inl.h
 create mode 100644 nan_weak.h
 create mode 100644 test/cpp/weak2.cpp
 create mode 100644 test/js/weak2-test.js

diff --git a/Makefile b/Makefile
index 2b128f58..8f13a6fe 100644
--- a/Makefile
+++ b/Makefile
@@ -15,10 +15,13 @@ LINT_SOURCES = \
 	examples/async_pi_estimate/sync.cc \
 	examples/async_pi_estimate/sync.h \
 	nan.h \
-	nan_string_bytes.h \
 	nan_implementation_12_inl.h \
 	nan_implementation_pre_12_inl.h \
 	nan_new.h \
+	nan_persistent_12_inl.h \
+	nan_persistent_pre_12_inl.h \
+	nan_string_bytes.h \
+	nan_weak.h \
 	test/cpp/asyncworker.cpp \
 	test/cpp/asyncprogressworker.cpp \
 	test/cpp/asyncworkererror.cpp \
@@ -46,6 +49,7 @@ LINT_SOURCES = \
 	test/cpp/symbols.cpp \
 	test/cpp/threadlocal.cpp \
 	test/cpp/weak.cpp \
+	test/cpp/weak2.cpp \
 	node_modules/node-gyp/gyp/data/win/large-pdb-shim.cc
 
 FILTER = -whitespace/parens
@@ -62,5 +66,7 @@ forcetest:
 	cd test/ && node-gyp rebuild && cd ..
 	npm test
 
-$(ADDONS): nan.h nan_string_bytes.h nan_new.h nan_implementation_pre_12_inl.h nan_implementation_12_inl.h test/binding.gyp $(SOURCES)
+$(ADDONS): nan.h nan_new.h nan_implementation_pre_12_inl.h nan_implementation_12_inl.h \
+		nan_persistent_12_inl.h nan_persistent_pre_12_inl.h nan_weak.h \
+		nan_string_bytes.h test/binding.gyp $(SOURCES)
 	cd test/ && ../node_modules/.bin/node-gyp rebuild
diff --git a/nan.h b/nan.h
index dd53fe7c..886c1419 100644
--- a/nan.h
+++ b/nan.h
@@ -89,6 +89,12 @@
 #define ATOM_0_21_MODULE_VERSION 41
 #define IOJS_1_0_MODULE_VERSION  42
 #define IOJS_1_1_MODULE_VERSION  43
+#define IOJS_2_0_MODULE_VERSION  44
+
+#define TYPE_CHECK(T, S)                                                       \
+    while (false) {                                                            \
+      *(static_cast<T *volatile *>(0)) = static_cast<S*>(0);                   \
+    }
 
 #if (NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION)
 typedef v8::InvocationCallback NanFunctionCallback;
@@ -108,6 +114,28 @@ typedef v8::String::ExternalOneByteStringResource
     NanExternalOneByteStringResource;
 #endif
 
+#if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+template<typename T>
+class NanNonCopyablePersistentTraits :
+    public v8::NonCopyablePersistentTraits<T> {};
+template<typename T>
+class NanCopyablePersistentTraits :
+    public v8::CopyablePersistentTraits<T> {};
+
+template<typename T>
+class NanPersistentBase :
+    public v8::PersistentBase<T> {};
+
+template<typename T, typename M = v8::NonCopyablePersistentTraits<T> >
+class NanPersistent;
+#else
+template<typename T> class NanNonCopyablePersistentTraits;
+template<typename T> class NanPersistentBase;
+template<typename T, typename P> class NanWeakCallbackData;
+template<typename T, typename M = NanNonCopyablePersistentTraits<T> >
+class NanPersistent;
+#endif
+
 #include "nan_new.h"  // NOLINT(build/include)
 
 // uv helpers
@@ -222,6 +250,27 @@ inline void nauv_key_set(nauv_key_t* key, void* value) {
 template<typename T>
 v8::Local<T> NanNew(v8::Handle<T>);
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+  typedef v8::WeakCallbackType NanWeakCallbackType;
+#else
+struct NanWeakCallbackType {
+  enum E {kParameter, kInternalFields};
+  E type;
+  NanWeakCallbackType(E other) : type(other) {}  // NOLINT(runtime/explicit)
+  inline bool operator==(E other) { return other == this->type; }
+  inline bool operator!=(E other) { return !operator==(other); }
+};
+#endif
+
+template<typename P> class NanWeakCallbackInfo;
+
+#if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+# include "nan_persistent_12_inl.h"  // NOLINT(build/include)
+#else
+# include "nan_persistent_pre_12_inl.h"  // NOLINT(build/include)
+#endif
+
 namespace Nan { namespace imp {
   template<typename T>
   NAN_INLINE v8::Persistent<T> &NanEnsureHandleOrPersistent(
@@ -535,20 +584,6 @@ class NanEscapableScope {
     v8::Isolate::GetCurrent()->GetHeapStatistics(heap_statistics);
   }
 
-  template<typename T>
-  NAN_INLINE void NanAssignPersistent(
-      v8::Persistent<T>& handle
-    , v8::Handle<T> obj) {
-      handle.Reset(v8::Isolate::GetCurrent(), obj);
-  }
-
-  template<typename T>
-  NAN_INLINE void NanAssignPersistent(
-      v8::Persistent<T>& handle
-    , const v8::Persistent<T>& obj) {
-      handle.Reset(v8::Isolate::GetCurrent(), obj);
-  }
-
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
       NanEscapableScope scope;                                                 \
@@ -584,12 +619,6 @@ class NanEscapableScope {
     v8::Isolate::GetCurrent()->ThrowException(error);
   }
 
-  template<typename T> NAN_INLINE void NanDisposePersistent(
-      v8::Persistent<T> &handle
-  ) {
-    handle.Reset();
-  }
-
   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
       char *data
     , size_t length
@@ -934,14 +963,6 @@ class NanEscapableScope {
     v8::V8::GetHeapStatistics(heap_statistics);
   }
 
-  template<typename T>
-  NAN_INLINE void NanAssignPersistent(
-      v8::Persistent<T>& handle
-    , v8::Handle<T> obj) {
-      handle.Dispose();
-      handle = v8::Persistent<T>::New(obj);
-  }
-
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
       NanEscapableScope scope;                                                 \
@@ -979,13 +1000,6 @@ class NanEscapableScope {
     return scope.Escape(v8::Local<v8::Value>::New(v8::ThrowException(error)));
   }
 
-  template<typename T>
-  NAN_INLINE void NanDisposePersistent(
-      v8::Persistent<T> &handle) {  // NOLINT(runtime/references)
-    handle.Dispose();
-    handle.Clear();
-  }
-
   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
       char *data
     , size_t length
@@ -1242,19 +1256,19 @@ class NanCallback {
   NanCallback() {
     NanScope scope;
     v8::Local<v8::Object> obj = NanNew<v8::Object>();
-    NanAssignPersistent(handle, obj);
+    handle.Reset(obj);
   }
 
   explicit NanCallback(const v8::Handle<v8::Function> &fn) {
     NanScope scope;
     v8::Local<v8::Object> obj = NanNew<v8::Object>();
-    NanAssignPersistent(handle, obj);
+    handle.Reset(obj);
     SetFunction(fn);
   }
 
   ~NanCallback() {
     if (handle.IsEmpty()) return;
-    NanDisposePersistent(handle);
+    handle.Reset();
   }
 
   bool operator==(const NanCallback &other) const {
@@ -1324,7 +1338,7 @@ class NanCallback {
 
  private:
   NAN_DISALLOW_ASSIGN_COPY_MOVE(NanCallback)
-  v8::Persistent<v8::Object> handle;
+  NanPersistent<v8::Object> handle;
   static const uint32_t kCallbackIndex = 0;
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
@@ -1350,7 +1364,7 @@ class NanCallback {
                            , v8::Handle<v8::Value> argv[]) const {
     NanEscapableScope scope;
 
-    v8::Local<v8::Function> callback = handle->
+    v8::Local<v8::Function> callback = NanNew(handle)->
         Get(kCallbackIndex).As<v8::Function>();
     return scope.Escape(Nan::imp::NanEnsureLocal(node::MakeCallback(
         target
@@ -1370,14 +1384,14 @@ class NanCallback {
 
     NanScope scope;
     v8::Local<v8::Object> obj = NanNew<v8::Object>();
-    NanAssignPersistent(persistentHandle, obj);
+    persistentHandle.Reset(obj);
   }
 
   virtual ~NanAsyncWorker() {
     NanScope scope;
 
     if (!persistentHandle.IsEmpty())
-      NanDisposePersistent(persistentHandle);
+      persistentHandle.Reset();
     if (callback)
       delete callback;
     if (errmsg_)
@@ -1438,7 +1452,7 @@ class NanCallback {
   }
 
  protected:
-  v8::Persistent<v8::Object> persistentHandle;
+  NanPersistent<v8::Object> persistentHandle;
   NanCallback *callback;
 
   virtual void HandleOKCallback() {
@@ -1746,114 +1760,13 @@ class NanObjectWrap : public node::ObjectWrap {
 
 //=== Weak Persistent Handling =================================================
 
-#if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
-# define NAN_WEAK_CALLBACK_DATA_TYPE_ \
-    v8::WeakCallbackData<T, NanWeakCallbackData<T, P> > const&
-# define NAN_WEAK_CALLBACK_SIG_ NAN_WEAK_CALLBACK_DATA_TYPE_
-#else
-# define NAN_WEAK_CALLBACK_DATA_TYPE_ void *
-# define NAN_WEAK_CALLBACK_SIG_ \
-    v8::Persistent<v8::Value>, NAN_WEAK_CALLBACK_DATA_TYPE_
-#endif
-
-template <typename T, typename P>
-class NanWeakCallbackData {
- public:  // constructors
-  typedef void (*Callback)(
-      NanWeakCallbackData & data  // NOLINT(runtime/references)
-      );
-  NanWeakCallbackData(v8::Handle<T> handle, P* param, Callback cb)
-    : parameter(param), callback(cb) {
-    NanAssignPersistent(persistent, handle);
-    Revive();
-  }
-  inline ~NanWeakCallbackData();
-
- public:  // member functions
-  v8::Local<T> GetValue() const { return NanNew(persistent); }
-  v8::Persistent<T> &GetPersistent() const { return persistent; }
-  P* GetParameter() const { return parameter; }
-  bool IsNearDeath() const { return persistent.IsNearDeath(); }
-  inline void Revive();
-
- private:  // constructors
-  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanWeakCallbackData)
-
- private:  // static member functions
-  static
-  void
-  invoke(NAN_WEAK_CALLBACK_SIG_ data) {
-    NanWeakCallbackData * wcbd = unwrap(data);
-    wcbd->callback(*wcbd);
-    if (wcbd->IsNearDeath()) {
-      delete wcbd;
-    }
-  }
-
-  static inline
-  NanWeakCallbackData *
-  unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
-
- private:  // data members
-  P* const parameter;
-  Callback const callback;
-  v8::Persistent<T> persistent;
-};
-
-#undef NAN_WEAK_CALLBACK_DATA_TYPE_
-#undef NAN_WEAK_CALLBACK_SIG_
-
-#if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
-
-template <typename T, typename P>
-NanWeakCallbackData<T, P>::~NanWeakCallbackData() { persistent.Reset(); }
-
-template <typename T, typename P>
-void
-NanWeakCallbackData<T, P>::Revive() { persistent.SetWeak(this, &invoke); }
-
-template <typename T, typename P>
-NanWeakCallbackData<T, P> *
-NanWeakCallbackData<T, P>::unwrap(
-    v8::WeakCallbackData<T, NanWeakCallbackData> const& data) {
-  return data.GetParameter();
-}
-
-#else
-
-template <typename T, typename P>
-NanWeakCallbackData<T, P>::~NanWeakCallbackData() {
-  persistent.Dispose();
-  persistent.Clear();
-}
-
-template <typename T, typename P>
-void
-NanWeakCallbackData<T, P>::Revive() { persistent.MakeWeak(this, &invoke); }
-
-template <typename T, typename P>
-NanWeakCallbackData<T, P> *
-NanWeakCallbackData<T, P>::unwrap(void * data) {
-  return static_cast<NanWeakCallbackData*>(data);
-}
-
-#endif
-
-template<typename T, typename P>
-inline
-NanWeakCallbackData<T, P>*
-NanMakeWeakPersistent(
-    v8::Handle<T> handle
-  , P* parameter
-  , typename NanWeakCallbackData<T, P>::Callback callback) {
-  return new NanWeakCallbackData<T, P>(handle, parameter, callback);
-}
+#include "nan_weak.h"  // NOLINT(build/include)
 
 //=== Export ==================================================================
 
 inline
 void
-NanExport(v8::Handle<v8::Object> target, const char * name,
+NanExport(v8::Handle<v8::Object> target, const char *name,
     NanFunctionCallback f) {
   target->Set(NanNew<v8::String>(name),
       NanNew<v8::FunctionTemplate>(f)->GetFunction());
@@ -1863,17 +1776,17 @@ NanExport(v8::Handle<v8::Object> target, const char * name,
 
 struct NanTap {
   explicit NanTap(v8::Handle<v8::Value> t) : t_() {
-    NanAssignPersistent(t_, t->ToObject());
+    t_.Reset(t->ToObject());
   }
 
-  ~NanTap() { NanDisposePersistent(t_); }  // not sure if neccessary
+  ~NanTap() { t_.Reset(); }  // not sure if neccessary
 
   inline void plan(int i) {
     v8::Handle<v8::Value> arg = NanNew(i);
     NanMakeCallback(NanNew(t_), "plan", 1, &arg);
   }
 
-  inline void ok(bool isOk, const char * msg = NULL) {
+  inline void ok(bool isOk, const char *msg = NULL) {
     v8::Handle<v8::Value> args[2];
     args[0] = NanNew(isOk);
     if (msg) args[1] = NanNew(msg);
@@ -1881,7 +1794,7 @@ struct NanTap {
   }
 
  private:
-  v8::Persistent<v8::Object> t_;
+  NanPersistent<v8::Object> t_;
 };
 
 #define NAN_STRINGIZE2(x) #x
@@ -1893,4 +1806,6 @@ struct NanTap {
 #define return_NanUndefined() NanReturnUndefined()
 #define NAN_EXPORT(target, function) NanExport(target, #function, function)
 
+#undef TYPE_CHECK
+
 #endif  // NAN_H_
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index 68c01f9d..60391ff3 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -254,8 +254,13 @@ inline v8::Local<T> NanNew(v8::Handle<T> h) {
   return v8::Local<T>::New(v8::Isolate::GetCurrent(), h);
 }
 
-template <typename T>
-inline v8::Local<T> NanNew(v8::Persistent<T> const& p) {
+template <typename T, typename M>
+inline v8::Local<T> NanNew(v8::Persistent<T, M> const& p) {
+  return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
+}
+
+template <typename T, typename M>
+inline v8::Local<T> NanNew(NanPersistent<T, M> const& p) {
   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 }
 
diff --git a/nan_implementation_pre_12_inl.h b/nan_implementation_pre_12_inl.h
index fe69d440..927c5724 100644
--- a/nan_implementation_pre_12_inl.h
+++ b/nan_implementation_pre_12_inl.h
@@ -265,4 +265,9 @@ inline v8::Local<T> NanNew(v8::Persistent<T> const& p) {
   return v8::Local<T>::New(p);
 }
 
+template <typename T, typename M>
+inline v8::Local<T> NanNew(NanPersistent<T, M> const& p) {
+  return v8::Local<T>::New(p.persistent);
+}
+
 #endif  // NAN_IMPLEMENTATION_PRE_12_INL_H_
diff --git a/nan_new.h b/nan_new.h
index c52e2a8d..67429f5d 100644
--- a/nan_new.h
+++ b/nan_new.h
@@ -253,7 +253,14 @@ NanNew( NanFunctionCallback callback
 // Convenience
 
 template <typename T> inline v8::Local<T> NanNew(v8::Handle<T> h);
+#if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+template <typename T, typename M>
+    inline v8::Local<T> NanNew(v8::Persistent<T, M> const& p);
+#else
 template <typename T> inline v8::Local<T> NanNew(v8::Persistent<T> const& p);
+#endif
+template <typename T, typename M>
+inline v8::Local<T> NanNew(NanPersistent<T, M> const& p);
 
 inline
 Nan::imp::Factory<v8::Boolean>::return_t
diff --git a/nan_persistent_12_inl.h b/nan_persistent_12_inl.h
new file mode 100644
index 00000000..41979560
--- /dev/null
+++ b/nan_persistent_12_inl.h
@@ -0,0 +1,58 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_PERSISTENT_12_INL_H_
+#define NAN_PERSISTENT_12_INL_H_
+
+template<typename T, typename M> class NanPersistent :
+    public v8::Persistent<T, M> {
+ public:
+  NAN_INLINE NanPersistent() : v8::Persistent<T, M>() {}
+
+  template<typename S> NAN_INLINE NanPersistent(v8::Handle<S> that) :
+      v8::Persistent<T, M>(v8::Isolate::GetCurrent(), that) {}
+
+  template<typename S, typename M2>
+  NAN_INLINE NanPersistent(const v8::Persistent<S, M2> &that) :
+      v8::Persistent<T, M2>(v8::Isolate::GetCurrent(), that) {}
+
+  NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
+
+  template <typename S>
+  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  }
+
+  template <typename S>
+  NAN_INLINE void Reset(const v8::PersistentBase<S> &other) {
+    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  }
+
+  template<typename P>
+  NAN_INLINE void SetWeak(
+    P *parameter
+    , typename NanWeakCallbackInfo<P>::Callback callback
+    , NanWeakCallbackType type);
+
+ private:
+  NAN_INLINE T *operator*() const { return *NanPersistentBase<T>::persistent; }
+
+  template<typename S, typename M2>
+  NAN_INLINE void Copy(const NanPersistent<S, M2> &that) {
+    TYPE_CHECK(T, S);
+
+    this->Reset();
+
+    if (!that.IsEmpty()) {
+      this->Reset(that);
+      M::Copy(that, this);
+    }
+  }
+};
+
+#endif  // NAN_PERSISTENT_12_INL_H_
diff --git a/nan_persistent_pre_12_inl.h b/nan_persistent_pre_12_inl.h
new file mode 100644
index 00000000..7d57dcdc
--- /dev/null
+++ b/nan_persistent_pre_12_inl.h
@@ -0,0 +1,180 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_PERSISTENT_PRE_12_INL_H_
+#define NAN_PERSISTENT_PRE_12_INL_H_
+
+template<typename T>
+class NanPersistentBase {
+  v8::Persistent<T> persistent;
+  template<typename U, typename M>
+  friend v8::Local<U> NanNew(const NanPersistent<U, M> &p);
+
+ public:
+  NAN_INLINE NanPersistentBase() :
+      persistent() {}
+
+  NAN_INLINE void Reset() {
+    persistent.Dispose();
+    persistent.Clear();
+  }
+
+  template<typename S>
+  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+    TYPE_CHECK(T, S);
+
+    if (!persistent.IsEmpty()) {
+      persistent.Dispose();
+    }
+
+    if (other.IsEmpty()) {
+      persistent.Clear();
+    } else {
+      persistent = v8::Persistent<T>::New(other);
+    }
+  }
+
+  template<typename S>
+  NAN_INLINE void Reset(const NanPersistentBase<S> &other) {
+    TYPE_CHECK(T, S);
+
+    if (!persistent.IsEmpty()) {
+      persistent.Dispose();
+    }
+
+    if (other.IsEmpty()) {
+      persistent.Clear();
+    } else {
+      persistent = v8::Persistent<T>::New(other.persistent);
+    }
+  }
+
+  NAN_INLINE bool IsEmpty() const { return persistent.IsEmpty(); }
+
+  NAN_INLINE void Empty() { persistent.Clear(); }
+
+  template<typename S>
+  NAN_INLINE bool operator==(const NanPersistentBase<S> &that) {
+    return this->persistent == that.persistent;
+  }
+
+  template<typename S>
+  NAN_INLINE bool operator==(const v8::Handle<S> &that) {
+    return this->persistent == that;
+  }
+
+  template<typename S>
+  NAN_INLINE bool operator!=(const NanPersistentBase<S> &that) {
+    return !operator==(that);
+  }
+
+  template<typename S>
+  NAN_INLINE bool operator!=(const v8::Handle<S> &that) {
+    return !operator==(that);
+  }
+
+  template<typename P>
+  NAN_INLINE void SetWeak(
+    P *parameter
+    , typename NanWeakCallbackInfo<P>::Callback callback
+    , NanWeakCallbackType type);
+
+  NAN_INLINE void ClearWeak() { persistent.ClearWeak(); }
+
+  NAN_INLINE void MarkIndependent() { persistent.MarkIndependent(); }
+
+  NAN_INLINE bool IsIndependent() const { return persistent.IsIndependent(); }
+
+  NAN_INLINE bool IsNearDeath() const { return persistent.IsNearDeath(); }
+
+  NAN_INLINE bool IsWeak() const { return persistent.IsWeak(); }
+
+ private:
+  NAN_INLINE explicit NanPersistentBase(v8::Persistent<T> that) :
+      persistent(that) { }
+  template<typename S, typename M> friend class NanPersistent;
+};
+
+template<typename T>
+class NanNonCopyablePersistentTraits {
+ public:
+  typedef NanPersistent<T, NanNonCopyablePersistentTraits<T> >
+      NonCopyablePersistent;
+  static const bool kResetInDestructor = false;
+  template<typename S, typename M>
+  NAN_INLINE static void Copy(const NanPersistent<S, M> &source,
+                             NonCopyablePersistent *dest) {
+    Uncompilable<v8::Object>();
+  }
+
+  template<typename O> NAN_INLINE static void Uncompilable() {
+    TYPE_CHECK(O, v8::Primitive);
+  }
+};
+
+template<typename T>
+struct NanCopyablePersistentTraits {
+  typedef NanPersistent<T, NanCopyablePersistentTraits<T> > CopyablePersistent;
+  static const bool kResetInDestructor = true;
+  template<typename S, typename M>
+  static NAN_INLINE void Copy(const NanPersistent<S, M> &source,
+                             CopyablePersistent *dest) {}
+};
+
+template<typename T, typename M> class NanPersistent :
+    public NanPersistentBase<T> {
+ public:
+  NAN_INLINE NanPersistent() {}
+
+  template<typename S> NAN_INLINE NanPersistent(v8::Handle<S> that)
+      : NanPersistentBase<T>(v8::Persistent<T>::New(that)) {
+    TYPE_CHECK(T, S);
+  }
+
+  NAN_INLINE NanPersistent(const NanPersistent &that) : NanPersistentBase<T>() {
+    Copy(that);
+  }
+
+  template<typename S, typename M2>
+  NAN_INLINE NanPersistent(const NanPersistent<S, M2> &that) :
+      NanPersistentBase<T>() {
+    Copy(that);
+  }
+
+  NAN_INLINE NanPersistent &operator=(const NanPersistent &that) {
+    Copy(that);
+    return *this;
+  }
+
+  template <class S, class M2>
+  NAN_INLINE NanPersistent &operator=(const NanPersistent<S, M2> &that) {
+    Copy(that);
+    return *this;
+  }
+
+  NAN_INLINE ~NanPersistent() {
+    if (M::kResetInDestructor) this->Reset();
+  }
+
+ private:
+  NAN_INLINE T *operator*() const { return *NanPersistentBase<T>::persistent; }
+
+  template<typename S, typename M2>
+  NAN_INLINE void Copy(const NanPersistent<S, M2> &that) {
+    TYPE_CHECK(T, S);
+
+    this->Reset();
+
+    if (!that.IsEmpty()) {
+      this->persistent = v8::Persistent<T>::New(that.persistent);
+      M::Copy(that, this);
+    }
+  }
+};
+
+#endif  // NAN_PERSISTENT_PRE_12_INL_H_
diff --git a/nan_weak.h b/nan_weak.h
new file mode 100644
index 00000000..d34137e1
--- /dev/null
+++ b/nan_weak.h
@@ -0,0 +1,414 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_WEAK_H_
+#define NAN_WEAK_H_
+
+static const int kInternalFieldsInWeakCallback = 2;
+static const int kNoInternalFieldIndex = -1;
+
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+# define NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ \
+    v8::WeakCallbackInfo<NanWeakCallbackInfo<T> > const&
+# define NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ \
+    NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
+# define NAN_WEAK_PARAMETER_CALLBACK_SIG_ NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
+# define NAN_WEAK_TWOFIELD_CALLBACK_SIG_ NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
+#elif NODE_MODULE_VERSION > IOJS_1_1_MODULE_VERSION
+# define NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ \
+    v8::PhantomCallbackData<NanWeakCallbackInfo<T> > const&
+# define NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ \
+    NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
+# define NAN_WEAK_PARAMETER_CALLBACK_SIG_ NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
+# define NAN_WEAK_TWOFIELD_CALLBACK_SIG_ NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
+#elif NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+# define NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ \
+    v8::PhantomCallbackData<NanWeakCallbackInfo<T> > const&
+# define NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ \
+    v8::InternalFieldsCallbackData<NanWeakCallbackInfo<T>, void> const&
+# define NAN_WEAK_PARAMETER_CALLBACK_SIG_ NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
+# define NAN_WEAK_TWOFIELD_CALLBACK_SIG_ NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
+#elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+# define NAN_WEAK_CALLBACK_DATA_TYPE_ \
+    v8::WeakCallbackData<S, NanWeakCallbackInfo<T> > const&
+# define NAN_WEAK_CALLBACK_SIG_ NAN_WEAK_CALLBACK_DATA_TYPE_
+#else
+# define NAN_WEAK_CALLBACK_DATA_TYPE_ void *
+# define NAN_WEAK_CALLBACK_SIG_ \
+    v8::Persistent<v8::Value>, NAN_WEAK_CALLBACK_DATA_TYPE_
+#endif
+
+template<typename T>
+class NanWeakCallbackInfo {
+ public:
+  typedef void (*Callback)(const NanWeakCallbackInfo<T>& data);
+  NanWeakCallbackInfo(
+      NanPersistent<v8::Value> *persistent
+    , Callback callback
+    , void *parameter
+    , void *field1 = 0
+    , void *field2 = 0) :
+        callback_(callback), isolate_(0), parameter_(parameter) {
+    std::memcpy(&persistent_, persistent, sizeof (v8::Persistent<v8::Value>));
+    internal_fields_[0] = field1;
+    internal_fields_[1] = field2;
+  }
+  NAN_INLINE v8::Isolate *GetIsolate() const { return isolate_; }
+  NAN_INLINE T *GetParameter() const { return static_cast<T*>(parameter_); }
+  NAN_INLINE void *GetInternalField(int index) const {
+    assert((index == 0 || index == 1) && "internal field index out of bounds");
+    if (index == 0) {
+      return internal_fields_[0];
+    } else {
+      return internal_fields_[1];
+    }
+  }
+
+ private:
+  Callback callback_;
+  v8::Isolate *isolate_;
+  void *parameter_;
+  void *internal_fields_[kInternalFieldsInWeakCallback];
+  v8::Persistent<v8::Value> persistent_;
+  template<typename S, typename M> friend class NanPersistent;
+  template<typename S> friend class NanPersistentBase;
+#if NODE_MODULE_VERSION <= NODE_0_12_MODULE_VERSION
+# if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+  template<typename S>
+  static void invoke(NAN_WEAK_CALLBACK_SIG_ data);
+  template<typename S>
+  static NanWeakCallbackInfo *unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
+# else
+  static void invoke(NAN_WEAK_CALLBACK_SIG_ data);
+  static NanWeakCallbackInfo *unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
+# endif
+#else
+  static void invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data);
+  static void invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data);
+  static NanWeakCallbackInfo *unwrapparameter(
+      NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ data);
+  static NanWeakCallbackInfo *unwraptwofield(
+      NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ data);
+#endif
+};
+
+
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+
+template<typename T>
+void
+NanWeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
+  NanWeakCallbackInfo<T> *cbinfo = unwrapparameter(data);
+  if (data.IsFirstPass()) {
+    cbinfo->persistent_.Reset();
+    data.SetSecondPassCallback(invokeparameter);
+  } else {
+    cbinfo->callback_(*cbinfo);
+    delete cbinfo;
+  }
+}
+
+template<typename T>
+void
+NanWeakCallbackInfo<T>::invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data) {
+  NanWeakCallbackInfo<T> *cbinfo = unwraptwofield(data);
+  if (data.IsFirstPass()) {
+    cbinfo->persistent_.Reset();
+    data.SetSecondPassCallback(invoketwofield);
+  } else {
+    cbinfo->callback_(*cbinfo);
+    delete cbinfo;
+  }
+}
+
+template<typename T>
+NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrapparameter(
+    NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ data) {
+  NanWeakCallbackInfo<T> *cbinfo =
+      static_cast<NanWeakCallbackInfo<T>*>(data.GetParameter());
+  cbinfo->isolate_ = data.GetIsolate();
+  return cbinfo;
+}
+
+template<typename T>
+NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwraptwofield(
+    NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ data) {
+  NanWeakCallbackInfo<T> *cbinfo =
+      static_cast<NanWeakCallbackInfo<T>*>(data.GetInternalField(0));
+  cbinfo->isolate_ = data.GetIsolate();
+  return cbinfo;
+}
+
+#undef NAN_WEAK_PARAMETER_CALLBACK_SIG_
+#undef NAN_WEAK_TWOFIELD_CALLBACK_SIG_
+#undef NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
+#undef NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
+# elif NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+
+template<typename T>
+void
+NanWeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
+  NanWeakCallbackInfo<T> *cbinfo = unwrapparameter(data);
+  cbinfo->persistent_.Reset();
+  cbinfo->callback_(*cbinfo);
+  delete cbinfo;
+}
+
+template<typename T>
+void
+NanWeakCallbackInfo<T>::invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data) {
+  NanWeakCallbackInfo<T> *cbinfo = unwraptwofield(data);
+  cbinfo->persistent_.Reset();
+  cbinfo->callback_(*cbinfo);
+  delete cbinfo;
+}
+
+template<typename T>
+NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrapparameter(
+    NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ data) {
+  NanWeakCallbackInfo<T> *cbinfo =
+       static_cast<NanWeakCallbackInfo<T>*>(data.GetParameter());
+  cbinfo->isolate_ = data.GetIsolate();
+  return cbinfo;
+}
+
+template<typename T>
+NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwraptwofield(
+    NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ data) {
+  NanWeakCallbackInfo<T> *cbinfo =
+       static_cast<NanWeakCallbackInfo<T>*>(data.GetInternalField1());
+  cbinfo->isolate_ = data.GetIsolate();
+  return cbinfo;
+}
+
+#undef NAN_WEAK_PARAMETER_CALLBACK_SIG_
+#undef NAN_WEAK_TWOFIELD_CALLBACK_SIG_
+#undef NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
+#undef NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
+#elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+
+template<typename T>
+template<typename S>
+void NanWeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
+  NanWeakCallbackInfo<T> *cbinfo = unwrap(data);
+  cbinfo->persistent_.Reset();
+  cbinfo->callback_(*cbinfo);
+  delete cbinfo;
+}
+
+template<typename T>
+template<typename S>
+NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrap(
+    NAN_WEAK_CALLBACK_DATA_TYPE_ data) {
+  void *parameter = data.GetParameter();
+  NanWeakCallbackInfo<T> *cbinfo =
+      static_cast<NanWeakCallbackInfo<T>*>(parameter);
+  cbinfo->isolate_ = data.GetIsolate();
+  return cbinfo;
+}
+
+#undef NAN_WEAK_CALLBACK_SIG_
+#undef NAN_WEAK_CALLBACK_DATA_TYPE_
+#else
+
+template<typename T>
+void NanWeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
+  NanWeakCallbackInfo<T> *cbinfo = unwrap(data);
+  cbinfo->persistent_.Dispose();
+  cbinfo->persistent_.Clear();
+  cbinfo->callback_(*cbinfo);
+  delete cbinfo;
+}
+
+template<typename T>
+NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrap(
+    NAN_WEAK_CALLBACK_DATA_TYPE_ data) {
+  NanWeakCallbackInfo<T> *cbinfo =
+      static_cast<NanWeakCallbackInfo<T>*>(data);
+  cbinfo->isolate_ = v8::Isolate::GetCurrent();
+  return cbinfo;
+}
+
+#undef NAN_WEAK_CALLBACK_SIG_
+#undef NAN_WEAK_CALLBACK_DATA_TYPE_
+#endif
+
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+template<typename T, typename M>
+template<typename P>
+NAN_INLINE void NanPersistent<T, M>::SetWeak(
+    P *parameter
+  , typename NanWeakCallbackInfo<P>::Callback callback
+  , NanWeakCallbackType type) {
+  NanWeakCallbackInfo<P> *wcbd;
+  if (type == NanWeakCallbackType::kParameter) {
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , parameter);
+    v8::PersistentBase<T>::SetWeak(wcbd, wcbd->invokeparameter, type);
+  } else {
+    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    assert((*self)->IsObject());
+    int count = (*self)->InternalFieldCount();
+    void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
+    for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
+      internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
+    }
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , 0
+      , internal_fields[0]
+      , internal_fields[1]);
+    (*self)->SetAlignedPointerInInternalField(0, wcbd);
+    v8::PersistentBase<T>::SetWeak(
+        static_cast<NanWeakCallbackInfo<P>*>(0)
+      , wcbd->invoketwofield
+      , type);
+  }
+}
+#elif NODE_MODULE_VERSION > IOJS_1_1_MODULE_VERSION
+template<typename T, typename M>
+template<typename P>
+NAN_INLINE void NanPersistent<T, M>::SetWeak(
+    P *parameter
+  , typename NanWeakCallbackInfo<P>::Callback callback
+  , NanWeakCallbackType type) {
+  NanWeakCallbackInfo<P> *wcbd;
+  if (type == NanWeakCallbackType::kParameter) {
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , parameter);
+    v8::PersistentBase<T>::SetPhantom(wcbd, wcbd->invokeparameter);
+  } else {
+    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    assert((*self)->IsObject());
+    int count = (*self)->InternalFieldCount();
+    void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
+    for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
+      internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
+    }
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , 0
+      , internal_fields[0]
+      , internal_fields[1]);
+    (*self)->SetAlignedPointerInInternalField(0, wcbd);
+    v8::PersistentBase<T>::SetPhantom(
+        static_cast<NanWeakCallbackInfo<P>*>(0)
+      , wcbd->invoketwofield
+      , 0
+      , count > 1 ? 1 : kNoInternalFieldIndex);
+  }
+}
+#elif NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+template<typename T, typename M>
+template<typename P>
+NAN_INLINE void NanPersistent<T, M>::SetWeak(
+    P *parameter
+  , typename NanWeakCallbackInfo<P>::Callback callback
+  , NanWeakCallbackType type) {
+  NanWeakCallbackInfo<P> *wcbd;
+  if (type == NanWeakCallbackType::kParameter) {
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , parameter);
+    v8::PersistentBase<T>::SetPhantom(wcbd, wcbd->invokeparameter);
+  } else {
+    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    assert((*self)->IsObject());
+    int count = (*self)->InternalFieldCount();
+    void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
+    for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
+      internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
+    }
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , 0
+      , internal_fields[0]
+      , internal_fields[1]);
+    (*self)->SetAlignedPointerInInternalField(0, wcbd);
+    v8::PersistentBase<T>::SetPhantom(
+        wcbd->invoketwofield
+      , 0
+      , count > 1 ? 1 : kNoInternalFieldIndex);
+  }
+}
+#elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+template<typename T, typename M>
+template<typename P>
+NAN_INLINE void NanPersistent<T, M>::SetWeak(
+    P *parameter
+  , typename NanWeakCallbackInfo<P>::Callback callback
+  , NanWeakCallbackType type) {
+  NanWeakCallbackInfo<P> *wcbd;
+  if (type == NanWeakCallbackType::kParameter) {
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , parameter);
+    v8::PersistentBase<T>::SetWeak(wcbd, wcbd->invoke);
+  } else {
+    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    assert((*self)->IsObject());
+    int count = (*self)->InternalFieldCount();
+    void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
+    for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
+      internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
+    }
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , 0
+      , internal_fields[0]
+      , internal_fields[1]);
+    v8::PersistentBase<T>::SetWeak(wcbd, wcbd->invoke);
+  }
+}
+#else
+template<typename T>
+template<typename P>
+NAN_INLINE void NanPersistentBase<T>::SetWeak(
+    P *parameter
+  , typename NanWeakCallbackInfo<P>::Callback callback
+  , NanWeakCallbackType type) {
+  NanWeakCallbackInfo<P> *wcbd;
+  if (type == NanWeakCallbackType::kParameter) {
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , parameter);
+    persistent.MakeWeak(wcbd, wcbd->invoke);
+  } else {
+    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    assert((*self)->IsObject());
+    int count = (*self)->InternalFieldCount();
+    void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
+    for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
+      internal_fields[i] = (*self)->GetPointerFromInternalField(i);
+    }
+    wcbd = new NanWeakCallbackInfo<P>(
+        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+      , callback
+      , 0
+      , internal_fields[0]
+      , internal_fields[1]);
+    persistent.MakeWeak(wcbd, wcbd->invoke);
+  }
+}
+#endif
+
+#endif  // NAN_WEAK_H_
diff --git a/test/binding.gyp b/test/binding.gyp
index 74392f1e..2db37af9 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -57,6 +57,10 @@
         "target_name" : "weak"
       , "sources"     : [ "cpp/weak.cpp" ]
     }
+  , {
+        "target_name" : "weak2"
+      , "sources"     : [ "cpp/weak2.cpp" ]
+    }
   , {
         "target_name" : "bufferworkerpersistent"
       , "sources"     : [ "cpp/bufferworkerpersistent.cpp" ]
diff --git a/test/cpp/makecallback.cpp b/test/cpp/makecallback.cpp
index b54c1608..51ab2dce 100644
--- a/test/cpp/makecallback.cpp
+++ b/test/cpp/makecallback.cpp
@@ -18,10 +18,10 @@ class MyObject : public node::ObjectWrap {
 
   static NAN_METHOD(New);
   static NAN_METHOD(CallEmit);
-  static v8::Persistent<v8::Function> constructor;
+  static NanPersistent<v8::Function> constructor;
 };
 
-v8::Persistent<v8::Function> MyObject::constructor;
+NanPersistent<v8::Function> MyObject::constructor;
 
 MyObject::MyObject() {
 }
@@ -37,7 +37,7 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
 
   NODE_SET_PROTOTYPE_METHOD(tpl, "call_emit", CallEmit);
 
-  NanAssignPersistent<v8::Function>(constructor, tpl->GetFunction());
+  constructor.Reset(tpl->GetFunction());
   exports->Set(NanNew<v8::String>("MyObject"), tpl->GetFunction());
 }
 
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index 1c3932a0..d6c7ff5d 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -344,10 +344,10 @@ NAN_METHOD(testPersistents) {
 
   t.plan(1);
 
-  Persistent<String> p;
-  NanAssignPersistent(p, NanNew("foo"));
+  NanPersistent<String> p;
+  p.Reset(NanNew("foo"));
   t.ok(_( assertType<String>( NanNew(p))));
-  NanDisposePersistent(p);
+  p.Reset();
 
   return_NanUndefined();
 }
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index a2b33897..e4ee1bb4 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -17,7 +17,7 @@ class MyObject : public NanObjectWrap {
 
     NODE_SET_PROTOTYPE_METHOD(tpl, "getHandle", GetHandle);
 
-    NanAssignPersistent(constructor, tpl->GetFunction());
+    constructor.Reset(tpl->GetFunction());
     exports->Set(NanNew("MyObject"), tpl->GetFunction());
   }
 
@@ -44,11 +44,11 @@ class MyObject : public NanObjectWrap {
     NanReturnValue(obj->handle());
   }
 
-  static v8::Persistent<v8::Function> constructor;
+  static NanPersistent<v8::Function> constructor;
   double value_;
 };
 
-v8::Persistent<v8::Function> MyObject::constructor;
+NanPersistent<v8::Function> MyObject::constructor;
 
 void Init(v8::Handle<v8::Object> exports) {
   MyObject::Init(exports);
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index 92a1d24e..512c250d 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -9,10 +9,10 @@
 #include <nan.h>
 #include <cstring>  // memset()
 
-static v8::Persistent<v8::String> persistentTest1;
+static NanPersistent<v8::String> persistentTest1;
 
 NAN_METHOD(Save1) {
-  NanAssignPersistent(persistentTest1, args[0].As<v8::String>());
+  persistentTest1.Reset(args[0].As<v8::String>());
   NanReturnUndefined();
 }
 
@@ -21,28 +21,32 @@ NAN_METHOD(Get1) {
 }
 
 NAN_METHOD(Dispose1) {
-  NanDisposePersistent(persistentTest1);
+  persistentTest1.Reset();
   NanReturnUndefined();
 }
 
 NAN_METHOD(ToPersistentAndBackAgain) {
-  v8::Persistent<v8::Object> persistent;
-  NanAssignPersistent(persistent, args[0].As<v8::Object>());
+  NanPersistent<v8::Object> persistent(args[0].As<v8::Object>());
   v8::Local<v8::Object> object = NanNew(persistent);
-  NanDisposePersistent(persistent);
+  persistent.Reset();
   memset(&persistent, -1, sizeof(persistent));  // Clobber it good.
   NanReturnValue(object);
 }
 
 NAN_METHOD(PersistentToPersistent) {
-  v8::Persistent<v8::String> persistent;
-  NanAssignPersistent(persistent, args[0].As<v8::String>());
-  NanAssignPersistent(persistentTest1, persistent);
-  NanDisposePersistent(persistent);
-  NanDisposePersistent(persistentTest1);
+  NanPersistent<v8::String> persistent(args[0].As<v8::String>());
+  persistentTest1.Reset(persistent);
+  persistent.Reset();
+  persistentTest1.Reset();
   NanReturnUndefined();
 }
 
+NAN_METHOD(CopyablePersistent) {
+  NanCopyablePersistentTraits<v8::String>::CopyablePersistent p;
+  p = persistentTest1;
+  NanReturnValue(p);
+}
+
 void Init (v8::Handle<v8::Object> target) {
   target->Set(
       NanNew<v8::String>("save1")
@@ -64,6 +68,10 @@ void Init (v8::Handle<v8::Object> target) {
       NanNew<v8::String>("persistentToPersistent")
     , NanNew<v8::FunctionTemplate>(PersistentToPersistent)->GetFunction()
   );
+  target->Set(
+      NanNew<v8::String>("copyablePersistent")
+    , NanNew<v8::FunctionTemplate>(CopyablePersistent)->GetFunction()
+  );
 }
 
 NODE_MODULE(persistent, Init)
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index 69874845..3a6381eb 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -8,7 +8,7 @@
 
 #include <nan.h>
 
-v8::Persistent<v8::Boolean> persistent;
+NanPersistent<v8::Boolean> persistent;
 
 NAN_METHOD(ReturnValue) {
   if (args.Length() == 1) {
@@ -31,7 +31,7 @@ NAN_METHOD(ReturnPersistent) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanAssignPersistent(persistent, NanNew(true));
+  persistent.Reset(NanNew(true));
 
   target->Set(
       NanNew<v8::String>("r")
diff --git a/test/cpp/settemplate.cpp b/test/cpp/settemplate.cpp
index 79a87880..b916f7d1 100644
--- a/test/cpp/settemplate.cpp
+++ b/test/cpp/settemplate.cpp
@@ -17,10 +17,10 @@ class MyObject : public node::ObjectWrap {
   ~MyObject();
 
   static NAN_METHOD(New);
-  static v8::Persistent<v8::Function> constructor;
+  static NanPersistent<v8::Function> constructor;
 };
 
-v8::Persistent<v8::Function> MyObject::constructor;
+NanPersistent<v8::Function> MyObject::constructor;
 
 MyObject::MyObject() {
 }
@@ -48,7 +48,7 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
   NanSetInstanceTemplate(
       tpl, NanNew("dontDelete"), NanNew("dontDelete"), v8::DontDelete);
 
-  NanAssignPersistent<v8::Function>(constructor, tpl->GetFunction());
+  constructor.Reset(tpl->GetFunction());
   exports->Set(NanNew<v8::String>("MyObject"), tpl->GetFunction());
 }
 
diff --git a/test/cpp/settergetter.cpp b/test/cpp/settergetter.cpp
index 875db98c..20c4a933 100644
--- a/test/cpp/settergetter.cpp
+++ b/test/cpp/settergetter.cpp
@@ -26,7 +26,7 @@ class SetterGetter : public node::ObjectWrap {
   char prop2[256];
 };
 
-static v8::Persistent<v8::FunctionTemplate> settergetter_constructor;
+static NanPersistent<v8::FunctionTemplate> settergetter_constructor;
 
 NAN_METHOD(CreateNew) {
   NanReturnValue(SetterGetter::NewInstance());
@@ -42,7 +42,7 @@ SetterGetter::SetterGetter() {
 void SetterGetter::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
     NanNew<v8::FunctionTemplate>(SetterGetter::New);
-  NanAssignPersistent(settergetter_constructor, tpl);
+  settergetter_constructor.Reset(tpl);
   tpl->SetClassName(NanNew<v8::String>("SetterGetter"));
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   NODE_SET_PROTOTYPE_METHOD(tpl, "log", SetterGetter::Log);
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index 62fc213b..7def25b2 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -27,19 +27,16 @@ NAN_METHOD(EncodeUCS2) {
   NanReturnValue(NanEncode("h\0e\0l\0l\0o\0", 10, Nan::UCS2));
 }
 
-v8::Persistent<v8::FunctionTemplate> returnUtf8String_persistent;
-v8::Persistent<v8::FunctionTemplate> heapString_persistent;
-v8::Persistent<v8::FunctionTemplate> encodeHex_persistent;
-v8::Persistent<v8::FunctionTemplate> encodeUCS2_persistent;
+NanPersistent<v8::FunctionTemplate> returnUtf8String_persistent;
+NanPersistent<v8::FunctionTemplate> heapString_persistent;
+NanPersistent<v8::FunctionTemplate> encodeHex_persistent;
+NanPersistent<v8::FunctionTemplate> encodeUCS2_persistent;
 
 void Init (v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> returnUtf8String =
     NanNew<v8::FunctionTemplate>(ReturnUtf8String);
 
-  NanAssignPersistent(
-    returnUtf8String_persistent
-  , returnUtf8String
-  );
+  returnUtf8String_persistent.Reset(returnUtf8String);
 
   target->Set(
       NanNew("returnUtf8String")
@@ -49,10 +46,7 @@ void Init (v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> heapString =
     NanNew<v8::FunctionTemplate>(HeapString);
 
-  NanAssignPersistent(
-    heapString_persistent
-  , heapString
-  );
+  heapString_persistent.Reset(heapString);
 
   target->Set(
       NanNew("heapString")
@@ -62,10 +56,7 @@ void Init (v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> encodeHex =
     NanNew<v8::FunctionTemplate>(EncodeHex);
 
-  NanAssignPersistent(
-    encodeHex_persistent
-  , encodeHex
-  );
+  encodeHex_persistent.Reset(encodeHex);
 
   target->Set(
       NanNew("encodeHex")
@@ -75,10 +66,7 @@ void Init (v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> encodeUCS2 =
     NanNew<v8::FunctionTemplate>(EncodeUCS2);
 
-  NanAssignPersistent(
-    encodeUCS2_persistent
-  , encodeUCS2
-  );
+  encodeUCS2_persistent.Reset(encodeUCS2);
 
   target->Set(
       NanNew("encodeUCS2")
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index fc4248e3..6a6ee68d 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -8,26 +8,28 @@
 
 #include <nan.h>
 
+static NanPersistent<v8::Function> cb;
+
 void weakCallback(
-NanWeakCallbackData<v8::Function, int> & data) {  // NOLINT(runtime/references)
+    const NanWeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)
   int *parameter = data.GetParameter();
-  NanMakeCallback(NanGetCurrentContext()->Global(), data.GetValue(), 0, NULL);
-  if ((*parameter)++ == 0) {
-    data.Revive();
-  } else {
-    delete parameter;
-  }
+  v8::Local<v8::Value> val = NanNew(*parameter);
+  NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(cb), 1, &val);
+  delete parameter;
 }
 
 v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
   NanEscapableScope scope;
   v8::Local<v8::String> lstring = NanNew<v8::String>("result");
-  int *parameter = new int(0);
-  NanMakeWeakPersistent(func, parameter, weakCallback);
+  int *parameter = new int(42);
+  NanPersistent<v8::Function> persistent(func);
+  persistent.SetWeak(parameter, weakCallback, NanWeakCallbackType::kParameter);
+  assert(persistent.IsWeak());
   return scope.Escape(lstring);
 }
 
 NAN_METHOD(Hustle) {
+  cb.Reset(args[1].As<v8::Function>());
   NanReturnValue(wrap(args[0].As<v8::Function>()));
 }
 
diff --git a/test/cpp/weak2.cpp b/test/cpp/weak2.cpp
new file mode 100644
index 00000000..58c9357d
--- /dev/null
+++ b/test/cpp/weak2.cpp
@@ -0,0 +1,48 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+
+static NanPersistent<v8::Function> cb;
+void weakCallback(
+    const NanWeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)
+  int *parameter = static_cast<int*>(data.GetInternalField(0));
+  v8::Local<v8::Value> val = NanNew(*parameter);
+  NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(cb), 1, &val);
+  delete parameter;
+}
+
+v8::Handle<v8::String> wrap() {
+  NanEscapableScope scope;
+  v8::Local<v8::String> lstring = NanNew<v8::String>("result");
+  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  otpl->SetInternalFieldCount(1);
+  v8::Local<v8::Object> obj = otpl->NewInstance();
+  NanSetInternalFieldPointer(obj, 0, new int(42));
+  NanPersistent<v8::Object> persistent(obj);
+  persistent.SetWeak(
+      static_cast<int*>(0)
+    , weakCallback
+    , NanWeakCallbackType::kInternalFields);
+  assert(persistent.IsWeak());
+  return scope.Escape(lstring);
+}
+
+NAN_METHOD(Hustle) {
+  cb.Reset(args[0].As<v8::Function>());
+  NanReturnValue(wrap());
+}
+
+void Init (v8::Handle<v8::Object> target) {
+  target->Set(
+      NanNew<v8::String>("hustle")
+    , NanNew<v8::FunctionTemplate>(Hustle)->GetFunction()
+  );
+}
+
+NODE_MODULE(weak2, Init)
diff --git a/test/js/persistent-test.js b/test/js/persistent-test.js
index 4e4ee4ce..d9105071 100644
--- a/test/js/persistent-test.js
+++ b/test/js/persistent-test.js
@@ -11,7 +11,7 @@ const test     = require('tap').test
     , bindings = require('bindings')({ module_root: testRoot, bindings: 'persistent' });
 
 test('persistent', function (t) {
-  t.plan(11)
+  t.plan(14);
 
   var persistent = bindings;
   t.type(persistent.save1, 'function');
@@ -19,22 +19,27 @@ test('persistent', function (t) {
   t.type(persistent.dispose1, 'function');
   t.type(persistent.toPersistentAndBackAgain, 'function');
   t.type(persistent.persistentToPersistent, 'function');
+  t.type(persistent.copyablePersistent, 'function');
   t.deepEqual(persistent.toPersistentAndBackAgain({ x: 42 }), { x: 42 });
 
   t.ok(persistent.persistentToPersistent('any string') || true);
 
-  persistent.save1('a string to save')
-  t.equal(persistent.get1(), 'a string to save')
+  persistent.save1('a string to save');
+  t.equal(persistent.get1(), 'a string to save');
   setTimeout(function () {
-    t.equal(persistent.get1(), 'a string to save')
-  }, 25)
+    t.equal(persistent.get1(), 'a string to save');
+  }, 25);
   setTimeout(function () {
-    t.equal(persistent.get1(), 'a string to save')
-  }, 50)
+    t.equal(persistent.get1(), 'a string to save');
+  }, 50);
   setTimeout(function () {
-    persistent.dispose1()
-  }, 75)
+    t.equal(persistent.copyablePersistent(), 'a string to save');
+  }, 75);
   setTimeout(function () {
-    t.ok(persistent.get1() === undefined, 'no more persistent')
-  }, 100)
-})
+    persistent.dispose1();
+  }, 75);
+  setTimeout(function () {
+    t.ok(persistent.get1() === undefined, 'no more persistent');
+    t.ok(persistent.copyablePersistent() === undefined, 'no more persistent');
+  }, 100);
+});
diff --git a/test/js/weak-test.js b/test/js/weak-test.js
index f6cb192d..6e40499b 100644
--- a/test/js/weak-test.js
+++ b/test/js/weak-test.js
@@ -13,24 +13,19 @@ const test     = require('tap').test
 test('weak', function (t) {
   t.plan(3);
 
-  var weak = bindings;
+  var weak = bindings, count = 0;
   t.type(weak.hustle, 'function');
 
-  function f() {
-    var count = 0;
-    weak.hustle(function () {
-      t.ok(count++ < 2);
-    });
-  };
-
-  f();
-
-  // run weak callback, should not dispose
-  gc();
+  weak.hustle(function () {}, function (val) {
+    t.equal(val, 42);
+    count++;
+  });
 
   // run weak callback, should dispose
   gc();
 
   // do not run weak callback
   gc();
+
+  t.equal(count, 1);
 });
diff --git a/test/js/weak2-test.js b/test/js/weak2-test.js
new file mode 100644
index 00000000..dff05b60
--- /dev/null
+++ b/test/js/weak2-test.js
@@ -0,0 +1,36 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'weak2' });
+
+test('weak2', function (t) {
+  t.plan(3);
+
+  var weak2 = bindings, count = 0;
+  t.type(weak2.hustle, 'function');
+
+  weak2.hustle(function (val) {
+    t.equal(val, 42);
+    count++;
+  });
+
+  // run weak callback, should dispose
+  gc();
+
+  // do not run weak callback
+  gc();
+
+  var timeout = setTimeout(function () {
+    if (count > 0) {
+      clearTimeout(timeout);
+      t.equal(count, 1);
+    }
+  }, 100);
+});

From 4408da1b47f44e788ae23987b088032e4399b8e6 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 23 May 2015 15:13:10 +0300
Subject: [PATCH 12/84] Introduce NanGlobal

---
 nan_persistent_12_inl.h     | 71 +++++++++++++++++++++++++++++++++++++
 nan_persistent_pre_12_inl.h | 57 +++++++++++++++++++++++++++++
 test/cpp/returnvalue.cpp    | 10 +++---
 3 files changed, 133 insertions(+), 5 deletions(-)

diff --git a/nan_persistent_12_inl.h b/nan_persistent_12_inl.h
index 41979560..23a6cc16 100644
--- a/nan_persistent_12_inl.h
+++ b/nan_persistent_12_inl.h
@@ -55,4 +55,75 @@ template<typename T, typename M> class NanPersistent :
   }
 };
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+template<typename T>
+class NanGlobal : public v8::Global<T> {
+ public:
+  NAN_INLINE NanGlobal() : v8::Global<T>() {}
+
+  template<typename S> NAN_INLINE NanGlobal(v8::Handle<S> that) :
+    v8::Global<T>(v8::Isolate::GetCurrent(), that) {}
+
+  template<typename S>
+  NAN_INLINE NanGlobal(const v8::PersistentBase<S> &that) :
+      v8::Global<S>(v8::Isolate::GetCurrent(), that) {}
+
+  NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
+
+  template <typename S>
+  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  }
+
+  template <typename S>
+  NAN_INLINE void Reset(const v8::PersistentBase<S> &other) {
+    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  }
+
+  template<typename P>
+  NAN_INLINE void SetWeak(
+    P *parameter
+    , typename NanWeakCallbackInfo<P>::Callback callback
+    , NanWeakCallbackType type) {
+    reinterpret_cast<NanPersistent<T>*>(this)->SetWeak(
+        parameter, callback, type);
+  }
+};
+#else
+template<typename T>
+class NanGlobal : public v8::UniquePersistent<T> {
+ public:
+  NAN_INLINE NanGlobal() : v8::UniquePersistent<T>() {}
+
+  template<typename S> NAN_INLINE NanGlobal(v8::Handle<S> that) :
+    v8::UniquePersistent<T>(v8::Isolate::GetCurrent(), that) {}
+
+  template<typename S>
+  NAN_INLINE NanGlobal(const v8::PersistentBase<S> &that) :
+      v8::UniquePersistent<S>(v8::Isolate::GetCurrent(), that) {}
+
+  NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
+
+  template <typename S>
+  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  }
+
+  template <typename S>
+  NAN_INLINE void Reset(const v8::PersistentBase<S> &other) {
+    v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
+  }
+
+  template<typename P>
+  NAN_INLINE void SetWeak(
+    P *parameter
+    , typename NanWeakCallbackInfo<P>::Callback callback
+    , NanWeakCallbackType type) {
+    reinterpret_cast<NanPersistent<T>*>(this)->SetWeak(
+        parameter, callback, type);
+  }
+};
+#endif
+
 #endif  // NAN_PERSISTENT_12_INL_H_
diff --git a/nan_persistent_pre_12_inl.h b/nan_persistent_pre_12_inl.h
index 7d57dcdc..51d4e4af 100644
--- a/nan_persistent_pre_12_inl.h
+++ b/nan_persistent_pre_12_inl.h
@@ -14,6 +14,7 @@ class NanPersistentBase {
   v8::Persistent<T> persistent;
   template<typename U, typename M>
   friend v8::Local<U> NanNew(const NanPersistent<U, M> &p);
+  template<typename S> friend class NanReturnValue;
 
  public:
   NAN_INLINE NanPersistentBase() :
@@ -97,7 +98,9 @@ class NanPersistentBase {
  private:
   NAN_INLINE explicit NanPersistentBase(v8::Persistent<T> that) :
       persistent(that) { }
+  NAN_INLINE explicit NanPersistentBase(T *val) : persistent(val) {}
   template<typename S, typename M> friend class NanPersistent;
+  template<typename S> friend class NanGlobal;
 };
 
 template<typename T>
@@ -177,4 +180,58 @@ template<typename T, typename M> class NanPersistent :
   }
 };
 
+template<typename T>
+class NanGlobal : public NanPersistentBase<T> {
+  struct RValue {
+    NAN_INLINE explicit RValue(NanGlobal* obj) : object(obj) {}
+    NanGlobal* object;
+  };
+
+ public:
+  NAN_INLINE NanGlobal() : NanPersistentBase<T>(0) { }
+
+  template <typename S>
+  NAN_INLINE NanGlobal(v8::Handle<S> that)
+      : NanPersistentBase<T>(v8::Persistent<T>::New(that)) {
+    TYPE_CHECK(T, S);
+  }
+
+  template <typename S>
+  NAN_INLINE NanGlobal(const NanPersistentBase<S> &that)
+    : NanPersistentBase<T>(that) {
+    TYPE_CHECK(T, S);
+  }
+  /**
+   * Move constructor.
+   */
+  NAN_INLINE NanGlobal(RValue rvalue)
+    : NanPersistentBase<T>(rvalue.object.persistent) {
+    rvalue.object->Reset();
+  }
+  NAN_INLINE ~NanGlobal() { this->Reset(); }
+  /**
+   * Move via assignment.
+   */
+  template<typename S>
+  NAN_INLINE NanGlobal &operator=(NanGlobal<S> rhs) {
+    TYPE_CHECK(T, S);
+    this->Reset(rhs.persistent);
+    rhs.Reset();
+    return *this;
+  }
+  /**
+   * Cast operator for moves.
+   */
+  NAN_INLINE operator RValue() { return RValue(this); }
+  /**
+   * Pass allows returning uniques from functions, etc.
+   */
+  NanGlobal Pass() { return NanGlobal(RValue(this)); }
+
+ private:
+  NanGlobal(NanGlobal &);
+  void operator=(NanGlobal &);
+  template<typename S> friend class NanReturnValue;
+};
+
 #endif  // NAN_PERSISTENT_PRE_12_INL_H_
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index 3a6381eb..00c1b1d4 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -8,7 +8,7 @@
 
 #include <nan.h>
 
-NanPersistent<v8::Boolean> persistent;
+NanGlobal<v8::Boolean> global;
 
 NAN_METHOD(ReturnValue) {
   if (args.Length() == 1) {
@@ -26,12 +26,12 @@ NAN_METHOD(ReturnString) {
   NanReturnValue("yes, it works");
 }
 
-NAN_METHOD(ReturnPersistent) {
-  NanReturnValue(persistent);
+NAN_METHOD(ReturnGlobal) {
+  NanReturnValue(global);
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  persistent.Reset(NanNew(true));
+  global.Reset(NanNew(true));
 
   target->Set(
       NanNew<v8::String>("r")
@@ -47,7 +47,7 @@ void Init (v8::Handle<v8::Object> target) {
   );
   target->Set(
       NanNew<v8::String>("q")
-    , NanNew<v8::FunctionTemplate>(ReturnPersistent)->GetFunction()
+    , NanNew<v8::FunctionTemplate>(ReturnGlobal)->GetFunction()
   );
 }
 

From d90a25c3baaba07bb8d45325b7ba05ba4ec04cd2 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 9 May 2015 20:06:39 +0300
Subject: [PATCH 13/84] Remove NanReturn* macros

---
 Makefile                                      |   7 +
 examples/async_pi_estimate/async.cc           |   5 +-
 examples/async_pi_estimate/sync.cc            |   4 +-
 nan.h                                         | 493 +++++++++++++-----
 nan_callbacks.h                               | 133 +++++
 nan_callbacks_12_inl.h                        | 472 +++++++++++++++++
 nan_callbacks_pre_12_inl.h                    | 450 ++++++++++++++++
 nan_implementation_12_inl.h                   |  50 +-
 nan_implementation_pre_12_inl.h               |  26 +-
 test/binding.gyp                              |  12 +-
 test/cpp/{settergetter.cpp => accessors.cpp}  |  33 +-
 test/cpp/asyncprogressworker.cpp              |  10 +-
 test/cpp/asyncworker.cpp                      |   6 +-
 test/cpp/asyncworkererror.cpp                 |   4 +-
 test/cpp/bufferworkerpersistent.cpp           |   8 +-
 test/cpp/gc.cpp                               |   6 +-
 test/cpp/indexedinterceptors.cpp              | 114 ++++
 test/cpp/isolatedata.cpp                      |   2 +-
 test/cpp/makecallback.cpp                     |  21 +-
 test/cpp/morenews.cpp                         |  16 +-
 test/cpp/multifile2.cpp                       |   4 +-
 test/cpp/namedinterceptors.cpp                | 114 ++++
 test/cpp/nancallback.cpp                      |  29 +-
 test/cpp/nannew.cpp                           |  96 ++--
 test/cpp/news.cpp                             |  53 +-
 test/cpp/objectwraphandle.cpp                 |  18 +-
 test/cpp/persistent.cpp                       |  18 +-
 test/cpp/returnemptystring.cpp                |   2 +-
 test/cpp/returnnull.cpp                       |   2 +-
 test/cpp/returnundefined.cpp                  |   2 +-
 test/cpp/returnvalue.cpp                      |  20 +-
 test/cpp/settemplate.cpp                      |   8 +-
 test/cpp/strings.cpp                          |  10 +-
 test/cpp/threadlocal.cpp                      |   4 +-
 test/cpp/weak.cpp                             |   4 +-
 test/cpp/weak2.cpp                            |   4 +-
 ...settergetter-test.js => accessors-test.js} |   4 +-
 test/js/indexedinterceptors-test.js           |  23 +
 test/js/namedinterceptors-test.js             |  23 +
 test/js/returnvalue-test.js                   |   4 +-
 40 files changed, 1967 insertions(+), 347 deletions(-)
 create mode 100644 nan_callbacks.h
 create mode 100644 nan_callbacks_12_inl.h
 create mode 100644 nan_callbacks_pre_12_inl.h
 rename test/cpp/{settergetter.cpp => accessors.cpp} (83%)
 create mode 100644 test/cpp/indexedinterceptors.cpp
 create mode 100644 test/cpp/namedinterceptors.cpp
 rename test/js/{settergetter-test.js => accessors-test.js} (93%)
 create mode 100644 test/js/indexedinterceptors-test.js
 create mode 100644 test/js/namedinterceptors-test.js

diff --git a/Makefile b/Makefile
index 8f13a6fe..665471a4 100644
--- a/Makefile
+++ b/Makefile
@@ -15,6 +15,9 @@ LINT_SOURCES = \
 	examples/async_pi_estimate/sync.cc \
 	examples/async_pi_estimate/sync.h \
 	nan.h \
+	nan_callbacks.h \
+	nan_callbacks_12_inl.h \
+	nan_callbacks_pre_12_inl.h \
 	nan_implementation_12_inl.h \
 	nan_implementation_pre_12_inl.h \
 	nan_new.h \
@@ -22,18 +25,21 @@ LINT_SOURCES = \
 	nan_persistent_pre_12_inl.h \
 	nan_string_bytes.h \
 	nan_weak.h \
+	test/cpp/accessors.cpp \
 	test/cpp/asyncworker.cpp \
 	test/cpp/asyncprogressworker.cpp \
 	test/cpp/asyncworkererror.cpp \
 	test/cpp/bufferworkerpersistent.cpp \
 	test/cpp/error.cpp \
 	test/cpp/gc.cpp \
+	test/cpp/indexedinterceptors.cpp \
 	test/cpp/isolatedata.cpp \
 	test/cpp/makecallback.cpp \
 	test/cpp/morenews.cpp \
 	test/cpp/multifile1.cpp \
 	test/cpp/multifile2.cpp \
 	test/cpp/multifile2.h \
+	test/cpp/namedinterceptors.cpp \
 	test/cpp/nancallback.cpp \
 	test/cpp/nannew.cpp \
 	test/cpp/news.cpp \
@@ -67,6 +73,7 @@ forcetest:
 	npm test
 
 $(ADDONS): nan.h nan_new.h nan_implementation_pre_12_inl.h nan_implementation_12_inl.h \
+		nan_callbacks.h nan_callbacks_12_inl.h nan_callbacks_pre_12_inl.h \
 		nan_persistent_12_inl.h nan_persistent_pre_12_inl.h nan_weak.h \
 		nan_string_bytes.h test/binding.gyp $(SOURCES)
 	cd test/ && ../node_modules/.bin/node-gyp rebuild
diff --git a/examples/async_pi_estimate/async.cc b/examples/async_pi_estimate/async.cc
index 8ce559c8..acab9b65 100644
--- a/examples/async_pi_estimate/async.cc
+++ b/examples/async_pi_estimate/async.cc
@@ -51,9 +51,8 @@ class PiWorker : public NanAsyncWorker {
 
 // Asynchronous access to the `Estimate()` function
 NAN_METHOD(CalculateAsync) {
-  int points = args[0]->Uint32Value();
-  NanCallback *callback = new NanCallback(args[1].As<Function>());
+  int points = info[0]->Uint32Value();
+  NanCallback *callback = new NanCallback(info[1].As<Function>());
 
   NanAsyncQueueWorker(new PiWorker(callback, points));
-  NanReturnUndefined();
 }
diff --git a/examples/async_pi_estimate/sync.cc b/examples/async_pi_estimate/sync.cc
index b2e7ba6c..88b04dd4 100644
--- a/examples/async_pi_estimate/sync.cc
+++ b/examples/async_pi_estimate/sync.cc
@@ -15,8 +15,8 @@ using v8::Number;
 // Simple synchronous access to the `Estimate()` function
 NAN_METHOD(CalculateSync) {
   // expect a number as the first argument
-  int points = args[0]->Uint32Value();
+  int points = info[0]->Uint32Value();
   double est = Estimate(points);
 
-  NanReturnValue(NanNew<Number>(est));
+  info.GetReturnValue().Set(est);
 }
diff --git a/nan.h b/nan.h
index 886c1419..ecaf6819 100644
--- a/nan.h
+++ b/nan.h
@@ -96,12 +96,16 @@
       *(static_cast<T *volatile *>(0)) = static_cast<S*>(0);                   \
     }
 
+//=== CallbackInfo =============================================================
+
+#include "nan_callbacks.h"  // NOLINT(build/include)
+
+//==============================================================================
+
 #if (NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION)
-typedef v8::InvocationCallback NanFunctionCallback;
 typedef v8::Script             NanUnboundScript;
 typedef v8::Script             NanBoundScript;
 #else
-typedef v8::FunctionCallback   NanFunctionCallback;
 typedef v8::UnboundScript      NanUnboundScript;
 typedef v8::Script             NanBoundScript;
 #endif
@@ -442,61 +446,6 @@ class NanEscapableScope {
 #endif
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)  // Node 0.12
-  typedef const v8::FunctionCallbackInfo<v8::Value>& NAN_METHOD_ARGS_TYPE;
-  typedef void NAN_METHOD_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Value>& NAN_GETTER_ARGS_TYPE;
-  typedef void NAN_GETTER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<void>& NAN_SETTER_ARGS_TYPE;
-  typedef void NAN_SETTER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Value>&
-      NAN_PROPERTY_GETTER_ARGS_TYPE;
-  typedef void NAN_PROPERTY_GETTER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Value>&
-      NAN_PROPERTY_SETTER_ARGS_TYPE;
-  typedef void NAN_PROPERTY_SETTER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Array>&
-      NAN_PROPERTY_ENUMERATOR_ARGS_TYPE;
-  typedef void NAN_PROPERTY_ENUMERATOR_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Boolean>&
-      NAN_PROPERTY_DELETER_ARGS_TYPE;
-  typedef void NAN_PROPERTY_DELETER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Integer>&
-      NAN_PROPERTY_QUERY_ARGS_TYPE;
-  typedef void NAN_PROPERTY_QUERY_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Value>& NAN_INDEX_GETTER_ARGS_TYPE;
-  typedef void NAN_INDEX_GETTER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Value>& NAN_INDEX_SETTER_ARGS_TYPE;
-  typedef void NAN_INDEX_SETTER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Array>&
-      NAN_INDEX_ENUMERATOR_ARGS_TYPE;
-  typedef void NAN_INDEX_ENUMERATOR_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Boolean>&
-      NAN_INDEX_DELETER_ARGS_TYPE;
-  typedef void NAN_INDEX_DELETER_RETURN_TYPE;
-
-  typedef const v8::PropertyCallbackInfo<v8::Integer>&
-      NAN_INDEX_QUERY_ARGS_TYPE;
-  typedef void NAN_INDEX_QUERY_RETURN_TYPE;
-
-# define NanReturnValue(value)                                                 \
-  return args.GetReturnValue().Set(Nan::imp::NanEnsureHandleOrPersistent(value))
-# define NanReturnUndefined() return
-# define NanReturnHolder() NanReturnValue(args.Holder())
-# define NanReturnThis() NanReturnValue(args.This())
-# define NanReturnNull() return args.GetReturnValue().SetNull()
-# define NanReturnEmptyString() return args.GetReturnValue().SetEmptyString()
-
   NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
     NanEscapableScope scope;
     return scope.Escape(NanNew(v8::Undefined(v8::Isolate::GetCurrent())));
@@ -834,53 +783,6 @@ class NanEscapableScope {
   };
 
 #else  // Node 0.8 and 0.10
-  typedef const v8::Arguments& NAN_METHOD_ARGS_TYPE;
-  typedef v8::Handle<v8::Value> NAN_METHOD_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo & NAN_GETTER_ARGS_TYPE;
-  typedef v8::Handle<v8::Value> NAN_GETTER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo & NAN_SETTER_ARGS_TYPE;
-  typedef void NAN_SETTER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_PROPERTY_GETTER_ARGS_TYPE;
-  typedef v8::Handle<v8::Value> NAN_PROPERTY_GETTER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_PROPERTY_SETTER_ARGS_TYPE;
-  typedef v8::Handle<v8::Value> NAN_PROPERTY_SETTER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_PROPERTY_ENUMERATOR_ARGS_TYPE;
-  typedef v8::Handle<v8::Array> NAN_PROPERTY_ENUMERATOR_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_PROPERTY_DELETER_ARGS_TYPE;
-  typedef v8::Handle<v8::Boolean> NAN_PROPERTY_DELETER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_PROPERTY_QUERY_ARGS_TYPE;
-  typedef v8::Handle<v8::Integer> NAN_PROPERTY_QUERY_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_INDEX_GETTER_ARGS_TYPE;
-  typedef v8::Handle<v8::Value> NAN_INDEX_GETTER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_INDEX_SETTER_ARGS_TYPE;
-  typedef v8::Handle<v8::Value> NAN_INDEX_SETTER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_INDEX_ENUMERATOR_ARGS_TYPE;
-  typedef v8::Handle<v8::Array> NAN_INDEX_ENUMERATOR_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_INDEX_DELETER_ARGS_TYPE;
-  typedef v8::Handle<v8::Boolean> NAN_INDEX_DELETER_RETURN_TYPE;
-
-  typedef const v8::AccessorInfo& NAN_INDEX_QUERY_ARGS_TYPE;
-  typedef v8::Handle<v8::Integer> NAN_INDEX_QUERY_RETURN_TYPE;
-
-# define NanReturnValue(value)                                                 \
-    return Nan::imp::NanEnsureHandleOrPersistent(value)
-# define NanReturnHolder() NanReturnValue(args.Holder())
-# define NanReturnThis() NanReturnValue(args.This())
-# define NanReturnUndefined() return v8::Undefined()
-# define NanReturnNull() return v8::Null()
-# define NanReturnEmptyString() return v8::String::Empty()
-
   NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
     NanEscapableScope scope;
     return scope.Escape(NanNew(v8::Undefined()));
@@ -974,17 +876,14 @@ class NanEscapableScope {
       return v8::Exception::NAME(errmsg);                                      \
     }                                                                          \
                                                                                \
-    NAN_INLINE v8::Local<v8::Value> NanThrow ## NAME(const char *errmsg) {     \
-      NanEscapableScope scope;                                                 \
-      return scope.Escape(NanNew(v8::ThrowException(                           \
-          v8::Exception::NAME(NanNew(errmsg)))));                              \
+    NAN_INLINE void NanThrow ## NAME(const char *errmsg) {                     \
+      NanScope scope;                                                          \
+      v8::ThrowException(v8::Exception::NAME(NanNew(errmsg)));                 \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    v8::Local<v8::Value> NanThrow ## NAME(v8::Handle<v8::String> errmsg) {     \
-      NanEscapableScope scope;                                                 \
-      return scope.Escape(NanNew(v8::ThrowException(                           \
-          v8::Exception::NAME(errmsg))));                                      \
+    void NanThrow ## NAME(v8::Handle<v8::String> errmsg) {                     \
+      v8::ThrowException(v8::Exception::NAME(errmsg));                         \
     }
 
   X(Error)
@@ -995,9 +894,8 @@ class NanEscapableScope {
 
 # undef X
 
-  NAN_INLINE v8::Local<v8::Value> NanThrowError(v8::Handle<v8::Value> error) {
-    NanEscapableScope scope;
-    return scope.Escape(v8::Local<v8::Value>::New(v8::ThrowException(error)));
+  NAN_INLINE void NanThrowError(v8::Handle<v8::Value> error) {
+    v8::ThrowException(error);
   }
 
   NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
@@ -1201,55 +1099,102 @@ class NanEscapableScope {
 
 typedef void (*NanFreeCallback)(char *data, void *hint);
 
-#define NAN_METHOD(name) NAN_METHOD_RETURN_TYPE name(NAN_METHOD_ARGS_TYPE args)
+typedef const NanFunctionCallbackInfo<v8::Value>& NAN_METHOD_ARGS_TYPE;
+typedef void NAN_METHOD_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Value>& NAN_GETTER_ARGS_TYPE;
+typedef void NAN_GETTER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<void>& NAN_SETTER_ARGS_TYPE;
+typedef void NAN_SETTER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Value>&
+    NAN_PROPERTY_GETTER_ARGS_TYPE;
+typedef void NAN_PROPERTY_GETTER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Value>&
+    NAN_PROPERTY_SETTER_ARGS_TYPE;
+typedef void NAN_PROPERTY_SETTER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Array>&
+    NAN_PROPERTY_ENUMERATOR_ARGS_TYPE;
+typedef void NAN_PROPERTY_ENUMERATOR_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Boolean>&
+    NAN_PROPERTY_DELETER_ARGS_TYPE;
+typedef void NAN_PROPERTY_DELETER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Integer>&
+    NAN_PROPERTY_QUERY_ARGS_TYPE;
+typedef void NAN_PROPERTY_QUERY_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Value>& NAN_INDEX_GETTER_ARGS_TYPE;
+typedef void NAN_INDEX_GETTER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Value>& NAN_INDEX_SETTER_ARGS_TYPE;
+typedef void NAN_INDEX_SETTER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Array>&
+    NAN_INDEX_ENUMERATOR_ARGS_TYPE;
+typedef void NAN_INDEX_ENUMERATOR_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Boolean>&
+    NAN_INDEX_DELETER_ARGS_TYPE;
+typedef void NAN_INDEX_DELETER_RETURN_TYPE;
+
+typedef const NanPropertyCallbackInfo<v8::Integer>&
+    NAN_INDEX_QUERY_ARGS_TYPE;
+typedef void NAN_INDEX_QUERY_RETURN_TYPE;
+
+#define NAN_METHOD(name) NAN_METHOD_RETURN_TYPE name(NAN_METHOD_ARGS_TYPE info)
 #define NAN_GETTER(name)                                                       \
     NAN_GETTER_RETURN_TYPE name(                                               \
         v8::Local<v8::String> property                                         \
-      , NAN_GETTER_ARGS_TYPE args)
+      , NAN_GETTER_ARGS_TYPE info)
 #define NAN_SETTER(name)                                                       \
     NAN_SETTER_RETURN_TYPE name(                                               \
         v8::Local<v8::String> property                                         \
       , v8::Local<v8::Value> value                                             \
-      , NAN_SETTER_ARGS_TYPE args)
+      , NAN_SETTER_ARGS_TYPE info)
 #define NAN_PROPERTY_GETTER(name)                                              \
     NAN_PROPERTY_GETTER_RETURN_TYPE name(                                      \
         v8::Local<v8::String> property                                         \
-      , NAN_PROPERTY_GETTER_ARGS_TYPE args)
+      , NAN_PROPERTY_GETTER_ARGS_TYPE info)
 #define NAN_PROPERTY_SETTER(name)                                              \
     NAN_PROPERTY_SETTER_RETURN_TYPE name(                                      \
         v8::Local<v8::String> property                                         \
       , v8::Local<v8::Value> value                                             \
-      , NAN_PROPERTY_SETTER_ARGS_TYPE args)
+      , NAN_PROPERTY_SETTER_ARGS_TYPE info)
 #define NAN_PROPERTY_ENUMERATOR(name)                                          \
     NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(                                  \
-        NAN_PROPERTY_ENUMERATOR_ARGS_TYPE args)
+        NAN_PROPERTY_ENUMERATOR_ARGS_TYPE info)
 #define NAN_PROPERTY_DELETER(name)                                             \
     NAN_PROPERTY_DELETER_RETURN_TYPE name(                                     \
         v8::Local<v8::String> property                                         \
-      , NAN_PROPERTY_DELETER_ARGS_TYPE args)
+      , NAN_PROPERTY_DELETER_ARGS_TYPE info)
 #define NAN_PROPERTY_QUERY(name)                                               \
     NAN_PROPERTY_QUERY_RETURN_TYPE name(                                       \
         v8::Local<v8::String> property                                         \
-      , NAN_PROPERTY_QUERY_ARGS_TYPE args)
+      , NAN_PROPERTY_QUERY_ARGS_TYPE info)
 # define NAN_INDEX_GETTER(name)                                                \
     NAN_INDEX_GETTER_RETURN_TYPE name(                                         \
         uint32_t index                                                         \
-      , NAN_INDEX_GETTER_ARGS_TYPE args)
+      , NAN_INDEX_GETTER_ARGS_TYPE info)
 #define NAN_INDEX_SETTER(name)                                                 \
     NAN_INDEX_SETTER_RETURN_TYPE name(                                         \
         uint32_t index                                                         \
       , v8::Local<v8::Value> value                                             \
-      , NAN_INDEX_SETTER_ARGS_TYPE args)
+      , NAN_INDEX_SETTER_ARGS_TYPE info)
 #define NAN_INDEX_ENUMERATOR(name)                                             \
-    NAN_INDEX_ENUMERATOR_RETURN_TYPE name(NAN_INDEX_ENUMERATOR_ARGS_TYPE args)
+    NAN_INDEX_ENUMERATOR_RETURN_TYPE name(NAN_INDEX_ENUMERATOR_ARGS_TYPE info)
 #define NAN_INDEX_DELETER(name)                                                \
     NAN_INDEX_DELETER_RETURN_TYPE name(                                        \
         uint32_t index                                                         \
-      , NAN_INDEX_DELETER_ARGS_TYPE args)
+      , NAN_INDEX_DELETER_ARGS_TYPE info)
 #define NAN_INDEX_QUERY(name)                                                  \
     NAN_INDEX_QUERY_RETURN_TYPE name(                                          \
         uint32_t index                                                         \
-      , NAN_INDEX_QUERY_ARGS_TYPE args)
+      , NAN_INDEX_QUERY_ARGS_TYPE info)
 
 class NanCallback {
  public:
@@ -1633,7 +1578,7 @@ IsExternal(v8::Local<v8::String> str) {
 
 namespace Nan {
   enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
-}
+}  // end of namespace Nan
 
 #if NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION
 # include "nan_string_bytes.h"  // NOLINT(build/include)
@@ -1748,6 +1693,288 @@ NAN_INLINE void NanSetInstanceTemplate(
   NanSetTemplate(templ->InstanceTemplate(), name, value, attributes);
 }
 
+template<typename T>
+NAN_INLINE void NanSetMethod(
+    const T &recv
+  , const char *name
+  , NanFunctionCallback callback) {
+  NanScope scope;
+  v8::Local<v8::Function> fn = NanNew<v8::FunctionTemplate>(
+      callback)->GetFunction();
+  v8::Local<v8::String> fn_name = NanNew(name);
+  fn->SetName(fn_name);
+  recv->Set(fn_name, fn);
+}
+
+NAN_INLINE void NanSetPrototypeMethod(
+    v8::Handle<v8::FunctionTemplate> recv
+  , const char* name, NanFunctionCallback callback) {
+  NanScope scope;
+  v8::Local<v8::Function> fn = NanNew<v8::FunctionTemplate>(
+      callback
+    , v8::Handle<v8::Value>()
+    , NanNew<v8::Signature>(recv))->GetFunction();
+  v8::Local<v8::String> fn_name = NanNew(name);
+  recv->PrototypeTemplate()->Set(fn_name, fn);
+  fn->SetName(fn_name);
+}
+
+//=== Accessors and Such =======================================================
+
+inline void NanSetAccessor(
+    v8::Handle<v8::ObjectTemplate> tpl
+  , v8::Handle<v8::String> name
+  , NanGetterCallback getter
+  , NanSetterCallback setter = 0
+  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
+  , v8::AccessControl settings = v8::DEFAULT
+  , v8::PropertyAttribute attribute = v8::None
+  , Nan::imp::Sig signature = Nan::imp::Sig()) {
+  NanScope scope;
+
+  Nan::imp::NativeGetter getter_ =
+      Nan::imp::GetterCallbackWrapper;
+  Nan::imp::NativeSetter setter_ =
+      setter ? Nan::imp::SetterCallbackWrapper : 0;
+
+  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  otpl->SetInternalFieldCount(Nan::imp::kAccessorFieldCount);
+  v8::Local<v8::Object> obj = otpl->NewInstance();
+  NanSetInternalFieldPointer(
+      obj
+    , Nan::imp::kGetterIndex
+    , Nan::imp::GetWrapper<NanGetterCallback, Nan::imp::GetterWrapper>(getter));
+  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+
+  if (setter != 0) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kSetterIndex
+      , Nan::imp::GetWrapper<NanSetterCallback,
+            Nan::imp::SetterWrapper>(setter));
+  }
+
+  if (!val.IsEmpty()) {
+    obj->SetInternalField(Nan::imp::kDataIndex, val);
+  }
+
+  tpl->SetAccessor(
+      name
+    , getter_
+    , setter_
+    , obj
+    , settings
+    , attribute
+    , signature);
+}
+
+inline bool NanSetAccessor(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> name
+  , NanGetterCallback getter
+  , NanSetterCallback setter = 0
+  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
+  , v8::AccessControl settings = v8::DEFAULT
+  , v8::PropertyAttribute attribute = v8::None) {
+  NanEscapableScope scope;
+
+  Nan::imp::NativeGetter getter_ =
+      Nan::imp::GetterCallbackWrapper;
+  Nan::imp::NativeSetter setter_ =
+      setter ? Nan::imp::SetterCallbackWrapper : 0;
+
+  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  otpl->SetInternalFieldCount(Nan::imp::kAccessorFieldCount);
+  v8::Local<v8::Object> dataobj = otpl->NewInstance();
+  NanSetInternalFieldPointer(
+      dataobj
+    , Nan::imp::kGetterIndex
+    , Nan::imp::GetWrapper<NanGetterCallback, Nan::imp::GetterWrapper>(getter));
+  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+
+  if (!val.IsEmpty()) {
+    dataobj->SetInternalField(Nan::imp::kDataIndex, val);
+  }
+
+  if (setter) {
+    NanSetInternalFieldPointer(
+        dataobj
+      , Nan::imp::kPropertySetterIndex
+      , Nan::imp::GetWrapper<NanSetterCallback,
+            Nan::imp::SetterWrapper>(setter));
+  }
+
+  return obj->SetAccessor(
+      name
+    , getter_
+    , setter_
+    , dataobj
+    , settings
+    , attribute);
+}
+
+inline void NanSetNamedPropertyHandler(
+    v8::Handle<v8::ObjectTemplate> tpl
+  , NanPropertyGetterCallback getter
+  , NanPropertySetterCallback setter = 0
+  , NanPropertyQueryCallback query = 0
+  , NanPropertyDeleterCallback deleter = 0
+  , NanPropertyEnumeratorCallback enumerator = 0
+  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
+  NanScope scope;
+
+  Nan::imp::NativePropertyGetter getter_ =
+      Nan::imp::PropertyGetterCallbackWrapper;
+  Nan::imp::NativePropertySetter setter_ =
+      setter ? Nan::imp::PropertySetterCallbackWrapper : 0;
+  Nan::imp::NativePropertyQuery query_ =
+      query ? Nan::imp::PropertyQueryCallbackWrapper : 0;
+  Nan::imp::NativePropertyDeleter *deleter_ =
+      deleter ? Nan::imp::PropertyDeleterCallbackWrapper : 0;
+  Nan::imp::NativePropertyEnumerator enumerator_ =
+      enumerator ? Nan::imp::PropertyEnumeratorCallbackWrapper : 0;
+
+  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  otpl->SetInternalFieldCount(Nan::imp::kPropertyFieldCount);
+  v8::Local<v8::Object> obj = otpl->NewInstance();
+  NanSetInternalFieldPointer(
+      obj
+    , Nan::imp::kPropertyGetterIndex
+    , Nan::imp::GetWrapper<NanPropertyGetterCallback,
+          Nan::imp::PropertyGetterWrapper>(getter));
+  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+
+  if (setter) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kPropertySetterIndex
+      , Nan::imp::GetWrapper<NanPropertySetterCallback,
+            Nan::imp::PropertySetterWrapper>(setter));
+  }
+
+  if (query) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kPropertyQueryIndex
+      , Nan::imp::GetWrapper<NanPropertyQueryCallback,
+            Nan::imp::PropertyQueryWrapper>(query));
+  }
+
+  if (deleter) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kPropertyDeleterIndex
+      , Nan::imp::GetWrapper<NanPropertyDeleterCallback,
+            Nan::imp::PropertyDeleterWrapper>(deleter));
+  }
+
+  if (enumerator) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kPropertyEnumeratorIndex
+      , Nan::imp::GetWrapper<NanPropertyEnumeratorCallback,
+            Nan::imp::PropertyEnumeratorWrapper>(enumerator));
+  }
+
+  if (!val.IsEmpty()) {
+    obj->SetInternalField(Nan::imp::kDataIndex, val);
+  }
+
+#if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+  tpl->SetHandler(v8::NamedPropertyHandlerConfiguration(
+      getter_, setter_, query_, deleter_, enumerator_, obj));
+#else
+  tpl->SetNamedPropertyHandler(
+      getter_
+    , setter_
+    , query_
+    , deleter_
+    , enumerator_
+    , obj);
+#endif
+}
+
+inline void NanSetIndexedPropertyHandler(
+    v8::Handle<v8::ObjectTemplate> tpl
+  , NanIndexGetterCallback getter
+  , NanIndexSetterCallback setter = 0
+  , NanIndexQueryCallback query = 0
+  , NanIndexDeleterCallback deleter = 0
+  , NanIndexEnumeratorCallback enumerator = 0
+  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
+  NanScope scope;
+
+  Nan::imp::NativeIndexGetter getter_ =
+      Nan::imp::IndexGetterCallbackWrapper;
+  Nan::imp::NativeIndexSetter setter_ =
+      setter ? Nan::imp::IndexSetterCallbackWrapper : 0;
+  Nan::imp::NativeIndexQuery query_ =
+      query ? Nan::imp::IndexQueryCallbackWrapper : 0;
+  Nan::imp::NativeIndexDeleter deleter_ =
+      deleter ? Nan::imp::IndexDeleterCallbackWrapper : 0;
+  Nan::imp::NativeIndexEnumerator enumerator_ =
+      enumerator ? Nan::imp::IndexEnumeratorCallbackWrapper : 0;
+
+  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  otpl->SetInternalFieldCount(Nan::imp::kIndexPropertyFieldCount);
+  v8::Local<v8::Object> obj = otpl->NewInstance();
+  NanSetInternalFieldPointer(
+      obj
+    , Nan::imp::kIndexPropertyGetterIndex
+    , Nan::imp::GetWrapper<NanIndexGetterCallback,
+          Nan::imp::IndexGetterWrapper>(getter));
+  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+
+  if (setter) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kIndexPropertySetterIndex
+      , Nan::imp::GetWrapper<NanIndexSetterCallback,
+            Nan::imp::IndexSetterWrapper>(setter));
+  }
+
+  if (query) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kIndexPropertyQueryIndex
+      , Nan::imp::GetWrapper<NanIndexQueryCallback,
+            Nan::imp::IndexQueryWrapper>(query));
+  }
+
+  if (deleter) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kIndexPropertyDeleterIndex
+      , Nan::imp::GetWrapper<NanIndexDeleterCallback,
+            Nan::imp::IndexDeleterWrapper>(deleter));
+  }
+
+  if (enumerator) {
+    NanSetInternalFieldPointer(
+        obj
+      , Nan::imp::kIndexPropertyEnumeratorIndex
+      , Nan::imp::GetWrapper<NanIndexEnumeratorCallback,
+            Nan::imp::IndexEnumeratorWrapper>(enumerator));
+  }
+
+  if (!val.IsEmpty()) {
+    obj->SetInternalField(Nan::imp::kDataIndex, val);
+  }
+
+#if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+  tpl->SetHandler(v8::IndexedPropertyHandlerConfiguration(
+      getter_, setter_, query_, deleter_, enumerator_, obj));
+#else
+  tpl->SetIndexedPropertyHandler(
+      getter_
+    , setter_
+    , query_
+    , deleter_
+    , enumerator_
+    , obj);
+#endif
+}
+
 //=== ObjectWrap ===============================================================
 
 class NanObjectWrap : public node::ObjectWrap {
@@ -1793,6 +2020,12 @@ struct NanTap {
     NanMakeCallback(NanNew(t_), "ok", msg ? 2 : 1, args);
   }
 
+  inline void pass(const char * msg = NULL) {
+    v8::Handle<v8::Value> hmsg;
+    if (msg) hmsg = NanNew(msg);
+    NanMakeCallback(NanNew(t_), "pass", msg ? 1 : 0, &hmsg);
+  }
+
  private:
   NanPersistent<v8::Object> t_;
 };
@@ -1802,8 +2035,6 @@ struct NanTap {
 #define NAN_TEST_EXPRESSION(expression) \
   ( expression ), __FILE__ ":" NAN_STRINGIZE(__LINE__) ": " #expression
 
-#define return_NanValue(v) NanReturnValue(v)
-#define return_NanUndefined() NanReturnUndefined()
 #define NAN_EXPORT(target, function) NanExport(target, #function, function)
 
 #undef TYPE_CHECK
diff --git a/nan_callbacks.h b/nan_callbacks.h
new file mode 100644
index 00000000..77ac18de
--- /dev/null
+++ b/nan_callbacks.h
@@ -0,0 +1,133 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_CALLBACKS_H_
+#define NAN_CALLBACKS_H_
+
+#if defined(_MSC_VER)
+# pragma warning( push )
+# pragma warning( disable : 4530 )
+# include <map>
+# pragma warning( pop )
+#else
+# include <map>
+#endif
+
+template<typename T> class NanFunctionCallbackInfo;
+template<typename T> class NanPropertyCallbackInfo;
+template<typename T> class NanGlobal;
+
+typedef void(*NanFunctionCallback)(const NanFunctionCallbackInfo<v8::Value>&);
+typedef void(*NanGetterCallback)
+    (v8::Local<v8::String>, const NanPropertyCallbackInfo<v8::Value>&);
+typedef void(*NanSetterCallback)(
+    v8::Local<v8::String>,
+    v8::Local<v8::Value>,
+    const NanPropertyCallbackInfo<void>&);
+typedef void(*NanPropertyGetterCallback)(
+    v8::Local<v8::String>,
+    const NanPropertyCallbackInfo<v8::Value>&);
+typedef void(*NanPropertySetterCallback)(
+    v8::Local<v8::String>,
+    v8::Local<v8::Value>,
+    const NanPropertyCallbackInfo<v8::Value>&);
+typedef void(*NanPropertyEnumeratorCallback)
+    (const NanPropertyCallbackInfo<v8::Array>&);
+typedef void(*NanPropertyDeleterCallback)(
+    v8::Local<v8::String>,
+    const NanPropertyCallbackInfo<v8::Boolean>&);
+typedef void(*NanPropertyQueryCallback)(
+    v8::Local<v8::String>,
+    const NanPropertyCallbackInfo<v8::Integer>&);
+typedef void(*NanIndexGetterCallback)(
+    uint32_t,
+    const NanPropertyCallbackInfo<v8::Value>&);
+typedef void(*NanIndexSetterCallback)(
+    uint32_t,
+    v8::Local<v8::Value>,
+    const NanPropertyCallbackInfo<v8::Value>&);
+typedef void(*NanIndexEnumeratorCallback)
+    (const NanPropertyCallbackInfo<v8::Array>&);
+typedef void(*NanIndexDeleterCallback)(
+    uint32_t,
+    const NanPropertyCallbackInfo<v8::Boolean>&);
+typedef void(*NanIndexQueryCallback)(
+    uint32_t,
+    const NanPropertyCallbackInfo<v8::Integer>&);
+
+namespace Nan { namespace imp {
+typedef v8::Handle<v8::AccessorSignature> Sig;
+
+#define X(NAME)                                                                \
+struct NAME ## Wrapper {                                                       \
+  explicit NAME ## Wrapper(Nan ## NAME ## Callback callback_) :                \
+      callback(callback_) {}                                                   \
+  Nan ## NAME ## Callback callback;                                            \
+};
+
+X(Function)
+X(Getter)
+X(Setter)
+X(PropertyGetter)
+X(PropertySetter)
+X(PropertyEnumerator)
+X(PropertyDeleter)
+X(PropertyQuery)
+X(IndexGetter)
+X(IndexSetter)
+X(IndexEnumerator)
+X(IndexDeleter)
+X(IndexQuery)
+
+#undef X
+
+static const int kDataIndex =                    0;
+
+static const int kFunctionIndex =                1;
+static const int kFunctionFieldCount =           2;
+
+static const int kGetterIndex =                  1;
+static const int kSetterIndex =                  2;
+static const int kAccessorFieldCount =           3;
+
+static const int kPropertyGetterIndex =          1;
+static const int kPropertySetterIndex =          2;
+static const int kPropertyEnumeratorIndex =      3;
+static const int kPropertyDeleterIndex =         4;
+static const int kPropertyQueryIndex =           5;
+static const int kPropertyFieldCount =           6;
+
+static const int kIndexPropertyGetterIndex =     1;
+static const int kIndexPropertySetterIndex =     2;
+static const int kIndexPropertyEnumeratorIndex = 3;
+static const int kIndexPropertyDeleterIndex =    4;
+static const int kIndexPropertyQueryIndex =      5;
+static const int kIndexPropertyFieldCount =      6;
+
+template<typename T, typename P>
+P *GetWrapper(T needle) {
+  static std::map<T, P*> haystack;
+  typename std::map<T, P*>::iterator it =
+      haystack.find(needle);
+
+  if (it == haystack.end()) {
+    return haystack.insert(it, std::make_pair(needle, new P(needle)))->second;
+  } else {
+    return it->second;
+  }
+}
+}  // end of namespace imp
+}  // end of namespace Nan
+
+#if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+# include "nan_callbacks_12_inl.h"  // NOLINT(build/include)
+#else
+# include "nan_callbacks_pre_12_inl.h"  // NOLINT(build/include)
+#endif
+
+#endif  // NAN_CALLBACKS_H_
diff --git a/nan_callbacks_12_inl.h b/nan_callbacks_12_inl.h
new file mode 100644
index 00000000..6740796e
--- /dev/null
+++ b/nan_callbacks_12_inl.h
@@ -0,0 +1,472 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_CALLBACKS_12_INL_H_
+#define NAN_CALLBACKS_12_INL_H_
+
+template<typename T>
+class NanReturnValue {
+  v8::ReturnValue<T> value_;
+
+ public:
+  template <class S>
+  explicit inline NanReturnValue(const v8::ReturnValue<S> &value) :
+      value_(value) {}
+  template <class S>
+  explicit inline NanReturnValue(const NanReturnValue<S>& that)
+      : value_(that.value_) {
+    TYPE_CHECK(T, S);
+  }
+
+  // Handle setters
+  template <typename S> inline void Set(const v8::Handle<S> &handle) {
+    TYPE_CHECK(T, S);
+    value_.Set(handle);
+  }
+
+  template <typename S> inline void Set(const NanGlobal<S> &handle) {
+    TYPE_CHECK(T, S);
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) &&                       \
+  (V8_MINOR_VERSION > 5 || (V8_MINOR_VERSION == 5 &&                           \
+  defined(V8_BUILD_NUMBER) && V8_BUILD_NUMBER >= 8))))
+    value_.Set(handle);
+#else
+    value_.Set(*reinterpret_cast<const v8::Persistent<S>*>(&handle));
+    const_cast<NanGlobal<S> &>(handle).Reset();
+#endif
+  }
+
+  // Fast primitive setters
+  inline void Set(bool value) {
+    TYPE_CHECK(T, v8::Boolean);
+    value_.Set(value);
+  }
+
+  inline void Set(double i) {
+    TYPE_CHECK(T, v8::Number);
+    value_.Set(i);
+  }
+
+  inline void Set(int32_t i) {
+    TYPE_CHECK(T, v8::Integer);
+    value_.Set(i);
+  }
+
+  inline void Set(uint32_t i) {
+    TYPE_CHECK(T, v8::Integer);
+    value_.Set(i);
+  }
+
+  // Fast JS primitive setters
+  inline void SetNull() {
+    TYPE_CHECK(T, v8::Primitive);
+    value_.SetNull();
+  }
+
+  inline void SetUndefined() {
+    TYPE_CHECK(T, v8::Primitive);
+    value_.SetUndefined();
+  }
+
+  inline void SetEmptyString() {
+    TYPE_CHECK(T, v8::String);
+    value_.SetEmptyString();
+  }
+
+  // Convenience getter for isolate
+  inline v8::Isolate *GetIsolate() const {
+    return value_.GetIsolate();
+  }
+
+  // Pointer setter: Uncompilable to prevent inadvertent misuse.
+  template<typename S>
+  inline void Set(S *whatever) { TYPE_CHECK(S*, v8::Primitive); }
+};
+
+template<typename T>
+class NanFunctionCallbackInfo {
+  const v8::FunctionCallbackInfo<T> &info_;
+  const v8::Local<v8::Value> data_;
+
+ public:
+  explicit inline NanFunctionCallbackInfo(
+      const v8::FunctionCallbackInfo<T> &info
+    , v8::Local<v8::Value> data) :
+          info_(info)
+        , data_(data) {}
+
+  inline NanReturnValue<T> GetReturnValue() const {
+    return NanReturnValue<T>(info_.GetReturnValue());
+  }
+
+  inline v8::Local<v8::Function> Callee() const { return info_.Callee(); }
+  inline v8::Local<v8::Value> Data() const { return data_; }
+  inline v8::Local<v8::Object> Holder() const { return info_.Holder(); }
+  inline bool IsConstructCall() const { return info_.IsConstructCall(); }
+  inline int Length() const { return info_.Length(); }
+  inline v8::Local<v8::Value> operator[](int i) const { return info_[i]; }
+  inline v8::Local<v8::Object> This() const { return info_.This(); }
+  inline v8::Isolate *GetIsolate() const { return info_.GetIsolate(); }
+
+
+ protected:
+  static const int kHolderIndex = 0;
+  static const int kIsolateIndex = 1;
+  static const int kReturnValueDefaultValueIndex = 2;
+  static const int kReturnValueIndex = 3;
+  static const int kDataIndex = 4;
+  static const int kCalleeIndex = 5;
+  static const int kContextSaveIndex = 6;
+  static const int kArgsLength = 7;
+};
+
+template<typename T>
+class NanPropertyCallbackInfo {
+  const v8::PropertyCallbackInfo<T> &info_;
+  const v8::Local<v8::Value> data_;
+
+ public:
+  explicit inline NanPropertyCallbackInfo(
+      const v8::PropertyCallbackInfo<T> &info
+    , const v8::Local<v8::Value> &data) :
+          info_(info)
+        , data_(data) {}
+
+  inline v8::Isolate* GetIsolate() const { return info_.GetIsolate(); }
+  inline v8::Local<v8::Value> Data() const { return data_; }
+  inline v8::Local<v8::Object> This() const { return info_.This(); }
+  inline v8::Local<v8::Object> Holder() const { return info_.Holder(); }
+  inline NanReturnValue<T> GetReturnValue() const {
+    return NanReturnValue<T>(info_.GetReturnValue());
+  }
+
+ protected:
+  static const int kHolderIndex = 0;
+  static const int kIsolateIndex = 1;
+  static const int kReturnValueDefaultValueIndex = 2;
+  static const int kReturnValueIndex = 3;
+  static const int kDataIndex = 4;
+  static const int kThisIndex = 5;
+  static const int kArgsLength = 6;
+};
+
+namespace Nan { namespace imp {
+static
+void FunctionCallbackWrapper(const v8::FunctionCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  FunctionWrapper *wrapper = static_cast<FunctionWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kFunctionIndex));
+  NanFunctionCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  wrapper->callback(cbinfo);
+}
+
+typedef void (*NativeFunction)(const v8::FunctionCallbackInfo<v8::Value> &);
+
+#if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+static
+void GetterCallbackWrapper(
+    v8::Local<v8::Name> property
+  , const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  GetterWrapper *wrapper = static_cast<GetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kGetterIndex));
+  wrapper->callback(property.As<v8::String>(), cbinfo);
+}
+
+typedef void (*NativeGetter)
+    (v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void SetterCallbackWrapper(
+    v8::Local<v8::Name> property
+  , v8::Local<v8::Value> value
+  , const v8::PropertyCallbackInfo<void> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<void>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  SetterWrapper *wrapper = static_cast<SetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kSetterIndex));
+  wrapper->callback(property.As<v8::String>(), value, cbinfo);
+}
+
+typedef void (*NativeSetter)(
+    v8::Local<v8::Name>
+  , v8::Local<v8::Value>
+  , const v8::PropertyCallbackInfo<void> &);
+#else
+static
+void GetterCallbackWrapper(
+    v8::Local<v8::String> property
+  , const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  GetterWrapper *wrapper = static_cast<GetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kGetterIndex));
+  wrapper->callback(property, cbinfo);
+}
+
+typedef void (*NativeGetter)
+    (v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void SetterCallbackWrapper(
+    v8::Local<v8::String> property
+  , v8::Local<v8::Value> value
+  , const v8::PropertyCallbackInfo<void> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<void>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  SetterWrapper *wrapper = static_cast<SetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kSetterIndex));
+  wrapper->callback(property, value, cbinfo);
+}
+
+typedef void (*NativeSetter)(
+    v8::Local<v8::String>
+  , v8::Local<v8::Value>
+  , const v8::PropertyCallbackInfo<void> &);
+#endif
+
+#if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+static
+void PropertyGetterCallbackWrapper(
+    v8::Local<v8::Name> property
+  , const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyGetterWrapper *wrapper = static_cast<PropertyGetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyGetterIndex));
+  wrapper->callback(property.As<v8::String>(), cbinfo);
+}
+
+typedef void (*NativePropertyGetter)
+    (v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void PropertySetterCallbackWrapper(
+    v8::Local<v8::Name> property
+  , v8::Local<v8::Value> value
+  , const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertySetterWrapper *wrapper = static_cast<PropertySetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertySetterIndex));
+  wrapper->callback(property.As<v8::String>(), value, cbinfo);
+}
+
+typedef void (*NativePropertySetter)(
+    v8::Local<v8::Name>
+  , v8::Local<v8::Value>
+  , const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void PropertyEnumeratorCallbackWrapper(
+    const v8::PropertyCallbackInfo<v8::Array> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Array>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyEnumeratorWrapper *wrapper = static_cast<PropertyEnumeratorWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyEnumeratorIndex));
+  wrapper->callback(cbinfo);
+}
+
+typedef void (*NativePropertyEnumerator)
+    (const v8::PropertyCallbackInfo<v8::Array> &);
+
+static
+void PropertyDeleterCallbackWrapper(
+    v8::Local<v8::Name> property
+  , const v8::PropertyCallbackInfo<v8::Boolean> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Boolean>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyDeleterWrapper *wrapper = static_cast<PropertyDeleterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyDeleterIndex));
+  wrapper->callback(property.As<v8::String>(), cbinfo);
+}
+
+typedef void (NativePropertyDeleter)
+    (v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Boolean> &);
+
+static
+void PropertyQueryCallbackWrapper(
+    v8::Local<v8::Name> property
+  , const v8::PropertyCallbackInfo<v8::Integer> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Integer>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyQueryWrapper *wrapper = static_cast<PropertyQueryWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyQueryIndex));
+  wrapper->callback(property.As<v8::String>(), cbinfo);
+}
+
+typedef void (*NativePropertyQuery)
+    (v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Integer> &);
+#else
+static
+void PropertyGetterCallbackWrapper(
+    v8::Local<v8::String> property
+  , const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyGetterWrapper *wrapper = static_cast<PropertyGetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyGetterIndex));
+  wrapper->callback(property, cbinfo);
+}
+
+typedef void (*NativePropertyGetter)
+    (v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void PropertySetterCallbackWrapper(
+    v8::Local<v8::String> property
+  , v8::Local<v8::Value> value
+  , const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertySetterWrapper *wrapper = static_cast<PropertySetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertySetterIndex));
+  wrapper->callback(property, value, cbinfo);
+}
+
+typedef void (*NativePropertySetter)(
+    v8::Local<v8::String>
+  , v8::Local<v8::Value>
+  , const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void PropertyEnumeratorCallbackWrapper(
+    const v8::PropertyCallbackInfo<v8::Array> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Array>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyEnumeratorWrapper *wrapper = static_cast<PropertyEnumeratorWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyEnumeratorIndex));
+  wrapper->callback(cbinfo);
+}
+
+typedef void (*NativePropertyEnumerator)
+    (const v8::PropertyCallbackInfo<v8::Array> &);
+
+static
+void PropertyDeleterCallbackWrapper(
+    v8::Local<v8::String> property
+  , const v8::PropertyCallbackInfo<v8::Boolean> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Boolean>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyDeleterWrapper *wrapper = static_cast<PropertyDeleterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyDeleterIndex));
+  wrapper->callback(property, cbinfo);
+}
+
+typedef void (NativePropertyDeleter)
+    (v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Boolean> &);
+
+static
+void PropertyQueryCallbackWrapper(
+    v8::Local<v8::String> property
+  , const v8::PropertyCallbackInfo<v8::Integer> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Integer>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyQueryWrapper *wrapper = static_cast<PropertyQueryWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kPropertyQueryIndex));
+  wrapper->callback(property, cbinfo);
+}
+
+typedef void (*NativePropertyQuery)
+    (v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Integer> &);
+#endif
+
+static
+void IndexGetterCallbackWrapper(
+    uint32_t index, const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexGetterWrapper *wrapper = static_cast<IndexGetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kIndexPropertyGetterIndex));
+  wrapper->callback(index, cbinfo);
+}
+
+typedef void (*NativeIndexGetter)
+    (uint32_t, const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void IndexSetterCallbackWrapper(
+    uint32_t index
+  , v8::Local<v8::Value> value
+  , const v8::PropertyCallbackInfo<v8::Value> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexSetterWrapper *wrapper = static_cast<IndexSetterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kIndexPropertySetterIndex));
+  wrapper->callback(index, value, cbinfo);
+}
+
+typedef void (*NativeIndexSetter)(
+    uint32_t
+  , v8::Local<v8::Value>
+  , const v8::PropertyCallbackInfo<v8::Value> &);
+
+static
+void IndexEnumeratorCallbackWrapper(
+    const v8::PropertyCallbackInfo<v8::Array> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Array>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexEnumeratorWrapper *wrapper = static_cast<IndexEnumeratorWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kIndexPropertyEnumeratorIndex));
+  wrapper->callback(cbinfo);
+}
+
+typedef void (*NativeIndexEnumerator)
+    (const v8::PropertyCallbackInfo<v8::Array> &);
+
+static
+void IndexDeleterCallbackWrapper(
+    uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Boolean>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexDeleterWrapper *wrapper = static_cast<IndexDeleterWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kIndexPropertyDeleterIndex));
+  wrapper->callback(index, cbinfo);
+}
+
+typedef void (*NativeIndexDeleter)
+    (uint32_t, const v8::PropertyCallbackInfo<v8::Boolean> &);
+
+static
+void IndexQueryCallbackWrapper(
+    uint32_t index, const v8::PropertyCallbackInfo<v8::Integer> &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Integer>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexQueryWrapper *wrapper = static_cast<IndexQueryWrapper*>(
+      obj->GetAlignedPointerFromInternalField(kIndexPropertyQueryIndex));
+  wrapper->callback(index, cbinfo);
+}
+
+typedef void (*NativeIndexQuery)
+    (uint32_t, const v8::PropertyCallbackInfo<v8::Integer> &);
+}  // end of namespace imp
+}  // end of namespace Nan
+
+#endif  // NAN_CALLBACKS_12_INL_H_
diff --git a/nan_callbacks_pre_12_inl.h b/nan_callbacks_pre_12_inl.h
new file mode 100644
index 00000000..5394206c
--- /dev/null
+++ b/nan_callbacks_pre_12_inl.h
@@ -0,0 +1,450 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_CALLBACKS_PRE_12_INL_H_
+#define NAN_CALLBACKS_PRE_12_INL_H_
+
+namespace Nan { namespace imp {
+template<typename T> class NanReturnValueImp;
+}  // end of namespace imp
+}  // end of namespace Nan
+
+template<typename T>
+class NanReturnValue {
+  v8::Isolate *isolate_;
+  v8::Persistent<T> *value_;
+  friend class Nan::imp::NanReturnValueImp<T>;
+
+ public:
+  template <class S>
+  explicit inline NanReturnValue(v8::Isolate *isolate, v8::Persistent<S> *p) :
+      isolate_(isolate), value_(p) {}
+  template <class S>
+  explicit inline NanReturnValue(const NanReturnValue<S>& that)
+      : isolate_(that.isolate_), value_(that.value_) {
+    TYPE_CHECK(T, S);
+  }
+
+  // Handle setters
+  template <typename S> inline void Set(const v8::Handle<S> &handle) {
+    TYPE_CHECK(T, S);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(handle);
+  }
+
+  template <typename S> inline void Set(const NanGlobal<S> &handle) {
+    TYPE_CHECK(T, S);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(handle.persistent);
+    const_cast<NanGlobal<S> &>(handle).Reset();
+  }
+
+  // Fast primitive setters
+  inline void Set(bool value) {
+    TYPE_CHECK(T, v8::Boolean);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(v8::Boolean::New(value));
+  }
+
+  inline void Set(double i) {
+    TYPE_CHECK(T, v8::Number);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(v8::Number::New(i));
+  }
+
+  inline void Set(int32_t i) {
+    TYPE_CHECK(T, v8::Integer);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(v8::Int32::New(i));
+  }
+
+  inline void Set(uint32_t i) {
+    TYPE_CHECK(T, v8::Integer);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(v8::Uint32::New(i));
+  }
+
+  // Fast JS primitive setters
+  inline void SetNull() {
+    TYPE_CHECK(T, v8::Primitive);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(v8::Null());
+  }
+
+  inline void SetUndefined() {
+    TYPE_CHECK(T, v8::Primitive);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(v8::Undefined());
+  }
+
+  inline void SetEmptyString() {
+    TYPE_CHECK(T, v8::String);
+    value_->Dispose();
+    *value_ = v8::Persistent<T>::New(v8::String::Empty());
+  }
+
+  // Convenience getter for isolate
+  inline v8::Isolate *GetIsolate() const {
+    return isolate_;
+  }
+
+  // Pointer setter: Uncompilable to prevent inadvertent misuse.
+  template<typename S>
+  inline void Set(S *whatever) { TYPE_CHECK(S*, v8::Primitive); }
+};
+
+template<typename T>
+class NanFunctionCallbackInfo {
+  const v8::Arguments &args_;
+  v8::Local<v8::Value> data_;
+  NanReturnValue<T> return_value_;
+  v8::Persistent<T> retval_;
+
+ public:
+  explicit inline NanFunctionCallbackInfo(
+      const v8::Arguments &args
+    , v8::Local<v8::Value> data) :
+          args_(args)
+        , data_(data)
+        , return_value_(args.GetIsolate(), &retval_)
+        , retval_(v8::Persistent<T>::New(v8::Undefined())) {}
+
+  inline NanReturnValue<T> GetReturnValue() const {
+    return NanReturnValue<T>(return_value_);
+  }
+
+  inline v8::Local<v8::Function> Callee() const { return args_.Callee(); }
+  inline v8::Local<v8::Value> Data() const { return data_; }
+  inline v8::Local<v8::Object> Holder() const { return args_.Holder(); }
+  inline bool IsConstructCall() const { return args_.IsConstructCall(); }
+  inline int Length() const { return args_.Length(); }
+  inline v8::Local<v8::Value> operator[](int i) const { return args_[i]; }
+  inline v8::Local<v8::Object> This() const { return args_.This(); }
+  inline v8::Isolate *GetIsolate() const { return args_.GetIsolate(); }
+
+
+ protected:
+  static const int kHolderIndex = 0;
+  static const int kIsolateIndex = 1;
+  static const int kReturnValueDefaultValueIndex = 2;
+  static const int kReturnValueIndex = 3;
+  static const int kDataIndex = 4;
+  static const int kCalleeIndex = 5;
+  static const int kContextSaveIndex = 6;
+  static const int kArgsLength = 7;
+};
+
+template<typename T>
+class NanPropertyCallbackInfoBase {
+  const v8::AccessorInfo &info_;
+  const v8::Local<v8::Value> &data_;
+
+ public:
+  explicit inline NanPropertyCallbackInfoBase(
+      const v8::AccessorInfo &info
+    , const v8::Local<v8::Value> &data) :
+          info_(info)
+        , data_(data) {}
+
+  inline v8::Isolate* GetIsolate() const { return info_.GetIsolate(); }
+  inline v8::Local<v8::Value> Data() const { return data_; }
+  inline v8::Local<v8::Object> This() const { return info_.This(); }
+  inline v8::Local<v8::Object> Holder() const { return info_.Holder(); }
+
+ protected:
+  static const int kHolderIndex = 0;
+  static const int kIsolateIndex = 1;
+  static const int kReturnValueDefaultValueIndex = 2;
+  static const int kReturnValueIndex = 3;
+  static const int kDataIndex = 4;
+  static const int kThisIndex = 5;
+  static const int kArgsLength = 6;
+};
+
+template<typename T>
+class NanPropertyCallbackInfo : public NanPropertyCallbackInfoBase<T> {
+  NanReturnValue<T> return_value_;
+  v8::Persistent<T> retval_;
+
+ public:
+  explicit inline NanPropertyCallbackInfo(
+      const v8::AccessorInfo &info
+    , const v8::Local<v8::Value> &data) :
+          NanPropertyCallbackInfoBase<T>(info, data)
+        , return_value_(info.GetIsolate(), &retval_)
+        , retval_(v8::Persistent<T>::New(v8::Undefined())) {}
+  inline NanReturnValue<T> GetReturnValue() const { return return_value_; }
+};
+
+template<>
+class NanPropertyCallbackInfo<v8::Array> :
+    public NanPropertyCallbackInfoBase<v8::Array> {
+  NanReturnValue<v8::Array> return_value_;
+  v8::Persistent<v8::Array> retval_;
+
+ public:
+  explicit inline NanPropertyCallbackInfo(
+      const v8::AccessorInfo &info
+    , const v8::Local<v8::Value> &data) :
+          NanPropertyCallbackInfoBase<v8::Array>(info, data)
+        , return_value_(info.GetIsolate(), &retval_)
+        , retval_(v8::Persistent<v8::Array>::New(v8::Local<v8::Array>())) {}
+  inline NanReturnValue<v8::Array> GetReturnValue() const {
+    return return_value_;
+  }
+};
+
+template<>
+class NanPropertyCallbackInfo<v8::Boolean> :
+    public NanPropertyCallbackInfoBase<v8::Boolean> {
+  NanReturnValue<v8::Boolean> return_value_;
+  v8::Persistent<v8::Boolean> retval_;
+
+ public:
+  explicit inline NanPropertyCallbackInfo(
+      const v8::AccessorInfo &info
+    , const v8::Local<v8::Value> &data) :
+          NanPropertyCallbackInfoBase<v8::Boolean>(info, data)
+        , return_value_(info.GetIsolate(), &retval_)
+        , retval_(v8::Persistent<v8::Boolean>::New(v8::Local<v8::Boolean>())) {}
+  inline NanReturnValue<v8::Boolean> GetReturnValue() const {
+    return return_value_;
+  }
+};
+
+template<>
+class NanPropertyCallbackInfo<v8::Integer> :
+    public NanPropertyCallbackInfoBase<v8::Integer> {
+  NanReturnValue<v8::Integer> return_value_;
+  v8::Persistent<v8::Integer> retval_;
+
+ public:
+  explicit inline NanPropertyCallbackInfo(
+      const v8::AccessorInfo &info
+    , const v8::Local<v8::Value> &data) :
+          NanPropertyCallbackInfoBase<v8::Integer>(info, data)
+        , return_value_(info.GetIsolate(), &retval_)
+        , retval_(v8::Persistent<v8::Integer>::New(v8::Local<v8::Integer>())) {}
+  inline NanReturnValue<v8::Integer> GetReturnValue() const {
+    return return_value_;
+  }
+};
+
+namespace Nan { namespace imp {
+template<typename T>
+class NanReturnValueImp : public NanReturnValue<T> {
+ public:
+  explicit NanReturnValueImp(NanReturnValue<T> that) :
+      NanReturnValue<T>(that) {}
+  NAN_INLINE v8::Handle<T> Value() {
+      return *NanReturnValue<T>::value_;
+  }
+};
+
+static
+v8::Handle<v8::Value> FunctionCallbackWrapper(const v8::Arguments &args) {
+  v8::Local<v8::Object> obj = args.Data().As<v8::Object>();
+  FunctionWrapper *wrapper = static_cast<FunctionWrapper*>(
+      obj->GetPointerFromInternalField(kFunctionIndex));
+  NanFunctionCallbackInfo<v8::Value>
+      cbinfo(args, obj->GetInternalField(kDataIndex));
+  wrapper->callback(cbinfo);
+  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Value> (*NativeFunction)(const v8::Arguments &);
+
+static
+v8::Handle<v8::Value> GetterCallbackWrapper(
+    v8::Local<v8::String> property, const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  GetterWrapper *wrapper = static_cast<GetterWrapper*>(
+      obj->GetPointerFromInternalField(kGetterIndex));
+  wrapper->callback(property, cbinfo);
+  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Value> (*NativeGetter)
+    (v8::Local<v8::String>, const v8::AccessorInfo &);
+
+static
+void SetterCallbackWrapper(
+    v8::Local<v8::String> property
+  , v8::Local<v8::Value> value
+  , const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<void>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  SetterWrapper *wrapper = static_cast<SetterWrapper*>(
+      obj->GetPointerFromInternalField(kSetterIndex));
+  wrapper->callback(property, value, cbinfo);
+}
+
+typedef void (*NativeSetter)
+    (v8::Local<v8::String>, v8::Local<v8::Value>, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Value> PropertyGetterCallbackWrapper(
+    v8::Local<v8::String> property, const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyGetterWrapper *wrapper = static_cast<PropertyGetterWrapper*>(
+      obj->GetPointerFromInternalField(kPropertyGetterIndex));
+  wrapper->callback(property, cbinfo);
+  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Value> (*NativePropertyGetter)
+    (v8::Local<v8::String>, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Value> PropertySetterCallbackWrapper(
+    v8::Local<v8::String> property
+  , v8::Local<v8::Value> value
+  , const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertySetterWrapper *wrapper = static_cast<PropertySetterWrapper*>(
+      obj->GetPointerFromInternalField(kPropertySetterIndex));
+  wrapper->callback(property, value, cbinfo);
+  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Value> (*NativePropertySetter)
+    (v8::Local<v8::String>, v8::Local<v8::Value>, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Array> PropertyEnumeratorCallbackWrapper(
+    const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Array>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyEnumeratorWrapper *wrapper = static_cast<PropertyEnumeratorWrapper*>(
+      obj->GetPointerFromInternalField(kPropertyEnumeratorIndex));
+  wrapper->callback(cbinfo);
+  return NanReturnValueImp<v8::Array>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Array> (*NativePropertyEnumerator)
+    (const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Boolean> PropertyDeleterCallbackWrapper(
+    v8::Local<v8::String> property
+  , const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Boolean>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyDeleterWrapper *wrapper = static_cast<PropertyDeleterWrapper*>(
+      obj->GetPointerFromInternalField(kPropertyDeleterIndex));
+  wrapper->callback(property, cbinfo);
+  return NanReturnValueImp<v8::Boolean>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Boolean> (NativePropertyDeleter)
+    (v8::Local<v8::String>, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Integer> PropertyQueryCallbackWrapper(
+    v8::Local<v8::String> property, const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Integer>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  PropertyQueryWrapper *wrapper = static_cast<PropertyQueryWrapper*>(
+      obj->GetPointerFromInternalField(kPropertyQueryIndex));
+  wrapper->callback(property, cbinfo);
+  return NanReturnValueImp<v8::Integer>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Integer> (*NativePropertyQuery)
+    (v8::Local<v8::String>, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Value> IndexGetterCallbackWrapper(
+    uint32_t index, const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexGetterWrapper *wrapper = static_cast<IndexGetterWrapper*>(
+      obj->GetPointerFromInternalField(kIndexPropertyGetterIndex));
+  wrapper->callback(index, cbinfo);
+  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Value> (*NativeIndexGetter)
+    (uint32_t, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Value> IndexSetterCallbackWrapper(
+    uint32_t index
+  , v8::Local<v8::Value> value
+  , const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Value>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexSetterWrapper *wrapper = static_cast<IndexSetterWrapper*>(
+      obj->GetPointerFromInternalField(kIndexPropertySetterIndex));
+  wrapper->callback(index, value, cbinfo);
+  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Value> (*NativeIndexSetter)
+    (uint32_t, v8::Local<v8::Value>, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Array> IndexEnumeratorCallbackWrapper(
+    const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Array>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexEnumeratorWrapper *wrapper = static_cast<IndexEnumeratorWrapper*>(
+      obj->GetPointerFromInternalField(kIndexPropertyEnumeratorIndex));
+  wrapper->callback(cbinfo);
+  return NanReturnValueImp<v8::Array>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Array> (*NativeIndexEnumerator)
+    (const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Boolean> IndexDeleterCallbackWrapper(
+    uint32_t index, const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Boolean>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexDeleterWrapper *wrapper = static_cast<IndexDeleterWrapper*>(
+      obj->GetPointerFromInternalField(kIndexPropertyDeleterIndex));
+  wrapper->callback(index, cbinfo);
+  return NanReturnValueImp<v8::Boolean>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Boolean> (*NativeIndexDeleter)
+    (uint32_t, const v8::AccessorInfo &);
+
+static
+v8::Handle<v8::Integer> IndexQueryCallbackWrapper(
+    uint32_t index, const v8::AccessorInfo &info) {
+  v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
+  NanPropertyCallbackInfo<v8::Integer>
+      cbinfo(info, obj->GetInternalField(kDataIndex));
+  IndexQueryWrapper *wrapper = static_cast<IndexQueryWrapper*>(
+      obj->GetPointerFromInternalField(kIndexPropertyQueryIndex));
+  wrapper->callback(index, cbinfo);
+  return NanReturnValueImp<v8::Integer>(cbinfo.GetReturnValue()).Value();
+}
+
+typedef v8::Handle<v8::Integer> (*NativeIndexQuery)
+    (uint32_t, const v8::AccessorInfo &);
+}  // end of namespace imp
+}  // end of namespace Nan
+
+#endif  // NAN_CALLBACKS_PRE_12_INL_H_
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index 60391ff3..8b5d206b 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -16,9 +16,11 @@
 # pragma warning( push )
 # pragma warning( disable : 4530 )
 # include <string>
+# include <map>
 # pragma warning( pop )
 #else
 # include <string>
+# include <map>
 #endif
 
 namespace Nan { namespace imp {
@@ -77,9 +79,26 @@ Factory<v8::External>::New(void * value) {
 Factory<v8::Function>::return_t
 Factory<v8::Function>::New( NanFunctionCallback callback
                           , v8::Handle<v8::Value> data) {
-  return v8::Function::New( v8::Isolate::GetCurrent()
-                          , callback
-                          , data);
+  v8::Isolate *isolate = v8::Isolate::GetCurrent();
+  v8::EscapableHandleScope scope(isolate);
+  static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
+  v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
+  tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+  v8::Local<v8::Object> obj = tpl->NewInstance();
+
+  obj->SetAlignedPointerInInternalField(
+      Nan::imp::kFunctionIndex
+    , Nan::imp::GetWrapper<NanFunctionCallback,
+          Nan::imp::FunctionWrapper>(callback));
+  v8::Local<v8::Value> val = v8::Local<v8::Value>::New(isolate, data);
+
+  if (!val.IsEmpty()) {
+    obj->SetInternalField(Nan::imp::kDataIndex, val);
+  }
+
+  return scope.Escape(v8::Function::New( isolate
+                          , Nan::imp::FunctionCallbackWrapper
+                          , obj));
 }
 
 //=== Function Template ========================================================
@@ -88,10 +107,27 @@ Factory<v8::FunctionTemplate>::return_t
 Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
                                   , v8::Handle<v8::Value> data
                                   , v8::Handle<v8::Signature> signature) {
-  return v8::FunctionTemplate::New( v8::Isolate::GetCurrent()
-                                  , callback
-                                  , data
-                                  , signature);
+  v8::Isolate *isolate = v8::Isolate::GetCurrent();
+  v8::EscapableHandleScope scope(isolate);
+  static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
+  v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
+  tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+  v8::Local<v8::Object> obj = tpl->NewInstance();
+
+  obj->SetAlignedPointerInInternalField(
+      Nan::imp::kFunctionIndex
+    , Nan::imp::GetWrapper<NanFunctionCallback,
+          Nan::imp::FunctionWrapper>(callback));
+  v8::Local<v8::Value> val = v8::Local<v8::Value>::New(isolate, data);
+
+  if (!val.IsEmpty()) {
+    obj->SetInternalField(Nan::imp::kDataIndex, val);
+  }
+
+  return scope.Escape(v8::FunctionTemplate::New( isolate
+                                  , Nan::imp::FunctionCallbackWrapper
+                                  , obj
+                                  , signature));
 }
 
 //=== Number ===================================================================
diff --git a/nan_implementation_pre_12_inl.h b/nan_implementation_pre_12_inl.h
index 927c5724..9473b0b8 100644
--- a/nan_implementation_pre_12_inl.h
+++ b/nan_implementation_pre_12_inl.h
@@ -16,10 +16,12 @@
 # pragma warning( disable : 4530 )
 # include <string>
 # include <vector>
+# include <map>
 # pragma warning( pop )
 #else
 # include <string>
 # include <vector>
+# include <map>
 #endif
 
 //==============================================================================
@@ -98,11 +100,29 @@ Factory<v8::FunctionTemplate>::return_t
 Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
                                   , v8::Handle<v8::Value> data
                                   , v8::Handle<v8::Signature> signature) {
+  v8::HandleScope scope;
+
+  static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
+  v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New();
+  tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+  v8::Local<v8::Object> obj = tpl->NewInstance();
+
+  obj->SetPointerInInternalField(
+      Nan::imp::kFunctionIndex
+    , Nan::imp::GetWrapper<NanFunctionCallback,
+          Nan::imp::FunctionWrapper>(callback));
+  v8::Local<v8::Value> val = v8::Local<v8::Value>::New(data);
+
+  if (!val.IsEmpty()) {
+    obj->SetInternalField(Nan::imp::kDataIndex, val);
+  }
+
   // Note(agnat): Emulate length argument here. Unfortunately, I couldn't find
   // a way. Have at it though...
-  return v8::FunctionTemplate::New( callback
-                                  , data
-                                  , signature);
+  return scope.Close(
+      v8::FunctionTemplate::New( Nan::imp::FunctionCallbackWrapper
+                               , obj
+                               , signature));
 }
 
 //=== Number ===================================================================
diff --git a/test/binding.gyp b/test/binding.gyp
index 2db37af9..96066642 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -46,8 +46,8 @@
       , "sources"     : [ "cpp/asyncworker.cpp" ]
     }
   , {
-        "target_name" : "settergetter"
-      , "sources"     : [ "cpp/settergetter.cpp" ]
+        "target_name" : "accessors"
+      , "sources"     : [ "cpp/accessors.cpp" ]
     }
   , {
         "target_name" : "persistent"
@@ -108,4 +108,12 @@
         "target_name" : "error"
       , "sources"     : [ "cpp/error.cpp" ]
     }
+    , {
+        "target_name" : "namedinterceptors"
+      , "sources"     : [ "cpp/namedinterceptors.cpp" ]
+    }
+    , {
+        "target_name" : "indexedinterceptors"
+      , "sources"     : [ "cpp/indexedinterceptors.cpp" ]
+    }
 ]}
diff --git a/test/cpp/settergetter.cpp b/test/cpp/accessors.cpp
similarity index 83%
rename from test/cpp/settergetter.cpp
rename to test/cpp/accessors.cpp
index 20c4a933..255959db 100644
--- a/test/cpp/settergetter.cpp
+++ b/test/cpp/accessors.cpp
@@ -9,7 +9,7 @@
 #include <nan.h>
 #include <cstring>
 
-class SetterGetter : public node::ObjectWrap {
+class SetterGetter : public NanObjectWrap {
  public:
   static void Init (v8::Handle<v8::Object> target);
   static v8::Handle<v8::Value> NewInstance ();
@@ -29,7 +29,7 @@ class SetterGetter : public node::ObjectWrap {
 static NanPersistent<v8::FunctionTemplate> settergetter_constructor;
 
 NAN_METHOD(CreateNew) {
-  NanReturnValue(SetterGetter::NewInstance());
+  info.GetReturnValue().Set(SetterGetter::NewInstance());
 }
 
 SetterGetter::SetterGetter() {
@@ -45,11 +45,12 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
   settergetter_constructor.Reset(tpl);
   tpl->SetClassName(NanNew<v8::String>("SetterGetter"));
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  NODE_SET_PROTOTYPE_METHOD(tpl, "log", SetterGetter::Log);
+  NanSetPrototypeMethod(tpl, "log", SetterGetter::Log);
   v8::Local<v8::ObjectTemplate> proto = tpl->PrototypeTemplate();
-  proto->SetAccessor(NanNew<v8::String>("prop1"), SetterGetter::GetProp1);
-  proto->SetAccessor(
-    NanNew<v8::String>("prop2")
+  NanSetAccessor(proto, NanNew<v8::String>("prop1"), SetterGetter::GetProp1);
+  NanSetAccessor(
+    proto
+  , NanNew<v8::String>("prop2")
   , SetterGetter::GetProp2
   , SetterGetter::SetProp2
   );
@@ -75,14 +76,14 @@ NAN_METHOD(SetterGetter::New) {
       settergetter->log
     , "New()\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
-  settergetter->Wrap(args.This());
+  settergetter->Wrap(info.This());
 
-  NanReturnValue(args.This());
+  info.GetReturnValue().Set(info.This());
 }
 
 NAN_GETTER(SetterGetter::GetProp1) {
   SetterGetter* settergetter =
-    node::ObjectWrap::Unwrap<SetterGetter>(args.This());
+    NanObjectWrap::Unwrap<SetterGetter>(info.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
   strncat(
       settergetter->log
@@ -99,12 +100,12 @@ NAN_GETTER(SetterGetter::GetProp1) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  NanReturnValue(NanNew(settergetter->prop1));
+  info.GetReturnValue().Set(NanNew(settergetter->prop1));
 }
 
 NAN_GETTER(SetterGetter::GetProp2) {
   SetterGetter* settergetter =
-    node::ObjectWrap::Unwrap<SetterGetter>(args.This());
+    NanObjectWrap::Unwrap<SetterGetter>(info.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
   strncat(
       settergetter->log
@@ -121,12 +122,12 @@ NAN_GETTER(SetterGetter::GetProp2) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  NanReturnValue(NanNew(settergetter->prop2));
+  info.GetReturnValue().Set(NanNew(settergetter->prop2));
 }
 
 NAN_SETTER(SetterGetter::SetProp2) {
   SetterGetter* settergetter =
-      node::ObjectWrap::Unwrap<SetterGetter>(args.This());
+      NanObjectWrap::Unwrap<SetterGetter>(info.This());
   strncpy(
       settergetter->prop2
     , *NanUtf8String(value)
@@ -151,9 +152,9 @@ NAN_SETTER(SetterGetter::SetProp2) {
 
 NAN_METHOD(SetterGetter::Log) {
   SetterGetter* settergetter =
-    node::ObjectWrap::Unwrap<SetterGetter>(args.This());
+    NanObjectWrap::Unwrap<SetterGetter>(info.This());
 
-  NanReturnValue(NanNew(settergetter->log));
+  info.GetReturnValue().Set(NanNew(settergetter->log));
 }
 
-NODE_MODULE(settergetter, SetterGetter::Init)
+NODE_MODULE(accessors, SetterGetter::Init)
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index 0639aac8..1024755f 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -46,14 +46,14 @@ class ProgressWorker : public NanAsyncProgressWorker {
 };
 
 NAN_METHOD(DoProgress) {
-  NanCallback *progress = new NanCallback(args[2].As<v8::Function>());
-  NanCallback *callback = new NanCallback(args[3].As<v8::Function>());
+  NanCallback *progress = new NanCallback(info[2].As<v8::Function>());
+  NanCallback *callback = new NanCallback(info[3].As<v8::Function>());
   NanAsyncQueueWorker(new ProgressWorker(
       callback
     , progress
-    , args[0]->Uint32Value()
-    , args[1]->Uint32Value()));
-  NanReturnUndefined();
+    , info[0]->Uint32Value()
+    , info[1]->Uint32Value()));
+  info.GetReturnValue().SetUndefined();
 }
 
 void Init(v8::Handle<v8::Object> exports) {
diff --git a/test/cpp/asyncworker.cpp b/test/cpp/asyncworker.cpp
index f11b489a..a66a00b2 100644
--- a/test/cpp/asyncworker.cpp
+++ b/test/cpp/asyncworker.cpp
@@ -27,9 +27,9 @@ class SleepWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(DoSleep) {
-  NanCallback *callback = new NanCallback(args[1].As<v8::Function>());
-  NanAsyncQueueWorker(new SleepWorker(callback, args[0]->Uint32Value()));
-  NanReturnUndefined();
+  NanCallback *callback = new NanCallback(info[1].As<v8::Function>());
+  NanAsyncQueueWorker(new SleepWorker(callback, info[0]->Uint32Value()));
+  info.GetReturnValue().SetUndefined();
 }
 
 void Init(v8::Handle<v8::Object> exports) {
diff --git a/test/cpp/asyncworkererror.cpp b/test/cpp/asyncworkererror.cpp
index 6b26a65b..c30935b3 100644
--- a/test/cpp/asyncworkererror.cpp
+++ b/test/cpp/asyncworkererror.cpp
@@ -19,9 +19,9 @@ class ErrorWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(Work) {
-  NanCallback *callback = new NanCallback(args[0].As<v8::Function>());
+  NanCallback *callback = new NanCallback(info[0].As<v8::Function>());
   NanAsyncQueueWorker(new ErrorWorker(callback));
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 void Init (v8::Handle<v8::Object> exports) {
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index 9fe5a46c..fb89ff97 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -49,12 +49,12 @@ class BufferWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(DoSleep) {
-  v8::Local<v8::Object> bufferHandle = args[1].As<v8::Object>();
-  NanCallback *callback = new NanCallback(args[2].As<v8::Function>());
+  v8::Local<v8::Object> bufferHandle = info[1].As<v8::Object>();
+  NanCallback *callback = new NanCallback(info[2].As<v8::Function>());
   assert(!callback->IsEmpty() && "Callback shoud not be empty");
   NanAsyncQueueWorker(
-      new BufferWorker(callback, args[0]->Uint32Value(), bufferHandle));
-  NanReturnUndefined();
+      new BufferWorker(callback, info[0]->Uint32Value(), bufferHandle));
+  info.GetReturnValue().SetUndefined();
 }
 
 void Init(v8::Handle<v8::Object> exports) {
diff --git a/test/cpp/gc.cpp b/test/cpp/gc.cpp
index c046f5a6..b788255a 100644
--- a/test/cpp/gc.cpp
+++ b/test/cpp/gc.cpp
@@ -22,11 +22,13 @@ NAN_GC_CALLBACK(gcEpilogueCallback) {
 NAN_METHOD(Hook) {
   NanAddGCPrologueCallback(gcPrologueCallback);
   NanAddGCEpilogueCallback(gcEpilogueCallback);
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(Check) {
-  NanReturnValue(NanNew(prologue_called && epilogue_called));
+  NanScope();
+  info.GetReturnValue().Set(
+      NanNew(prologue_called && epilogue_called));
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/indexedinterceptors.cpp b/test/cpp/indexedinterceptors.cpp
new file mode 100644
index 00000000..65d56aa7
--- /dev/null
+++ b/test/cpp/indexedinterceptors.cpp
@@ -0,0 +1,114 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+#include <cstring>
+
+class IndexedInterceptor : public NanObjectWrap {
+  char buf[256];
+
+ public:
+  IndexedInterceptor() { std::strncpy(this->buf, "foo", sizeof (this->buf)); }
+  static void Init (v8::Handle<v8::Object> target);
+  static v8::Handle<v8::Value> NewInstance ();
+  static NAN_METHOD(New);
+
+  static NAN_INDEX_GETTER(PropertyGetter);
+  static NAN_INDEX_SETTER(PropertySetter);
+  static NAN_INDEX_ENUMERATOR(PropertyEnumerator);
+  static NAN_INDEX_DELETER(PropertyDeleter);
+  static NAN_INDEX_QUERY(PropertyQuery);
+};
+
+static NanPersistent<v8::FunctionTemplate> indexedinterceptors_constructor;
+
+NAN_METHOD(CreateNew) {
+  info.GetReturnValue().Set(IndexedInterceptor::NewInstance());
+}
+
+void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
+  v8::Local<v8::FunctionTemplate> tpl =
+    NanNew<v8::FunctionTemplate>(IndexedInterceptor::New);
+  indexedinterceptors_constructor.Reset(tpl);
+  tpl->SetClassName(NanNew<v8::String>("IndexedInterceptor"));
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+  v8::Local<v8::ObjectTemplate> inst = tpl->InstanceTemplate();
+
+  NanSetIndexedPropertyHandler(
+      inst
+    , IndexedInterceptor::PropertyGetter
+    , IndexedInterceptor::PropertySetter
+    , IndexedInterceptor::PropertyQuery
+    , IndexedInterceptor::PropertyDeleter
+    , IndexedInterceptor::PropertyEnumerator);
+
+  v8::Local<v8::Function> createnew =
+    NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
+  target->Set(NanNew<v8::String>("create"), createnew);
+}
+
+v8::Handle<v8::Value> IndexedInterceptor::NewInstance () {
+  NanEscapableScope scope;
+  v8::Local<v8::FunctionTemplate> constructorHandle =
+      NanNew(indexedinterceptors_constructor);
+  v8::Local<v8::Object> instance =
+    constructorHandle->GetFunction()->NewInstance(0, NULL);
+  return scope.Escape(instance);
+}
+
+NAN_METHOD(IndexedInterceptor::New) {
+  IndexedInterceptor* interceptor = new IndexedInterceptor();
+  interceptor->Wrap(info.This());
+  info.GetReturnValue().Set(info.This());
+}
+
+
+NAN_INDEX_GETTER(IndexedInterceptor::PropertyGetter) {
+  IndexedInterceptor* interceptor =
+    NanObjectWrap::Unwrap<IndexedInterceptor>(info.This());
+  if (index == 0) {
+    info.GetReturnValue().Set(NanNew(interceptor->buf));
+  } else {
+    info.GetReturnValue().Set(NanNew("bar"));
+  }
+}
+
+NAN_INDEX_SETTER(IndexedInterceptor::PropertySetter) {
+  IndexedInterceptor* interceptor =
+    NanObjectWrap::Unwrap<IndexedInterceptor>(info.This());
+  if (index == 0) {
+    std::strncpy(
+        interceptor->buf
+      , *v8::String::Utf8Value(value)
+      , sizeof (interceptor->buf));
+    info.GetReturnValue().Set(info.This());
+  } else {
+    info.GetReturnValue().Set(info.This());
+  }
+}
+
+NAN_INDEX_ENUMERATOR(IndexedInterceptor::PropertyEnumerator) {
+  v8::Local<v8::Array> arr = NanNew<v8::Array>();
+  arr->Set(0, NanNew("whee"));
+  info.GetReturnValue().Set(arr);
+}
+
+NAN_INDEX_DELETER(IndexedInterceptor::PropertyDeleter) {
+  IndexedInterceptor* interceptor =
+    NanObjectWrap::Unwrap<IndexedInterceptor>(info.This());
+  std::strncpy(interceptor->buf, "goober", sizeof (interceptor->buf));
+  info.GetReturnValue().Set(NanTrue());
+}
+
+NAN_INDEX_QUERY(IndexedInterceptor::PropertyQuery) {
+  if (index == 1) {
+    info.GetReturnValue().Set(NanNew<v8::Integer>(v8::DontEnum));
+  }
+}
+
+NODE_MODULE(indexedinterceptors, IndexedInterceptor::Init)
diff --git a/test/cpp/isolatedata.cpp b/test/cpp/isolatedata.cpp
index a97a8ee5..c47ce7d7 100644
--- a/test/cpp/isolatedata.cpp
+++ b/test/cpp/isolatedata.cpp
@@ -23,7 +23,7 @@ NAN_METHOD(SetAndGet) {
 
   delete d1;
 
-  NanReturnValue(NanNew<v8::Boolean>(d0 == d1));
+  info.GetReturnValue().Set(NanNew<v8::Boolean>(d0 == d1));
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/makecallback.cpp b/test/cpp/makecallback.cpp
index 51ab2dce..2fc0eb25 100644
--- a/test/cpp/makecallback.cpp
+++ b/test/cpp/makecallback.cpp
@@ -35,21 +35,20 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
   tpl->SetClassName(NanNew<v8::String>("MyObject"));
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
-  NODE_SET_PROTOTYPE_METHOD(tpl, "call_emit", CallEmit);
+  NanSetPrototypeMethod(tpl, "call_emit", CallEmit);
 
   constructor.Reset(tpl->GetFunction());
   exports->Set(NanNew<v8::String>("MyObject"), tpl->GetFunction());
 }
 
 NAN_METHOD(MyObject::New) {
-  if (args.IsConstructCall()) {
-      MyObject* obj = new MyObject();
-      obj->Wrap(args.This());
-      NanReturnValue(args.This());
-  }
-  else {
-      v8::Local<v8::Function> cons = NanNew<v8::Function>(constructor);
-      NanReturnValue(cons->NewInstance());
+  if (info.IsConstructCall()) {
+    MyObject* obj = new MyObject();
+    obj->Wrap(info.This());
+    info.GetReturnValue().Set(info.This());
+  } else {
+    v8::Local<v8::Function> cons = NanNew<v8::Function>(constructor);
+    info.GetReturnValue().Set(cons->NewInstance());
   }
 }
 
@@ -58,8 +57,8 @@ NAN_METHOD(MyObject::CallEmit) {
       NanNew("event"), // event name
   };
 
-  NanMakeCallback(args.This(), "emit", 1, argv);
-  NanReturnUndefined();
+  NanMakeCallback(info.This(), "emit", 1, argv);
+  info.GetReturnValue().SetUndefined();
 }
 
 void Init(v8::Handle<v8::Object> exports) {
diff --git a/test/cpp/morenews.cpp b/test/cpp/morenews.cpp
index 86983da6..a986f679 100644
--- a/test/cpp/morenews.cpp
+++ b/test/cpp/morenews.cpp
@@ -9,30 +9,30 @@
 #include <nan.h>
 
 NAN_METHOD(NewNumber) {
-  NanReturnValue(NanNew(0.5));
+  info.GetReturnValue().Set(NanNew(0.5));
 }
 
 NAN_METHOD(NewNegativeInteger) {
-  NanReturnValue(NanNew(-1));
+  info.GetReturnValue().Set(NanNew(-1));
 }
 
 NAN_METHOD(NewPositiveInteger) {
-  NanReturnValue(NanNew(1));
+  info.GetReturnValue().Set(NanNew(1));
 }
 
 NAN_METHOD(NewUtf8String) {
   const char s[] = "strïng";
-  NanReturnValue(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s));
 }
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  NanReturnValue(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s));
 }
 
 NAN_METHOD(NewUcs2String) {
   uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
-  NanReturnValue(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s));
 }
 
 static const uint16_t ws[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
@@ -55,12 +55,12 @@ class ExtAsciiString : public NanExternalOneByteStringResource {
 
 NAN_METHOD(NewExternalStringResource) {
   v8::Local<v8::String> ext = NanNew(new ExtString());
-  NanReturnValue(ext);
+  info.GetReturnValue().Set(ext);
 }
 
 NAN_METHOD(NewExternalAsciiStringResource) {
   v8::Local<v8::String> ext = NanNew(new ExtAsciiString());
-  NanReturnValue(ext);
+  info.GetReturnValue().Set(ext);
 }
 
 void Init(v8::Handle<v8::Object> target) {
diff --git a/test/cpp/multifile2.cpp b/test/cpp/multifile2.cpp
index 7f0c0c51..144a0556 100644
--- a/test/cpp/multifile2.cpp
+++ b/test/cpp/multifile2.cpp
@@ -9,6 +9,6 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnString) {
-  v8::Local<v8::String> s = NanNew<v8::String>(*NanUtf8String(args[0]));
-  NanReturnValue(s);
+  v8::Local<v8::String> s = NanNew<v8::String>(*NanUtf8String(info[0]));
+  info.GetReturnValue().Set(s);
 }
diff --git a/test/cpp/namedinterceptors.cpp b/test/cpp/namedinterceptors.cpp
new file mode 100644
index 00000000..01bf5ef4
--- /dev/null
+++ b/test/cpp/namedinterceptors.cpp
@@ -0,0 +1,114 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+#include <cstring>
+
+class NamedInterceptor : public NanObjectWrap {
+  char buf[256];
+
+ public:
+  NamedInterceptor() { std::strncpy(this->buf, "foo", sizeof (this->buf)); }
+  static void Init (v8::Handle<v8::Object> target);
+  static v8::Handle<v8::Value> NewInstance ();
+  static NAN_METHOD(New);
+
+  static NAN_PROPERTY_GETTER(PropertyGetter);
+  static NAN_PROPERTY_SETTER(PropertySetter);
+  static NAN_PROPERTY_ENUMERATOR(PropertyEnumerator);
+  static NAN_PROPERTY_DELETER(PropertyDeleter);
+  static NAN_PROPERTY_QUERY(PropertyQuery);
+};
+
+static NanPersistent<v8::FunctionTemplate> namedinterceptors_constructor;
+
+NAN_METHOD(CreateNew) {
+  info.GetReturnValue().Set(NamedInterceptor::NewInstance());
+}
+
+void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
+  v8::Local<v8::FunctionTemplate> tpl =
+    NanNew<v8::FunctionTemplate>(NamedInterceptor::New);
+  namedinterceptors_constructor.Reset(tpl);
+  tpl->SetClassName(NanNew<v8::String>("NamedInterceptor"));
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+  v8::Local<v8::ObjectTemplate> inst = tpl->InstanceTemplate();
+
+  NanSetNamedPropertyHandler(
+      inst
+    , NamedInterceptor::PropertyGetter
+    , NamedInterceptor::PropertySetter
+    , NamedInterceptor::PropertyQuery
+    , NamedInterceptor::PropertyDeleter
+    , NamedInterceptor::PropertyEnumerator);
+
+  v8::Local<v8::Function> createnew =
+    NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
+  target->Set(NanNew<v8::String>("create"), createnew);
+}
+
+v8::Handle<v8::Value> NamedInterceptor::NewInstance () {
+  NanEscapableScope scope;
+  v8::Local<v8::FunctionTemplate> constructorHandle =
+      NanNew(namedinterceptors_constructor);
+  v8::Local<v8::Object> instance =
+    constructorHandle->GetFunction()->NewInstance(0, NULL);
+  return scope.Escape(instance);
+}
+
+NAN_METHOD(NamedInterceptor::New) {
+  NamedInterceptor* interceptor = new NamedInterceptor();
+  interceptor->Wrap(info.This());
+  info.GetReturnValue().Set(info.This());
+}
+
+
+NAN_PROPERTY_GETTER(NamedInterceptor::PropertyGetter) {
+  NamedInterceptor* interceptor =
+    NanObjectWrap::Unwrap<NamedInterceptor>(info.This());
+  if (!std::strcmp(*v8::String::Utf8Value(property), "prop")) {
+    info.GetReturnValue().Set(NanNew(interceptor->buf));
+  } else {
+    info.GetReturnValue().Set(NanNew("bar"));
+  }
+}
+
+NAN_PROPERTY_SETTER(NamedInterceptor::PropertySetter) {
+  NamedInterceptor* interceptor =
+    NanObjectWrap::Unwrap<NamedInterceptor>(info.This());
+  if (!std::strcmp(*v8::String::Utf8Value(property), "prop")) {
+    std::strncpy(
+        interceptor->buf
+      , *v8::String::Utf8Value(value)
+      , sizeof (interceptor->buf));
+    info.GetReturnValue().Set(info.This());
+  } else {
+    info.GetReturnValue().Set(info.This());
+  }
+}
+
+NAN_PROPERTY_ENUMERATOR(NamedInterceptor::PropertyEnumerator) {
+  v8::Local<v8::Array> arr = NanNew<v8::Array>();
+  arr->Set(0, NanNew("value"));
+  info.GetReturnValue().Set(arr);
+}
+
+NAN_PROPERTY_DELETER(NamedInterceptor::PropertyDeleter) {
+  NamedInterceptor* interceptor =
+    NanObjectWrap::Unwrap<NamedInterceptor>(info.This());
+  std::strncpy(interceptor->buf, "goober", sizeof (interceptor->buf));
+  info.GetReturnValue().Set(NanTrue());
+}
+
+NAN_PROPERTY_QUERY(NamedInterceptor::PropertyQuery) {
+  if (!std::strcmp(*v8::String::Utf8Value(property), "thing")) {
+    info.GetReturnValue().Set(NanNew<v8::Integer>(v8::DontEnum));
+  }
+}
+
+NODE_MODULE(namedinterceptors, NamedInterceptor::Init)
diff --git a/test/cpp/nancallback.cpp b/test/cpp/nancallback.cpp
index 4b418149..fe32f685 100644
--- a/test/cpp/nancallback.cpp
+++ b/test/cpp/nancallback.cpp
@@ -9,41 +9,36 @@
 #include <nan.h>
 
 NAN_METHOD(GlobalContext) {
-  NanCallback(args[0].As<v8::Function>()).Call(0, NULL);
-  NanReturnUndefined();
+  NanCallback(info[0].As<v8::Function>()).Call(0, NULL);
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(SpecificContext) {
-  NanCallback cb(args[0].As<v8::Function>());
+  NanCallback cb(info[0].As<v8::Function>());
   cb.Call(NanGetCurrentContext()->Global(), 0, NULL);
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(CustomReceiver) {
-  NanCallback cb(args[0].As<v8::Function>());
-  cb.Call(args[1].As<v8::Object>(), 0, NULL);
-  NanReturnUndefined();
+  NanCallback cb(info[0].As<v8::Function>());
+  cb.Call(info[1].As<v8::Object>(), 0, NULL);
 }
 
 NAN_METHOD(CompareCallbacks) {
-  NanCallback cb1(args[0].As<v8::Function>());
-  NanCallback cb2(args[1].As<v8::Function>());
-  NanCallback cb3(args[2].As<v8::Function>());
+  NanCallback cb1(info[0].As<v8::Function>());
+  NanCallback cb2(info[1].As<v8::Function>());
+  NanCallback cb3(info[2].As<v8::Function>());
 
-  NanReturnValue(NanNew<v8::Boolean>(cb1 == cb2 && cb1 != cb3));
+  info.GetReturnValue().Set(NanNew<v8::Boolean>(cb1 == cb2 && cb1 != cb3));
 }
 
 NAN_METHOD(CallDirect) {
-  NanCallback cb(args[0].As<v8::Function>());
+  NanCallback cb(info[0].As<v8::Function>());
   (*cb)->Call(NanGetCurrentContext()->Global(), 0, NULL);
-
-  NanReturnUndefined();
 }
 
 NAN_METHOD(CallAsFunction) {
-  NanCallback(args[0].As<v8::Function>())();
-
-  NanReturnUndefined();
+  NanCallback(info[0].As<v8::Function>())();
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index d6c7ff5d..e1d45484 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -52,7 +52,7 @@ stringMatches(Local<Value> value, const char * match) {
 #define _(e) NAN_TEST_EXPRESSION(e)
 
 NAN_METHOD(testArray) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(3);
 
@@ -60,11 +60,11 @@ NAN_METHOD(testArray) {
   t.ok(_( NanNew<Array>(7)->Length() == 7));
   t.ok(_( assertType<Array>(NanNew<Array>(7))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testBoolean) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(6);
 
@@ -76,7 +76,7 @@ NAN_METHOD(testBoolean) {
   t.ok(_( NanNew(false)->Value() == false));
   t.ok(_( assertType<Boolean>( NanNew(true))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 #if (NODE_MODULE_VERSION < 12)
@@ -85,7 +85,7 @@ NAN_METHOD(testBoolean) {
 # define V(x) x->ValueOf()
 #endif
 NAN_METHOD(testBooleanObject) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(3);
 
@@ -93,12 +93,12 @@ NAN_METHOD(testBooleanObject) {
   t.ok(_( V(NanNew<BooleanObject>(true)) == true));
   t.ok(_( V(NanNew<BooleanObject>(false)) == false));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 #undef V
 
 NAN_METHOD(testContext) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(5);
   t.ok(_( assertType<Context>( NanNew<Context>())));
@@ -113,45 +113,45 @@ NAN_METHOD(testContext) {
           NanNew<Context>(&extensions
           , Handle<ObjectTemplate>(), Handle<Value>()))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testDate) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(1);
 
   t.ok(_( assertType<Date>( NanNew<Date>(static_cast<double>(time(NULL))))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 int ttt = 23;
 
 NAN_METHOD(testExternal) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(2);
 
   t.ok(_(NanNew<External>(&ttt)->Value() == &ttt));
   t.ok(_( assertType<External>(NanNew<External>(&ttt))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testFunction) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
   t.plan(2);
 
   t.ok(_( assertType<Function>(NanNew<Function>(testFunction))));
   v8::Local<String> data = NanNew("plonk");
   t.ok(_( assertType<Function>(NanNew<Function>(testFunction, data))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testFunctionTemplate) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(4);
 
@@ -165,13 +165,13 @@ NAN_METHOD(testFunctionTemplate) {
   t.ok(_( assertType<FunctionTemplate>(
           NanNew<FunctionTemplate>( testFunctionTemplate, data, signature))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 const double epsilon = 1e-9;
 
 NAN_METHOD(testNumber) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(17);
 
@@ -201,42 +201,42 @@ NAN_METHOD(testNumber) {
   t.ok(_( fabs(NanNew(M_PI)->Value() - M_PI) < epsilon));
   t.ok(_( assertType<Number>( NanNew(M_E) )));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testNumberObject) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(2);
 
   t.ok(_( assertType<NumberObject>( NanNew<NumberObject>(M_PI))));
   t.ok(_( fabs(NanNew<NumberObject>(M_PI)->NumberValue() - M_PI) < epsilon));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testObject) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(1);
 
   t.ok(_(assertType<Object>( NanNew<Object>())));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testObjectTemplate) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(1);
 
   t.ok(_(assertType<ObjectTemplate>( NanNew<ObjectTemplate>())));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testScript) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(6);
 
@@ -255,11 +255,11 @@ NAN_METHOD(testScript) {
   t.ok(_( NanRunScript(
       NanNew<NanUnboundScript>(NanNew("2 + 3")))->Int32Value() == 5));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testSignature) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(3);
 
@@ -271,11 +271,11 @@ NAN_METHOD(testSignature) {
   t.ok(_( assertType<Sig>(
       NanNew<Sig>(NanNew<FT>(testSignature)))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testString) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(14);
 
@@ -304,7 +304,7 @@ NAN_METHOD(testString) {
   t.ok(_( stringMatches( NanNew(std::string("bar")), "bar")));
   t.ok(_( assertType<String>( NanNew(std::string("plonk.")))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 #if (NODE_MODULE_VERSION < 12)
@@ -313,7 +313,7 @@ NAN_METHOD(testString) {
 # define V(x) x->ValueOf()
 #endif
 NAN_METHOD(testStringObject) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(2);
 
@@ -323,24 +323,24 @@ NAN_METHOD(testStringObject) {
   t.ok(_( assertType<StringObject>(
           NanNew<StringObject>(NanNew<String>("plonk")))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 #undef V
 
 template <typename T> Handle<T> asHandle(Local<T> l) { return l; }
 NAN_METHOD(testHandles) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(2);
 
   t.ok(_( assertType<String>( NanNew( asHandle(NanNew("foo"))))));
   t.ok(_( assertType<Uint32>( NanNew( asHandle(NanNew(5u))))));
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testPersistents) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(1);
 
@@ -349,7 +349,7 @@ NAN_METHOD(testPersistents) {
   t.ok(_( assertType<String>( NanNew(p))));
   p.Reset();
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 //==============================================================================
@@ -359,7 +359,7 @@ NAN_METHOD(testPersistents) {
 
 // See https://github.com/nodejs/nan/issues/212
 NAN_METHOD(testRegression212) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   t.plan(1);
 
@@ -374,7 +374,7 @@ NAN_METHOD(testRegression212) {
 # pragma warning( pop )
 #endif
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 /* Compile time regression test for https://github.com/nodejs/nan/issues/242
@@ -384,11 +384,11 @@ NAN_METHOD(testRegression212) {
 void overloaded() {}
 NAN_METHOD(overloaded) {
     overloaded();  // not unused
-    return_NanUndefined();
+    info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testRegression242) {
-  NanTap t(args[0]);
+  NanTap t(info[0]);
 
   // These lines must *compile*. Not much to test at runtime.
   Local<FunctionTemplate> ft = NanNew<FunctionTemplate>(overloaded);
@@ -400,7 +400,7 @@ NAN_METHOD(testRegression242) {
 
   t.ok(true, "compile-time regression test #242");
 
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 
@@ -409,31 +409,31 @@ NAN_METHOD(testRegression242) {
 //==============================================================================
 
 NAN_METHOD(newIntegerWithValue) {
-  return_NanValue(NanNew<Integer>(args[0]->Int32Value()));
+  info.GetReturnValue().Set(NanNew<Integer>(info[0]->Int32Value()));
 }
 
 NAN_METHOD(newNumberWithValue) {
-  return_NanValue(NanNew<Number>(args[0]->NumberValue()));
+  info.GetReturnValue().Set(NanNew<Number>(info[0]->NumberValue()));
 }
 
 NAN_METHOD(newUint32WithValue) {
-  return_NanValue(NanNew<Uint32>(args[0]->Uint32Value()));
+  info.GetReturnValue().Set(NanNew<Uint32>(info[0]->Uint32Value()));
 }
 
 NAN_METHOD(newStringFromChars) {
-  return_NanValue(NanNew<String>("hello?"));
+  info.GetReturnValue().Set(NanNew<String>("hello?"));
 }
 
 NAN_METHOD(newStringFromCharsWithLength) {
-  return_NanValue(NanNew<String>("hello?", 4));
+  info.GetReturnValue().Set(NanNew<String>("hello?", 4));
 }
 
 NAN_METHOD(newStringFromStdString) {
-  return_NanValue(NanNew<String>(std::string("hello!")));
+  info.GetReturnValue().Set(NanNew<String>(std::string("hello!")));
 }
 
 NAN_METHOD(newExternal) {
-  return_NanValue(NanNew<External>(&ttt));
+  info.GetReturnValue().Set(NanNew<External>(&ttt));
 }
 
 void Init(Handle<Object> exports) {
diff --git a/test/cpp/news.cpp b/test/cpp/news.cpp
index 04519ff1..d8a3df42 100644
--- a/test/cpp/news.cpp
+++ b/test/cpp/news.cpp
@@ -19,77 +19,78 @@
 static int magic = 1337;
 
 NAN_METHOD(NewNumber) {
-  NanReturnValue(NanNew<v8::Number>(0.5));
+  info.GetReturnValue().Set(NanNew<v8::Number>(0.5));
 }
 
 NAN_METHOD(NewNegativeInteger) {
-  NanReturnValue(NanNew<v8::Integer>(-1));
+  info.GetReturnValue().Set(NanNew<v8::Integer>(-1));
 }
 
 NAN_METHOD(NewPositiveInteger) {
-  NanReturnValue(NanNew<v8::Integer>(1));
+  info.GetReturnValue().Set(NanNew<v8::Integer>(1));
 }
 
 NAN_METHOD(NewUnsignedInteger) {
-  NanReturnValue(NanNew<v8::Integer>(0xFFFFFFFFu));
+  info.GetReturnValue().Set(NanNew<v8::Integer>(0xFFFFFFFFu));
 }
 
 NAN_METHOD(NewInt32FromPositive) {
-  NanReturnValue(NanNew<v8::Int32>(0xFFFFFFFF));
+  info.GetReturnValue().Set(NanNew<v8::Int32>(0xFFFFFFFF));
 }
 
 NAN_METHOD(NewInt32FromNegative) {
-  NanReturnValue(NanNew<v8::Int32>(-1));
+  info.GetReturnValue().Set(NanNew<v8::Int32>(-1));
 }
 
 NAN_METHOD(NewUint32FromPositive) {
-  NanReturnValue(NanNew<v8::Uint32>(0xFFFFFFFF));
+  info.GetReturnValue().Set(NanNew<v8::Uint32>(0xFFFFFFFF));
 }
 
 NAN_METHOD(NewUint32FromNegative) {
-  NanReturnValue(NanNew<v8::Uint32>(-1));
+  info.GetReturnValue().Set(NanNew<v8::Uint32>(-1));
 }
 
 NAN_METHOD(NewUtf8String) {
   const char s[] = "strïng";
-  NanReturnValue(NanNew<v8::String>(s));
+  info.GetReturnValue().Set(NanNew<v8::String>(s));
 }
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  NanReturnValue(NanNew<v8::String>(s));
+  info.GetReturnValue().Set(NanNew<v8::String>(s));
 }
 
 NAN_METHOD(NewUcs2String) {
   const uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
-  NanReturnValue(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s));
 }
 
 NAN_METHOD(NewStdString) {
   const std::string s = "strïng";
-  NanReturnValue(NanNew<v8::String>(s));
+  info.GetReturnValue().Set(NanNew<v8::String>(s));
 }
 
 NAN_METHOD(NewRegExp) {
-  NanReturnValue(NanNew<v8::RegExp>(NanNew("foo"), v8::RegExp::kNone));
+  info.GetReturnValue().Set(
+      NanNew<v8::RegExp>(NanNew("foo"), v8::RegExp::kNone));
 }
 
 NAN_METHOD(NewStringObject) {
-  NanReturnValue(NanNew<v8::StringObject>(NanNew<v8::String>("foo")));
+  info.GetReturnValue().Set(NanNew<v8::StringObject>(NanNew("foo")));
 }
 
 NAN_METHOD(NewNumberObject) {
-  NanReturnValue(NanNew<v8::NumberObject>(0.5));
+  info.GetReturnValue().Set(NanNew<v8::NumberObject>(0.5));
 }
 
 NAN_METHOD(NewBooleanObject) {
-  NanReturnValue(NanNew<v8::BooleanObject>(true));
+  info.GetReturnValue().Set(NanNew<v8::BooleanObject>(true));
 }
 
 NAN_METHOD(NewExternal) {
   v8::Local<v8::External> ext = NanNew<v8::External>(&magic);
   assert(*static_cast<int *>(ext->Value()) == 1337);
-  NanReturnValue(NanNew<v8::String>("passed"));
+  info.GetReturnValue().Set(NanNew<v8::String>("passed"));
 }
 
 NAN_METHOD(NewSignature) {
@@ -98,42 +99,42 @@ NAN_METHOD(NewSignature) {
   v8::Local<v8::Signature> sig = NanNew<v8::Signature>(tmpl);
   tmpl = NanNew<v8::FunctionTemplate>(
       NewSignature, v8::Handle<v8::Value>(), sig);
-  NanReturnValue(NanNew<v8::String>("string"));
+  info.GetReturnValue().Set(NanNew<v8::String>("string"));
 }
 
 NAN_METHOD(NewScript) {
   v8::Local<NanUnboundScript> script = NanNew<NanUnboundScript>(NanNew("2+4"));
-  NanReturnValue(NanRunScript(script)->ToInt32());
+  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
 }
 
 NAN_METHOD(NewScript2) {
   v8::ScriptOrigin origin(NanNew<v8::String>("x"));
   v8::Local<NanUnboundScript> script =
       NanNew<NanUnboundScript>(NanNew("2+4"), origin);
-  NanReturnValue(NanRunScript(script)->ToInt32());
+  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
 }
 
 NAN_METHOD(CompileScript) {
   v8::Local<NanBoundScript> script = NanCompileScript(NanNew("2+4"));
-  NanReturnValue(NanRunScript(script)->ToInt32());
+  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
 }
 
 NAN_METHOD(CompileScript2) {
   v8::ScriptOrigin origin(NanNew<v8::String>("x"));
   v8::Local<NanBoundScript> script = NanCompileScript(NanNew("2+4"), origin);
-  NanReturnValue(NanRunScript(script)->ToInt32());
+  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
 }
 
 NAN_METHOD(NewDate) {
-  NanReturnValue(NanNew<v8::Date>(1337));
+  info.GetReturnValue().Set(NanNew<v8::Date>(1337));
 }
 
 NAN_METHOD(NewArray) {
-  NanReturnValue(NanNew<v8::Array>());
+  info.GetReturnValue().Set(NanNew<v8::Array>());
 }
 
 NAN_METHOD(NewBoolean) {
-  NanReturnValue(NanNew<v8::Boolean>(true));
+  info.GetReturnValue().Set(NanNew<v8::Boolean>(true));
 }
 
 // #212
@@ -142,7 +143,7 @@ NAN_METHOD(NewBoolean2) {
 # pragma warning( push )
 # pragma warning( disable : 4800 )
 #endif
-  NanReturnValue(NanNew<v8::Boolean>(1));
+  info.GetReturnValue().Set(NanNew<v8::Boolean>(1));
 #if defined(_MSC_VER)
 # pragma warning( pop )
 #endif
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index e4ee1bb4..ab3c3969 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -15,7 +15,7 @@ class MyObject : public NanObjectWrap {
     tpl->SetClassName(NanNew("MyObject"));
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
-    NODE_SET_PROTOTYPE_METHOD(tpl, "getHandle", GetHandle);
+    NanSetPrototypeMethod(tpl, "getHandle", GetHandle);
 
     constructor.Reset(tpl->GetFunction());
     exports->Set(NanNew("MyObject"), tpl->GetFunction());
@@ -26,22 +26,22 @@ class MyObject : public NanObjectWrap {
   ~MyObject() {}
 
   static NAN_METHOD(New) {
-    if (args.IsConstructCall()) {
-      double value = args[0]->IsUndefined() ? 0 : args[0]->NumberValue();
+    if (info.IsConstructCall()) {
+      double value = info[0]->IsUndefined() ? 0 : info[0]->NumberValue();
       MyObject *obj = new MyObject(value);
-      obj->Wrap(args.This());
-      NanReturnThis();
+      obj->Wrap(info.This());
+      info.GetReturnValue().Set(info.This());
     } else {
       const int argc = 1;
-      v8::Local<v8::Value> argv[argc] = {args[0]};
+      v8::Local<v8::Value> argv[argc] = {info[0]};
       v8::Local<v8::Function> cons = NanNew(constructor);
-      NanReturnValue(cons->NewInstance(argc, argv));
+      info.GetReturnValue().Set(cons->NewInstance(argc, argv));
     }
   }
 
   static NAN_METHOD(GetHandle) {
-    MyObject* obj = NanObjectWrap::Unwrap<MyObject>(args.This());
-    NanReturnValue(obj->handle());
+    MyObject* obj = NanObjectWrap::Unwrap<MyObject>(info.This());
+    info.GetReturnValue().Set(obj->handle());
   }
 
   static NanPersistent<v8::Function> constructor;
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index 512c250d..4416efea 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -12,39 +12,39 @@
 static NanPersistent<v8::String> persistentTest1;
 
 NAN_METHOD(Save1) {
-  persistentTest1.Reset(args[0].As<v8::String>());
-  NanReturnUndefined();
+  persistentTest1.Reset(info[0].As<v8::String>());
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(Get1) {
-  NanReturnValue(NanNew(persistentTest1));
+  info.GetReturnValue().Set(NanNew(persistentTest1));
 }
 
 NAN_METHOD(Dispose1) {
   persistentTest1.Reset();
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(ToPersistentAndBackAgain) {
-  NanPersistent<v8::Object> persistent(args[0].As<v8::Object>());
+  NanPersistent<v8::Object> persistent(info[0].As<v8::Object>());
   v8::Local<v8::Object> object = NanNew(persistent);
   persistent.Reset();
   memset(&persistent, -1, sizeof(persistent));  // Clobber it good.
-  NanReturnValue(object);
+  info.GetReturnValue().Set(object);
 }
 
 NAN_METHOD(PersistentToPersistent) {
-  NanPersistent<v8::String> persistent(args[0].As<v8::String>());
+  NanPersistent<v8::String> persistent(info[0].As<v8::String>());
   persistentTest1.Reset(persistent);
   persistent.Reset();
   persistentTest1.Reset();
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(CopyablePersistent) {
   NanCopyablePersistentTraits<v8::String>::CopyablePersistent p;
   p = persistentTest1;
-  NanReturnValue(p);
+  info.GetReturnValue().Set(NanNew(p));
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/returnemptystring.cpp b/test/cpp/returnemptystring.cpp
index 1f37033c..646cc573 100644
--- a/test/cpp/returnemptystring.cpp
+++ b/test/cpp/returnemptystring.cpp
@@ -9,7 +9,7 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnEmptyString) {
-  NanReturnEmptyString();
+  info.GetReturnValue().SetEmptyString();
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/returnnull.cpp b/test/cpp/returnnull.cpp
index c283cd5a..766617bb 100644
--- a/test/cpp/returnnull.cpp
+++ b/test/cpp/returnnull.cpp
@@ -9,7 +9,7 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnNull) {
-  NanReturnNull();
+  info.GetReturnValue().SetNull();
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/returnundefined.cpp b/test/cpp/returnundefined.cpp
index 2463f2de..9394696c 100644
--- a/test/cpp/returnundefined.cpp
+++ b/test/cpp/returnundefined.cpp
@@ -9,7 +9,7 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnUndefined) {
-  NanReturnUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index 00c1b1d4..7f620d57 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -11,23 +11,21 @@
 NanGlobal<v8::Boolean> global;
 
 NAN_METHOD(ReturnValue) {
-  if (args.Length() == 1) {
-    NanReturnValue(args[0]);
+  const NanFunctionCallbackInfo<v8::Value> cbinfo = info;
+  NanReturnValue<v8::Value> ret = cbinfo.GetReturnValue();
+  if (cbinfo.Length() == 1) {
+    ret.Set(info[0].As<v8::String>());
   } else {
-    NanReturnValue(NanNew<v8::String>("default"));
+    ret.Set(NanNew<v8::String>("default"));
   }
 }
 
 NAN_METHOD(ReturnPrimitive) {
-  NanReturnValue(true);
-}
-
-NAN_METHOD(ReturnString) {
-  NanReturnValue("yes, it works");
+  info.GetReturnValue().Set(true);
 }
 
 NAN_METHOD(ReturnGlobal) {
-  NanReturnValue(global);
+  info.GetReturnValue().Set(global);
 }
 
 void Init (v8::Handle<v8::Object> target) {
@@ -41,10 +39,6 @@ void Init (v8::Handle<v8::Object> target) {
       NanNew<v8::String>("p")
     , NanNew<v8::FunctionTemplate>(ReturnPrimitive)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("s")
-    , NanNew<v8::FunctionTemplate>(ReturnString)->GetFunction()
-  );
   target->Set(
       NanNew<v8::String>("q")
     , NanNew<v8::FunctionTemplate>(ReturnGlobal)->GetFunction()
diff --git a/test/cpp/settemplate.cpp b/test/cpp/settemplate.cpp
index b916f7d1..24fcf10d 100644
--- a/test/cpp/settemplate.cpp
+++ b/test/cpp/settemplate.cpp
@@ -53,13 +53,13 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
 }
 
 NAN_METHOD(MyObject::New) {
-  if (args.IsConstructCall()) {
+  if (info.IsConstructCall()) {
     MyObject* obj = new MyObject();
-    obj->Wrap(args.This());
-    NanReturnValue(args.This());
+    obj->Wrap(info.This());
+    info.GetReturnValue().Set(info.This());
   } else {
     v8::Local<v8::Function> cons = NanNew<v8::Function>(constructor);
-    NanReturnValue(cons->NewInstance());
+    info.GetReturnValue().Set(cons->NewInstance());
   }
 }
 
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index 7def25b2..f862d668 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -9,22 +9,22 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnUtf8String) {
-  NanReturnValue(NanNew(*NanUtf8String(args[0])));
+  info.GetReturnValue().Set(NanNew(*NanUtf8String(info[0])));
 }
 
 NAN_METHOD(HeapString) {
-  NanUtf8String *s = new NanUtf8String(args[0]);
+  NanUtf8String *s = new NanUtf8String(info[0]);
   v8::Local<v8::String> res = NanNew(**s);
   delete s;
-  NanReturnValue(res);
+  info.GetReturnValue().Set(res);
 }
 
 NAN_METHOD(EncodeHex) {
-  NanReturnValue(NanEncode("hello", 5, Nan::HEX));
+  info.GetReturnValue().Set(NanEncode("hello", 5, Nan::HEX));
 }
 
 NAN_METHOD(EncodeUCS2) {
-  NanReturnValue(NanEncode("h\0e\0l\0l\0o\0", 10, Nan::UCS2));
+  info.GetReturnValue().Set(NanEncode("h\0e\0l\0l\0o\0", 10, Nan::UCS2));
 }
 
 NanPersistent<v8::FunctionTemplate> returnUtf8String_persistent;
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index 1680e0bf..10563cc6 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -54,9 +54,9 @@ class TlsTest : public NanAsyncWorker {
 };
 
 NAN_METHOD(thread_local_storage) {
-  NanTap *t = new NanTap(args[0]);
+  NanTap *t = new NanTap(info[0]);
   NanAsyncQueueWorker(new TlsTest(t));
-  return_NanUndefined();
+  info.GetReturnValue().SetUndefined();
 }
 
 void Init(v8::Handle<v8::Object> exports) {
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index 6a6ee68d..1b8a2ecd 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -29,8 +29,8 @@ v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
 }
 
 NAN_METHOD(Hustle) {
-  cb.Reset(args[1].As<v8::Function>());
-  NanReturnValue(wrap(args[0].As<v8::Function>()));
+  cb.Reset(info[1].As<v8::Function>());
+  info.GetReturnValue().Set(wrap(info[0].As<v8::Function>()));
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/weak2.cpp b/test/cpp/weak2.cpp
index 58c9357d..e63dc44d 100644
--- a/test/cpp/weak2.cpp
+++ b/test/cpp/weak2.cpp
@@ -34,8 +34,8 @@ v8::Handle<v8::String> wrap() {
 }
 
 NAN_METHOD(Hustle) {
-  cb.Reset(args[0].As<v8::Function>());
-  NanReturnValue(wrap());
+  cb.Reset(info[0].As<v8::Function>());
+  info.GetReturnValue().Set(wrap());
 }
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/js/settergetter-test.js b/test/js/accessors-test.js
similarity index 93%
rename from test/js/settergetter-test.js
rename to test/js/accessors-test.js
index 8ceb6bfc..76506814 100644
--- a/test/js/settergetter-test.js
+++ b/test/js/accessors-test.js
@@ -8,9 +8,9 @@
 
 const test     = require('tap').test
     , testRoot = require('path').resolve(__dirname, '..')
-    , bindings = require('bindings')({ module_root: testRoot, bindings: 'settergetter' });
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'accessors' });
 
-test('settergetter', function (t) {
+test('accessors', function (t) {
   t.plan(4)
   var settergetter = bindings.create()
   t.equal(settergetter.prop1, 'this is property 1')
diff --git a/test/js/indexedinterceptors-test.js b/test/js/indexedinterceptors-test.js
new file mode 100644
index 00000000..2c07ebc4
--- /dev/null
+++ b/test/js/indexedinterceptors-test.js
@@ -0,0 +1,23 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'indexedinterceptors' });
+
+test('indexedinterceptors', function (t) {
+  t.plan(5);
+  var interceptor = bindings.create();
+  t.equal(interceptor[2], 'bar');
+  interceptor[0] = 'setting a value';
+  t.equal(interceptor[0], 'setting a value');
+  delete interceptor[0];
+  t.equal(interceptor[0], 'goober');
+  t.ok(Object.prototype.hasOwnProperty.call(interceptor, 1));
+  t.equal(Object.keys(interceptor)[0], 'whee');
+});
diff --git a/test/js/namedinterceptors-test.js b/test/js/namedinterceptors-test.js
new file mode 100644
index 00000000..8c548f6f
--- /dev/null
+++ b/test/js/namedinterceptors-test.js
@@ -0,0 +1,23 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'namedinterceptors' });
+
+test('namedinterceptors', function (t) {
+  t.plan(5);
+  var interceptor = bindings.create();
+  t.equal(interceptor.prop, 'foo');
+  interceptor.prop = 'setting a value';
+  t.equal(interceptor.prop, 'setting a value');
+  delete interceptor.something;
+  t.equal(interceptor.prop, 'goober');
+  t.ok(Object.prototype.hasOwnProperty.call(interceptor, "thing"));
+  t.ok(Object.keys(interceptor)[0] === 'value');
+});
diff --git a/test/js/returnvalue-test.js b/test/js/returnvalue-test.js
index 74af7889..1b818f6c 100644
--- a/test/js/returnvalue-test.js
+++ b/test/js/returnvalue-test.js
@@ -11,14 +11,12 @@ const test     = require('tap').test
     , bindings = require('bindings')({ module_root: testRoot, bindings: 'returnvalue' });
 
 test('returnvalue', function (t) {
-  t.plan(9);
+  t.plan(7);
   t.type(bindings.r, 'function');
   t.type(bindings.p, 'function');
-  t.type(bindings.s, 'function');
   t.type(bindings.q, 'function');
   t.equal(bindings.r('a string value'), 'a string value');
   t.equal(bindings.r(), 'default');
   t.ok(bindings.p());
-  t.equal(bindings.s(), 'yes, it works');
   t.ok(bindings.q());
 });

From 4b6404af2e0cb6d7fe238688ea9549de17da658d Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 23 May 2015 15:14:51 +0300
Subject: [PATCH 14/84] Update for V8 v4.3

---
 Makefile                            |  13 ++
 examples/async_pi_estimate/addon.cc |   4 +-
 nan.h                               | 160 ++++++++++++----
 nan_converters.h                    |  65 +++++++
 nan_converters_43_inl.h             |  42 ++++
 nan_converters_pre_43_inl.h         |  42 ++++
 nan_implementation_12_inl.h         | 159 +++++++++++++--
 nan_implementation_pre_12_inl.h     |  28 +--
 nan_maybe_43_inl.h                  | 215 +++++++++++++++++++++
 nan_maybe_pre_43_inl.h              | 287 ++++++++++++++++++++++++++++
 nan_new.h                           |  30 ++-
 nan_string_bytes.h                  |  16 +-
 test/binding.gyp                    |   8 +
 test/cpp/accessors.cpp              |  23 ++-
 test/cpp/accessors2.cpp             | 161 ++++++++++++++++
 test/cpp/asyncprogressworker.cpp    |   9 +-
 test/cpp/asyncworker.cpp            |   8 +-
 test/cpp/asyncworkererror.cpp       |   4 +-
 test/cpp/bufferworkerpersistent.cpp |  15 +-
 test/cpp/converters.cpp             | 128 +++++++++++++
 test/cpp/error.cpp                  |   9 +-
 test/cpp/gc.cpp                     |   8 +-
 test/cpp/indexedinterceptors.cpp    |  10 +-
 test/cpp/isolatedata.cpp            |   4 +-
 test/cpp/makecallback.cpp           |   6 +-
 test/cpp/morenews.cpp               |  42 ++--
 test/cpp/multifile1.cpp             |   4 +-
 test/cpp/multifile2.cpp             |   2 +-
 test/cpp/namedinterceptors.cpp      |  10 +-
 test/cpp/nancallback.cpp            |  26 ++-
 test/cpp/nannew.cpp                 |  97 ++++++----
 test/cpp/news.cpp                   | 153 ++++++++-------
 test/cpp/objectwraphandle.cpp       |   4 +-
 test/cpp/persistent.cpp             |  24 +--
 test/cpp/returnemptystring.cpp      |   4 +-
 test/cpp/returnnull.cpp             |   4 +-
 test/cpp/returnundefined.cpp        |   4 +-
 test/cpp/returnvalue.cpp            |  14 +-
 test/cpp/settemplate.cpp            |  38 +++-
 test/cpp/strings.cpp                |  16 +-
 test/cpp/symbols.cpp                |   5 +-
 test/cpp/threadlocal.cpp            |   6 +-
 test/cpp/weak.cpp                   |   6 +-
 test/cpp/weak2.cpp                  |   6 +-
 test/js/accessors2-test.js          |  27 +++
 test/js/converters-test.js          |  45 +++++
 46 files changed, 1652 insertions(+), 339 deletions(-)
 create mode 100644 nan_converters.h
 create mode 100644 nan_converters_43_inl.h
 create mode 100644 nan_converters_pre_43_inl.h
 create mode 100644 nan_maybe_43_inl.h
 create mode 100644 nan_maybe_pre_43_inl.h
 create mode 100644 test/cpp/accessors2.cpp
 create mode 100644 test/cpp/converters.cpp
 create mode 100644 test/js/accessors2-test.js
 create mode 100644 test/js/converters-test.js

diff --git a/Makefile b/Makefile
index 665471a4..34138dce 100644
--- a/Makefile
+++ b/Makefile
@@ -18,14 +18,20 @@ LINT_SOURCES = \
 	nan_callbacks.h \
 	nan_callbacks_12_inl.h \
 	nan_callbacks_pre_12_inl.h \
+	nan_converters.h \
+	nan_converters_43_inl.h \
+	nan_converters_pre_43_inl.h \
 	nan_implementation_12_inl.h \
 	nan_implementation_pre_12_inl.h \
+	nan_maybe_43_inl.h \
+	nan_maybe_pre_43_inl.h \
 	nan_new.h \
 	nan_persistent_12_inl.h \
 	nan_persistent_pre_12_inl.h \
 	nan_string_bytes.h \
 	nan_weak.h \
 	test/cpp/accessors.cpp \
+	test/cpp/accessors2.cpp \
 	test/cpp/asyncworker.cpp \
 	test/cpp/asyncprogressworker.cpp \
 	test/cpp/asyncworkererror.cpp \
@@ -36,6 +42,10 @@ LINT_SOURCES = \
 	test/cpp/isolatedata.cpp \
 	test/cpp/makecallback.cpp \
 	test/cpp/morenews.cpp \
+	test/cpp/converters.cpp \
+	test/cpp/isolatedata.cpp \
+	test/cpp/makecallback.cpp \
+	test/cpp/morenews.cpp \
 	test/cpp/multifile1.cpp \
 	test/cpp/multifile2.cpp \
 	test/cpp/multifile2.h \
@@ -54,6 +64,7 @@ LINT_SOURCES = \
 	test/cpp/strings.cpp \
 	test/cpp/symbols.cpp \
 	test/cpp/threadlocal.cpp \
+	test/cpp/trycatch.cpp \
 	test/cpp/weak.cpp \
 	test/cpp/weak2.cpp \
 	node_modules/node-gyp/gyp/data/win/large-pdb-shim.cc
@@ -74,6 +85,8 @@ forcetest:
 
 $(ADDONS): nan.h nan_new.h nan_implementation_pre_12_inl.h nan_implementation_12_inl.h \
 		nan_callbacks.h nan_callbacks_12_inl.h nan_callbacks_pre_12_inl.h \
+		nan_converters.h nan_converters_43_inl.h nan_converters_pre_43_inl.h \
+		nan_maybe_43_inl.h nan_maybe_pre_43_inl.h \
 		nan_persistent_12_inl.h nan_persistent_pre_12_inl.h nan_weak.h \
 		nan_string_bytes.h test/binding.gyp $(SOURCES)
 	cd test/ && ../node_modules/.bin/node-gyp rebuild
diff --git a/examples/async_pi_estimate/addon.cc b/examples/async_pi_estimate/addon.cc
index e8956938..b0e72da3 100644
--- a/examples/async_pi_estimate/addon.cc
+++ b/examples/async_pi_estimate/addon.cc
@@ -18,10 +18,10 @@ using v8::String;
 // Expose synchronous and asynchronous access to our
 // Estimate() function
 void InitAll(Handle<Object> exports) {
-  exports->Set(NanNew<String>("calculateSync"),
+  exports->Set(NanNew<String>("calculateSync").ToLocalChecked(),
     NanNew<FunctionTemplate>(CalculateSync)->GetFunction());
 
-  exports->Set(NanNew<String>("calculateAsync"),
+  exports->Set(NanNew<String>("calculateAsync").ToLocalChecked(),
     NanNew<FunctionTemplate>(CalculateAsync)->GetFunction());
 }
 
diff --git a/nan.h b/nan.h
index ecaf6819..3316522b 100644
--- a/nan.h
+++ b/nan.h
@@ -118,7 +118,7 @@ typedef v8::String::ExternalOneByteStringResource
     NanExternalOneByteStringResource;
 #endif
 
-#if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
+#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
 template<typename T>
 class NanNonCopyablePersistentTraits :
     public v8::NonCopyablePersistentTraits<T> {};
@@ -138,8 +138,17 @@ template<typename T> class NanPersistentBase;
 template<typename T, typename P> class NanWeakCallbackData;
 template<typename T, typename M = NanNonCopyablePersistentTraits<T> >
 class NanPersistent;
+#endif  // NODE_MODULE_VERSION
+
+
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+# include "nan_maybe_43_inl.h"  // NOLINT(build/include)
+#else
+# include "nan_maybe_pre_43_inl.h"  // NOLINT(build/include)
 #endif
 
+#include "nan_converters.h"  // NOLINT(build/include)
 #include "nan_new.h"  // NOLINT(build/include)
 
 // uv helpers
@@ -276,6 +285,19 @@ template<typename P> class NanWeakCallbackInfo;
 #endif
 
 namespace Nan { namespace imp {
+  template<typename T>
+  NAN_INLINE
+  v8::Local<T>
+  NanUnwrap(NanMaybeLocal<T> maybe) {
+    return maybe.ToLocalChecked();
+  }
+
+  template<typename T>
+  NAN_INLINE
+  v8::Local<T> NanUnwrap(v8::Local<T> val) {
+    return val;
+  }
+
   template<typename T>
   NAN_INLINE v8::Persistent<T> &NanEnsureHandleOrPersistent(
       v8::Persistent<T> &val) {  // NOLINT(runtime/references)
@@ -294,8 +316,10 @@ namespace Nan { namespace imp {
   }
 
   template<typename T>
-  NAN_INLINE v8::Local<v8::Value> NanEnsureHandleOrPersistent(const T &val) {
-    return NanNew(val);
+  NAN_INLINE
+  v8::Local<v8::Value>
+  NanEnsureHandleOrPersistent(T val) {
+    return NanUnwrap(NanNew(val));
   }
 
   template<typename T>
@@ -314,8 +338,9 @@ namespace Nan { namespace imp {
   }
 
   template<typename T>
-  NAN_INLINE v8::Local<v8::Value> NanEnsureLocal(const T &val) {
-    return NanNew(val);
+  NAN_INLINE
+  v8::Local<v8::Value> NanEnsureLocal(T val) {
+    return NanUnwrap(NanNew(val));
   }
 }  // end of namespace imp
 }  // end of namespace Nan
@@ -405,9 +430,17 @@ class NanEscapableScope {
     v8::Isolate::GetCurrent()->SetAddHistogramSampleFunction(cb);
   }
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+  NAN_INLINE bool NanIdleNotification(int idle_time_in_ms) {
+    return v8::Isolate::GetCurrent()->IdleNotificationDeadline(
+        idle_time_in_ms * 0.001);
+  }
+# else
   NAN_INLINE bool NanIdleNotification(int idle_time_in_ms) {
     return v8::Isolate::GetCurrent()->IdleNotification(idle_time_in_ms);
   }
+#endif
 
   NAN_INLINE void NanLowMemoryNotification() {
     v8::Isolate::GetCurrent()->LowMemoryNotification();
@@ -466,6 +499,10 @@ class NanEscapableScope {
     return scope.Escape(NanNew(v8::False(v8::Isolate::GetCurrent())));
   }
 
+  NAN_INLINE v8::Local<v8::String> NanEmptyString() {
+    return v8::String::Empty(v8::Isolate::GetCurrent());
+  }
+
   NAN_INLINE int NanAdjustExternalMemory(int bc) {
     return static_cast<int>(
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(bc));
@@ -534,26 +571,26 @@ class NanEscapableScope {
   }
 
 # define X(NAME)                                                               \
-    NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
+    NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *msg) {             \
       NanEscapableScope scope;                                                 \
-      return scope.Escape(v8::Exception::NAME(NanNew(errmsg)));                \
+      return scope.Escape(v8::Exception::NAME(NanNew(msg).ToLocalChecked()));  \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    v8::Local<v8::Value> Nan ## NAME(v8::Handle<v8::String> errmsg) {          \
-      return v8::Exception::NAME(errmsg);                                      \
+    v8::Local<v8::Value> Nan ## NAME(v8::Handle<v8::String> msg) {             \
+      return v8::Exception::NAME(msg);                                         \
     }                                                                          \
                                                                                \
-    NAN_INLINE void NanThrow ## NAME(const char *errmsg) {                     \
+    NAN_INLINE void NanThrow ## NAME(const char *msg) {                        \
       NanScope scope;                                                          \
       v8::Isolate::GetCurrent()->ThrowException(                               \
-          v8::Exception::NAME(NanNew(errmsg)));                                \
+          v8::Exception::NAME(NanNew(msg).ToLocalChecked()));                  \
     }                                                                          \
                                                                                \
-    NAN_INLINE void NanThrow ## NAME(v8::Handle<v8::String> errmsg) {          \
+    NAN_INLINE void NanThrow ## NAME(v8::Handle<v8::String> msg) {             \
       NanScope scope;                                                          \
       v8::Isolate::GetCurrent()->ThrowException(                               \
-          v8::Exception::NAME(NanNew(errmsg)));                                \
+          v8::Exception::NAME(NanNew(msg)));                                   \
     }
 
   X(Error)
@@ -603,33 +640,65 @@ class NanEscapableScope {
     return NanNew(function_template)->HasInstance(value);
   }
 
-  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
   ) {
     v8::ScriptCompiler::Source source(s, origin);
-    return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source);
+    return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &source);
   }
 
-  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
   ) {
     v8::ScriptCompiler::Source source(s);
-    return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source);
+    return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &source);
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanRunScript(
+  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
       v8::Handle<NanUnboundScript> script
   ) {
-    return script->BindToCurrentContext()->Run();
+    return script->BindToCurrentContext()->Run(NanGetCurrentContext());
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanRunScript(
+  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
       v8::Handle<NanBoundScript> script
   ) {
-    return script->Run();
+    return script->Run(NanGetCurrentContext());
+  }
+#else
+  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+      v8::Local<v8::String> s
+    , const v8::ScriptOrigin& origin
+  ) {
+    v8::ScriptCompiler::Source source(s, origin);
+    return NanMaybeLocal<NanBoundScript>(
+        v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
+  }
+
+  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+      v8::Local<v8::String> s
+  ) {
+    v8::ScriptCompiler::Source source(s);
+    return NanMaybeLocal<NanBoundScript>(
+        v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
   }
 
+  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
+      v8::Handle<NanUnboundScript> script
+  ) {
+    return NanMaybeLocal<v8::Value>(script->BindToCurrentContext()->Run());
+  }
+
+  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
+      v8::Handle<NanBoundScript> script
+  ) {
+    return NanMaybeLocal<v8::Value>(script->Run());
+  }
+#endif
+
   NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
       v8::Handle<v8::Object> target
     , v8::Handle<v8::Function> func
@@ -803,6 +872,10 @@ class NanEscapableScope {
     return scope.Escape(NanNew(v8::False()));
   }
 
+  NAN_INLINE v8::Local<v8::String> NanEmptyString() {
+    return v8::String::Empty();
+  }
+
   NAN_INLINE int NanAdjustExternalMemory(int bc) {
     return static_cast<int>(v8::V8::AdjustAmountOfExternalAllocatedMemory(bc));
   }
@@ -866,19 +939,19 @@ class NanEscapableScope {
   }
 
 # define X(NAME)                                                               \
-    NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *errmsg) {          \
+    NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *msg) {             \
       NanEscapableScope scope;                                                 \
-      return scope.Escape(v8::Exception::NAME(NanNew(errmsg)));                \
+      return scope.Escape(v8::Exception::NAME(NanNew(msg).ToLocalChecked()));  \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    v8::Local<v8::Value> Nan ## NAME(v8::Handle<v8::String> errmsg) {          \
-      return v8::Exception::NAME(errmsg);                                      \
+    v8::Local<v8::Value> Nan ## NAME(v8::Handle<v8::String> msg) {             \
+      return v8::Exception::NAME(msg);                                         \
     }                                                                          \
                                                                                \
-    NAN_INLINE void NanThrow ## NAME(const char *errmsg) {                     \
+    NAN_INLINE void NanThrow ## NAME(const char *msg) {                        \
       NanScope scope;                                                          \
-      v8::ThrowException(v8::Exception::NAME(NanNew(errmsg)));                 \
+      v8::ThrowException(v8::Exception::NAME(NanNew(msg).ToLocalChecked()));   \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
@@ -944,21 +1017,23 @@ class NanEscapableScope {
     return function_template->HasInstance(value);
   }
 
-  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
   ) {
-    return v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin));
+    return NanMaybeLocal<NanBoundScript>(
+        v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin)));
   }
 
-  NAN_INLINE v8::Local<NanBoundScript> NanCompileScript(
+  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
     v8::Local<v8::String> s
   ) {
-    return v8::Script::Compile(s);
+    return NanMaybeLocal<NanBoundScript>(v8::Script::Compile(s));
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanRunScript(v8::Handle<v8::Script> script) {
-    return script->Run();
+  NAN_INLINE
+  NanMaybeLocal<v8::Value> NanRunScript(v8::Handle<v8::Script> script) {
+    return NanMaybeLocal<v8::Value>(script->Run());
   }
 
   NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
@@ -1245,7 +1320,7 @@ class NanCallback {
 
   NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
     NanScope scope;
-    NanNew(handle)->Set(kCallbackIndex, fn);
+    NanSet(NanNew(handle), kCallbackIndex, fn);
   }
 
   NAN_INLINE v8::Local<v8::Function> GetFunction() const {
@@ -1357,7 +1432,7 @@ class NanCallback {
   NAN_INLINE void SaveToPersistent(
       const char *key, const v8::Local<v8::Value> &value) {
     NanScope scope;
-    NanNew(persistentHandle)->Set(NanNew(key), value);
+    NanNew(persistentHandle)->Set(NanNew(key).ToLocalChecked(), value);
   }
 
   NAN_INLINE void SaveToPersistent(
@@ -1374,7 +1449,8 @@ class NanCallback {
 
   NAN_INLINE v8::Local<v8::Value> GetFromPersistent(const char *key) const {
     NanEscapableScope scope;
-    return scope.Escape(NanNew(persistentHandle)->Get(NanNew(key)));
+    return scope.Escape(
+        NanNew(persistentHandle)->Get(NanNew(key).ToLocalChecked()));
   }
 
   NAN_INLINE v8::Local<v8::Object>
@@ -1408,7 +1484,7 @@ class NanCallback {
     NanScope scope;
 
     v8::Local<v8::Value> argv[] = {
-        v8::Exception::Error(NanNew<v8::String>(ErrorMessage()))
+      v8::Exception::Error(NanNew<v8::String>(ErrorMessage()).ToLocalChecked())
     };
     callback->Call(1, argv);
   }
@@ -1714,7 +1790,7 @@ NAN_INLINE void NanSetPrototypeMethod(
       callback
     , v8::Handle<v8::Value>()
     , NanNew<v8::Signature>(recv))->GetFunction();
-  v8::Local<v8::String> fn_name = NanNew(name);
+  v8::Local<v8::String> fn_name = NanNew(name).ToLocalChecked();
   recv->PrototypeTemplate()->Set(fn_name, fn);
   fn->SetName(fn_name);
 }
@@ -1995,7 +2071,7 @@ inline
 void
 NanExport(v8::Handle<v8::Object> target, const char *name,
     NanFunctionCallback f) {
-  target->Set(NanNew<v8::String>(name),
+  NanSet(target, NanNew<v8::String>(name).ToLocalChecked(),
       NanNew<v8::FunctionTemplate>(f)->GetFunction());
 }
 
@@ -2003,7 +2079,7 @@ NanExport(v8::Handle<v8::Object> target, const char *name,
 
 struct NanTap {
   explicit NanTap(v8::Handle<v8::Value> t) : t_() {
-    t_.Reset(t->ToObject());
+    t_.Reset(NanTo<v8::Object>(t).ToLocalChecked());
   }
 
   ~NanTap() { t_.Reset(); }  // not sure if neccessary
@@ -2016,13 +2092,13 @@ struct NanTap {
   inline void ok(bool isOk, const char *msg = NULL) {
     v8::Handle<v8::Value> args[2];
     args[0] = NanNew(isOk);
-    if (msg) args[1] = NanNew(msg);
+    if (msg) args[1] = NanNew(msg).ToLocalChecked();
     NanMakeCallback(NanNew(t_), "ok", msg ? 2 : 1, args);
   }
 
   inline void pass(const char * msg = NULL) {
     v8::Handle<v8::Value> hmsg;
-    if (msg) hmsg = NanNew(msg);
+    if (msg) hmsg = NanNew(msg).ToLocalChecked();
     NanMakeCallback(NanNew(t_), "pass", msg ? 1 : 0, &hmsg);
   }
 
diff --git a/nan_converters.h b/nan_converters.h
new file mode 100644
index 00000000..776e6d8e
--- /dev/null
+++ b/nan_converters.h
@@ -0,0 +1,65 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_CONVERTERS_H_
+#define NAN_CONVERTERS_H_
+
+namespace Nan { namespace imp {
+template<typename T> struct ToFactoryBase {
+  typedef NanMaybeLocal<T> return_t;
+};
+template<typename T> struct ValueFactoryBase { typedef NanMaybe<T> return_t; };
+
+template<typename T> struct ToFactory;
+
+#define X(TYPE)                                                                \
+    template<>                                                                 \
+    struct ToFactory<v8::TYPE> : ToFactoryBase<v8::TYPE> {                     \
+      static inline return_t convert(v8::Handle<v8::Value> val);               \
+    };
+
+X(Boolean)
+X(Number)
+X(String)
+X(Object)
+X(Integer)
+X(Uint32)
+X(Int32)
+
+#undef X
+
+#define X(TYPE)                                                                \
+    template<>                                                                 \
+    struct ToFactory<TYPE> : ValueFactoryBase<TYPE> {                          \
+      static inline return_t convert(v8::Handle<v8::Value> val);               \
+    };
+
+X(bool)
+X(double)
+X(int64_t)
+X(uint32_t)
+X(int32_t)
+
+#undef X
+}  // end of namespace imp
+}  // end of namespace Nan
+
+template<typename T>
+NAN_INLINE
+typename Nan::imp::ToFactory<T>::return_t NanTo(v8::Handle<v8::Value> val) {
+  return Nan::imp::ToFactory<T>::convert(val);
+}
+
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+# include "nan_converters_43_inl.h"
+#else
+# include "nan_converters_pre_43_inl.h"
+#endif
+
+#endif  // NAN_CONVERTERS_H_
diff --git a/nan_converters_43_inl.h b/nan_converters_43_inl.h
new file mode 100644
index 00000000..ba5fe776
--- /dev/null
+++ b/nan_converters_43_inl.h
@@ -0,0 +1,42 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_CONVERTERS_43_INL_H_
+#define NAN_CONVERTERS_43_INL_H_
+
+#define X(TYPE)                                                                \
+Nan::imp::ToFactory<v8::TYPE>::return_t                                        \
+Nan::imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {            \
+  return val->To ## TYPE(NanGetCurrentContext());                              \
+}
+
+X(Boolean)
+X(Number)
+X(String)
+X(Object)
+X(Integer)
+X(Uint32)
+X(Int32)
+
+#undef X
+
+#define X(TYPE, NAME)                                                          \
+Nan::imp::ToFactory<TYPE>::return_t                                            \
+Nan::imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                \
+  return val->NAME ##Value(NanGetCurrentContext());                            \
+}
+
+X(bool, Boolean)
+X(double, Number)
+X(int64_t, Integer)
+X(uint32_t, Uint32)
+X(int32_t, Int32)
+
+#undef X
+
+#endif  // NAN_CONVERTERS_43_INL_H_
diff --git a/nan_converters_pre_43_inl.h b/nan_converters_pre_43_inl.h
new file mode 100644
index 00000000..f3772da7
--- /dev/null
+++ b/nan_converters_pre_43_inl.h
@@ -0,0 +1,42 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_CONVERTERS_PRE_43_INL_H_
+#define NAN_CONVERTERS_PRE_43_INL_H_
+
+#define X(TYPE)                                                                \
+Nan::imp::ToFactory<v8::TYPE>::return_t                                        \
+Nan::imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {            \
+  return NanMaybeLocal<v8::TYPE>(val->To ## TYPE());                           \
+}
+
+X(Boolean)
+X(Number)
+X(String)
+X(Object)
+X(Integer)
+X(Uint32)
+X(Int32)
+
+#undef X
+
+#define X(TYPE, NAME)                                                          \
+Nan::imp::ToFactory<TYPE>::return_t                                            \
+Nan::imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                \
+  return NanJust<TYPE>(val->NAME ##Value());                                   \
+}
+
+X(bool, Boolean)
+X(double, Number)
+X(int64_t, Integer)
+X(uint32_t, Uint32)
+X(int32_t, Int32)
+
+#undef X
+
+#endif  // NAN_CONVERTERS_PRE_43_INL_H_
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index 8b5d206b..f9af72ce 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -62,10 +62,25 @@ Factory<v8::Context>::New( v8::ExtensionConfiguration* extensions
 
 //=== Date =====================================================================
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 Factory<v8::Date>::return_t
 Factory<v8::Date>::New(double value) {
-  return v8::Date::New(v8::Isolate::GetCurrent(), value).As<v8::Date>();
+  v8::Local<v8::Date> ret;
+  if (v8::Date::New(NanGetCurrentContext(), value).
+      ToLocal(reinterpret_cast<v8::Local<v8::Value>*>(&ret))) {
+    return v8::MaybeLocal<v8::Date>(ret);
+  } else {
+    return v8::MaybeLocal<v8::Date>(ret);
+  }
+}
+#else
+Factory<v8::Date>::return_t
+Factory<v8::Date>::New(double value) {
+  return Factory<v8::Date>::return_t(
+      v8::Date::New(v8::Isolate::GetCurrent(), value).As<v8::Date>());
 }
+#endif
 
 //=== External =================================================================
 
@@ -84,7 +99,13 @@ Factory<v8::Function>::New( NanFunctionCallback callback
   static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
   tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+  v8::Local<v8::Object> obj =
+      tpl->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+#else
   v8::Local<v8::Object> obj = tpl->NewInstance();
+#endif
 
   obj->SetAlignedPointerInInternalField(
       Nan::imp::kFunctionIndex
@@ -112,7 +133,13 @@ Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
   static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
   tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+  v8::Local<v8::Object> obj =
+      tpl->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+#else
   v8::Local<v8::Object> obj = tpl->NewInstance();
+#endif
 
   obj->SetAlignedPointerInInternalField(
       Nan::imp::kFunctionIndex
@@ -187,28 +214,56 @@ Factory<v8::ObjectTemplate>::New() {
 
 //=== RegExp ===================================================================
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+Factory<v8::RegExp>::return_t
+Factory<v8::RegExp>::New(
+    v8::Handle<v8::String> pattern
+  , v8::RegExp::Flags flags) {
+  return v8::RegExp::New(NanGetCurrentContext(), pattern, flags);
+}
+#else
 Factory<v8::RegExp>::return_t
 Factory<v8::RegExp>::New(
     v8::Handle<v8::String> pattern
   , v8::RegExp::Flags flags) {
-  return v8::RegExp::New(pattern, flags);
+  return Factory<v8::RegExp>::return_t(v8::RegExp::New(pattern, flags));
 }
+#endif
 
 //=== Script ===================================================================
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 Factory<v8::Script>::return_t
 Factory<v8::Script>::New( v8::Local<v8::String> source) {
   v8::ScriptCompiler::Source src(source);
-  return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src);
+  return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &src);
 }
 
 Factory<v8::Script>::return_t
 Factory<v8::Script>::New( v8::Local<v8::String> source
                         , v8::ScriptOrigin const& origin) {
   v8::ScriptCompiler::Source src(source, origin);
-  return v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src);
+  return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &src);
+}
+#else
+Factory<v8::Script>::return_t
+Factory<v8::Script>::New( v8::Local<v8::String> source) {
+  v8::ScriptCompiler::Source src(source);
+  return Factory<v8::Script>::return_t(
+      v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src));
 }
 
+Factory<v8::Script>::return_t
+Factory<v8::Script>::New( v8::Local<v8::String> source
+                        , v8::ScriptOrigin const& origin) {
+  v8::ScriptCompiler::Source src(source, origin);
+  return Factory<v8::Script>::return_t(
+      v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &src));
+}
+#endif
+
 //=== Signature ================================================================
 
 Factory<v8::Signature>::return_t
@@ -220,44 +275,100 @@ Factory<v8::Signature>::New(Factory<v8::Signature>::FTH receiver) {
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New() {
-  return v8::String::Empty(v8::Isolate::GetCurrent());
+  return Factory<v8::String>::return_t(
+      v8::String::Empty(v8::Isolate::GetCurrent()));
 }
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const char * value, int length) {
-  return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), value,
-      v8::String::kNormalString, length);
+  return v8::String::NewFromUtf8(
+      v8::Isolate::GetCurrent(), value, v8::NewStringType::kNormal, length);
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(std::string const& value) {
   assert(value.size() <= INT_MAX && "string too long");
   return v8::String::NewFromUtf8(v8::Isolate::GetCurrent(),
-      value.data(), v8::String::kNormalString, static_cast<int>(value.size()));
+      value.data(), v8::NewStringType::kNormal, static_cast<int>(value.size()));
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const uint8_t * value, int length) {
   return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value,
-        v8::String::kNormalString, length);
+        v8::NewStringType::kNormal, length);
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const uint16_t * value, int length) {
   return v8::String::NewFromTwoByte(v8::Isolate::GetCurrent(), value,
-        v8::String::kNormalString, length);
+        v8::NewStringType::kNormal, length);
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
-  return v8::String::NewExternal(v8::Isolate::GetCurrent(), value);
+  return v8::String::NewExternalTwoByte(v8::Isolate::GetCurrent(), value);
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(NanExternalOneByteStringResource * value) {
-  return v8::String::NewExternal(v8::Isolate::GetCurrent(), value);
+  return v8::String::NewExternalOneByte(v8::Isolate::GetCurrent(), value);
+}
+#else
+Factory<v8::String>::return_t
+Factory<v8::String>::New(const char * value, int length) {
+  return Factory<v8::String>::return_t(
+      v8::String::NewFromUtf8(
+          v8::Isolate::GetCurrent()
+        , value
+        , v8::String::kNormalString
+        , length));
 }
 
+Factory<v8::String>::return_t
+Factory<v8::String>::New(std::string const& value) {
+  assert(value.size() <= INT_MAX && "string too long");
+  return Factory<v8::String>::return_t(
+      v8::String::NewFromUtf8(
+          v8::Isolate::GetCurrent()
+        , value.data()
+        , v8::String::kNormalString
+        , static_cast<int>(value.size())));
+}
+
+Factory<v8::String>::return_t
+Factory<v8::String>::New(const uint8_t * value, int length) {
+  return Factory<v8::String>::return_t(
+      v8::String::NewFromOneByte(
+          v8::Isolate::GetCurrent()
+        , value
+        , v8::String::kNormalString, length));
+}
+
+Factory<v8::String>::return_t
+Factory<v8::String>::New(const uint16_t * value, int length) {
+  return Factory<v8::String>::return_t(
+      v8::String::NewFromTwoByte(
+          v8::Isolate::GetCurrent()
+        , value
+        , v8::String::kNormalString
+        , length));
+}
+
+Factory<v8::String>::return_t
+Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
+  return Factory<v8::String>::return_t(
+      v8::String::NewExternal(v8::Isolate::GetCurrent(), value));
+}
+
+Factory<v8::String>::return_t
+Factory<v8::String>::New(NanExternalOneByteStringResource * value) {
+  return Factory<v8::String>::return_t(
+      v8::String::NewExternal(v8::Isolate::GetCurrent(), value));
+}
+#endif
+
 //=== String Object ============================================================
 
 Factory<v8::StringObject>::return_t
@@ -267,18 +378,38 @@ Factory<v8::StringObject>::New(v8::Handle<v8::String> value) {
 
 //=== Unbound Script ===========================================================
 
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+Factory<v8::UnboundScript>::return_t
+Factory<v8::UnboundScript>::New(v8::Local<v8::String> source) {
+  v8::ScriptCompiler::Source src(source);
+  return v8::ScriptCompiler::CompileUnboundScript(
+      v8::Isolate::GetCurrent(), &src);
+}
+
+Factory<v8::UnboundScript>::return_t
+Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
+                               , v8::ScriptOrigin const& origin) {
+  v8::ScriptCompiler::Source src(source, origin);
+  return v8::ScriptCompiler::CompileUnboundScript(
+      v8::Isolate::GetCurrent(), &src);
+}
+#else
 Factory<v8::UnboundScript>::return_t
 Factory<v8::UnboundScript>::New(v8::Local<v8::String> source) {
   v8::ScriptCompiler::Source src(source);
-  return v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src);
+  return Factory<v8::UnboundScript>::return_t(
+      v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src));
 }
 
 Factory<v8::UnboundScript>::return_t
 Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
                                , v8::ScriptOrigin const& origin) {
   v8::ScriptCompiler::Source src(source, origin);
-  return v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src);
+  return Factory<v8::UnboundScript>::return_t(
+      v8::ScriptCompiler::CompileUnbound(v8::Isolate::GetCurrent(), &src));
 }
+#endif
 
 }  // end of namespace imp
 }  // end of namespace Nan
diff --git a/nan_implementation_pre_12_inl.h b/nan_implementation_pre_12_inl.h
index 9473b0b8..6b222b8c 100644
--- a/nan_implementation_pre_12_inl.h
+++ b/nan_implementation_pre_12_inl.h
@@ -72,7 +72,7 @@ Factory<v8::Context>::New( v8::ExtensionConfiguration* extensions
 
 Factory<v8::Date>::return_t
 Factory<v8::Date>::New(double value) {
-  return v8::Date::New(value).As<v8::Date>();
+  return Factory<v8::Date>::return_t(v8::Date::New(value).As<v8::Date>());
 }
 
 //=== External =================================================================
@@ -184,19 +184,20 @@ Factory<v8::RegExp>::return_t
 Factory<v8::RegExp>::New(
     v8::Handle<v8::String> pattern
   , v8::RegExp::Flags flags) {
-  return v8::RegExp::New(pattern, flags);
+  return Factory<v8::RegExp>::return_t(v8::RegExp::New(pattern, flags));
 }
 
 //=== Script ===================================================================
 
 Factory<v8::Script>::return_t
 Factory<v8::Script>::New( v8::Local<v8::String> source) {
-  return v8::Script::New(source);
+  return Factory<v8::Script>::return_t(v8::Script::New(source));
 }
 Factory<v8::Script>::return_t
 Factory<v8::Script>::New( v8::Local<v8::String> source
                         , v8::ScriptOrigin const& origin) {
-  return v8::Script::New(source, const_cast<v8::ScriptOrigin*>(&origin));
+  return Factory<v8::Script>::return_t(
+      v8::Script::New(source, const_cast<v8::ScriptOrigin*>(&origin)));
 }
 
 //=== Signature ================================================================
@@ -210,18 +211,19 @@ Factory<v8::Signature>::New(Factory<v8::Signature>::FTH receiver) {
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New() {
-  return v8::String::Empty();
+  return Factory<v8::String>::return_t(v8::String::Empty());
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const char * value, int length) {
-  return v8::String::New(value, length);
+  return Factory<v8::String>::return_t(v8::String::New(value, length));
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(std::string const& value) {
   assert(value.size() <= INT_MAX && "string too long");
-  return v8::String::New( value.data(), static_cast<int>(value.size()));
+  return Factory<v8::String>::return_t(
+      v8::String::New( value.data(), static_cast<int>(value.size())));
 }
 
 inline
@@ -238,7 +240,7 @@ widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l = -1) {
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const uint16_t * value, int length) {
-  return v8::String::New(value, length);
+  return Factory<v8::String>::return_t(v8::String::New(value, length));
 }
 
 Factory<v8::String>::return_t
@@ -246,21 +248,21 @@ Factory<v8::String>::New(const uint8_t * value, int length) {
   std::vector<uint16_t> wideString;
   widenString(&wideString, value, length);
   if (wideString.size() == 0) {
-    return v8::String::Empty();
+    return Factory<v8::String>::return_t(v8::String::Empty());
   } else {
-    return v8::String::New(&wideString.front()
-         , static_cast<int>(wideString.size()));
+    return Factory<v8::String>::return_t(v8::String::New(&wideString.front()
+         , static_cast<int>(wideString.size())));
   }
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
-  return v8::String::NewExternal(value);
+  return Factory<v8::String>::return_t(v8::String::NewExternal(value));
 }
 
 Factory<v8::String>::return_t
 Factory<v8::String>::New(v8::String::ExternalAsciiStringResource * value) {
-  return v8::String::NewExternal(value);
+  return Factory<v8::String>::return_t(v8::String::NewExternal(value));
 }
 
 //=== String Object ============================================================
diff --git a/nan_maybe_43_inl.h b/nan_maybe_43_inl.h
new file mode 100644
index 00000000..dd8d47bc
--- /dev/null
+++ b/nan_maybe_43_inl.h
@@ -0,0 +1,215 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_MAYBE_43_INL_H_
+#define NAN_MAYBE_43_INL_H_
+
+template<typename T>
+using NanMaybeLocal = v8::MaybeLocal<T>;
+
+template<typename T>
+using NanMaybe = v8::Maybe<T>;
+
+template<typename T>
+NAN_INLINE NanMaybe<T> NanNothing() {
+  return v8::Nothing<T>();
+}
+
+template<typename T>
+NAN_INLINE NanMaybe<T> NanJust(const T& t) {
+  return v8::Just<T>(t);
+}
+
+v8::Local<v8::Context> NanGetCurrentContext();
+
+NAN_INLINE
+NanMaybeLocal<v8::String> NanToDetailString(v8::Handle<v8::Value> val) {
+  return val->ToDetailString(NanGetCurrentContext());
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Uint32> NanToArrayIndex(v8::Handle<v8::Value> val) {
+  return val->ToArrayIndex(NanGetCurrentContext());
+}
+
+NAN_INLINE
+NanMaybe<bool> NanEquals(v8::Handle<v8::Value> a, v8::Handle<v8::Value>(b)) {
+  return a->Equals(NanGetCurrentContext(), b);
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::Function> h) {
+  return NanMaybeLocal<v8::Object>(h->NewInstance(NanGetCurrentContext()));
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::ObjectTemplate> h) {
+  return NanMaybeLocal<v8::Object>(h->NewInstance(NanGetCurrentContext()));
+}
+
+
+NAN_INLINE NanMaybeLocal<v8::Function> NanGetFunction(
+    v8::Handle<v8::FunctionTemplate> t) {
+  return t->GetFunction(NanGetCurrentContext());
+}
+
+NAN_INLINE NanMaybe<bool> NanSet(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key
+  , v8::Handle<v8::Value> value) {
+  return obj->Set(NanGetCurrentContext(), key, value);
+}
+
+NAN_INLINE NanMaybe<bool> NanSet(
+    v8::Handle<v8::Object> obj
+  , uint32_t index
+  , v8::Handle<v8::Value> value) {
+  return obj->Set(NanGetCurrentContext(), index, value);
+}
+
+NAN_INLINE NanMaybe<bool> NanForceSet(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key
+  , v8::Handle<v8::Value> value
+  , v8::PropertyAttribute attribs = v8::None) {
+  return obj->ForceSet(NanGetCurrentContext(), key, value, attribs);
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanGet(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key) {
+  return obj->Get(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Value> NanGet(v8::Handle<v8::Object> obj, uint32_t index) {
+  return obj->Get(NanGetCurrentContext(), index);
+}
+
+NAN_INLINE v8::PropertyAttribute NanGetPropertyAttributes(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key) {
+  return obj->GetPropertyAttributes(NanGetCurrentContext(), key).FromJust();
+}
+
+NAN_INLINE NanMaybe<bool> NanHas(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return obj->Has(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE NanMaybe<bool> NanHas(v8::Handle<v8::Object> obj, uint32_t index) {
+  return obj->Has(NanGetCurrentContext(), index);
+}
+
+NAN_INLINE NanMaybe<bool> NanDelete(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return obj->Delete(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE
+NanMaybe<bool> NanDelete(v8::Handle<v8::Object> obj, uint32_t index) {
+  return obj->Delete(NanGetCurrentContext(), index);
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Array> NanGetPropertyNames(v8::Handle<v8::Object> obj) {
+  return obj->GetPropertyNames(NanGetCurrentContext());
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Array> NanGetOwnPropertyNames(v8::Handle<v8::Object> obj) {
+  return obj->GetOwnPropertyNames(NanGetCurrentContext());
+}
+
+NAN_INLINE NanMaybe<bool> NanSetPrototype(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> prototype) {
+  return obj->SetPrototype(NanGetCurrentContext(), prototype);
+}
+
+NAN_INLINE NanMaybeLocal<v8::String> NanObjectProtoToString(
+    v8::Handle<v8::Object> obj) {
+  return obj->ObjectProtoToString(NanGetCurrentContext());
+}
+
+NAN_INLINE NanMaybe<bool> NanHasOwnProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return obj->HasOwnProperty(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE NanMaybe<bool> NanHasRealNamedProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return obj->HasRealNamedProperty(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE NanMaybe<bool> NanHasRealIndexedProperty(
+    v8::Handle<v8::Object> obj
+  , uint32_t index) {
+  return obj->HasRealIndexedProperty(NanGetCurrentContext(), index);
+}
+
+NAN_INLINE NanMaybe<bool> NanHasRealNamedCallbackProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return obj->HasRealNamedCallbackProperty(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedPropertyInPrototypeChain(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return obj->GetRealNamedPropertyInPrototypeChain(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return obj->GetRealNamedProperty(NanGetCurrentContext(), key);
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsFunction(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Object> recv
+  , int argc
+  , v8::Handle<v8::Value> argv[]) {
+  return obj->CallAsFunction(NanGetCurrentContext(), recv, argc, argv);
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsConstructor(
+    v8::Handle<v8::Object> obj
+  , int argc, v8::Local<v8::Value> argv[]) {
+  return obj->CallAsConstructor(NanGetCurrentContext(), argc, argv);
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::String> NanGetSourceLine(v8::Handle<v8::Message> msg) {
+  return msg->GetSourceLine(NanGetCurrentContext());
+}
+
+NAN_INLINE NanMaybe<int> NanGetLineNumber(v8::Handle<v8::Message> msg) {
+  return msg->GetLineNumber(NanGetCurrentContext());
+}
+
+NAN_INLINE NanMaybe<int> NanGetStartColumn(v8::Handle<v8::Message> msg) {
+  return msg->GetStartColumn(NanGetCurrentContext());
+}
+
+NAN_INLINE NanMaybe<int> NanGetEndColumn(v8::Handle<v8::Message> msg) {
+  return msg->GetEndColumn(NanGetCurrentContext());
+}
+
+NAN_INLINE NanMaybeLocal<v8::Object> NanCloneElementAt(
+    v8::Handle<v8::Array> array
+  , uint32_t index) {
+  return array->CloneElementAt(NanGetCurrentContext(), index);
+}
+
+#endif  // NAN_MAYBE_43_INL_H_
diff --git a/nan_maybe_pre_43_inl.h b/nan_maybe_pre_43_inl.h
new file mode 100644
index 00000000..ef096da3
--- /dev/null
+++ b/nan_maybe_pre_43_inl.h
@@ -0,0 +1,287 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#ifndef NAN_MAYBE_PRE_43_INL_H_
+#define NAN_MAYBE_PRE_43_INL_H_
+
+template<typename T>
+class NanMaybeLocal {
+ public:
+  NAN_INLINE NanMaybeLocal() : val_(v8::Local<T>()) {}
+
+  template<typename S>
+# if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
+  NAN_INLINE NanMaybeLocal(v8::Local<S> that) : val_(that) {}
+# else
+  NAN_INLINE NanMaybeLocal(v8::Local<S> that) :
+      val_(*reinterpret_cast<v8::Local<T>*>(&that)) {}
+# endif
+
+  NAN_INLINE bool IsEmpty() const { return val_.IsEmpty(); }
+
+  template<typename S>
+  NAN_INLINE bool ToLocal(v8::Local<S> *out) const {
+    *out = val_;
+    return !IsEmpty();
+  }
+
+  NAN_INLINE v8::Local<T> ToLocalChecked() const {
+#if defined(V8_ENABLE_CHECKS)
+    assert(!IsEmpty() && "ToLocalChecked is Empty");
+#endif  // V8_ENABLE_CHECKS
+    return val_;
+  }
+
+  template<typename S>
+  NAN_INLINE v8::Local<S> FromMaybe(v8::Local<S> default_value) const {
+    return IsEmpty() ? default_value : val_;
+  }
+
+ private:
+  v8::Local<T> val_;
+};
+
+template<typename T>
+class NanMaybe {
+ public:
+  NAN_INLINE bool IsNothing() const { return !has_value_; }
+  NAN_INLINE bool IsJust() const { return has_value_; }
+
+  NAN_INLINE T FromJust() const {
+#if defined(V8_ENABLE_CHECKS)
+    assert(IsJust() && "FromJust is Nothing");
+#endif  // V8_ENABLE_CHECKS
+    return value_;
+  }
+
+  NAN_INLINE T FromMaybe(const T& default_value) const {
+    return has_value_ ? value_ : default_value;
+  }
+
+  NAN_INLINE bool operator==(const NanMaybe &other) const {
+    return (IsJust() == other.IsJust()) &&
+        (!IsJust() || FromJust() == other.FromJust());
+  }
+
+  NAN_INLINE bool operator!=(const NanMaybe &other) const {
+    return !operator==(other);
+  }
+
+ private:
+  NanMaybe() : has_value_(false) {}
+  explicit NanMaybe(const T& t) : has_value_(true), value_(t) {}
+  bool has_value_;
+  T value_;
+
+  template<typename U>
+  friend NanMaybe<U> NanNothing();
+  template<typename U>
+  friend NanMaybe<U> NanJust(const U& u);
+};
+
+template<typename T>
+inline NanMaybe<T> NanNothing() {
+  return NanMaybe<T>();
+}
+
+template<typename T>
+inline NanMaybe<T> NanJust(const T& t) {
+  return NanMaybe<T>(t);
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::String> NanToDetailString(v8::Handle<v8::Value> val) {
+  return NanMaybeLocal<v8::String>(val->ToDetailString());
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Uint32> NanToArrayIndex(v8::Handle<v8::Value> val) {
+  return NanMaybeLocal<v8::Uint32>(val->ToArrayIndex());
+}
+
+NAN_INLINE
+NanMaybe<bool> NanEquals(v8::Handle<v8::Value> a, v8::Handle<v8::Value>(b)) {
+  return NanJust<bool>(a->Equals(b));
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::Function> h) {
+  return NanMaybeLocal<v8::Object>(h->NewInstance());
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::ObjectTemplate> h) {
+  return NanMaybeLocal<v8::Object>(h->NewInstance());
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Function> NanGetFunction(v8::Handle<v8::FunctionTemplate> t) {
+  return NanMaybeLocal<v8::Function>(t->GetFunction());
+}
+
+NAN_INLINE NanMaybe<bool> NanSet(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key
+  , v8::Handle<v8::Value> value) {
+  return NanJust<bool>(obj->Set(key, value));
+}
+
+NAN_INLINE NanMaybe<bool> NanSet(
+    v8::Handle<v8::Object> obj
+  , uint32_t index
+  , v8::Handle<v8::Value> value) {
+  return NanJust<bool>(obj->Set(index, value));
+}
+
+NAN_INLINE NanMaybe<bool> NanForceSet(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key
+  , v8::Handle<v8::Value> value
+  , v8::PropertyAttribute attribs = v8::None) {
+  return NanJust<bool>(obj->ForceSet(key, value, attribs));
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanGet(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key) {
+  return NanMaybeLocal<v8::Value>(obj->Get(key));
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanGet(
+    v8::Handle<v8::Object> obj
+  , uint32_t index) {
+  return NanMaybeLocal<v8::Value>(obj->Get(index));
+}
+
+NAN_INLINE NanMaybe<v8::PropertyAttribute> NanGetPropertyAttributes(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> key) {
+  return NanJust<v8::PropertyAttribute>(obj->GetPropertyAttributes(key));
+}
+
+NAN_INLINE NanMaybe<bool> NanHas(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return NanJust<bool>(obj->Has(key));
+}
+
+NAN_INLINE NanMaybe<bool> NanHas(
+    v8::Handle<v8::Object> obj
+  , uint32_t index) {
+  return NanJust<bool>(obj->Has(index));
+}
+
+NAN_INLINE NanMaybe<bool> NanDelete(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return NanJust<bool>(obj->Delete(key));
+}
+
+NAN_INLINE NanMaybe<bool> NanDelete(
+    v8::Handle<v8::Object> obj
+  , uint32_t index) {
+  return NanJust<bool>(obj->Delete(index));
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Array> NanGetPropertyNames(v8::Handle<v8::Object> obj) {
+  return NanMaybeLocal<v8::Array>(obj->GetPropertyNames());
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::Array> NanGetOwnPropertyNames(v8::Handle<v8::Object> obj) {
+  return NanMaybeLocal<v8::Array>(obj->GetOwnPropertyNames());
+}
+
+NAN_INLINE NanMaybe<bool> NanSetPrototype(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Value> prototype) {
+  return NanJust<bool>(obj->SetPrototype(prototype));
+}
+
+NAN_INLINE NanMaybeLocal<v8::String> NanObjectProtoToString(
+    v8::Handle<v8::Object> obj) {
+  return NanMaybeLocal<v8::String>(obj->ObjectProtoToString());
+}
+
+NAN_INLINE NanMaybe<bool> NanHasOwnProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return NanJust<bool>(obj->HasOwnProperty(key));
+}
+
+NAN_INLINE NanMaybe<bool> NanHasRealNamedProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return NanJust<bool>(obj->HasRealNamedProperty(key));
+}
+
+NAN_INLINE NanMaybe<bool> NanHasRealIndexedProperty(
+    v8::Handle<v8::Object> obj
+  , uint32_t index) {
+  return NanJust<bool>(obj->HasRealIndexedProperty(index));
+}
+
+NAN_INLINE NanMaybe<bool> NanHasRealNamedCallbackProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return NanJust<bool>(obj->HasRealNamedCallbackProperty(key));
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedPropertyInPrototypeChain(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return NanMaybeLocal<v8::Value>(
+      obj->GetRealNamedPropertyInPrototypeChain(key));
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedProperty(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::String> key) {
+  return NanMaybeLocal<v8::Value>(obj->GetRealNamedProperty(key));
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsFunction(
+    v8::Handle<v8::Object> obj
+  , v8::Handle<v8::Object> recv
+  , int argc
+  , v8::Handle<v8::Value> argv[]) {
+  return NanMaybeLocal<v8::Value>(obj->CallAsFunction(recv, argc, argv));
+}
+
+NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsConstructor(
+    v8::Handle<v8::Object> obj
+  , int argc
+  , v8::Local<v8::Value> argv[]) {
+  return NanMaybeLocal<v8::Value>(obj->CallAsConstructor(argc, argv));
+}
+
+NAN_INLINE
+NanMaybeLocal<v8::String> NanGetSourceLine(v8::Handle<v8::Message> msg) {
+  return NanMaybeLocal<v8::String>(msg->GetSourceLine());
+}
+
+NAN_INLINE NanMaybe<int> NanGetLineNumber(v8::Handle<v8::Message> msg) {
+  return NanJust<int>(msg->GetLineNumber());
+}
+
+NAN_INLINE NanMaybe<int> NanGetStartColumn(v8::Handle<v8::Message> msg) {
+  return NanJust<int>(msg->GetStartColumn());
+}
+
+NAN_INLINE NanMaybe<int> NanGetEndColumn(v8::Handle<v8::Message> msg) {
+  return NanJust<int>(msg->GetEndColumn());
+}
+
+NAN_INLINE NanMaybeLocal<v8::Object> NanCloneElementAt(
+    v8::Handle<v8::Array> array
+  , uint32_t index) {
+  return NanMaybeLocal<v8::Object>(array->CloneElementAt(index));
+}
+
+#endif  // NAN_MAYBE_PRE_43_INL_H_
diff --git a/nan_new.h b/nan_new.h
index 67429f5d..3d5bcf71 100644
--- a/nan_new.h
+++ b/nan_new.h
@@ -26,19 +26,31 @@ template <typename T> v8::Local<T> To(v8::Handle<v8::Integer> i);
 template <>
 inline
 v8::Local<v8::Integer>
-To<v8::Integer>(v8::Handle<v8::Integer> i) { return i->ToInteger(); }
+To<v8::Integer>(v8::Handle<v8::Integer> i) {
+  return NanTo<v8::Integer>(i).ToLocalChecked();
+}
 
 template <>
 inline
 v8::Local<v8::Int32>
-To<v8::Int32>(v8::Handle<v8::Integer> i)   { return i->ToInt32(); }
+To<v8::Int32>(v8::Handle<v8::Integer> i) {
+  return NanTo<v8::Int32>(i).ToLocalChecked();
+}
 
 template <>
 inline
 v8::Local<v8::Uint32>
-To<v8::Uint32>(v8::Handle<v8::Integer> i)  { return i->ToUint32(); }
+To<v8::Uint32>(v8::Handle<v8::Integer> i) {
+  return NanTo<v8::Uint32>(i).ToLocalChecked();
+}
 
-template <typename T> struct FactoryBase { typedef v8::Local<T> return_t; };
+template <typename T> struct FactoryBase {
+  typedef v8::Local<T> return_t;
+};
+
+template <typename T> struct MaybeFactoryBase {
+  typedef NanMaybeLocal<T> return_t;
+};
 
 template <typename T> struct Factory;
 
@@ -68,7 +80,7 @@ struct Factory<v8::Context> : FactoryBase<v8::Context> {
 };
 
 template <>
-struct Factory<v8::Date> : FactoryBase<v8::Date> {
+struct Factory<v8::Date> : MaybeFactoryBase<v8::Date> {
   static inline return_t New(double value);
 };
 
@@ -134,13 +146,13 @@ struct Factory<v8::ObjectTemplate> : FactoryBase<v8::ObjectTemplate> {
 };
 
 template <>
-struct Factory<v8::RegExp> : FactoryBase<v8::RegExp> {
+struct Factory<v8::RegExp> : MaybeFactoryBase<v8::RegExp> {
   static inline return_t New(
       v8::Handle<v8::String> pattern, v8::RegExp::Flags flags);
 };
 
 template <>
-struct Factory<v8::Script> : FactoryBase<v8::Script> {
+struct Factory<v8::Script> : MaybeFactoryBase<v8::Script> {
   static inline return_t New( v8::Local<v8::String> source);
   static inline return_t New( v8::Local<v8::String> source
                             , v8::ScriptOrigin const& origin);
@@ -153,7 +165,7 @@ struct Factory<v8::Signature> : FactoryBase<v8::Signature> {
 };
 
 template <>
-struct Factory<v8::String> : FactoryBase<v8::String> {
+struct Factory<v8::String> : MaybeFactoryBase<v8::String> {
   static inline return_t New();
   static inline return_t New(const char *value, int length = -1);
   static inline return_t New(const uint16_t *value, int length = -1);
@@ -179,7 +191,7 @@ struct Factory<v8::StringObject> : FactoryBase<v8::StringObject> {
 namespace Nan { namespace imp {
 
 template <>
-struct Factory<v8::UnboundScript> : FactoryBase<v8::UnboundScript> {
+struct Factory<v8::UnboundScript> : MaybeFactoryBase<v8::UnboundScript> {
   static inline return_t New( v8::Local<v8::String> source);
   static inline return_t New( v8::Local<v8::String> source
                             , v8::ScriptOrigin const& origin);
diff --git a/nan_string_bytes.h b/nan_string_bytes.h
index 44122f07..f5040a5e 100644
--- a/nan_string_bytes.h
+++ b/nan_string_bytes.h
@@ -233,7 +233,7 @@ static Local<Value> Encode(const char* buf,
                            enum Nan::Encoding encoding) {
   assert(buflen <= node::Buffer::kMaxLength);
   if (!buflen && encoding != Nan::BUFFER)
-    return NanNew("");
+    return NanNew("").ToLocalChecked();
 
   Local<String> val;
   switch (encoding) {
@@ -244,15 +244,15 @@ static Local<Value> Encode(const char* buf,
       if (contains_non_ascii(buf, buflen)) {
         char* out = new char[buflen];
         force_ascii(buf, out, buflen);
-        val = NanNew<String>(out, buflen);
+        val = NanNew<String>(out, buflen).ToLocalChecked();
         delete[] out;
       } else {
-        val = NanNew<String>(buf, buflen);
+        val = NanNew<String>(buf, buflen).ToLocalChecked();
       }
       break;
 
     case Nan::UTF8:
-      val = NanNew<String>(buf, buflen);
+      val = NanNew<String>(buf, buflen).ToLocalChecked();
       break;
 
     case Nan::BINARY: {
@@ -263,7 +263,7 @@ static Local<Value> Encode(const char* buf,
         // XXX is the following line platform independent?
         twobytebuf[i] = cbuf[i];
       }
-      val = NanNew<String>(twobytebuf, buflen);
+      val = NanNew<String>(twobytebuf, buflen).ToLocalChecked();
       delete[] twobytebuf;
       break;
     }
@@ -275,14 +275,14 @@ static Local<Value> Encode(const char* buf,
       size_t written = base64_encode(buf, buflen, dst, dlen);
       assert(written == dlen);
 
-      val = NanNew<String>(dst, dlen);
+      val = NanNew<String>(dst, dlen).ToLocalChecked();
       delete[] dst;
       break;
     }
 
     case Nan::UCS2: {
       const uint16_t* data = reinterpret_cast<const uint16_t*>(buf);
-      val = NanNew<String>(data, buflen / 2);
+      val = NanNew<String>(data, buflen / 2).ToLocalChecked();
       break;
     }
 
@@ -292,7 +292,7 @@ static Local<Value> Encode(const char* buf,
       size_t written = hex_encode(buf, buflen, dst, dlen);
       assert(written == dlen);
 
-      val = NanNew<String>(dst, dlen);
+      val = NanNew<String>(dst, dlen).ToLocalChecked();
       delete[] dst;
       break;
     }
diff --git a/test/binding.gyp b/test/binding.gyp
index 96066642..4277337e 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -49,6 +49,10 @@
         "target_name" : "accessors"
       , "sources"     : [ "cpp/accessors.cpp" ]
     }
+  , {
+        "target_name" : "accessors2"
+      , "sources"     : [ "cpp/accessors2.cpp" ]
+    }
   , {
         "target_name" : "persistent"
       , "sources"     : [ "cpp/persistent.cpp" ]
@@ -116,4 +120,8 @@
         "target_name" : "indexedinterceptors"
       , "sources"     : [ "cpp/indexedinterceptors.cpp" ]
     }
+    , {
+        "target_name" : "converters"
+      , "sources"     : [ "cpp/converters.cpp" ]
+    }
 ]}
diff --git a/test/cpp/accessors.cpp b/test/cpp/accessors.cpp
index 255959db..46927815 100644
--- a/test/cpp/accessors.cpp
+++ b/test/cpp/accessors.cpp
@@ -43,21 +43,24 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
     NanNew<v8::FunctionTemplate>(SetterGetter::New);
   settergetter_constructor.Reset(tpl);
-  tpl->SetClassName(NanNew<v8::String>("SetterGetter"));
+  tpl->SetClassName(NanNew<v8::String>("SetterGetter").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   NanSetPrototypeMethod(tpl, "log", SetterGetter::Log);
   v8::Local<v8::ObjectTemplate> proto = tpl->PrototypeTemplate();
-  NanSetAccessor(proto, NanNew<v8::String>("prop1"), SetterGetter::GetProp1);
   NanSetAccessor(
-    proto
-  , NanNew<v8::String>("prop2")
-  , SetterGetter::GetProp2
-  , SetterGetter::SetProp2
+      proto
+    , NanNew("prop1").ToLocalChecked()
+    , SetterGetter::GetProp1);
+  NanSetAccessor(
+      proto
+    , NanNew<v8::String>("prop2").ToLocalChecked()
+    , SetterGetter::GetProp2
+    , SetterGetter::SetProp2
   );
 
   v8::Local<v8::Function> createnew =
     NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
-  target->Set(NanNew<v8::String>("create"), createnew);
+  NanSet(target, NanNew<v8::String>("create").ToLocalChecked(), createnew);
 }
 
 v8::Handle<v8::Value> SetterGetter::NewInstance () {
@@ -100,7 +103,7 @@ NAN_GETTER(SetterGetter::GetProp1) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  info.GetReturnValue().Set(NanNew(settergetter->prop1));
+  info.GetReturnValue().Set(NanNew(settergetter->prop1).ToLocalChecked());
 }
 
 NAN_GETTER(SetterGetter::GetProp2) {
@@ -122,7 +125,7 @@ NAN_GETTER(SetterGetter::GetProp2) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  info.GetReturnValue().Set(NanNew(settergetter->prop2));
+  info.GetReturnValue().Set(NanNew(settergetter->prop2).ToLocalChecked());
 }
 
 NAN_SETTER(SetterGetter::SetProp2) {
@@ -154,7 +157,7 @@ NAN_METHOD(SetterGetter::Log) {
   SetterGetter* settergetter =
     NanObjectWrap::Unwrap<SetterGetter>(info.This());
 
-  info.GetReturnValue().Set(NanNew(settergetter->log));
+  info.GetReturnValue().Set(NanNew(settergetter->log).ToLocalChecked());
 }
 
 NODE_MODULE(accessors, SetterGetter::Init)
diff --git a/test/cpp/accessors2.cpp b/test/cpp/accessors2.cpp
new file mode 100644
index 00000000..f50c5cce
--- /dev/null
+++ b/test/cpp/accessors2.cpp
@@ -0,0 +1,161 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+#include <cstring>
+
+class SetterGetter : public NanObjectWrap {
+ public:
+  static void Init (v8::Handle<v8::Object> target);
+  static v8::Handle<v8::Value> NewInstance ();
+  static NAN_METHOD(New);
+  static NAN_METHOD(Log);
+  static NAN_GETTER(GetProp1);
+  static NAN_GETTER(GetProp2);
+  static NAN_SETTER(SetProp2);
+
+  SetterGetter();
+
+  char log[1024];
+  char prop1[256];
+  char prop2[256];
+};
+
+static NanPersistent<v8::FunctionTemplate> settergetter_constructor;
+
+NAN_METHOD(CreateNew) {
+  info.GetReturnValue().Set(SetterGetter::NewInstance());
+}
+
+SetterGetter::SetterGetter() {
+  log[0] = '\0';
+  strncpy(prop1, "this is property 1", sizeof (prop1) - 1);
+  prop1[sizeof (prop1) - 1] = '\0';
+  prop2[0] = '\0';
+}
+
+void SetterGetter::Init(v8::Handle<v8::Object> target) {
+  v8::Local<v8::FunctionTemplate> tpl =
+    NanNew<v8::FunctionTemplate>(SetterGetter::New);
+  settergetter_constructor.Reset(tpl);
+  tpl->SetClassName(NanNew<v8::String>("SetterGetter").ToLocalChecked());
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+  NanSetPrototypeMethod(tpl, "log", SetterGetter::Log);
+  v8::Local<v8::Function> createnew =
+    NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
+  NanSet(target, NanNew<v8::String>("create").ToLocalChecked(), createnew);
+}
+
+v8::Handle<v8::Value> SetterGetter::NewInstance () {
+  NanEscapableScope scope;
+  v8::Local<v8::FunctionTemplate> constructorHandle =
+      NanNew(settergetter_constructor);
+  v8::Local<v8::Object> instance =
+    constructorHandle->GetFunction()->NewInstance(0, NULL);
+  NanSetAccessor(
+      instance
+    , NanNew("prop1").ToLocalChecked()
+    , SetterGetter::GetProp1);
+  NanSetAccessor(
+      instance
+    , NanNew<v8::String>("prop2").ToLocalChecked()
+    , SetterGetter::GetProp2
+    , SetterGetter::SetProp2
+  );
+  return scope.Escape(instance);
+}
+
+NAN_METHOD(SetterGetter::New) {
+  SetterGetter* settergetter = new SetterGetter();
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , "New()\n"
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+  settergetter->Wrap(info.This());
+
+  info.GetReturnValue().Set(info.This());
+}
+
+NAN_GETTER(SetterGetter::GetProp1) {
+  SetterGetter* settergetter =
+    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , "Prop1:GETTER("
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , settergetter->prop1
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , ")\n"
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+
+  info.GetReturnValue().Set(NanNew(settergetter->prop1).ToLocalChecked());
+}
+
+NAN_GETTER(SetterGetter::GetProp2) {
+  SetterGetter* settergetter =
+    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , "Prop2:GETTER("
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , settergetter->prop2
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , ")\n"
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+
+  info.GetReturnValue().Set(NanNew(settergetter->prop2).ToLocalChecked());
+}
+
+NAN_SETTER(SetterGetter::SetProp2) {
+  SetterGetter* settergetter =
+      NanObjectWrap::Unwrap<SetterGetter>(info.This());
+  strncpy(
+      settergetter->prop2
+    , *v8::String::Utf8Value(value)
+    , sizeof (settergetter->prop2));
+  settergetter->prop2[sizeof (settergetter->prop2) - 1] = '\0';
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , "Prop2:SETTER("
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , settergetter->prop2
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+  assert(strlen(settergetter->log) < sizeof (settergetter->log));
+  strncat(
+      settergetter->log
+    , ")\n"
+    , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
+}
+
+NAN_METHOD(SetterGetter::Log) {
+  SetterGetter* settergetter =
+    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+
+  info.GetReturnValue().Set(NanNew(settergetter->log).ToLocalChecked());
+}
+
+NODE_MODULE(accessors2, SetterGetter::Init)
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index 1024755f..46bf2f06 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -51,14 +51,13 @@ NAN_METHOD(DoProgress) {
   NanAsyncQueueWorker(new ProgressWorker(
       callback
     , progress
-    , info[0]->Uint32Value()
-    , info[1]->Uint32Value()));
-  info.GetReturnValue().SetUndefined();
+    , NanTo<uint32_t>(info[0]).FromJust()
+    , NanTo<uint32_t>(info[1]).FromJust()));
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  exports->Set(
-      NanNew<v8::String>("a")
+  NanSet(exports
+    , NanNew<v8::String>("a").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(DoProgress)->GetFunction());
 }
 
diff --git a/test/cpp/asyncworker.cpp b/test/cpp/asyncworker.cpp
index a66a00b2..f7ddb326 100644
--- a/test/cpp/asyncworker.cpp
+++ b/test/cpp/asyncworker.cpp
@@ -28,13 +28,13 @@ class SleepWorker : public NanAsyncWorker {
 
 NAN_METHOD(DoSleep) {
   NanCallback *callback = new NanCallback(info[1].As<v8::Function>());
-  NanAsyncQueueWorker(new SleepWorker(callback, info[0]->Uint32Value()));
-  info.GetReturnValue().SetUndefined();
+  NanAsyncQueueWorker(
+      new SleepWorker(callback, NanTo<uint32_t>(info[0]).FromJust()));
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  exports->Set(
-      NanNew<v8::String>("a")
+  NanSet(exports
+    , NanNew<v8::String>("a").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(DoSleep)->GetFunction());
 }
 
diff --git a/test/cpp/asyncworkererror.cpp b/test/cpp/asyncworkererror.cpp
index c30935b3..244368ae 100644
--- a/test/cpp/asyncworkererror.cpp
+++ b/test/cpp/asyncworkererror.cpp
@@ -25,7 +25,9 @@ NAN_METHOD(Work) {
 }
 
 void Init (v8::Handle<v8::Object> exports) {
-  exports->Set(NanNew("a"), NanNew<v8::FunctionTemplate>(Work)->GetFunction());
+  NanSet(exports
+    , NanNew("a").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(Work)->GetFunction());
 }
 
 NODE_MODULE(asyncworkererror, Init)
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index fb89ff97..31606b7b 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -21,7 +21,7 @@ class BufferWorker : public NanAsyncWorker {
       )
     : NanAsyncWorker(callback), milliseconds(milliseconds) {
       SaveToPersistent("buffer", bufferHandle);
-      SaveToPersistent(NanNew("puffer"), bufferHandle);
+      SaveToPersistent(NanNew("puffer").ToLocalChecked(), bufferHandle);
       SaveToPersistent(0u, bufferHandle);
     }
 
@@ -37,7 +37,7 @@ class BufferWorker : public NanAsyncWorker {
     v8::Local<v8::Value> handle = GetFromPersistent("buffer");
     callback->Call(1, &handle);
 
-    handle = GetFromPersistent(NanNew("puffer"));
+    handle = GetFromPersistent(NanNew("puffer").ToLocalChecked());
     callback->Call(1, &handle);
 
     handle = GetFromPersistent(0u);
@@ -52,14 +52,15 @@ NAN_METHOD(DoSleep) {
   v8::Local<v8::Object> bufferHandle = info[1].As<v8::Object>();
   NanCallback *callback = new NanCallback(info[2].As<v8::Function>());
   assert(!callback->IsEmpty() && "Callback shoud not be empty");
-  NanAsyncQueueWorker(
-      new BufferWorker(callback, info[0]->Uint32Value(), bufferHandle));
-  info.GetReturnValue().SetUndefined();
+  NanAsyncQueueWorker(new BufferWorker(
+      callback
+    , NanTo<uint32_t>(info[0]).FromJust()
+    , bufferHandle));
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  exports->Set(
-      NanNew<v8::String>("a")
+  NanSet(exports
+    , NanNew<v8::String>("a").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(DoSleep)->GetFunction());
 }
 
diff --git a/test/cpp/converters.cpp b/test/cpp/converters.cpp
new file mode 100644
index 00000000..1418d2bd
--- /dev/null
+++ b/test/cpp/converters.cpp
@@ -0,0 +1,128 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+
+NAN_METHOD(ToBoolean) {
+  info.GetReturnValue().Set(NanTo<v8::Boolean>(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToNumber) {
+  info.GetReturnValue().Set(NanTo<v8::Number>(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToString) {
+  info.GetReturnValue().Set(NanTo<v8::String>(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToDetailString) {
+  info.GetReturnValue().Set(NanToDetailString(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToObject) {
+  info.GetReturnValue().Set(NanTo<v8::Object>(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToInteger) {
+  info.GetReturnValue().Set(NanTo<v8::Integer>(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToUint32) {
+  info.GetReturnValue().Set(NanTo<v8::Uint32>(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToInt32) {
+  info.GetReturnValue().Set(NanTo<v8::Int32>(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(ToArrayIndex) {
+  NanScope();
+  info.GetReturnValue().Set(NanToArrayIndex(info[0]).ToLocalChecked());
+}
+
+NAN_METHOD(BooleanValue) {
+  info.GetReturnValue().Set(NanNew(NanTo<bool>(info[0]).FromJust()));
+}
+
+NAN_METHOD(NumberValue) {
+  info.GetReturnValue().Set(NanNew(NanTo<double>(info[0]).FromJust()));
+}
+
+NAN_METHOD(IntegerValue) {
+  info.GetReturnValue().Set(NanNew<v8::Integer>(static_cast<int32_t>(
+      NanTo<int64_t>(info[0]).FromJust())));
+}
+
+NAN_METHOD(Uint32Value) {
+  info.GetReturnValue().Set(NanNew(NanTo<uint32_t>(info[0]).FromJust()));
+}
+
+NAN_METHOD(Int32Value) {
+  info.GetReturnValue().Set(NanNew(NanTo<int32_t>(info[0]).FromJust()));
+}
+
+void Init (v8::Handle<v8::Object> target) {
+  NanSet(target
+    , NanNew<v8::String>("toBoolean").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToBoolean)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toNumber").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToNumber)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toString").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToString)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toDetailString").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToDetailString)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toObject").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToObject)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toInteger").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToInteger)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toUint32").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToUint32)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toInt32").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToInt32)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("toArrayIndex").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(ToArrayIndex)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("booleanValue").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(BooleanValue)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("numberValue").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(NumberValue)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("integerValue").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(IntegerValue)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("uint32Value").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(Uint32Value)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("int32Value").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(Int32Value)->GetFunction()
+  );
+}
+
+NODE_MODULE(converters, Init)
diff --git a/test/cpp/error.cpp b/test/cpp/error.cpp
index 608a04f1..57f43d3a 100644
--- a/test/cpp/error.cpp
+++ b/test/cpp/error.cpp
@@ -14,7 +14,7 @@
   }                                                                            \
                                                                                \
   NAN_METHOD(Throw ## NAME ## 2) {                                             \
-    return NanThrow ## NAME(NanNew("errmsg"));                                 \
+    return NanThrow ## NAME(NanNew("errmsg").ToLocalChecked());                \
   }                                                                            \
                                                                                \
   NAN_METHOD(Throw ## NAME ## 3) {                                             \
@@ -22,7 +22,7 @@
   }                                                                            \
                                                                                \
   NAN_METHOD(Throw ## NAME ## 4) {                                             \
-    return NanThrowError(Nan ## NAME(NanNew("errmsg")));                       \
+    return NanThrowError(Nan ## NAME(NanNew("errmsg").ToLocalChecked()));      \
   }
 
 X(Error)
@@ -40,7 +40,10 @@ X(TypeError)
   X(Throw ## NAME ## 4)
 
 #define X(NAME)                                                                \
-  target->Set(NanNew(#NAME), NanNew<v8::FunctionTemplate>(NAME)->GetFunction());
+  NanSet(                                                                      \
+      target                                                                   \
+    , NanNew(#NAME).ToLocalChecked()                                           \
+    , NanNew<v8::FunctionTemplate>(NAME)->GetFunction());
 
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/gc.cpp b/test/cpp/gc.cpp
index b788255a..ef89744c 100644
--- a/test/cpp/gc.cpp
+++ b/test/cpp/gc.cpp
@@ -32,12 +32,12 @@ NAN_METHOD(Check) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("hook")
+  NanSet(target
+    , NanNew<v8::String>("hook").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(Hook)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("check")
+  NanSet(target
+    , NanNew<v8::String>("check").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(Check)->GetFunction()
   );
 }
diff --git a/test/cpp/indexedinterceptors.cpp b/test/cpp/indexedinterceptors.cpp
index 65d56aa7..729b1f14 100644
--- a/test/cpp/indexedinterceptors.cpp
+++ b/test/cpp/indexedinterceptors.cpp
@@ -35,7 +35,7 @@ void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
     NanNew<v8::FunctionTemplate>(IndexedInterceptor::New);
   indexedinterceptors_constructor.Reset(tpl);
-  tpl->SetClassName(NanNew<v8::String>("IndexedInterceptor"));
+  tpl->SetClassName(NanNew("IndexedInterceptor").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   v8::Local<v8::ObjectTemplate> inst = tpl->InstanceTemplate();
 
@@ -49,7 +49,7 @@ void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
 
   v8::Local<v8::Function> createnew =
     NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
-  target->Set(NanNew<v8::String>("create"), createnew);
+  NanSet(target, NanNew("create").ToLocalChecked(), createnew);
 }
 
 v8::Handle<v8::Value> IndexedInterceptor::NewInstance () {
@@ -72,9 +72,9 @@ NAN_INDEX_GETTER(IndexedInterceptor::PropertyGetter) {
   IndexedInterceptor* interceptor =
     NanObjectWrap::Unwrap<IndexedInterceptor>(info.This());
   if (index == 0) {
-    info.GetReturnValue().Set(NanNew(interceptor->buf));
+    info.GetReturnValue().Set(NanNew(interceptor->buf).ToLocalChecked());
   } else {
-    info.GetReturnValue().Set(NanNew("bar"));
+    info.GetReturnValue().Set(NanNew("bar").ToLocalChecked());
   }
 }
 
@@ -94,7 +94,7 @@ NAN_INDEX_SETTER(IndexedInterceptor::PropertySetter) {
 
 NAN_INDEX_ENUMERATOR(IndexedInterceptor::PropertyEnumerator) {
   v8::Local<v8::Array> arr = NanNew<v8::Array>();
-  arr->Set(0, NanNew("whee"));
+  NanSet(arr, 0, NanNew("whee").ToLocalChecked());
   info.GetReturnValue().Set(arr);
 }
 
diff --git a/test/cpp/isolatedata.cpp b/test/cpp/isolatedata.cpp
index c47ce7d7..87607725 100644
--- a/test/cpp/isolatedata.cpp
+++ b/test/cpp/isolatedata.cpp
@@ -27,8 +27,8 @@ NAN_METHOD(SetAndGet) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("setAndGet")
+  NanSet(target
+    , NanNew<v8::String>("setAndGet").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(SetAndGet)->GetFunction()
   );
 }
diff --git a/test/cpp/makecallback.cpp b/test/cpp/makecallback.cpp
index 2fc0eb25..8239ede9 100644
--- a/test/cpp/makecallback.cpp
+++ b/test/cpp/makecallback.cpp
@@ -32,13 +32,13 @@ MyObject::~MyObject() {
 void MyObject::Init(v8::Handle<v8::Object> exports) {
   // Prepare constructor template
   v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
-  tpl->SetClassName(NanNew<v8::String>("MyObject"));
+  tpl->SetClassName(NanNew<v8::String>("MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   NanSetPrototypeMethod(tpl, "call_emit", CallEmit);
 
   constructor.Reset(tpl->GetFunction());
-  exports->Set(NanNew<v8::String>("MyObject"), tpl->GetFunction());
+  NanSet(exports, NanNew("MyObject").ToLocalChecked(), tpl->GetFunction());
 }
 
 NAN_METHOD(MyObject::New) {
@@ -54,7 +54,7 @@ NAN_METHOD(MyObject::New) {
 
 NAN_METHOD(MyObject::CallEmit) {
   v8::Handle<v8::Value> argv[1] = {
-      NanNew("event"), // event name
+    NanNew("event").ToLocalChecked(),  // event name
   };
 
   NanMakeCallback(info.This(), "emit", 1, argv);
diff --git a/test/cpp/morenews.cpp b/test/cpp/morenews.cpp
index a986f679..eef689a5 100644
--- a/test/cpp/morenews.cpp
+++ b/test/cpp/morenews.cpp
@@ -22,17 +22,17 @@ NAN_METHOD(NewPositiveInteger) {
 
 NAN_METHOD(NewUtf8String) {
   const char s[] = "strïng";
-  info.GetReturnValue().Set(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  info.GetReturnValue().Set(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewUcs2String) {
   uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
-  info.GetReturnValue().Set(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
 }
 
 static const uint16_t ws[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
@@ -54,46 +54,46 @@ class ExtAsciiString : public NanExternalOneByteStringResource {
 };
 
 NAN_METHOD(NewExternalStringResource) {
-  v8::Local<v8::String> ext = NanNew(new ExtString());
+  v8::Local<v8::String> ext = NanNew(new ExtString()).ToLocalChecked();
   info.GetReturnValue().Set(ext);
 }
 
 NAN_METHOD(NewExternalAsciiStringResource) {
-  v8::Local<v8::String> ext = NanNew(new ExtAsciiString());
+  v8::Local<v8::String> ext = NanNew(new ExtAsciiString()).ToLocalChecked();
   info.GetReturnValue().Set(ext);
 }
 
 void Init(v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew("newNumber")
+  NanSet(target
+    , NanNew("newNumber").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewNumber)->GetFunction()
   );
-  target->Set(
-      NanNew("newNegativeInteger")
+  NanSet(target
+    , NanNew("newNegativeInteger").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewNegativeInteger)->GetFunction()
   );
-  target->Set(
-      NanNew("newPositiveInteger")
+  NanSet(target
+    , NanNew("newPositiveInteger").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewPositiveInteger)->GetFunction()
   );
-  target->Set(
-      NanNew("newUtf8String")
+  NanSet(target
+    , NanNew("newUtf8String").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewUtf8String)->GetFunction()
   );
-  target->Set(
-      NanNew("newLatin1String")
+  NanSet(target
+    , NanNew("newLatin1String").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewLatin1String)->GetFunction()
   );
-  target->Set(
-      NanNew("newUcs2String")
+  NanSet(target
+    , NanNew("newUcs2String").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewUcs2String)->GetFunction()
   );
-  target->Set(
-      NanNew("newExternalStringResource")
+  NanSet(target
+    , NanNew("newExternalStringResource").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewExternalStringResource)->GetFunction()
   );
-  target->Set(
-      NanNew("newExternalAsciiStringResource")
+  NanSet(target
+    , NanNew("newExternalAsciiStringResource").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewExternalAsciiStringResource)
     ->GetFunction()
   );
diff --git a/test/cpp/multifile1.cpp b/test/cpp/multifile1.cpp
index a1ce38f1..748168a4 100644
--- a/test/cpp/multifile1.cpp
+++ b/test/cpp/multifile1.cpp
@@ -10,8 +10,8 @@
 #include "./multifile2.h"
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("r")
+  NanSet(target
+    , NanNew<v8::String>("r").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ReturnString)->GetFunction()
   );
 }
diff --git a/test/cpp/multifile2.cpp b/test/cpp/multifile2.cpp
index 144a0556..83bc8852 100644
--- a/test/cpp/multifile2.cpp
+++ b/test/cpp/multifile2.cpp
@@ -9,6 +9,6 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnString) {
-  v8::Local<v8::String> s = NanNew<v8::String>(*NanUtf8String(info[0]));
+  v8::Local<v8::String> s = NanNew(*NanUtf8String(info[0])).ToLocalChecked();
   info.GetReturnValue().Set(s);
 }
diff --git a/test/cpp/namedinterceptors.cpp b/test/cpp/namedinterceptors.cpp
index 01bf5ef4..342309f5 100644
--- a/test/cpp/namedinterceptors.cpp
+++ b/test/cpp/namedinterceptors.cpp
@@ -35,7 +35,7 @@ void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
     NanNew<v8::FunctionTemplate>(NamedInterceptor::New);
   namedinterceptors_constructor.Reset(tpl);
-  tpl->SetClassName(NanNew<v8::String>("NamedInterceptor"));
+  tpl->SetClassName(NanNew("NamedInterceptor").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   v8::Local<v8::ObjectTemplate> inst = tpl->InstanceTemplate();
 
@@ -49,7 +49,7 @@ void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
 
   v8::Local<v8::Function> createnew =
     NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
-  target->Set(NanNew<v8::String>("create"), createnew);
+  NanSet(target, NanNew("create").ToLocalChecked(), createnew);
 }
 
 v8::Handle<v8::Value> NamedInterceptor::NewInstance () {
@@ -72,9 +72,9 @@ NAN_PROPERTY_GETTER(NamedInterceptor::PropertyGetter) {
   NamedInterceptor* interceptor =
     NanObjectWrap::Unwrap<NamedInterceptor>(info.This());
   if (!std::strcmp(*v8::String::Utf8Value(property), "prop")) {
-    info.GetReturnValue().Set(NanNew(interceptor->buf));
+    info.GetReturnValue().Set(NanNew(interceptor->buf).ToLocalChecked());
   } else {
-    info.GetReturnValue().Set(NanNew("bar"));
+    info.GetReturnValue().Set(NanNew("bar").ToLocalChecked());
   }
 }
 
@@ -94,7 +94,7 @@ NAN_PROPERTY_SETTER(NamedInterceptor::PropertySetter) {
 
 NAN_PROPERTY_ENUMERATOR(NamedInterceptor::PropertyEnumerator) {
   v8::Local<v8::Array> arr = NanNew<v8::Array>();
-  arr->Set(0, NanNew("value"));
+  NanSet(arr, 0, NanNew("value").ToLocalChecked());
   info.GetReturnValue().Set(arr);
 }
 
diff --git a/test/cpp/nancallback.cpp b/test/cpp/nancallback.cpp
index fe32f685..8ec68be9 100644
--- a/test/cpp/nancallback.cpp
+++ b/test/cpp/nancallback.cpp
@@ -10,13 +10,11 @@
 
 NAN_METHOD(GlobalContext) {
   NanCallback(info[0].As<v8::Function>()).Call(0, NULL);
-  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(SpecificContext) {
   NanCallback cb(info[0].As<v8::Function>());
   cb.Call(NanGetCurrentContext()->Global(), 0, NULL);
-  info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(CustomReceiver) {
@@ -42,28 +40,28 @@ NAN_METHOD(CallAsFunction) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("globalContext")
+  NanSet(target
+    , NanNew<v8::String>("globalContext").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(GlobalContext)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("specificContext")
+  NanSet(target
+    , NanNew<v8::String>("specificContext").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(SpecificContext)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("customReceiver")
+  NanSet(target
+    , NanNew<v8::String>("customReceiver").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(CustomReceiver)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("compareCallbacks")
+  NanSet(target
+    , NanNew<v8::String>("compareCallbacks").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(CompareCallbacks)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("callDirect")
+  NanSet(target
+    , NanNew<v8::String>("callDirect").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(CallDirect)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("callAsFunction")
+  NanSet(target
+    , NanNew<v8::String>("callAsFunction").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(CallAsFunction)->GetFunction()
   );
 }
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index e1d45484..dc6f0557 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -121,7 +121,8 @@ NAN_METHOD(testDate) {
 
   t.plan(1);
 
-  t.ok(_( assertType<Date>( NanNew<Date>(static_cast<double>(time(NULL))))));
+  t.ok(_( assertType<Date>(
+      NanNew<Date>(static_cast<double>(time(NULL))).ToLocalChecked())));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -144,7 +145,7 @@ NAN_METHOD(testFunction) {
   t.plan(2);
 
   t.ok(_( assertType<Function>(NanNew<Function>(testFunction))));
-  v8::Local<String> data = NanNew("plonk");
+  v8::Local<String> data = NanNew("plonk").ToLocalChecked();
   t.ok(_( assertType<Function>(NanNew<Function>(testFunction, data))));
 
   info.GetReturnValue().SetUndefined();
@@ -158,7 +159,7 @@ NAN_METHOD(testFunctionTemplate) {
   t.ok(_( assertType<FunctionTemplate>( NanNew<FunctionTemplate>())));
   t.ok(_( assertType<FunctionTemplate>(
           NanNew<FunctionTemplate>(testFunctionTemplate))));
-  v8::Local<String> data = NanNew("plonk");
+  v8::Local<String> data = NanNew("plonk").ToLocalChecked();
   t.ok(_( assertType<FunctionTemplate>(
           NanNew<FunctionTemplate>( testFunctionTemplate, data))));
   v8::Local<Signature> signature = NanNew<Signature>();
@@ -210,7 +211,10 @@ NAN_METHOD(testNumberObject) {
   t.plan(2);
 
   t.ok(_( assertType<NumberObject>( NanNew<NumberObject>(M_PI))));
-  t.ok(_( fabs(NanNew<NumberObject>(M_PI)->NumberValue() - M_PI) < epsilon));
+  t.ok(_(
+      fabs(
+          NanTo<double>(NanNew<NumberObject>(M_PI)).FromJust() - M_PI
+      ) < epsilon));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -240,20 +244,26 @@ NAN_METHOD(testScript) {
 
   t.plan(6);
 
-  ScriptOrigin origin(NanNew("foo"), NanNew(5));
+  ScriptOrigin origin(NanNew("foo").ToLocalChecked(), NanNew(5));
 
-  t.ok(_( assertType<Script>( NanNew<Script>(NanNew("2 + 3")))));
-  t.ok(_( assertType<Script>( NanNew<Script>(NanNew("2 + 3"), origin))));
+  t.ok(_( assertType<Script>(NanNew<Script>(
+      NanNew("2 + 3").ToLocalChecked()).ToLocalChecked())));
+  t.ok(_( assertType<Script>(NanNew<Script>(
+      NanNew("2 + 3").ToLocalChecked(), origin).ToLocalChecked())));
+  t.ok(_( assertType<NanUnboundScript>(NanNew<NanUnboundScript>(
+      NanNew("2 + 3").ToLocalChecked()).ToLocalChecked())));
   t.ok(_( assertType<NanUnboundScript>(
-      NanNew<NanUnboundScript>(NanNew("2 + 3")))));
-  t.ok(_( assertType<NanUnboundScript>(
-          NanNew<NanUnboundScript>(NanNew("2 + 3"), origin))));
+      NanNew<NanUnboundScript>(
+          NanNew("2 + 3").ToLocalChecked()
+        , origin).ToLocalChecked())));
 
   // for the fans of the bound script
-  t.ok(_( NanRunScript(
-      NanNew<NanBoundScript>(NanNew("2 + 3")))->Int32Value() == 5));
-  t.ok(_( NanRunScript(
-      NanNew<NanUnboundScript>(NanNew("2 + 3")))->Int32Value() == 5));
+  t.ok(_( NanTo<int32_t>(NanRunScript(
+      NanNew<NanBoundScript>(NanNew("2 + 3").ToLocalChecked()
+    ).ToLocalChecked()).ToLocalChecked()).FromJust() == 5));
+  t.ok(_( NanTo<int32_t>(NanRunScript(
+      NanNew<NanUnboundScript>(NanNew("2 + 3").ToLocalChecked()
+    ).ToLocalChecked()).ToLocalChecked()).FromJust() == 5));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -279,30 +289,37 @@ NAN_METHOD(testString) {
 
   t.plan(14);
 
-  t.ok(_( stringMatches( NanNew<String>("Hello World"), "Hello World")));
-  t.ok(_( stringMatches( NanNew<String>("Hello World", 4), "Hell")));
-  t.ok(_( stringMatches( NanNew<String>(std::string("foo")), "foo")));
-  t.ok(_( assertType<String>( NanNew<String>("plonk."))));
+  t.ok(_( stringMatches(
+      NanNew<String>("Hello World").ToLocalChecked(), "Hello World")));
+  t.ok(_( stringMatches(
+      NanNew<String>("Hello World", 4).ToLocalChecked(), "Hell")));
+  t.ok(_( stringMatches(
+      NanNew<String>(std::string("foo")).ToLocalChecked(), "foo")));
+  t.ok(_( assertType<String>(
+      NanNew<String>("plonk.").ToLocalChecked())));
 
-  t.ok(_( stringMatches( NanNew<String>(), "")));
-  t.ok(_( assertType<String>( NanNew<String>())));
+  t.ok(_( stringMatches( NanNew<String>().ToLocalChecked(), "")));
+  t.ok(_( assertType<String>( NanNew<String>().ToLocalChecked())));
 
   // These should be deprecated
   const uint8_t *ustring = reinterpret_cast<const uint8_t *>("unsigned chars");
-  t.ok(_( stringMatches( NanNew<String>(ustring), "unsigned chars")));
-  t.ok(_( stringMatches( NanNew<String>(ustring, 8), "unsigned")));
+  t.ok(_( stringMatches(
+      NanNew<String>(ustring).ToLocalChecked(), "unsigned chars")));
+  t.ok(_( stringMatches(
+      NanNew<String>(ustring, 8).ToLocalChecked(), "unsigned")));
 
   // === Convenience
 
-  t.ok(_( stringMatches( NanNew("using namespace nan; // is poetry"),
-          "using namespace nan; // is poetry")));
-  t.ok(_( assertType<String>( NanNew("plonk."))));
+  t.ok(_( stringMatches(
+      NanNew("using namespace nan; // is poetry").ToLocalChecked()
+    , "using namespace nan; // is poetry")));
+  t.ok(_( assertType<String>( NanNew("plonk.").ToLocalChecked())));
 
-  t.ok(_( stringMatches( NanNew("Hello World", 4), "Hell")));
-  t.ok(_( assertType<String>( NanNew("plonk.", 4))));
+  t.ok(_( stringMatches( NanNew("Hello World", 4).ToLocalChecked(), "Hell")));
+  t.ok(_( assertType<String>( NanNew("plonk.", 4).ToLocalChecked())));
 
-  t.ok(_( stringMatches( NanNew(std::string("bar")), "bar")));
-  t.ok(_( assertType<String>( NanNew(std::string("plonk.")))));
+  t.ok(_( stringMatches( NanNew(std::string("bar")).ToLocalChecked(), "bar")));
+  t.ok(_( assertType<String>( NanNew(std::string("plonk.")).ToLocalChecked())));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -318,10 +335,10 @@ NAN_METHOD(testStringObject) {
   t.plan(2);
 
   t.ok(_( stringMatches(
-          V(NanNew<StringObject>(NanNew<String>("plonk"))),
+          V(NanNew<StringObject>(NanNew<String>("plonk").ToLocalChecked())),
           "plonk")));
   t.ok(_( assertType<StringObject>(
-          NanNew<StringObject>(NanNew<String>("plonk")))));
+          NanNew<StringObject>(NanNew<String>("plonk").ToLocalChecked()))));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -333,7 +350,8 @@ NAN_METHOD(testHandles) {
 
   t.plan(2);
 
-  t.ok(_( assertType<String>( NanNew( asHandle(NanNew("foo"))))));
+  t.ok(_( assertType<String>(
+      NanNew( asHandle(NanNew("foo").ToLocalChecked())))));
   t.ok(_( assertType<Uint32>( NanNew( asHandle(NanNew(5u))))));
 
   info.GetReturnValue().SetUndefined();
@@ -345,7 +363,7 @@ NAN_METHOD(testPersistents) {
   t.plan(1);
 
   NanPersistent<String> p;
-  p.Reset(NanNew("foo"));
+  p.Reset(NanNew("foo").ToLocalChecked());
   t.ok(_( assertType<String>( NanNew(p))));
   p.Reset();
 
@@ -409,27 +427,28 @@ NAN_METHOD(testRegression242) {
 //==============================================================================
 
 NAN_METHOD(newIntegerWithValue) {
-  info.GetReturnValue().Set(NanNew<Integer>(info[0]->Int32Value()));
+  info.GetReturnValue().Set(
+      NanNew(static_cast<int32_t>(NanTo<int64_t>(info[0]).FromJust())));
 }
 
 NAN_METHOD(newNumberWithValue) {
-  info.GetReturnValue().Set(NanNew<Number>(info[0]->NumberValue()));
+  info.GetReturnValue().Set(NanNew(NanTo<double>(info[0]).FromJust()));
 }
 
 NAN_METHOD(newUint32WithValue) {
-  info.GetReturnValue().Set(NanNew<Uint32>(info[0]->Uint32Value()));
+  info.GetReturnValue().Set(NanNew(NanTo<uint32_t>(info[0]).FromJust()));
 }
 
 NAN_METHOD(newStringFromChars) {
-  info.GetReturnValue().Set(NanNew<String>("hello?"));
+  info.GetReturnValue().Set(NanNew("hello?").ToLocalChecked());
 }
 
 NAN_METHOD(newStringFromCharsWithLength) {
-  info.GetReturnValue().Set(NanNew<String>("hello?", 4));
+  info.GetReturnValue().Set(NanNew("hello?", 4).ToLocalChecked());
 }
 
 NAN_METHOD(newStringFromStdString) {
-  info.GetReturnValue().Set(NanNew<String>(std::string("hello!")));
+  info.GetReturnValue().Set(NanNew(std::string("hello!")).ToLocalChecked());
 }
 
 NAN_METHOD(newExternal) {
diff --git a/test/cpp/news.cpp b/test/cpp/news.cpp
index d8a3df42..538879f9 100644
--- a/test/cpp/news.cpp
+++ b/test/cpp/news.cpp
@@ -52,31 +52,33 @@ NAN_METHOD(NewUint32FromNegative) {
 
 NAN_METHOD(NewUtf8String) {
   const char s[] = "strïng";
-  info.GetReturnValue().Set(NanNew<v8::String>(s));
+  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  info.GetReturnValue().Set(NanNew<v8::String>(s));
+  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewUcs2String) {
   const uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
-  info.GetReturnValue().Set(NanNew(s));
+  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewStdString) {
   const std::string s = "strïng";
-  info.GetReturnValue().Set(NanNew<v8::String>(s));
+  info.GetReturnValue().Set(NanNew<v8::String>(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewRegExp) {
   info.GetReturnValue().Set(
-      NanNew<v8::RegExp>(NanNew("foo"), v8::RegExp::kNone));
+      NanNew<v8::RegExp>(NanNew("foo").ToLocalChecked()
+    , v8::RegExp::kNone).ToLocalChecked());
 }
 
 NAN_METHOD(NewStringObject) {
-  info.GetReturnValue().Set(NanNew<v8::StringObject>(NanNew("foo")));
+  info.GetReturnValue().Set(
+      NanNew<v8::StringObject>(NanNew("foo").ToLocalChecked()));
 }
 
 NAN_METHOD(NewNumberObject) {
@@ -90,7 +92,7 @@ NAN_METHOD(NewBooleanObject) {
 NAN_METHOD(NewExternal) {
   v8::Local<v8::External> ext = NanNew<v8::External>(&magic);
   assert(*static_cast<int *>(ext->Value()) == 1337);
-  info.GetReturnValue().Set(NanNew<v8::String>("passed"));
+  info.GetReturnValue().Set(NanNew("passed").ToLocalChecked());
 }
 
 NAN_METHOD(NewSignature) {
@@ -99,34 +101,43 @@ NAN_METHOD(NewSignature) {
   v8::Local<v8::Signature> sig = NanNew<v8::Signature>(tmpl);
   tmpl = NanNew<v8::FunctionTemplate>(
       NewSignature, v8::Handle<v8::Value>(), sig);
-  info.GetReturnValue().Set(NanNew<v8::String>("string"));
+  info.GetReturnValue().Set(NanNew("string").ToLocalChecked());
 }
 
 NAN_METHOD(NewScript) {
-  v8::Local<NanUnboundScript> script = NanNew<NanUnboundScript>(NanNew("2+4"));
-  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
+  v8::Local<NanUnboundScript> script =
+      NanNew<NanUnboundScript>(NanNew("2+4").ToLocalChecked()).ToLocalChecked();
+  info.GetReturnValue().Set(
+      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(NewScript2) {
-  v8::ScriptOrigin origin(NanNew<v8::String>("x"));
+  v8::ScriptOrigin origin(NanNew<v8::String>("x").ToLocalChecked());
   v8::Local<NanUnboundScript> script =
-      NanNew<NanUnboundScript>(NanNew("2+4"), origin);
-  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
+      NanNew<NanUnboundScript>(
+          NanNew("2+4").ToLocalChecked()
+        , origin).ToLocalChecked();
+  info.GetReturnValue().Set(
+      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(CompileScript) {
-  v8::Local<NanBoundScript> script = NanCompileScript(NanNew("2+4"));
-  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
+  v8::Local<NanBoundScript> script =
+      NanCompileScript(NanNew("2+4").ToLocalChecked()).ToLocalChecked();
+  info.GetReturnValue().Set(
+      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(CompileScript2) {
-  v8::ScriptOrigin origin(NanNew<v8::String>("x"));
-  v8::Local<NanBoundScript> script = NanCompileScript(NanNew("2+4"), origin);
-  info.GetReturnValue().Set(NanRunScript(script)->ToInt32());
+  v8::ScriptOrigin origin(NanNew<v8::String>("x").ToLocalChecked());
+  v8::Local<NanBoundScript> script =
+      NanCompileScript(NanNew("2+4").ToLocalChecked(), origin).ToLocalChecked();
+  info.GetReturnValue().Set(
+      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(NewDate) {
-  info.GetReturnValue().Set(NanNew<v8::Date>(1337));
+  info.GetReturnValue().Set(NanNew<v8::Date>(1337).ToLocalChecked());
 }
 
 NAN_METHOD(NewArray) {
@@ -150,108 +161,108 @@ NAN_METHOD(NewBoolean2) {
 }
 
 void Init(v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("newNumber")
+  NanSet(target
+    , NanNew<v8::String>("newNumber").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewNumber)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newNegativeInteger")
+  NanSet(target
+    , NanNew<v8::String>("newNegativeInteger").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewNegativeInteger)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newPositiveInteger")
+  NanSet(target
+    , NanNew<v8::String>("newPositiveInteger").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewPositiveInteger)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newUnsignedInteger")
+  NanSet(target
+    , NanNew<v8::String>("newUnsignedInteger").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewUnsignedInteger)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newInt32FromPositive")
+  NanSet(target
+    , NanNew<v8::String>("newInt32FromPositive").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewInt32FromPositive)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newInt32FromNegative")
+  NanSet(target
+    , NanNew<v8::String>("newInt32FromNegative").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewInt32FromNegative)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newUint32FromPositive")
+  NanSet(target
+    , NanNew<v8::String>("newUint32FromPositive").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewUint32FromPositive)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newUint32FromNegative")
+  NanSet(target
+    , NanNew<v8::String>("newUint32FromNegative").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewUint32FromNegative)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newUtf8String")
+  NanSet(target
+    , NanNew<v8::String>("newUtf8String").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewUtf8String)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newLatin1String")
+  NanSet(target
+    , NanNew<v8::String>("newLatin1String").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewLatin1String)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newUcs2String")
+  NanSet(target
+    , NanNew<v8::String>("newUcs2String").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewUcs2String)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newStdString")
+  NanSet(target
+    , NanNew<v8::String>("newStdString").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewStdString)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newRegExp")
+  NanSet(target
+    , NanNew<v8::String>("newRegExp").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewRegExp)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newStringObject")
+  NanSet(target
+    , NanNew<v8::String>("newStringObject").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewStringObject)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newNumberObject")
+  NanSet(target
+    , NanNew<v8::String>("newNumberObject").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewNumberObject)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newBooleanObject")
+  NanSet(target
+    , NanNew<v8::String>("newBooleanObject").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewBooleanObject)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newExternal")
+  NanSet(target
+    , NanNew<v8::String>("newExternal").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewExternal)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newSignature")
+  NanSet(target
+    , NanNew<v8::String>("newSignature").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewSignature)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newScript")
+  NanSet(target
+    , NanNew<v8::String>("newScript").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewScript)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newScript2")
+  NanSet(target
+    , NanNew<v8::String>("newScript2").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewScript2)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("compileScript")
+  NanSet(target
+    , NanNew<v8::String>("compileScript").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(CompileScript)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("compileScript2")
+  NanSet(target
+    , NanNew<v8::String>("compileScript2").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(CompileScript2)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newDate")
+  NanSet(target
+    , NanNew<v8::String>("newDate").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewDate)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newArray")
+  NanSet(target
+    , NanNew<v8::String>("newArray").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewArray)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newBoolean")
+  NanSet(target
+    , NanNew<v8::String>("newBoolean").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewBoolean)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("newBoolean2")
+  NanSet(target
+    , NanNew<v8::String>("newBoolean2").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(NewBoolean2)->GetFunction()
   );
 }
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index ab3c3969..3e2b8098 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -12,13 +12,13 @@ class MyObject : public NanObjectWrap {
  public:
   static void Init(v8::Handle<v8::Object> exports) {
     v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
-    tpl->SetClassName(NanNew("MyObject"));
+    tpl->SetClassName(NanNew("MyObject").ToLocalChecked());
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
     NanSetPrototypeMethod(tpl, "getHandle", GetHandle);
 
     constructor.Reset(tpl->GetFunction());
-    exports->Set(NanNew("MyObject"), tpl->GetFunction());
+    NanSet(exports, NanNew("MyObject").ToLocalChecked(), tpl->GetFunction());
   }
 
  private:
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index 4416efea..cb773b8a 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -48,28 +48,28 @@ NAN_METHOD(CopyablePersistent) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("save1")
+  NanSet(target
+    , NanNew<v8::String>("save1").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(Save1)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("get1")
+  NanSet(target
+    , NanNew<v8::String>("get1").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(Get1)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("dispose1")
+  NanSet(target
+    , NanNew<v8::String>("dispose1").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(Dispose1)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("toPersistentAndBackAgain")
+  NanSet(target
+    , NanNew<v8::String>("toPersistentAndBackAgain").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ToPersistentAndBackAgain)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("persistentToPersistent")
+  NanSet(target
+    , NanNew<v8::String>("persistentToPersistent").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(PersistentToPersistent)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("copyablePersistent")
+  NanSet(target
+    , NanNew<v8::String>("copyablePersistent").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(CopyablePersistent)->GetFunction()
   );
 }
diff --git a/test/cpp/returnemptystring.cpp b/test/cpp/returnemptystring.cpp
index 646cc573..14af5169 100644
--- a/test/cpp/returnemptystring.cpp
+++ b/test/cpp/returnemptystring.cpp
@@ -13,8 +13,8 @@ NAN_METHOD(ReturnEmptyString) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("r")
+  NanSet(target
+    , NanNew<v8::String>("r").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ReturnEmptyString)->GetFunction()
   );
 }
diff --git a/test/cpp/returnnull.cpp b/test/cpp/returnnull.cpp
index 766617bb..4c354f74 100644
--- a/test/cpp/returnnull.cpp
+++ b/test/cpp/returnnull.cpp
@@ -13,8 +13,8 @@ NAN_METHOD(ReturnNull) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("r")
+  NanSet(target
+    , NanNew<v8::String>("r").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ReturnNull)->GetFunction()
   );
 }
diff --git a/test/cpp/returnundefined.cpp b/test/cpp/returnundefined.cpp
index 9394696c..310a82ad 100644
--- a/test/cpp/returnundefined.cpp
+++ b/test/cpp/returnundefined.cpp
@@ -13,8 +13,8 @@ NAN_METHOD(ReturnUndefined) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("r")
+  NanSet(target
+    , NanNew<v8::String>("r").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ReturnUndefined)->GetFunction()
   );
 }
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index 7f620d57..be10f773 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -16,7 +16,7 @@ NAN_METHOD(ReturnValue) {
   if (cbinfo.Length() == 1) {
     ret.Set(info[0].As<v8::String>());
   } else {
-    ret.Set(NanNew<v8::String>("default"));
+    ret.Set(NanNew("default").ToLocalChecked());
   }
 }
 
@@ -31,16 +31,16 @@ NAN_METHOD(ReturnGlobal) {
 void Init (v8::Handle<v8::Object> target) {
   global.Reset(NanNew(true));
 
-  target->Set(
-      NanNew<v8::String>("r")
+  NanSet(target
+    , NanNew<v8::String>("r").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ReturnValue)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("p")
+  NanSet(target
+    , NanNew<v8::String>("p").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ReturnPrimitive)->GetFunction()
   );
-  target->Set(
-      NanNew<v8::String>("q")
+  NanSet(target
+    , NanNew<v8::String>("q").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(ReturnGlobal)->GetFunction()
   );
 }
diff --git a/test/cpp/settemplate.cpp b/test/cpp/settemplate.cpp
index 24fcf10d..3e08d8ca 100644
--- a/test/cpp/settemplate.cpp
+++ b/test/cpp/settemplate.cpp
@@ -31,25 +31,47 @@ MyObject::~MyObject() {
 void MyObject::Init(v8::Handle<v8::Object> exports) {
   // Prepare constructor template
   v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
-  tpl->SetClassName(NanNew<v8::String>("MyObject"));
+  tpl->SetClassName(NanNew<v8::String>("MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   // Prototype
-  NanSetPrototypeTemplate(tpl, "prototypeProp", NanNew("a prototype property"));
+  NanSetPrototypeTemplate(
+    tpl
+  , "prototypeProp"
+  , NanNew<v8::String>("a prototype property").ToLocalChecked());
+
   // Instance
-  NanSetInstanceTemplate(tpl, "instanceProp", NanNew("an instance property"));
+  NanSetInstanceTemplate(
+    tpl
+  , "instanceProp"
+  , NanNew<v8::String>("an instance property").ToLocalChecked());
+
   // PropertyAttributes
   NanSetInstanceTemplate(
-      tpl, NanNew("none"), NanNew("none"), v8::None);
+    tpl
+  , NanNew<v8::String>("none").ToLocalChecked()
+  , NanNew<v8::String>("none").ToLocalChecked()
+  , v8::None);
   NanSetInstanceTemplate(
-      tpl, NanNew("readOnly"), NanNew("readOnly"), v8::ReadOnly);
+    tpl
+  , NanNew<v8::String>("readOnly").ToLocalChecked()
+  , NanNew<v8::String>("readOnly").ToLocalChecked()
+  , v8::ReadOnly);
   NanSetInstanceTemplate(
-      tpl, NanNew("dontEnum"), NanNew("dontEnum"), v8::DontEnum);
+    tpl
+  , NanNew<v8::String>("dontEnum").ToLocalChecked()
+  , NanNew<v8::String>("dontEnum").ToLocalChecked()
+  , v8::DontEnum);
   NanSetInstanceTemplate(
-      tpl, NanNew("dontDelete"), NanNew("dontDelete"), v8::DontDelete);
+    tpl
+  , NanNew<v8::String>("dontDelete").ToLocalChecked()
+  , NanNew<v8::String>("dontDelete").ToLocalChecked()
+  , v8::DontDelete);
 
   constructor.Reset(tpl->GetFunction());
-  exports->Set(NanNew<v8::String>("MyObject"), tpl->GetFunction());
+  NanSet(exports
+  , NanNew<v8::String>("MyObject").ToLocalChecked()
+  , tpl->GetFunction());
 }
 
 NAN_METHOD(MyObject::New) {
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index f862d668..f623aa93 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -9,12 +9,12 @@
 #include <nan.h>
 
 NAN_METHOD(ReturnUtf8String) {
-  info.GetReturnValue().Set(NanNew(*NanUtf8String(info[0])));
+  info.GetReturnValue().Set(NanNew(*NanUtf8String(info[0])).ToLocalChecked());
 }
 
 NAN_METHOD(HeapString) {
   NanUtf8String *s = new NanUtf8String(info[0]);
-  v8::Local<v8::String> res = NanNew(**s);
+  v8::Local<v8::String> res = NanNew(**s).ToLocalChecked();
   delete s;
   info.GetReturnValue().Set(res);
 }
@@ -39,7 +39,7 @@ void Init (v8::Handle<v8::Object> target) {
   returnUtf8String_persistent.Reset(returnUtf8String);
 
   target->Set(
-      NanNew("returnUtf8String")
+      NanNew("returnUtf8String").ToLocalChecked()
     , returnUtf8String->GetFunction()
   );
 
@@ -49,7 +49,7 @@ void Init (v8::Handle<v8::Object> target) {
   heapString_persistent.Reset(heapString);
 
   target->Set(
-      NanNew("heapString")
+      NanNew("heapString").ToLocalChecked()
     , heapString->GetFunction()
   );
 
@@ -58,8 +58,8 @@ void Init (v8::Handle<v8::Object> target) {
 
   encodeHex_persistent.Reset(encodeHex);
 
-  target->Set(
-      NanNew("encodeHex")
+  NanSet(target
+    , NanNew("encodeHex").ToLocalChecked()
     , encodeHex->GetFunction()
   );
 
@@ -68,8 +68,8 @@ void Init (v8::Handle<v8::Object> target) {
 
   encodeUCS2_persistent.Reset(encodeUCS2);
 
-  target->Set(
-      NanNew("encodeUCS2")
+  NanSet(target
+    , NanNew("encodeUCS2").ToLocalChecked()
     , encodeUCS2->GetFunction()
   );
 }
diff --git a/test/cpp/symbols.cpp b/test/cpp/symbols.cpp
index c21d200e..79775759 100644
--- a/test/cpp/symbols.cpp
+++ b/test/cpp/symbols.cpp
@@ -9,7 +9,10 @@
 #include <nan.h>
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(NanNew<v8::String>("key"), NanNew<v8::String>("a property"));
+  NanSet(target
+    , NanNew<v8::String>("key").ToLocalChecked()
+    , NanNew<v8::String>("a property").ToLocalChecked()
+  );
 }
 
 NODE_MODULE(symbols, Init)
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index 10563cc6..f883333f 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -15,8 +15,6 @@
 class TlsTest : public NanAsyncWorker {
  public:
   explicit TlsTest(NanTap *t) : NanAsyncWorker(NULL), t(t), i(0) {
-    NanScope();
-
     t->plan(7);
     t->ok(_(0 == nauv_key_create(&tls_key)));
     t->ok(_(NULL == nauv_key_get(&tls_key)));
@@ -60,8 +58,8 @@ NAN_METHOD(thread_local_storage) {
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  exports->Set(
-      NanNew<v8::String>("thread_local_storage")
+  NanSet(exports
+    , NanNew<v8::String>("thread_local_storage").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(thread_local_storage)->GetFunction()
   );
 }
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index 1b8a2ecd..abffa9ba 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -20,7 +20,7 @@ void weakCallback(
 
 v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
   NanEscapableScope scope;
-  v8::Local<v8::String> lstring = NanNew<v8::String>("result");
+  v8::Local<v8::String> lstring = NanNew<v8::String>("result").ToLocalChecked();
   int *parameter = new int(42);
   NanPersistent<v8::Function> persistent(func);
   persistent.SetWeak(parameter, weakCallback, NanWeakCallbackType::kParameter);
@@ -34,8 +34,8 @@ NAN_METHOD(Hustle) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("hustle")
+  NanSet(target
+    , NanNew<v8::String>("hustle").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(Hustle)->GetFunction()
   );
 }
diff --git a/test/cpp/weak2.cpp b/test/cpp/weak2.cpp
index e63dc44d..5cd77409 100644
--- a/test/cpp/weak2.cpp
+++ b/test/cpp/weak2.cpp
@@ -19,7 +19,7 @@ void weakCallback(
 
 v8::Handle<v8::String> wrap() {
   NanEscapableScope scope;
-  v8::Local<v8::String> lstring = NanNew<v8::String>("result");
+  v8::Local<v8::String> lstring = NanNew("result").ToLocalChecked();
   v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
   otpl->SetInternalFieldCount(1);
   v8::Local<v8::Object> obj = otpl->NewInstance();
@@ -39,8 +39,8 @@ NAN_METHOD(Hustle) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  target->Set(
-      NanNew<v8::String>("hustle")
+  NanSet(target
+    , NanNew<v8::String>("hustle").ToLocalChecked()
     , NanNew<v8::FunctionTemplate>(Hustle)->GetFunction()
   );
 }
diff --git a/test/js/accessors2-test.js b/test/js/accessors2-test.js
new file mode 100644
index 00000000..8fdb5b86
--- /dev/null
+++ b/test/js/accessors2-test.js
@@ -0,0 +1,27 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'accessors2' });
+
+test('accessors2', function (t) {
+  t.plan(4)
+  var settergetter = bindings.create()
+  t.equal(settergetter.prop1, 'this is property 1')
+  t.ok(settergetter.prop2 === '')
+  settergetter.prop2 = 'setting a value'
+  t.equal(settergetter.prop2, 'setting a value')
+  t.equal(settergetter.log(),
+    'New()\n' +
+    'Prop1:GETTER(this is property 1)\n' +
+    'Prop2:GETTER()\n' +
+    'Prop2:SETTER(setting a value)\n' +
+    'Prop2:GETTER(setting a value)\n'
+  )
+})
diff --git a/test/js/converters-test.js b/test/js/converters-test.js
new file mode 100644
index 00000000..ac9aaec3
--- /dev/null
+++ b/test/js/converters-test.js
@@ -0,0 +1,45 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'converters' });
+
+test('converters', function (t) {
+  t.plan(28);
+
+  var converters = bindings;
+  t.type(converters.toBoolean, 'function');
+  t.type(converters.toNumber, 'function');
+  t.type(converters.toString, 'function');
+  t.type(converters.toDetailString, 'function');
+  t.type(converters.toObject, 'function');
+  t.type(converters.toInteger, 'function');
+  t.type(converters.toUint32, 'function');
+  t.type(converters.toInt32, 'function');
+  t.type(converters.toArrayIndex, 'function');
+  t.type(converters.booleanValue, 'function');
+  t.type(converters.numberValue, 'function');
+  t.type(converters.integerValue, 'function');
+  t.type(converters.uint32Value, 'function');
+  t.type(converters.int32Value, 'function');
+  t.equal(converters.toBoolean(true), true);
+  t.equal(converters.toNumber(15.3), 15.3);
+  t.equal(converters.toString('sol'), 'sol');
+  t.equal(converters.toDetailString('sol'), 'sol');
+  t.strictDeepEqual(converters.toObject({prop : 'x'}), {prop : 'x'});
+  t.equal(converters.toInteger(12), 12);
+  t.equal(converters.toUint32(12), 12);
+  t.equal(converters.toInt32(-12), -12);
+  t.equal(converters.toArrayIndex('12'), 12);
+  t.equal(converters.booleanValue(true), true);
+  t.equal(converters.numberValue(15.3), 15.3);
+  t.equal(converters.integerValue(12), 12);
+  t.equal(converters.uint32Value(12), 12);
+  t.equal(converters.int32Value(-12), -12);
+});

From 10f1ca4f67a2a0cb3761c3524f27c829d6d54a5e Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Wed, 20 May 2015 16:55:57 +0300
Subject: [PATCH 15/84] Added NanTryCatch

---
 nan.h                    | 58 +++++++++++++++++++++++++++++++++++-----
 test/binding.gyp         |  4 +++
 test/cpp/trycatch.cpp    | 30 +++++++++++++++++++++
 test/js/trycatch-test.js | 21 +++++++++++++++
 4 files changed, 107 insertions(+), 6 deletions(-)
 create mode 100644 test/cpp/trycatch.cpp
 create mode 100644 test/js/trycatch-test.js

diff --git a/nan.h b/nan.h
index 3316522b..29e259f5 100644
--- a/nan.h
+++ b/nan.h
@@ -85,7 +85,7 @@
     NAN_DISALLOW_MOVE(CLASS)
 
 #define NODE_0_10_MODULE_VERSION 11
-#define NODE_0_12_MODULE_VERSION 12
+#define NODE_0_12_MODULE_VERSION 14
 #define ATOM_0_21_MODULE_VERSION 41
 #define IOJS_1_0_MODULE_VERSION  42
 #define IOJS_1_1_MODULE_VERSION  43
@@ -140,7 +140,6 @@ template<typename T, typename M = NanNonCopyablePersistentTraits<T> >
 class NanPersistent;
 #endif  // NODE_MODULE_VERSION
 
-
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 # include "nan_maybe_43_inl.h"  // NOLINT(build/include)
@@ -413,6 +412,53 @@ class NanEscapableScope {
   void operator delete(void *, size_t);
 };
 
+//=== TryCatch =================================================================
+
+class NanTryCatch {
+  v8::TryCatch try_catch_;
+  friend void NanFatalException(const NanTryCatch&);
+
+ public:
+#if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
+  NanTryCatch() : try_catch_(v8::Isolate::GetCurrent()) {}
+#endif
+
+  NAN_INLINE bool HasCaught() const { return try_catch_.HasCaught(); }
+
+  NAN_INLINE bool CanContinue() const { return try_catch_.CanContinue(); }
+
+  NAN_INLINE v8::Handle<v8::Value> ReThrow() { return try_catch_.ReThrow(); }
+
+  NAN_INLINE v8::Local<v8::Value> Exception() const {
+    return try_catch_.Exception();
+  }
+
+#if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
+  (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+  NAN_INLINE v8::MaybeLocal<v8::Value> StackTrace() const {
+    return try_catch_.StackTrace(NanGetCurrentContext());
+  }
+#else
+  NAN_INLINE NanMaybeLocal<v8::Value> StackTrace() const {
+    return NanMaybeLocal<v8::Value>(try_catch_.StackTrace());
+  }
+#endif
+
+  NAN_INLINE v8::Local<v8::Message> Message() const {
+    return try_catch_.Message();
+  }
+
+  NAN_INLINE void Reset() { try_catch_.Reset(); }
+
+  NAN_INLINE void SetVerbose(bool value) { try_catch_.SetVerbose(value); }
+
+  NAN_INLINE void SetCaptureMessage(bool value) {
+    try_catch_.SetCaptureMessage(value);
+  }
+};
+
+//============ =================================================================
+
 /* node 0.12  */
 #if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
   NAN_INLINE
@@ -726,8 +772,8 @@ class NanEscapableScope {
         v8::Isolate::GetCurrent(), target, method, argc, argv));
   }
 
-  NAN_INLINE void NanFatalException(const v8::TryCatch& try_catch) {
-    node::FatalException(v8::Isolate::GetCurrent(), try_catch);
+  NAN_INLINE void NanFatalException(const NanTryCatch& try_catch) {
+    node::FatalException(v8::Isolate::GetCurrent(), try_catch.try_catch_);
   }
 
   NAN_INLINE v8::Local<v8::Value> NanErrnoException(
@@ -1060,8 +1106,8 @@ class NanEscapableScope {
     return NanNew(node::MakeCallback(target, method, argc, argv));
   }
 
-  NAN_INLINE void NanFatalException(const v8::TryCatch& try_catch) {
-    node::FatalException(const_cast<v8::TryCatch&>(try_catch));
+  NAN_INLINE void NanFatalException(const NanTryCatch& try_catch) {
+    node::FatalException(const_cast<v8::TryCatch &>(try_catch.try_catch_));
   }
 
   NAN_INLINE v8::Local<v8::Value> NanErrnoException(
diff --git a/test/binding.gyp b/test/binding.gyp
index 4277337e..4e909f76 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -124,4 +124,8 @@
         "target_name" : "converters"
       , "sources"     : [ "cpp/converters.cpp" ]
     }
+    , {
+        "target_name" : "trycatch"
+      , "sources"     : [ "cpp/trycatch.cpp" ]
+    }
 ]}
diff --git a/test/cpp/trycatch.cpp b/test/cpp/trycatch.cpp
new file mode 100644
index 00000000..230f9953
--- /dev/null
+++ b/test/cpp/trycatch.cpp
@@ -0,0 +1,30 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+
+NAN_METHOD(TryCatch) {
+  NanTryCatch try_catch;
+  v8::Local<v8::Value> v =
+      NanRunScript(NanNew<NanUnboundScript>(
+          NanNew("throw 'waaa'").ToLocalChecked()).ToLocalChecked())
+              .ToLocalChecked();
+  if (v.IsEmpty()) {
+    assert(try_catch.HasCaught());
+    try_catch.ReThrow();
+  }
+}
+
+void Init (v8::Handle<v8::Object> target) {
+  NanSet(target
+    , NanNew<v8::String>("r").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(TryCatch)->GetFunction()
+  );
+}
+
+NODE_MODULE(trycatch, Init)
diff --git a/test/js/trycatch-test.js b/test/js/trycatch-test.js
new file mode 100644
index 00000000..0a90fab6
--- /dev/null
+++ b/test/js/trycatch-test.js
@@ -0,0 +1,21 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'trycatch' });
+
+test('returnemptystring', function (t) {
+  t.plan(2);
+  t.type(bindings.r, 'function');
+  try {
+    bindings.r();
+  } catch (err) {
+    t.equal(err, 'waaa');
+  }
+});

From c543d32cf52e423c3f66233880f040c6337951dc Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 23 May 2015 18:33:13 +0300
Subject: [PATCH 16/84] Introduce NanNewOneByteString

---
 nan.h                           | 37 +++++++++++++++++++++++++++++++++
 nan_implementation_12_inl.h     | 15 -------------
 nan_implementation_pre_12_inl.h | 24 ---------------------
 nan_new.h                       |  9 --------
 test/cpp/morenews.cpp           |  2 +-
 test/cpp/nannew.cpp             |  5 ++---
 test/cpp/news.cpp               |  2 +-
 7 files changed, 41 insertions(+), 53 deletions(-)

diff --git a/nan.h b/nan.h
index 29e259f5..83a66c10 100644
--- a/nan.h
+++ b/nan.h
@@ -688,6 +688,12 @@ class NanTryCatch {
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
+  NAN_INLINE NanMaybeLocal<v8::String>
+  NanNewOneByteString(const uint8_t * value, int length = -1) {
+    return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value,
+          v8::NewStringType::kNormal, length);
+  }
+
   NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
@@ -715,6 +721,15 @@ class NanTryCatch {
     return script->Run(NanGetCurrentContext());
   }
 #else
+  NAN_INLINE NanMaybeLocal<v8::String>
+  NanNewOneByteString(const uint8_t * value, int length = -1) {
+    return NanMaybeLocal<v8::String>(
+        v8::String::NewFromOneByte(
+            v8::Isolate::GetCurrent()
+          , value
+          , v8::String::kNormalString, length));
+  }
+
   NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
@@ -1063,6 +1078,28 @@ class NanTryCatch {
     return function_template->HasInstance(value);
   }
 
+  namespace Nan { namespace imp {
+  NAN_INLINE void
+  widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
+    size_t len = static_cast<size_t>(l);
+    if (l < 0) {
+      len = strlen(reinterpret_cast<const char*>(s));
+    }
+    assert(len <= INT_MAX && "string too long");
+    ws->resize(len);
+    std::copy(s, s + len, ws->begin());  // NOLINT(build/include_what_you_use)
+  }
+  }  // end of namespace imp NOLINT(readability/namespace)
+  }  // end of namespace Nan NOLINT(readability/namespace)
+
+  NAN_INLINE NanMaybeLocal<v8::String>
+  NanNewOneByteString(const uint8_t * value, int length = -1) {
+    std::vector<uint16_t> wideString;  // NOLINT(build/include_what_you_use)
+    Nan::imp::widenString(&wideString, value, length);
+    return Nan::imp::Factory<v8::String>::return_t(v8::String::New(
+        &wideString.front(), static_cast<int>(wideString.size())));
+  }
+
   NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index f9af72ce..7fa4da4b 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -294,12 +294,6 @@ Factory<v8::String>::New(std::string const& value) {
       value.data(), v8::NewStringType::kNormal, static_cast<int>(value.size()));
 }
 
-Factory<v8::String>::return_t
-Factory<v8::String>::New(const uint8_t * value, int length) {
-  return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value,
-        v8::NewStringType::kNormal, length);
-}
-
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const uint16_t * value, int length) {
   return v8::String::NewFromTwoByte(v8::Isolate::GetCurrent(), value,
@@ -337,15 +331,6 @@ Factory<v8::String>::New(std::string const& value) {
         , static_cast<int>(value.size())));
 }
 
-Factory<v8::String>::return_t
-Factory<v8::String>::New(const uint8_t * value, int length) {
-  return Factory<v8::String>::return_t(
-      v8::String::NewFromOneByte(
-          v8::Isolate::GetCurrent()
-        , value
-        , v8::String::kNormalString, length));
-}
-
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const uint16_t * value, int length) {
   return Factory<v8::String>::return_t(
diff --git a/nan_implementation_pre_12_inl.h b/nan_implementation_pre_12_inl.h
index 6b222b8c..ad6f3d32 100644
--- a/nan_implementation_pre_12_inl.h
+++ b/nan_implementation_pre_12_inl.h
@@ -226,35 +226,11 @@ Factory<v8::String>::New(std::string const& value) {
       v8::String::New( value.data(), static_cast<int>(value.size())));
 }
 
-inline
-void
-widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l = -1) {
-  size_t len = static_cast<size_t>(l);
-  if (l < 0) {
-    len = strlen(reinterpret_cast<const char*>(s));
-  }
-  assert(len <= INT_MAX && "string too long");
-  ws->resize(len);
-  std::copy(s, s + len, ws->begin());
-}
-
 Factory<v8::String>::return_t
 Factory<v8::String>::New(const uint16_t * value, int length) {
   return Factory<v8::String>::return_t(v8::String::New(value, length));
 }
 
-Factory<v8::String>::return_t
-Factory<v8::String>::New(const uint8_t * value, int length) {
-  std::vector<uint16_t> wideString;
-  widenString(&wideString, value, length);
-  if (wideString.size() == 0) {
-    return Factory<v8::String>::return_t(v8::String::Empty());
-  } else {
-    return Factory<v8::String>::return_t(v8::String::New(&wideString.front()
-         , static_cast<int>(wideString.size())));
-  }
-}
-
 Factory<v8::String>::return_t
 Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
   return Factory<v8::String>::return_t(v8::String::NewExternal(value));
diff --git a/nan_new.h b/nan_new.h
index 3d5bcf71..62748744 100644
--- a/nan_new.h
+++ b/nan_new.h
@@ -173,9 +173,6 @@ struct Factory<v8::String> : MaybeFactoryBase<v8::String> {
 
   static inline return_t New(v8::String::ExternalStringResource * value);
   static inline return_t New(NanExternalOneByteStringResource * value);
-
-  // TODO(agnat): Deprecate.
-  static inline return_t New(const uint8_t * value, int length = -1);
 };
 
 template <>
@@ -316,12 +313,6 @@ NanNew(const char * value) {
   return NanNew<v8::String>(value);
 }
 
-inline
-Nan::imp::Factory<v8::String>::return_t
-NanNew(const uint8_t * value) {
-  return NanNew<v8::String>(value);
-}
-
 inline
 Nan::imp::Factory<v8::String>::return_t
 NanNew(const uint16_t * value) {
diff --git a/test/cpp/morenews.cpp b/test/cpp/morenews.cpp
index eef689a5..9b4bbb32 100644
--- a/test/cpp/morenews.cpp
+++ b/test/cpp/morenews.cpp
@@ -27,7 +27,7 @@ NAN_METHOD(NewUtf8String) {
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
+  info.GetReturnValue().Set(NanNewOneByteString(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewUcs2String) {
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index dc6f0557..745e345b 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -301,12 +301,11 @@ NAN_METHOD(testString) {
   t.ok(_( stringMatches( NanNew<String>().ToLocalChecked(), "")));
   t.ok(_( assertType<String>( NanNew<String>().ToLocalChecked())));
 
-  // These should be deprecated
   const uint8_t *ustring = reinterpret_cast<const uint8_t *>("unsigned chars");
   t.ok(_( stringMatches(
-      NanNew<String>(ustring).ToLocalChecked(), "unsigned chars")));
+      NanNewOneByteString(ustring).ToLocalChecked(), "unsigned chars")));
   t.ok(_( stringMatches(
-      NanNew<String>(ustring, 8).ToLocalChecked(), "unsigned")));
+      NanNewOneByteString(ustring, 8).ToLocalChecked(), "unsigned")));
 
   // === Convenience
 
diff --git a/test/cpp/news.cpp b/test/cpp/news.cpp
index 538879f9..b28ddbc6 100644
--- a/test/cpp/news.cpp
+++ b/test/cpp/news.cpp
@@ -57,7 +57,7 @@ NAN_METHOD(NewUtf8String) {
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
+  info.GetReturnValue().Set(NanNewOneByteString(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewUcs2String) {

From 6745f99b332972ec3d2269f19cd09566253b75b1 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 25 May 2015 01:22:20 +0300
Subject: [PATCH 17/84] Rename NanNewBufferHandle to NanNewBuffer

---
 nan.h              | 12 ++++++------
 nan_string_bytes.h |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/nan.h b/nan.h
index 83a66c10..39225e0a 100644
--- a/nan.h
+++ b/nan.h
@@ -651,7 +651,7 @@ class NanTryCatch {
     v8::Isolate::GetCurrent()->ThrowException(error);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
       char *data
     , size_t length
     , node::smalloc::FreeCallback callback
@@ -661,14 +661,14 @@ class NanTryCatch {
         v8::Isolate::GetCurrent(), data, length, callback, hint);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
       const char *data
     , uint32_t size
   ) {
     return node::Buffer::New(v8::Isolate::GetCurrent(), data, size);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(uint32_t size) {
     return node::Buffer::New(v8::Isolate::GetCurrent(), size);
   }
 
@@ -1032,7 +1032,7 @@ class NanTryCatch {
     v8::ThrowException(error);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
       char *data
     , size_t length
     , node::Buffer::free_callback callback
@@ -1042,7 +1042,7 @@ class NanTryCatch {
         node::Buffer::New(data, length, callback, hint)->handle_);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
       const char *data
     , uint32_t size
   ) {
@@ -1054,7 +1054,7 @@ class NanTryCatch {
 #endif
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBufferHandle (uint32_t size) {
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(uint32_t size) {
     return NanNew(node::Buffer::New(size)->handle_);
   }
 
diff --git a/nan_string_bytes.h b/nan_string_bytes.h
index f5040a5e..0956ddbd 100644
--- a/nan_string_bytes.h
+++ b/nan_string_bytes.h
@@ -238,7 +238,7 @@ static Local<Value> Encode(const char* buf,
   Local<String> val;
   switch (encoding) {
     case Nan::BUFFER:
-      return NanNewBufferHandle(buf, buflen);
+      return NanNewBuffer(buf, buflen);
 
     case Nan::ASCII:
       if (contains_non_ascii(buf, buflen)) {

From 3e8b0a516afd002cf545e299aa5932ee847e1c88 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 25 May 2015 01:23:20 +0300
Subject: [PATCH 18/84] Rename NanBufferUse to NanNewBuffer

---
 nan.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nan.h b/nan.h
index 39225e0a..01f217a3 100644
--- a/nan.h
+++ b/nan.h
@@ -672,7 +672,7 @@ class NanTryCatch {
     return node::Buffer::New(v8::Isolate::GetCurrent(), size);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanBufferUse(
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
       char* data
     , uint32_t size
   ) {
@@ -1063,7 +1063,7 @@ class NanTryCatch {
     delete[] data;
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanBufferUse(
+  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
       char* data
     , uint32_t size
   ) {

From d6af78dc064d1c1549d8818017a780f8a9ca37be Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Wed, 27 May 2015 14:49:34 +0300
Subject: [PATCH 19/84] Rename NanNewBuffer to NanCopyBuffer

---
 nan.h              | 28 ++++++++++++++++++++++++++--
 nan_string_bytes.h |  2 +-
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/nan.h b/nan.h
index 01f217a3..9dfc54cd 100644
--- a/nan.h
+++ b/nan.h
@@ -657,18 +657,27 @@ class NanTryCatch {
     , node::smalloc::FreeCallback callback
     , void *hint
   ) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(length <= 0x3fffffff && "too large buffer");
     return node::Buffer::New(
         v8::Isolate::GetCurrent(), data, length, callback, hint);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
+  NAN_INLINE v8::Local<v8::Object> NanCopyBuffer(
       const char *data
     , uint32_t size
   ) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(size <= 0x3fffffff && "too large buffer");
     return node::Buffer::New(v8::Isolate::GetCurrent(), data, size);
   }
 
   NAN_INLINE v8::Local<v8::Object> NanNewBuffer(uint32_t size) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(size <= 0x3fffffff && "too large buffer");
     return node::Buffer::New(v8::Isolate::GetCurrent(), size);
   }
 
@@ -676,6 +685,9 @@ class NanTryCatch {
       char* data
     , uint32_t size
   ) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(size <= 0x3fffffff && "too large buffer");
     return node::Buffer::Use(v8::Isolate::GetCurrent(), data, size);
   }
 
@@ -1038,14 +1050,20 @@ class NanTryCatch {
     , node::Buffer::free_callback callback
     , void *hint
   ) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(length <= 0x3fffffff && "too large buffer");
     return NanNew(
         node::Buffer::New(data, length, callback, hint)->handle_);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
+  NAN_INLINE v8::Local<v8::Object> NanCopyBuffer(
       const char *data
     , uint32_t size
   ) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(size <= 0x3fffffff && "too large buffer");
 #if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION
     return NanNew(node::Buffer::New(data, size)->handle_);
 #else
@@ -1055,6 +1073,9 @@ class NanTryCatch {
   }
 
   NAN_INLINE v8::Local<v8::Object> NanNewBuffer(uint32_t size) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(size <= 0x3fffffff && "too large buffer");
     return NanNew(node::Buffer::New(size)->handle_);
   }
 
@@ -1067,6 +1088,9 @@ class NanTryCatch {
       char* data
     , uint32_t size
   ) {
+    // arbitrary buffer lengths requires
+    // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
+    assert(size <= 0x3fffffff && "too large buffer");
     return NanNew(
         node::Buffer::New(data, size, FreeData, NULL)->handle_);
   }
diff --git a/nan_string_bytes.h b/nan_string_bytes.h
index 0956ddbd..8f32ff3e 100644
--- a/nan_string_bytes.h
+++ b/nan_string_bytes.h
@@ -238,7 +238,7 @@ static Local<Value> Encode(const char* buf,
   Local<String> val;
   switch (encoding) {
     case Nan::BUFFER:
-      return NanNewBuffer(buf, buflen);
+      return NanCopyBuffer(buf, buflen);
 
     case Nan::ASCII:
       if (contains_non_ascii(buf, buflen)) {

From deaeea91b57ce4bee933d8922a4de8a9114e44dd Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Wed, 27 May 2015 14:50:03 +0300
Subject: [PATCH 20/84] Add tests for Buffer

---
 Makefile               |  1 +
 test/binding.gyp       |  3 ++
 test/cpp/buffer.cpp    | 63 ++++++++++++++++++++++++++++++++++++++++++
 test/js/buffer-test.js | 23 +++++++++++++++
 4 files changed, 90 insertions(+)
 create mode 100644 test/cpp/buffer.cpp
 create mode 100644 test/js/buffer-test.js

diff --git a/Makefile b/Makefile
index 34138dce..7f7bf7f4 100644
--- a/Makefile
+++ b/Makefile
@@ -35,6 +35,7 @@ LINT_SOURCES = \
 	test/cpp/asyncworker.cpp \
 	test/cpp/asyncprogressworker.cpp \
 	test/cpp/asyncworkererror.cpp \
+	test/cpp/buffer.cpp \
 	test/cpp/bufferworkerpersistent.cpp \
 	test/cpp/error.cpp \
 	test/cpp/gc.cpp \
diff --git a/test/binding.gyp b/test/binding.gyp
index 4e909f76..e3d3f6c5 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -123,6 +123,9 @@
     , {
         "target_name" : "converters"
       , "sources"     : [ "cpp/converters.cpp" ]
+    }, {
+        "target_name" : "buffer"
+      , "sources"     : [ "cpp/buffer.cpp" ]
     }
     , {
         "target_name" : "trycatch"
diff --git a/test/cpp/buffer.cpp b/test/cpp/buffer.cpp
new file mode 100644
index 00000000..d89d5af4
--- /dev/null
+++ b/test/cpp/buffer.cpp
@@ -0,0 +1,63 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+#include <nan.h>
+
+static const size_t DATA_SIZE = 26;
+
+static char data[DATA_SIZE];
+
+void callback(char* data, void* hint) {
+  fprintf(stderr, "callback\n");
+}
+
+NAN_METHOD(New1) {
+  info.GetReturnValue().Set(NanNewBuffer(data, DATA_SIZE, callback, 0));
+}
+
+NAN_METHOD(New2) {
+  v8::Local<v8::Object> buf = NanNewBuffer(DATA_SIZE);
+  char* pbuf = node::Buffer::Data(buf);
+  for (unsigned char i = 0; i < DATA_SIZE; i++) {
+    pbuf[i] = 'a' + i;
+  }
+  info.GetReturnValue().Set(buf);
+}
+
+NAN_METHOD(New3) {
+  info.GetReturnValue().Set(NanNewBuffer(data, DATA_SIZE));
+}
+
+NAN_METHOD(Copy) {
+  info.GetReturnValue().Set(NanCopyBuffer(data, DATA_SIZE));
+}
+
+
+void Init (v8::Handle<v8::Object> target) {
+  for (unsigned char i = 0; i < DATA_SIZE; i++) {
+    data[i] = 'a' + i;
+  }
+  NanSet(target
+    , NanNew<v8::String>("new1").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(New1)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("new2").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(New2)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("new3").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(New3)->GetFunction()
+  );
+  NanSet(target
+    , NanNew<v8::String>("copy").ToLocalChecked()
+    , NanNew<v8::FunctionTemplate>(Copy)->GetFunction()
+  );
+}
+
+NODE_MODULE(buffer, Init)
diff --git a/test/js/buffer-test.js b/test/js/buffer-test.js
new file mode 100644
index 00000000..2c64856d
--- /dev/null
+++ b/test/js/buffer-test.js
@@ -0,0 +1,23 @@
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+const test     = require('tap').test
+    , testRoot = require('path').resolve(__dirname, '..')
+    , bindings = require('bindings')({ module_root: testRoot, bindings: 'buffer' });
+
+test('buffer', function (t) {
+  t.plan(8);
+  t.type(bindings.new1, 'function');
+  t.type(bindings.new2, 'function');
+  t.type(bindings.new3, 'function');
+  t.type(bindings.copy, 'function');
+  t.equal(bindings.new1().toString(), 'abcdefghijklmnopqrstuvwxyz');
+  t.equal(bindings.new2().toString(), 'abcdefghijklmnopqrstuvwxyz');
+  t.equal(bindings.new3().toString(), 'abcdefghijklmnopqrstuvwxyz');
+  t.equal(bindings.copy().toString(), 'abcdefghijklmnopqrstuvwxyz');
+});

From 5d31159c7a2a036ce204aad6295b1a24de96c4e9 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Wed, 27 May 2015 14:46:16 +0300
Subject: [PATCH 21/84] Use MaybeLocal in Buffer

---
 nan.h               | 73 ++++++++++++++++++++++++++++++---------------
 nan_string_bytes.h  |  2 +-
 test/cpp/buffer.cpp | 19 ++++++++----
 3 files changed, 64 insertions(+), 30 deletions(-)

diff --git a/nan.h b/nan.h
index 9dfc54cd..faa692c0 100644
--- a/nan.h
+++ b/nan.h
@@ -284,6 +284,8 @@ template<typename P> class NanWeakCallbackInfo;
 #endif
 
 namespace Nan { namespace imp {
+  static const size_t kMaxLength = 0x3fffffff;
+
   template<typename T>
   NAN_INLINE
   v8::Local<T>
@@ -651,7 +653,7 @@ class NanTryCatch {
     v8::Isolate::GetCurrent()->ThrowException(error);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
+  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(
       char *data
     , size_t length
     , node::smalloc::FreeCallback callback
@@ -659,26 +661,43 @@ class NanTryCatch {
   ) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(length <= 0x3fffffff && "too large buffer");
+    assert(length <= Nan::imp::kMaxLength && "too large buffer");
+#if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
     return node::Buffer::New(
         v8::Isolate::GetCurrent(), data, length, callback, hint);
+#else
+    return NanMaybeLocal<v8::Object>(node::Buffer::New(
+        v8::Isolate::GetCurrent(), data, length, callback, hint));
+#endif
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanCopyBuffer(
+  NAN_INLINE NanMaybeLocal<v8::Object> NanCopyBuffer(
       const char *data
     , uint32_t size
   ) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= 0x3fffffff && "too large buffer");
-    return node::Buffer::New(v8::Isolate::GetCurrent(), data, size);
+    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+#if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
+    return node::Buffer::New(
+        v8::Isolate::GetCurrent(), data, size);
+#else
+    return NanMaybeLocal<v8::Object>(node::Buffer::New(
+        v8::Isolate::GetCurrent(), data, size));
+#endif
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(uint32_t size) {
+  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(uint32_t size) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= 0x3fffffff && "too large buffer");
-    return node::Buffer::New(v8::Isolate::GetCurrent(), size);
+    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+#if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
+    return node::Buffer::New(
+        v8::Isolate::GetCurrent(), size);
+#else
+    return NanMaybeLocal<v8::Object>(node::Buffer::New(
+        v8::Isolate::GetCurrent(), size));
+#endif
   }
 
   NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
@@ -687,7 +706,7 @@ class NanTryCatch {
   ) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= 0x3fffffff && "too large buffer");
+    assert(size <= Nan::imp::kMaxLength && "too large buffer");
     return node::Buffer::Use(v8::Isolate::GetCurrent(), data, size);
   }
 
@@ -1044,39 +1063,44 @@ class NanTryCatch {
     v8::ThrowException(error);
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
+  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(
       char *data
     , size_t length
     , node::Buffer::free_callback callback
     , void *hint
   ) {
+    NanScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(length <= 0x3fffffff && "too large buffer");
-    return NanNew(
-        node::Buffer::New(data, length, callback, hint)->handle_);
+    assert(length <= Nan::imp::kMaxLength && "too large buffer");
+    return NanMaybeLocal<v8::Object>(
+        NanNew(node::Buffer::New(data, length, callback, hint)->handle_));
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanCopyBuffer(
+  NAN_INLINE NanMaybeLocal<v8::Object> NanCopyBuffer(
       const char *data
     , uint32_t size
   ) {
+    NanEscapableScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= 0x3fffffff && "too large buffer");
+    assert(size <= Nan::imp::kMaxLength && "too large buffer");
 #if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION
-    return NanNew(node::Buffer::New(data, size)->handle_);
+    return NanMaybeLocal<v8::Object>(
+        scope.Escape(NanNew(node::Buffer::New(data, size)->handle_)));
 #else
-    return NanNew(
-      node::Buffer::New(const_cast<char*>(data), size)->handle_);
+    return NanMaybeLocal<v8::Object>(scope.Escape(
+        NanNew(node::Buffer::New(const_cast<char*>(data), size)->handle_)));
 #endif
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(uint32_t size) {
+  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(uint32_t size) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= 0x3fffffff && "too large buffer");
-    return NanNew(node::Buffer::New(size)->handle_);
+    NanEscapableScope scope;
+    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+    return NanMaybeLocal<v8::Object>(
+        scope.Escape(NanNew(node::Buffer::New(size)->handle_)));
   }
 
   NAN_INLINE void FreeData(char *data, void *hint) {
@@ -1088,11 +1112,12 @@ class NanTryCatch {
       char* data
     , uint32_t size
   ) {
+    NanEscapableScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= 0x3fffffff && "too large buffer");
-    return NanNew(
-        node::Buffer::New(data, size, FreeData, NULL)->handle_);
+    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+    return scope.Escape(NanNew(
+        node::Buffer::New(data, size, FreeData, NULL)->handle_));
   }
 
   NAN_INLINE bool NanHasInstance(
diff --git a/nan_string_bytes.h b/nan_string_bytes.h
index 8f32ff3e..51281efd 100644
--- a/nan_string_bytes.h
+++ b/nan_string_bytes.h
@@ -238,7 +238,7 @@ static Local<Value> Encode(const char* buf,
   Local<String> val;
   switch (encoding) {
     case Nan::BUFFER:
-      return NanCopyBuffer(buf, buflen);
+      return NanCopyBuffer(buf, buflen).ToLocalChecked();
 
     case Nan::ASCII:
       if (contains_non_ascii(buf, buflen)) {
diff --git a/test/cpp/buffer.cpp b/test/cpp/buffer.cpp
index d89d5af4..c68e2fed 100644
--- a/test/cpp/buffer.cpp
+++ b/test/cpp/buffer.cpp
@@ -13,15 +13,20 @@ static const size_t DATA_SIZE = 26;
 static char data[DATA_SIZE];
 
 void callback(char* data, void* hint) {
-  fprintf(stderr, "callback\n");
+  free(data);
 }
 
 NAN_METHOD(New1) {
-  info.GetReturnValue().Set(NanNewBuffer(data, DATA_SIZE, callback, 0));
+  char *dynamic_data = static_cast<char *>(malloc(DATA_SIZE));
+  for (unsigned char i = 0; i < DATA_SIZE; i++) {
+    dynamic_data[i] = 'a' + i;
+  }
+  info.GetReturnValue().Set(
+      NanNewBuffer(dynamic_data, DATA_SIZE, callback, 0).ToLocalChecked());
 }
 
 NAN_METHOD(New2) {
-  v8::Local<v8::Object> buf = NanNewBuffer(DATA_SIZE);
+  v8::Local<v8::Object> buf = NanNewBuffer(DATA_SIZE).ToLocalChecked();
   char* pbuf = node::Buffer::Data(buf);
   for (unsigned char i = 0; i < DATA_SIZE; i++) {
     pbuf[i] = 'a' + i;
@@ -30,11 +35,15 @@ NAN_METHOD(New2) {
 }
 
 NAN_METHOD(New3) {
-  info.GetReturnValue().Set(NanNewBuffer(data, DATA_SIZE));
+  char *dynamic_data = static_cast<char *>(malloc(DATA_SIZE));
+  for (unsigned char i = 0; i < DATA_SIZE; i++) {
+    dynamic_data[i] = 'a' + i;
+  }
+  info.GetReturnValue().Set(NanNewBuffer(dynamic_data, DATA_SIZE));
 }
 
 NAN_METHOD(Copy) {
-  info.GetReturnValue().Set(NanCopyBuffer(data, DATA_SIZE));
+  info.GetReturnValue().Set(NanCopyBuffer(data, DATA_SIZE).ToLocalChecked());
 }
 
 

From 67ed1b17b2afa9e650c6b667ebe67a0a8bd9ef20 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 23 May 2015 19:19:48 +0300
Subject: [PATCH 22/84] Introduce namespace Nan

---
 examples/async_pi_estimate/addon.cc |   2 +
 examples/async_pi_estimate/async.cc |   2 +
 examples/async_pi_estimate/async.h  |   2 +
 examples/async_pi_estimate/sync.cc  |   2 +
 examples/async_pi_estimate/sync.h   |   2 +
 nan.h                               | 481 ++++++++++++----------------
 nan_callbacks.h                     |  14 +-
 nan_callbacks_12_inl.h              |   3 +-
 nan_callbacks_pre_12_inl.h          |   6 +-
 nan_converters.h                    |   3 +-
 nan_implementation_12_inl.h         |  20 +-
 nan_implementation_pre_12_inl.h     |  24 +-
 nan_new.h                           |  17 +-
 nan_string_bytes.h                  |  29 +-
 test/cpp/accessors.cpp              |   2 +
 test/cpp/accessors2.cpp             |   2 +
 test/cpp/asyncprogressworker.cpp    |   2 +
 test/cpp/asyncworker.cpp            |   2 +
 test/cpp/asyncworkererror.cpp       |   2 +
 test/cpp/buffer.cpp                 |   2 +
 test/cpp/bufferworkerpersistent.cpp |   2 +
 test/cpp/converters.cpp             |   2 +
 test/cpp/error.cpp                  |   2 +
 test/cpp/gc.cpp                     |   2 +
 test/cpp/indexedinterceptors.cpp    |   2 +
 test/cpp/isolatedata.cpp            |   2 +
 test/cpp/makecallback.cpp           |   2 +
 test/cpp/morenews.cpp               |   2 +
 test/cpp/multifile1.cpp             |   2 +
 test/cpp/multifile2.cpp             |   2 +
 test/cpp/multifile2.h               |   2 +
 test/cpp/namedinterceptors.cpp      |   2 +
 test/cpp/nancallback.cpp            |   2 +
 test/cpp/nannew.cpp                 |   2 +
 test/cpp/news.cpp                   |   2 +
 test/cpp/objectwraphandle.cpp       |   2 +
 test/cpp/persistent.cpp             |   2 +
 test/cpp/returnemptystring.cpp      |   2 +
 test/cpp/returnnull.cpp             |   2 +
 test/cpp/returnundefined.cpp        |   2 +
 test/cpp/returnvalue.cpp            |   2 +
 test/cpp/settemplate.cpp            |   2 +
 test/cpp/strings.cpp                |   6 +-
 test/cpp/symbols.cpp                |   2 +
 test/cpp/threadlocal.cpp            |   2 +
 test/cpp/trycatch.cpp               |   2 +
 test/cpp/weak.cpp                   |   2 +
 test/cpp/weak2.cpp                  |   2 +
 48 files changed, 306 insertions(+), 373 deletions(-)

diff --git a/examples/async_pi_estimate/addon.cc b/examples/async_pi_estimate/addon.cc
index b0e72da3..3b1ba0b1 100644
--- a/examples/async_pi_estimate/addon.cc
+++ b/examples/async_pi_estimate/addon.cc
@@ -10,6 +10,8 @@
 #include "sync.h"   // NOLINT(build/include)
 #include "async.h"  // NOLINT(build/include)
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 using v8::FunctionTemplate;
 using v8::Handle;
 using v8::Object;
diff --git a/examples/async_pi_estimate/async.cc b/examples/async_pi_estimate/async.cc
index acab9b65..173f565e 100644
--- a/examples/async_pi_estimate/async.cc
+++ b/examples/async_pi_estimate/async.cc
@@ -10,6 +10,8 @@
 #include "pi_est.h"  // NOLINT(build/include)
 #include "async.h"  // NOLINT(build/include)
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 using v8::Function;
 using v8::Local;
 using v8::Null;
diff --git a/examples/async_pi_estimate/async.h b/examples/async_pi_estimate/async.h
index ad3e8897..adba6769 100644
--- a/examples/async_pi_estimate/async.h
+++ b/examples/async_pi_estimate/async.h
@@ -11,6 +11,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(CalculateAsync);
 
 #endif  // EXAMPLES_ASYNC_PI_ESTIMATE_ASYNC_H_
diff --git a/examples/async_pi_estimate/sync.cc b/examples/async_pi_estimate/sync.cc
index 88b04dd4..28ebb6c4 100644
--- a/examples/async_pi_estimate/sync.cc
+++ b/examples/async_pi_estimate/sync.cc
@@ -10,6 +10,8 @@
 #include "pi_est.h"  // NOLINT(build/include)
 #include "sync.h"  // NOLINT(build/include)
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 using v8::Number;
 
 // Simple synchronous access to the `Estimate()` function
diff --git a/examples/async_pi_estimate/sync.h b/examples/async_pi_estimate/sync.h
index 282d540d..b76d6d6a 100644
--- a/examples/async_pi_estimate/sync.h
+++ b/examples/async_pi_estimate/sync.h
@@ -11,6 +11,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(CalculateSync);
 
 #endif  // EXAMPLES_ASYNC_PI_ESTIMATE_SYNC_H_
diff --git a/nan.h b/nan.h
index faa692c0..a85ad9ae 100644
--- a/nan.h
+++ b/nan.h
@@ -25,18 +25,45 @@
 #include <node_buffer.h>
 #include <node_version.h>
 #include <node_object_wrap.h>
+#include <algorithm>
 #include <cstring>
 #include <climits>
 #include <cstdlib>
 #if defined(_MSC_VER)
 # pragma warning( push )
 # pragma warning( disable : 4530 )
+# include <map>
 # include <string>
+# include <vector>
 # pragma warning( pop )
 #else
+# include <map>
 # include <string>
+# include <vector>
 #endif
 
+// uv helpers
+#ifdef UV_VERSION_MAJOR
+# ifndef UV_VERSION_PATCH
+#  define UV_VERSION_PATCH 0
+# endif
+# define NAUV_UVVERSION  ((UV_VERSION_MAJOR << 16) | \
+                     (UV_VERSION_MINOR <<  8) | \
+                     (UV_VERSION_PATCH))
+#else
+# define NAUV_UVVERSION 0x000b00
+#endif
+
+#if NAUV_UVVERSION < 0x000b0b
+# ifdef WIN32
+#  include <windows.h>
+# else
+#  include <pthread.h>
+# endif
+#endif
+
+namespace Nan {
+
 #if defined(__GNUC__) && !(defined(DEBUG) && DEBUG)
 # define NAN_INLINE inline __attribute__((always_inline))
 #elif defined(_MSC_VER) && !(defined(DEBUG) && DEBUG)
@@ -150,19 +177,6 @@ class NanPersistent;
 #include "nan_converters.h"  // NOLINT(build/include)
 #include "nan_new.h"  // NOLINT(build/include)
 
-// uv helpers
-#ifdef UV_VERSION_MAJOR
-#ifndef UV_VERSION_PATCH
-#define UV_VERSION_PATCH 0
-#endif
-#define NAUV_UVVERSION  ((UV_VERSION_MAJOR << 16) | \
-                     (UV_VERSION_MINOR <<  8) | \
-                     (UV_VERSION_PATCH))
-#else
-#define NAUV_UVVERSION 0x000b00
-#endif
-
-
 #if NAUV_UVVERSION < 0x000b17
 #define NAUV_WORK_CB(func) \
     void func(uv_async_t *async, int)
@@ -200,8 +214,6 @@ inline void nauv_key_set(nauv_key_t *key, void *value) {
 
 #ifndef WIN32
 
-#include <pthread.h>
-
 typedef pthread_key_t nauv_key_t;
 
 inline int nauv_key_create(nauv_key_t* key) {
@@ -224,8 +236,6 @@ inline void nauv_key_set(nauv_key_t* key, void* value) {
 
 #else
 
-#include <windows.h>
-
 typedef struct {
   DWORD tls_index;
 } nauv_key_t;
@@ -283,9 +293,8 @@ template<typename P> class NanWeakCallbackInfo;
 # include "nan_persistent_pre_12_inl.h"  // NOLINT(build/include)
 #endif
 
-namespace Nan { namespace imp {
+namespace imp {
   static const size_t kMaxLength = 0x3fffffff;
-
   template<typename T>
   NAN_INLINE
   v8::Local<T>
@@ -344,7 +353,6 @@ namespace Nan { namespace imp {
     return NanUnwrap(NanNew(val));
   }
 }  // end of namespace imp
-}  // end of namespace Nan
 
 //=== HandleScope ==============================================================
 
@@ -846,102 +854,47 @@ class NanTryCatch {
       return static_cast<T*>(isolate->GetData(0));
   }
 
-  class NanAsciiString {
-   public:
-    NAN_INLINE explicit NanAsciiString(v8::Handle<v8::Value> from) {
-      v8::Local<v8::String> toStr = from->ToString();
-      size = toStr->Length();
-      buf = new char[size + 1];
-      size = toStr->WriteOneByte(reinterpret_cast<unsigned char*>(buf));
-    }
-
-    NAN_INLINE int length() const {
-      return size;
-    }
-
-
-    NAN_INLINE char* operator*() { return buf; }
-    NAN_INLINE const char* operator*() const { return buf; }
-
-    NAN_INLINE ~NanAsciiString() {
-      delete[] buf;
-    }
-
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(NanAsciiString)
-
-    char *buf;
-    int size;
-  };
-
-  class NanUtf8String {
-   public:
-    NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) :
-        length_(0), str_(str_st_) {
-      if (!from.IsEmpty()) {
-        v8::Local<v8::String> string = from->ToString();
-        if (!string.IsEmpty()) {
-          size_t len = 3 * string->Length() + 1;
-          assert(len <= INT_MAX);
-          if (len > sizeof (str_st_)) {
-            str_ = static_cast<char*>(malloc(len));
-            assert(str_ != 0);
-          }
-          const int flags = v8::String::NO_NULL_TERMINATION |
-                            v8::String::REPLACE_INVALID_UTF8;
-          length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
-          str_[length_] = '\0';
+class NanUtf8String {
+ public:
+  NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) :
+      length_(0), str_(str_st_) {
+    if (!from.IsEmpty()) {
+      v8::Local<v8::String> string = from->ToString();
+      if (!string.IsEmpty()) {
+        size_t len = 3 * string->Length() + 1;
+        assert(len <= INT_MAX);
+        if (len > sizeof (str_st_)) {
+          str_ = static_cast<char*>(malloc(len));
+          assert(str_ != 0);
         }
+        const int flags = v8::String::NO_NULL_TERMINATION |
+                          v8::String::REPLACE_INVALID_UTF8;
+        length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
+        str_[length_] = '\0';
       }
     }
+  }
 
-    NAN_INLINE int length() const {
-      return length_;
-    }
-
-    NAN_INLINE char* operator*() { return str_; }
-    NAN_INLINE const char* operator*() const { return str_; }
-
-    NAN_INLINE ~NanUtf8String() {
-      if (str_ != str_st_) {
-        free(str_);
-      }
-    }
-
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUtf8String)
-
-    int length_;
-    char *str_;
-    char str_st_[1024];
-  };
-
-  class NanUcs2String {
-   public:
-    NAN_INLINE explicit NanUcs2String(v8::Handle<v8::Value> from) {
-      v8::Local<v8::String> toStr = from->ToString();
-      size = toStr->Length();
-      buf = new uint16_t[size + 1];
-      toStr->Write(buf);
-    }
-
-    NAN_INLINE int length() const {
-      return size;
-    }
+  NAN_INLINE int length() const {
+    return length_;
+  }
 
-    NAN_INLINE uint16_t* operator*() { return buf; }
-    NAN_INLINE const uint16_t* operator*() const { return buf; }
+  NAN_INLINE char* operator*() { return str_; }
+  NAN_INLINE const char* operator*() const { return str_; }
 
-    NAN_INLINE ~NanUcs2String() {
-      delete[] buf;
+  NAN_INLINE ~NanUtf8String() {
+    if (str_ != str_st_) {
+      free(str_);
     }
+  }
 
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUcs2String)
+ private:
+  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUtf8String)
 
-    uint16_t *buf;
-    int size;
-  };
+  int length_;
+  char *str_;
+  char str_st_[1024];
+};
 
 #else  // Node 0.8 and 0.10
   NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
@@ -1127,25 +1080,24 @@ class NanTryCatch {
     return function_template->HasInstance(value);
   }
 
-  namespace Nan { namespace imp {
-  NAN_INLINE void
-  widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
-    size_t len = static_cast<size_t>(l);
-    if (l < 0) {
-      len = strlen(reinterpret_cast<const char*>(s));
-    }
-    assert(len <= INT_MAX && "string too long");
-    ws->resize(len);
-    std::copy(s, s + len, ws->begin());  // NOLINT(build/include_what_you_use)
+namespace imp {
+NAN_INLINE void
+widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
+  size_t len = static_cast<size_t>(l);
+  if (l < 0) {
+    len = strlen(reinterpret_cast<const char*>(s));
   }
-  }  // end of namespace imp NOLINT(readability/namespace)
-  }  // end of namespace Nan NOLINT(readability/namespace)
+  assert(len <= INT_MAX && "string too long");
+  ws->resize(len);
+  std::copy(s, s + len, ws->begin());  // NOLINT(build/include_what_you_use)
+}
+}  // end of namespace imp
 
   NAN_INLINE NanMaybeLocal<v8::String>
   NanNewOneByteString(const uint8_t * value, int length = -1) {
     std::vector<uint16_t> wideString;  // NOLINT(build/include_what_you_use)
     Nan::imp::widenString(&wideString, value, length);
-    return Nan::imp::Factory<v8::String>::return_t(v8::String::New(
+    return imp::Factory<v8::String>::return_t(v8::String::New(
         &wideString.front(), static_cast<int>(wideString.size())));
   }
 
@@ -1220,87 +1172,47 @@ class NanTryCatch {
       return static_cast<T*>(isolate->GetData());
   }
 
-  class NanAsciiString {
-   public:
-    NAN_INLINE explicit NanAsciiString(v8::Handle<v8::Value> from) {
-      v8::Local<v8::String> toStr = from->ToString();
-      size = toStr->Length();
-      buf = new char[size + 1];
-      size = toStr->WriteAscii(buf);
-    }
-
-    NAN_INLINE int length() const {
-      return size;
-    }
-
-
-    NAN_INLINE char* operator*() { return buf; }
-    NAN_INLINE const char* operator*() const { return buf; }
-
-    NAN_INLINE ~NanAsciiString() {
-      delete[] buf;
-    }
-
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(NanAsciiString)
-
-    char *buf;
-    int size;
-  };
-
-  class NanUtf8String {
-   public:
-    NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) {
-      v8::Local<v8::String> toStr = from->ToString();
-      size = toStr->Utf8Length();
-      buf = new char[size + 1];
-      toStr->WriteUtf8(buf);
-    }
-
-    NAN_INLINE int length() const {
-      return size;
-    }
-
-    NAN_INLINE char* operator*() { return buf; }
-    NAN_INLINE const char* operator*() const { return buf; }
-
-    NAN_INLINE ~NanUtf8String() {
-      delete[] buf;
-    }
-
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUtf8String)
-
-    char *buf;
-    int size;
-  };
-
-  class NanUcs2String {
-   public:
-    NAN_INLINE explicit NanUcs2String(v8::Handle<v8::Value> from) {
-      v8::Local<v8::String> toStr = from->ToString();
-      size = toStr->Length();
-      buf = new uint16_t[size + 1];
-      toStr->Write(buf);
+class NanUtf8String {
+ public:
+  NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) :
+      length_(0), str_(str_st_) {
+    if (!from.IsEmpty()) {
+      v8::Local<v8::String> string = from->ToString();
+      if (!string.IsEmpty()) {
+        size_t len = 3 * string->Length() + 1;
+        assert(len <= INT_MAX);
+        if (len > sizeof (str_st_)) {
+          str_ = static_cast<char*>(malloc(len));
+          assert(str_ != 0);
+        }
+        const int flags = v8::String::NO_NULL_TERMINATION |
+                          v8::String::REPLACE_INVALID_UTF8;
+        length_ = string->WriteUtf8(str_, static_cast<int>(len), 0, flags);
+        str_[length_] = '\0';
+      }
     }
+  }
 
-    NAN_INLINE int length() const {
-      return size;
-    }
+  NAN_INLINE int length() const {
+    return length_;
+  }
 
-    NAN_INLINE uint16_t* operator*() { return buf; }
-    NAN_INLINE const uint16_t* operator*() const { return buf; }
+  NAN_INLINE char* operator*() { return str_; }
+  NAN_INLINE const char* operator*() const { return str_; }
 
-    NAN_INLINE ~NanUcs2String() {
-      delete[] buf;
+  NAN_INLINE ~NanUtf8String() {
+    if (str_ != str_st_) {
+      free(str_);
     }
+  }
 
-   private:
-    NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUcs2String)
+ private:
+  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUtf8String)
 
-    uint16_t *buf;
-    int size;
-  };
+  int length_;
+  char *str_;
+  char str_st_[1024];
+};
 
 #endif  // NODE_MODULE_VERSION
 
@@ -1502,7 +1414,7 @@ class NanCallback {
 
     v8::Local<v8::Function> callback = NanNew(handle)->
         Get(kCallbackIndex).As<v8::Function>();
-    return scope.Escape(Nan::imp::NanEnsureLocal(node::MakeCallback(
+    return scope.Escape(imp::NanEnsureLocal(node::MakeCallback(
         isolate
       , target
       , callback
@@ -1518,7 +1430,7 @@ class NanCallback {
 
     v8::Local<v8::Function> callback = NanNew(handle)->
         Get(kCallbackIndex).As<v8::Function>();
-    return scope.Escape(Nan::imp::NanEnsureLocal(node::MakeCallback(
+    return scope.Escape(imp::NanEnsureLocal(node::MakeCallback(
         target
       , callback
       , argc
@@ -1759,7 +1671,7 @@ NAN_INLINE void NanAsyncQueueWorker (NanAsyncWorker* worker) {
   );
 }
 
-namespace Nan { namespace imp {
+namespace imp {
 
 inline
 NanExternalOneByteStringResource const*
@@ -1782,23 +1694,20 @@ IsExternal(v8::Local<v8::String> str) {
 }
 
 }  // end of namespace imp
-}  // end of namespace Nan
 
-namespace Nan {
-  enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
-}  // end of namespace Nan
+enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
 
 #if NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION
 # include "nan_string_bytes.h"  // NOLINT(build/include)
 #endif
 
 NAN_INLINE v8::Local<v8::Value> NanEncode(
-    const void *buf, size_t len, enum Nan::Encoding encoding = Nan::BINARY) {
+    const void *buf, size_t len, enum Encoding encoding = BINARY) {
 #if (NODE_MODULE_VERSION >= ATOM_0_21_MODULE_VERSION)
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   node::encoding node_enc = static_cast<node::encoding>(encoding);
 
-  if (encoding == Nan::UCS2) {
+  if (encoding == UCS2) {
     return node::Encode(
         isolate
       , reinterpret_cast<const uint16_t *>(buf)
@@ -1819,13 +1728,13 @@ NAN_INLINE v8::Local<v8::Value> NanEncode(
 # if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION
   return node::Encode(buf, len, static_cast<node::encoding>(encoding));
 # else
-  return Nan::imp::Encode(reinterpret_cast<const char*>(buf), len, encoding);
+  return imp::Encode(reinterpret_cast<const char*>(buf), len, encoding);
 # endif
 #endif
 }
 
 NAN_INLINE ssize_t NanDecodeBytes(
-    v8::Handle<v8::Value> val, enum Nan::Encoding encoding = Nan::BINARY) {
+    v8::Handle<v8::Value> val, enum Encoding encoding = BINARY) {
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
   return node::DecodeBytes(
       v8::Isolate::GetCurrent()
@@ -1833,7 +1742,7 @@ NAN_INLINE ssize_t NanDecodeBytes(
     , static_cast<node::encoding>(encoding));
 #else
 # if (NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION)
-  if (encoding == Nan::BUFFER) {
+  if (encoding == BUFFER) {
     return node::DecodeBytes(val, node::BINARY);
   }
 # endif
@@ -1845,7 +1754,7 @@ NAN_INLINE ssize_t NanDecodeWrite(
     char *buf
   , size_t len
   , v8::Handle<v8::Value> val
-  , enum Nan::Encoding encoding = Nan::BINARY) {
+  , enum Encoding encoding = BINARY) {
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
   return node::DecodeWrite(
       v8::Isolate::GetCurrent()
@@ -1855,7 +1764,7 @@ NAN_INLINE ssize_t NanDecodeWrite(
     , static_cast<node::encoding>(encoding));
 #else
 # if (NODE_MODULE_VERSION < NODE_0_10_MODULE_VERSION)
-  if (encoding == Nan::BUFFER) {
+  if (encoding == BUFFER) {
     return node::DecodeWrite(buf, len, val, node::BINARY);
   }
 # endif
@@ -1937,33 +1846,33 @@ inline void NanSetAccessor(
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
   , v8::AccessControl settings = v8::DEFAULT
   , v8::PropertyAttribute attribute = v8::None
-  , Nan::imp::Sig signature = Nan::imp::Sig()) {
+  , imp::Sig signature = imp::Sig()) {
   NanScope scope;
 
-  Nan::imp::NativeGetter getter_ =
-      Nan::imp::GetterCallbackWrapper;
-  Nan::imp::NativeSetter setter_ =
-      setter ? Nan::imp::SetterCallbackWrapper : 0;
+  imp::NativeGetter getter_ =
+      imp::GetterCallbackWrapper;
+  imp::NativeSetter setter_ =
+      setter ? imp::SetterCallbackWrapper : 0;
 
   v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
-  otpl->SetInternalFieldCount(Nan::imp::kAccessorFieldCount);
+  otpl->SetInternalFieldCount(imp::kAccessorFieldCount);
   v8::Local<v8::Object> obj = otpl->NewInstance();
   NanSetInternalFieldPointer(
       obj
-    , Nan::imp::kGetterIndex
-    , Nan::imp::GetWrapper<NanGetterCallback, Nan::imp::GetterWrapper>(getter));
+    , imp::kGetterIndex
+    , imp::GetWrapper<NanGetterCallback, imp::GetterWrapper>(getter));
   v8::Local<v8::Value> val = NanNew<v8::Value>(data);
 
   if (setter != 0) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kSetterIndex
-      , Nan::imp::GetWrapper<NanSetterCallback,
-            Nan::imp::SetterWrapper>(setter));
+      , imp::kSetterIndex
+      , imp::GetWrapper<NanSetterCallback,
+            imp::SetterWrapper>(setter));
   }
 
   if (!val.IsEmpty()) {
-    obj->SetInternalField(Nan::imp::kDataIndex, val);
+    obj->SetInternalField(imp::kDataIndex, val);
   }
 
   tpl->SetAccessor(
@@ -1986,30 +1895,30 @@ inline bool NanSetAccessor(
   , v8::PropertyAttribute attribute = v8::None) {
   NanEscapableScope scope;
 
-  Nan::imp::NativeGetter getter_ =
-      Nan::imp::GetterCallbackWrapper;
-  Nan::imp::NativeSetter setter_ =
-      setter ? Nan::imp::SetterCallbackWrapper : 0;
+  imp::NativeGetter getter_ =
+      imp::GetterCallbackWrapper;
+  imp::NativeSetter setter_ =
+      setter ? imp::SetterCallbackWrapper : 0;
 
   v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
-  otpl->SetInternalFieldCount(Nan::imp::kAccessorFieldCount);
+  otpl->SetInternalFieldCount(imp::kAccessorFieldCount);
   v8::Local<v8::Object> dataobj = otpl->NewInstance();
   NanSetInternalFieldPointer(
       dataobj
-    , Nan::imp::kGetterIndex
-    , Nan::imp::GetWrapper<NanGetterCallback, Nan::imp::GetterWrapper>(getter));
+    , imp::kGetterIndex
+    , imp::GetWrapper<NanGetterCallback, imp::GetterWrapper>(getter));
   v8::Local<v8::Value> val = NanNew<v8::Value>(data);
 
   if (!val.IsEmpty()) {
-    dataobj->SetInternalField(Nan::imp::kDataIndex, val);
+    dataobj->SetInternalField(imp::kDataIndex, val);
   }
 
   if (setter) {
     NanSetInternalFieldPointer(
         dataobj
-      , Nan::imp::kPropertySetterIndex
-      , Nan::imp::GetWrapper<NanSetterCallback,
-            Nan::imp::SetterWrapper>(setter));
+      , imp::kPropertySetterIndex
+      , imp::GetWrapper<NanSetterCallback,
+            imp::SetterWrapper>(setter));
   }
 
   return obj->SetAccessor(
@@ -2031,61 +1940,61 @@ inline void NanSetNamedPropertyHandler(
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
   NanScope scope;
 
-  Nan::imp::NativePropertyGetter getter_ =
-      Nan::imp::PropertyGetterCallbackWrapper;
-  Nan::imp::NativePropertySetter setter_ =
-      setter ? Nan::imp::PropertySetterCallbackWrapper : 0;
-  Nan::imp::NativePropertyQuery query_ =
-      query ? Nan::imp::PropertyQueryCallbackWrapper : 0;
-  Nan::imp::NativePropertyDeleter *deleter_ =
-      deleter ? Nan::imp::PropertyDeleterCallbackWrapper : 0;
-  Nan::imp::NativePropertyEnumerator enumerator_ =
-      enumerator ? Nan::imp::PropertyEnumeratorCallbackWrapper : 0;
+  imp::NativePropertyGetter getter_ =
+      imp::PropertyGetterCallbackWrapper;
+  imp::NativePropertySetter setter_ =
+      setter ? imp::PropertySetterCallbackWrapper : 0;
+  imp::NativePropertyQuery query_ =
+      query ? imp::PropertyQueryCallbackWrapper : 0;
+  imp::NativePropertyDeleter *deleter_ =
+      deleter ? imp::PropertyDeleterCallbackWrapper : 0;
+  imp::NativePropertyEnumerator enumerator_ =
+      enumerator ? imp::PropertyEnumeratorCallbackWrapper : 0;
 
   v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
-  otpl->SetInternalFieldCount(Nan::imp::kPropertyFieldCount);
+  otpl->SetInternalFieldCount(imp::kPropertyFieldCount);
   v8::Local<v8::Object> obj = otpl->NewInstance();
   NanSetInternalFieldPointer(
       obj
-    , Nan::imp::kPropertyGetterIndex
-    , Nan::imp::GetWrapper<NanPropertyGetterCallback,
-          Nan::imp::PropertyGetterWrapper>(getter));
+    , imp::kPropertyGetterIndex
+    , imp::GetWrapper<NanPropertyGetterCallback,
+          imp::PropertyGetterWrapper>(getter));
   v8::Local<v8::Value> val = NanNew<v8::Value>(data);
 
   if (setter) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kPropertySetterIndex
-      , Nan::imp::GetWrapper<NanPropertySetterCallback,
-            Nan::imp::PropertySetterWrapper>(setter));
+      , imp::kPropertySetterIndex
+      , imp::GetWrapper<NanPropertySetterCallback,
+            imp::PropertySetterWrapper>(setter));
   }
 
   if (query) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kPropertyQueryIndex
-      , Nan::imp::GetWrapper<NanPropertyQueryCallback,
-            Nan::imp::PropertyQueryWrapper>(query));
+      , imp::kPropertyQueryIndex
+      , imp::GetWrapper<NanPropertyQueryCallback,
+            imp::PropertyQueryWrapper>(query));
   }
 
   if (deleter) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kPropertyDeleterIndex
-      , Nan::imp::GetWrapper<NanPropertyDeleterCallback,
-            Nan::imp::PropertyDeleterWrapper>(deleter));
+      , imp::kPropertyDeleterIndex
+      , imp::GetWrapper<NanPropertyDeleterCallback,
+            imp::PropertyDeleterWrapper>(deleter));
   }
 
   if (enumerator) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kPropertyEnumeratorIndex
-      , Nan::imp::GetWrapper<NanPropertyEnumeratorCallback,
-            Nan::imp::PropertyEnumeratorWrapper>(enumerator));
+      , imp::kPropertyEnumeratorIndex
+      , imp::GetWrapper<NanPropertyEnumeratorCallback,
+            imp::PropertyEnumeratorWrapper>(enumerator));
   }
 
   if (!val.IsEmpty()) {
-    obj->SetInternalField(Nan::imp::kDataIndex, val);
+    obj->SetInternalField(imp::kDataIndex, val);
   }
 
 #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
@@ -2112,61 +2021,61 @@ inline void NanSetIndexedPropertyHandler(
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
   NanScope scope;
 
-  Nan::imp::NativeIndexGetter getter_ =
-      Nan::imp::IndexGetterCallbackWrapper;
-  Nan::imp::NativeIndexSetter setter_ =
-      setter ? Nan::imp::IndexSetterCallbackWrapper : 0;
-  Nan::imp::NativeIndexQuery query_ =
-      query ? Nan::imp::IndexQueryCallbackWrapper : 0;
-  Nan::imp::NativeIndexDeleter deleter_ =
-      deleter ? Nan::imp::IndexDeleterCallbackWrapper : 0;
-  Nan::imp::NativeIndexEnumerator enumerator_ =
-      enumerator ? Nan::imp::IndexEnumeratorCallbackWrapper : 0;
+  imp::NativeIndexGetter getter_ =
+      imp::IndexGetterCallbackWrapper;
+  imp::NativeIndexSetter setter_ =
+      setter ? imp::IndexSetterCallbackWrapper : 0;
+  imp::NativeIndexQuery query_ =
+      query ? imp::IndexQueryCallbackWrapper : 0;
+  imp::NativeIndexDeleter deleter_ =
+      deleter ? imp::IndexDeleterCallbackWrapper : 0;
+  imp::NativeIndexEnumerator enumerator_ =
+      enumerator ? imp::IndexEnumeratorCallbackWrapper : 0;
 
   v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
-  otpl->SetInternalFieldCount(Nan::imp::kIndexPropertyFieldCount);
+  otpl->SetInternalFieldCount(imp::kIndexPropertyFieldCount);
   v8::Local<v8::Object> obj = otpl->NewInstance();
   NanSetInternalFieldPointer(
       obj
-    , Nan::imp::kIndexPropertyGetterIndex
-    , Nan::imp::GetWrapper<NanIndexGetterCallback,
-          Nan::imp::IndexGetterWrapper>(getter));
+    , imp::kIndexPropertyGetterIndex
+    , imp::GetWrapper<NanIndexGetterCallback,
+          imp::IndexGetterWrapper>(getter));
   v8::Local<v8::Value> val = NanNew<v8::Value>(data);
 
   if (setter) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kIndexPropertySetterIndex
-      , Nan::imp::GetWrapper<NanIndexSetterCallback,
-            Nan::imp::IndexSetterWrapper>(setter));
+      , imp::kIndexPropertySetterIndex
+      , imp::GetWrapper<NanIndexSetterCallback,
+            imp::IndexSetterWrapper>(setter));
   }
 
   if (query) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kIndexPropertyQueryIndex
-      , Nan::imp::GetWrapper<NanIndexQueryCallback,
-            Nan::imp::IndexQueryWrapper>(query));
+      , imp::kIndexPropertyQueryIndex
+      , imp::GetWrapper<NanIndexQueryCallback,
+            imp::IndexQueryWrapper>(query));
   }
 
   if (deleter) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kIndexPropertyDeleterIndex
-      , Nan::imp::GetWrapper<NanIndexDeleterCallback,
-            Nan::imp::IndexDeleterWrapper>(deleter));
+      , imp::kIndexPropertyDeleterIndex
+      , imp::GetWrapper<NanIndexDeleterCallback,
+            imp::IndexDeleterWrapper>(deleter));
   }
 
   if (enumerator) {
     NanSetInternalFieldPointer(
         obj
-      , Nan::imp::kIndexPropertyEnumeratorIndex
-      , Nan::imp::GetWrapper<NanIndexEnumeratorCallback,
-            Nan::imp::IndexEnumeratorWrapper>(enumerator));
+      , imp::kIndexPropertyEnumeratorIndex
+      , imp::GetWrapper<NanIndexEnumeratorCallback,
+            imp::IndexEnumeratorWrapper>(enumerator));
   }
 
   if (!val.IsEmpty()) {
-    obj->SetInternalField(Nan::imp::kDataIndex, val);
+    obj->SetInternalField(imp::kDataIndex, val);
   }
 
 #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
@@ -2247,4 +2156,6 @@ struct NanTap {
 
 #undef TYPE_CHECK
 
+}  // end of namespace Nan
+
 #endif  // NAN_H_
diff --git a/nan_callbacks.h b/nan_callbacks.h
index 77ac18de..e2dccb34 100644
--- a/nan_callbacks.h
+++ b/nan_callbacks.h
@@ -9,15 +9,6 @@
 #ifndef NAN_CALLBACKS_H_
 #define NAN_CALLBACKS_H_
 
-#if defined(_MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4530 )
-# include <map>
-# pragma warning( pop )
-#else
-# include <map>
-#endif
-
 template<typename T> class NanFunctionCallbackInfo;
 template<typename T> class NanPropertyCallbackInfo;
 template<typename T> class NanGlobal;
@@ -60,7 +51,7 @@ typedef void(*NanIndexQueryCallback)(
     uint32_t,
     const NanPropertyCallbackInfo<v8::Integer>&);
 
-namespace Nan { namespace imp {
+namespace imp {
 typedef v8::Handle<v8::AccessorSignature> Sig;
 
 #define X(NAME)                                                                \
@@ -112,7 +103,7 @@ static const int kIndexPropertyFieldCount =      6;
 template<typename T, typename P>
 P *GetWrapper(T needle) {
   static std::map<T, P*> haystack;
-  typename std::map<T, P*>::iterator it =
+  typename std::map<T, P*>::iterator it =  // NOLINT(build/include_what_you_use)
       haystack.find(needle);
 
   if (it == haystack.end()) {
@@ -122,7 +113,6 @@ P *GetWrapper(T needle) {
   }
 }
 }  // end of namespace imp
-}  // end of namespace Nan
 
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
 # include "nan_callbacks_12_inl.h"  // NOLINT(build/include)
diff --git a/nan_callbacks_12_inl.h b/nan_callbacks_12_inl.h
index 6740796e..e38d9b8c 100644
--- a/nan_callbacks_12_inl.h
+++ b/nan_callbacks_12_inl.h
@@ -156,7 +156,7 @@ class NanPropertyCallbackInfo {
   static const int kArgsLength = 6;
 };
 
-namespace Nan { namespace imp {
+namespace imp {
 static
 void FunctionCallbackWrapper(const v8::FunctionCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
@@ -467,6 +467,5 @@ void IndexQueryCallbackWrapper(
 typedef void (*NativeIndexQuery)
     (uint32_t, const v8::PropertyCallbackInfo<v8::Integer> &);
 }  // end of namespace imp
-}  // end of namespace Nan
 
 #endif  // NAN_CALLBACKS_12_INL_H_
diff --git a/nan_callbacks_pre_12_inl.h b/nan_callbacks_pre_12_inl.h
index 5394206c..2477087c 100644
--- a/nan_callbacks_pre_12_inl.h
+++ b/nan_callbacks_pre_12_inl.h
@@ -9,10 +9,9 @@
 #ifndef NAN_CALLBACKS_PRE_12_INL_H_
 #define NAN_CALLBACKS_PRE_12_INL_H_
 
-namespace Nan { namespace imp {
+namespace imp {
 template<typename T> class NanReturnValueImp;
 }  // end of namespace imp
-}  // end of namespace Nan
 
 template<typename T>
 class NanReturnValue {
@@ -235,7 +234,7 @@ class NanPropertyCallbackInfo<v8::Integer> :
   }
 };
 
-namespace Nan { namespace imp {
+namespace imp {
 template<typename T>
 class NanReturnValueImp : public NanReturnValue<T> {
  public:
@@ -445,6 +444,5 @@ v8::Handle<v8::Integer> IndexQueryCallbackWrapper(
 typedef v8::Handle<v8::Integer> (*NativeIndexQuery)
     (uint32_t, const v8::AccessorInfo &);
 }  // end of namespace imp
-}  // end of namespace Nan
 
 #endif  // NAN_CALLBACKS_PRE_12_INL_H_
diff --git a/nan_converters.h b/nan_converters.h
index 776e6d8e..c1ebd203 100644
--- a/nan_converters.h
+++ b/nan_converters.h
@@ -9,7 +9,7 @@
 #ifndef NAN_CONVERTERS_H_
 #define NAN_CONVERTERS_H_
 
-namespace Nan { namespace imp {
+namespace imp {
 template<typename T> struct ToFactoryBase {
   typedef NanMaybeLocal<T> return_t;
 };
@@ -47,7 +47,6 @@ X(int32_t)
 
 #undef X
 }  // end of namespace imp
-}  // end of namespace Nan
 
 template<typename T>
 NAN_INLINE
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index 7fa4da4b..a1a7ab77 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -12,18 +12,7 @@
 // node v0.11 implementation
 //==============================================================================
 
-#if defined(_MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4530 )
-# include <string>
-# include <map>
-# pragma warning( pop )
-#else
-# include <string>
-# include <map>
-#endif
-
-namespace Nan { namespace imp {
+namespace imp {
 
 //=== Array ====================================================================
 
@@ -130,7 +119,8 @@ Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
                                   , v8::Handle<v8::Signature> signature) {
   v8::Isolate *isolate = v8::Isolate::GetCurrent();
   v8::EscapableHandleScope scope(isolate);
-  static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
+  static std::map<NanFunctionCallback,  // NOLINT(build/include_what_you_use)
+      Nan::imp::FunctionWrapper*> cbmap;
   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
   tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
@@ -321,7 +311,8 @@ Factory<v8::String>::New(const char * value, int length) {
 }
 
 Factory<v8::String>::return_t
-Factory<v8::String>::New(std::string const& value) {
+Factory<v8::String>::New(
+    std::string const& value) /* NOLINT(build/include_what_you_use) */ {
   assert(value.size() <= INT_MAX && "string too long");
   return Factory<v8::String>::return_t(
       v8::String::NewFromUtf8(
@@ -397,7 +388,6 @@ Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
 #endif
 
 }  // end of namespace imp
-}  // end of namespace Nan
 
 //=== Presistents and Handles ==================================================
 
diff --git a/nan_implementation_pre_12_inl.h b/nan_implementation_pre_12_inl.h
index ad6f3d32..11475762 100644
--- a/nan_implementation_pre_12_inl.h
+++ b/nan_implementation_pre_12_inl.h
@@ -9,26 +9,11 @@
 #ifndef NAN_IMPLEMENTATION_PRE_12_INL_H_
 #define NAN_IMPLEMENTATION_PRE_12_INL_H_
 
-#include <algorithm>
-
-#if defined(_MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4530 )
-# include <string>
-# include <vector>
-# include <map>
-# pragma warning( pop )
-#else
-# include <string>
-# include <vector>
-# include <map>
-#endif
-
 //==============================================================================
 // node v0.10 implementation
 //==============================================================================
 
-namespace Nan { namespace imp {
+namespace imp {
 
 //=== Array ====================================================================
 
@@ -102,7 +87,8 @@ Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
                                   , v8::Handle<v8::Signature> signature) {
   v8::HandleScope scope;
 
-  static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
+  static std::map<NanFunctionCallback,  // NOLINT(build/include_what_you_use)
+      Nan::imp::FunctionWrapper*> cbmap;
   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New();
   tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
   v8::Local<v8::Object> obj = tpl->NewInstance();
@@ -220,7 +206,8 @@ Factory<v8::String>::New(const char * value, int length) {
 }
 
 Factory<v8::String>::return_t
-Factory<v8::String>::New(std::string const& value) {
+Factory<v8::String>::New(
+    std::string const& value) /* NOLINT(build/include_what_you_use) */ {
   assert(value.size() <= INT_MAX && "string too long");
   return Factory<v8::String>::return_t(
       v8::String::New( value.data(), static_cast<int>(value.size())));
@@ -249,7 +236,6 @@ Factory<v8::StringObject>::New(v8::Handle<v8::String> value) {
 }
 
 }  // end of namespace imp
-}  // end of namespace Nan
 
 //=== Presistents and Handles ==================================================
 
diff --git a/nan_new.h b/nan_new.h
index 62748744..cfd91177 100644
--- a/nan_new.h
+++ b/nan_new.h
@@ -9,16 +9,7 @@
 #ifndef NAN_NEW_H_
 #define NAN_NEW_H_
 
-#if defined(_MSC_VER)
-# pragma warning( push )
-# pragma warning( disable : 4530 )
-# include <string>
-# pragma warning( pop )
-#else
-# include <string>
-#endif
-
-namespace Nan { namespace imp {  // scnr
+namespace imp {  // scnr
 
 // TODO(agnat): Generalize
 template <typename T> v8::Local<T> To(v8::Handle<v8::Integer> i);
@@ -181,11 +172,10 @@ struct Factory<v8::StringObject> : FactoryBase<v8::StringObject> {
 };
 
 }  // end of namespace imp
-}  // end of namespace Nan
 
 #if (NODE_MODULE_VERSION >= 12)
 
-namespace Nan { namespace imp {
+namespace imp {
 
 template <>
 struct Factory<v8::UnboundScript> : MaybeFactoryBase<v8::UnboundScript> {
@@ -195,7 +185,6 @@ struct Factory<v8::UnboundScript> : MaybeFactoryBase<v8::UnboundScript> {
 };
 
 }  // end of namespace imp
-}  // end of namespace Nan
 
 # include "nan_implementation_12_inl.h"
 
@@ -297,7 +286,7 @@ NanNew(double value) {
 
 inline
 Nan::imp::Factory<v8::String>::return_t
-NanNew(std::string const& value) {
+NanNew(std::string const& value) {  // NOLINT(build/include_what_you_use)
   return NanNew<v8::String>(value);
 }
 
diff --git a/nan_string_bytes.h b/nan_string_bytes.h
index 51281efd..2b8dcb84 100644
--- a/nan_string_bytes.h
+++ b/nan_string_bytes.h
@@ -24,13 +24,7 @@
 
 // Decodes a v8::Handle<v8::String> or Buffer to a raw char*
 
-#include <node.h>
-#include <node_buffer.h>
-#include <assert.h>
-#include <string.h>  // memcpy
-#include <limits.h>
-
-namespace Nan { namespace imp {
+namespace imp {
 
 using v8::Local;
 using v8::Handle;
@@ -45,7 +39,7 @@ using v8::Value;
 
 
 
-//// Nan::HEX ////
+//// HEX ////
 
 static bool contains_non_ascii_slow(const char* buf, size_t len) {
   for (size_t i = 0; i < len; ++i) {
@@ -230,17 +224,17 @@ static size_t hex_encode(const char* src, size_t slen, char* dst, size_t dlen) {
 
 static Local<Value> Encode(const char* buf,
                            size_t buflen,
-                           enum Nan::Encoding encoding) {
+                           enum Encoding encoding) {
   assert(buflen <= node::Buffer::kMaxLength);
-  if (!buflen && encoding != Nan::BUFFER)
+  if (!buflen && encoding != BUFFER)
     return NanNew("").ToLocalChecked();
 
   Local<String> val;
   switch (encoding) {
-    case Nan::BUFFER:
+    case BUFFER:
       return NanCopyBuffer(buf, buflen).ToLocalChecked();
 
-    case Nan::ASCII:
+    case ASCII:
       if (contains_non_ascii(buf, buflen)) {
         char* out = new char[buflen];
         force_ascii(buf, out, buflen);
@@ -251,11 +245,11 @@ static Local<Value> Encode(const char* buf,
       }
       break;
 
-    case Nan::UTF8:
+    case UTF8:
       val = NanNew<String>(buf, buflen).ToLocalChecked();
       break;
 
-    case Nan::BINARY: {
+    case BINARY: {
       // TODO(isaacs) use ExternalTwoByteString?
       const unsigned char *cbuf = reinterpret_cast<const unsigned char*>(buf);
       uint16_t * twobytebuf = new uint16_t[buflen];
@@ -268,7 +262,7 @@ static Local<Value> Encode(const char* buf,
       break;
     }
 
-    case Nan::BASE64: {
+    case BASE64: {
       size_t dlen = base64_encoded_size(buflen);
       char* dst = new char[dlen];
 
@@ -280,13 +274,13 @@ static Local<Value> Encode(const char* buf,
       break;
     }
 
-    case Nan::UCS2: {
+    case UCS2: {
       const uint16_t* data = reinterpret_cast<const uint16_t*>(buf);
       val = NanNew<String>(data, buflen / 2).ToLocalChecked();
       break;
     }
 
-    case Nan::HEX: {
+    case HEX: {
       size_t dlen = buflen * 2;
       char* dst = new char[dlen];
       size_t written = hex_encode(buf, buflen, dst, dlen);
@@ -308,6 +302,5 @@ static Local<Value> Encode(const char* buf,
 #undef base64_encoded_size
 
 }  // end of namespace imp
-}  // end of namespace Nan
 
 #endif  // NAN_STRING_BYTES_H_
diff --git a/test/cpp/accessors.cpp b/test/cpp/accessors.cpp
index 46927815..5b3ad91b 100644
--- a/test/cpp/accessors.cpp
+++ b/test/cpp/accessors.cpp
@@ -9,6 +9,8 @@
 #include <nan.h>
 #include <cstring>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class SetterGetter : public NanObjectWrap {
  public:
   static void Init (v8::Handle<v8::Object> target);
diff --git a/test/cpp/accessors2.cpp b/test/cpp/accessors2.cpp
index f50c5cce..09920e7c 100644
--- a/test/cpp/accessors2.cpp
+++ b/test/cpp/accessors2.cpp
@@ -9,6 +9,8 @@
 #include <nan.h>
 #include <cstring>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class SetterGetter : public NanObjectWrap {
  public:
   static void Init (v8::Handle<v8::Object> target);
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index 46bf2f06..1e6c2ac2 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -12,6 +12,8 @@
 #endif
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class ProgressWorker : public NanAsyncProgressWorker {
  public:
   ProgressWorker(
diff --git a/test/cpp/asyncworker.cpp b/test/cpp/asyncworker.cpp
index f7ddb326..1d269549 100644
--- a/test/cpp/asyncworker.cpp
+++ b/test/cpp/asyncworker.cpp
@@ -12,6 +12,8 @@
 #endif
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class SleepWorker : public NanAsyncWorker {
  public:
   SleepWorker(NanCallback *callback, int milliseconds)
diff --git a/test/cpp/asyncworkererror.cpp b/test/cpp/asyncworkererror.cpp
index 244368ae..80f9ffa4 100644
--- a/test/cpp/asyncworkererror.cpp
+++ b/test/cpp/asyncworkererror.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class ErrorWorker : public NanAsyncWorker {
  public:
   explicit ErrorWorker(NanCallback *callback) : NanAsyncWorker(callback) {}
diff --git a/test/cpp/buffer.cpp b/test/cpp/buffer.cpp
index c68e2fed..2ad2c5d4 100644
--- a/test/cpp/buffer.cpp
+++ b/test/cpp/buffer.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 static const size_t DATA_SIZE = 26;
 
 static char data[DATA_SIZE];
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index 31606b7b..851fa290 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -12,6 +12,8 @@
 #endif
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class BufferWorker : public NanAsyncWorker {
  public:
   BufferWorker(
diff --git a/test/cpp/converters.cpp b/test/cpp/converters.cpp
index 1418d2bd..182a209a 100644
--- a/test/cpp/converters.cpp
+++ b/test/cpp/converters.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(ToBoolean) {
   info.GetReturnValue().Set(NanTo<v8::Boolean>(info[0]).ToLocalChecked());
 }
diff --git a/test/cpp/error.cpp b/test/cpp/error.cpp
index 57f43d3a..a6ab8f12 100644
--- a/test/cpp/error.cpp
+++ b/test/cpp/error.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 #define X(NAME)                                                                \
   NAN_METHOD(Throw ## NAME ## 1) {                                             \
     return NanThrow ## NAME("errmsg");                                         \
diff --git a/test/cpp/gc.cpp b/test/cpp/gc.cpp
index ef89744c..078fd626 100644
--- a/test/cpp/gc.cpp
+++ b/test/cpp/gc.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 static bool prologue_called = false;
 static bool epilogue_called = false;
 
diff --git a/test/cpp/indexedinterceptors.cpp b/test/cpp/indexedinterceptors.cpp
index 729b1f14..40a93f54 100644
--- a/test/cpp/indexedinterceptors.cpp
+++ b/test/cpp/indexedinterceptors.cpp
@@ -9,6 +9,8 @@
 #include <nan.h>
 #include <cstring>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class IndexedInterceptor : public NanObjectWrap {
   char buf[256];
 
diff --git a/test/cpp/isolatedata.cpp b/test/cpp/isolatedata.cpp
index 87607725..d4d024ac 100644
--- a/test/cpp/isolatedata.cpp
+++ b/test/cpp/isolatedata.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 struct Dummy {
   int value;
 };
diff --git a/test/cpp/makecallback.cpp b/test/cpp/makecallback.cpp
index 8239ede9..d4297f5a 100644
--- a/test/cpp/makecallback.cpp
+++ b/test/cpp/makecallback.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class MyObject : public node::ObjectWrap {
  public:
   static void Init(v8::Handle<v8::Object> exports);
diff --git a/test/cpp/morenews.cpp b/test/cpp/morenews.cpp
index 9b4bbb32..53f609e3 100644
--- a/test/cpp/morenews.cpp
+++ b/test/cpp/morenews.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(NewNumber) {
   info.GetReturnValue().Set(NanNew(0.5));
 }
diff --git a/test/cpp/multifile1.cpp b/test/cpp/multifile1.cpp
index 748168a4..43640e67 100644
--- a/test/cpp/multifile1.cpp
+++ b/test/cpp/multifile1.cpp
@@ -9,6 +9,8 @@
 #include <nan.h>
 #include "./multifile2.h"
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 void Init (v8::Handle<v8::Object> target) {
   NanSet(target
     , NanNew<v8::String>("r").ToLocalChecked()
diff --git a/test/cpp/multifile2.cpp b/test/cpp/multifile2.cpp
index 83bc8852..b754644e 100644
--- a/test/cpp/multifile2.cpp
+++ b/test/cpp/multifile2.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(ReturnString) {
   v8::Local<v8::String> s = NanNew(*NanUtf8String(info[0])).ToLocalChecked();
   info.GetReturnValue().Set(s);
diff --git a/test/cpp/multifile2.h b/test/cpp/multifile2.h
index d04dda11..49f8b422 100644
--- a/test/cpp/multifile2.h
+++ b/test/cpp/multifile2.h
@@ -11,6 +11,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(ReturnString);
 
 #endif  // TEST_CPP_MULTIFILE2_H_
diff --git a/test/cpp/namedinterceptors.cpp b/test/cpp/namedinterceptors.cpp
index 342309f5..1aaf60c3 100644
--- a/test/cpp/namedinterceptors.cpp
+++ b/test/cpp/namedinterceptors.cpp
@@ -9,6 +9,8 @@
 #include <nan.h>
 #include <cstring>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class NamedInterceptor : public NanObjectWrap {
   char buf[256];
 
diff --git a/test/cpp/nancallback.cpp b/test/cpp/nancallback.cpp
index 8ec68be9..eabcf92b 100644
--- a/test/cpp/nancallback.cpp
+++ b/test/cpp/nancallback.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(GlobalContext) {
   NanCallback(info[0].As<v8::Function>()).Call(0, NULL);
 }
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index 745e345b..7ede8bff 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -23,6 +23,8 @@
 # include <string>
 #endif
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 using namespace v8;  // NOLINT(build/namespaces)
 
 namespace {
diff --git a/test/cpp/news.cpp b/test/cpp/news.cpp
index b28ddbc6..3ba97ee5 100644
--- a/test/cpp/news.cpp
+++ b/test/cpp/news.cpp
@@ -16,6 +16,8 @@
 # include <string>
 #endif
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 static int magic = 1337;
 
 NAN_METHOD(NewNumber) {
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index 3e2b8098..09083d3d 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class MyObject : public NanObjectWrap {
  public:
   static void Init(v8::Handle<v8::Object> exports) {
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index cb773b8a..9d9dd5c7 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -9,6 +9,8 @@
 #include <nan.h>
 #include <cstring>  // memset()
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 static NanPersistent<v8::String> persistentTest1;
 
 NAN_METHOD(Save1) {
diff --git a/test/cpp/returnemptystring.cpp b/test/cpp/returnemptystring.cpp
index 14af5169..8e378ebb 100644
--- a/test/cpp/returnemptystring.cpp
+++ b/test/cpp/returnemptystring.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(ReturnEmptyString) {
   info.GetReturnValue().SetEmptyString();
 }
diff --git a/test/cpp/returnnull.cpp b/test/cpp/returnnull.cpp
index 4c354f74..121111eb 100644
--- a/test/cpp/returnnull.cpp
+++ b/test/cpp/returnnull.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(ReturnNull) {
   info.GetReturnValue().SetNull();
 }
diff --git a/test/cpp/returnundefined.cpp b/test/cpp/returnundefined.cpp
index 310a82ad..b0241de1 100644
--- a/test/cpp/returnundefined.cpp
+++ b/test/cpp/returnundefined.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(ReturnUndefined) {
   info.GetReturnValue().SetUndefined();
 }
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index be10f773..b4ba61c7 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NanGlobal<v8::Boolean> global;
 
 NAN_METHOD(ReturnValue) {
diff --git a/test/cpp/settemplate.cpp b/test/cpp/settemplate.cpp
index 3e08d8ca..fc5bf11e 100644
--- a/test/cpp/settemplate.cpp
+++ b/test/cpp/settemplate.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 class MyObject : public node::ObjectWrap {
  public:
   static void Init(v8::Handle<v8::Object> exports);
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index f623aa93..cfc198ed 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(ReturnUtf8String) {
   info.GetReturnValue().Set(NanNew(*NanUtf8String(info[0])).ToLocalChecked());
 }
@@ -20,11 +22,11 @@ NAN_METHOD(HeapString) {
 }
 
 NAN_METHOD(EncodeHex) {
-  info.GetReturnValue().Set(NanEncode("hello", 5, Nan::HEX));
+  info.GetReturnValue().Set(NanEncode("hello", 5, HEX));
 }
 
 NAN_METHOD(EncodeUCS2) {
-  info.GetReturnValue().Set(NanEncode("h\0e\0l\0l\0o\0", 10, Nan::UCS2));
+  info.GetReturnValue().Set(NanEncode("h\0e\0l\0l\0o\0", 10, UCS2));
 }
 
 NanPersistent<v8::FunctionTemplate> returnUtf8String_persistent;
diff --git a/test/cpp/symbols.cpp b/test/cpp/symbols.cpp
index 79775759..b889c319 100644
--- a/test/cpp/symbols.cpp
+++ b/test/cpp/symbols.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 void Init (v8::Handle<v8::Object> target) {
   NanSet(target
     , NanNew<v8::String>("key").ToLocalChecked()
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index f883333f..ccaa6ed1 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 #define _(e) NAN_TEST_EXPRESSION(e)
 
 // Based on test-thread.c from libuv.
diff --git a/test/cpp/trycatch.cpp b/test/cpp/trycatch.cpp
index 230f9953..1e35aa06 100644
--- a/test/cpp/trycatch.cpp
+++ b/test/cpp/trycatch.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 NAN_METHOD(TryCatch) {
   NanTryCatch try_catch;
   v8::Local<v8::Value> v =
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index abffa9ba..1536b6f2 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 static NanPersistent<v8::Function> cb;
 
 void weakCallback(
diff --git a/test/cpp/weak2.cpp b/test/cpp/weak2.cpp
index 5cd77409..bcc5a3cb 100644
--- a/test/cpp/weak2.cpp
+++ b/test/cpp/weak2.cpp
@@ -8,6 +8,8 @@
 
 #include <nan.h>
 
+using namespace Nan;  // NOLINT(build/namespaces)
+
 static NanPersistent<v8::Function> cb;
 void weakCallback(
     const NanWeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)

From 594ed2afd28d7cc907dd1e87d882029df142c232 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Wed, 27 May 2015 18:02:18 +0300
Subject: [PATCH 23/84] Added version conversion script

---
 tools/1to2.js      | 362 +++++++++++++++++++++++++++++++++++++++++++++
 tools/README.md    |   1 +
 tools/package.json |  19 +++
 3 files changed, 382 insertions(+)
 create mode 100755 tools/1to2.js
 create mode 100644 tools/README.md
 create mode 100644 tools/package.json

diff --git a/tools/1to2.js b/tools/1to2.js
new file mode 100755
index 00000000..e9399f2f
--- /dev/null
+++ b/tools/1to2.js
@@ -0,0 +1,362 @@
+#!/usr/bin/env node
+/*********************************************************************
+ * NAN - Native Abstractions for Node.js
+ *
+ * Copyright (c) 2015 NAN contributors
+ *
+ * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
+ ********************************************************************/
+
+var commander = require('commander'),
+    fs = require('fs'),
+    glob = require('glob'),
+    callbacks = [
+      'NAN_METHOD',
+      'NAN_GETTER',
+      'NAN_SETTER',
+      'NAN_PROPERTY_GETTER',
+      'NAN_PROPERTY_SETTER',
+      'NAN_PROPERTY_ENUMERATOR',
+      'NAN_PROPERTY_DELETER',
+      'NAN_PROPERTY_QUERY',
+      'NAN_INDEX_GETTER',
+      'NAN_INDEX_SETTER',
+      'NAN_INDEX_ENUMERATOR',
+      'NAN_INDEX_DELETER',
+      'NAN_INDEX_QUERY'],
+    removed = [
+      'GetIndexedPropertiesExternalArrayDataLength',
+      'GetIndexedPropertiesExternalArrayData',
+      'GetIndexedPropertiesExternalArrayDataType',
+      'GetIndexedPropertiesPixelData',
+      'GetIndexedPropertiesPixelDataLength',
+      'HasIndexedPropertiesInExternalArrayData',
+      'HasIndexedPropertiesInPixelData',
+      'SetIndexedPropertiesToExternalArrayData',
+      'SetIndexedPropertiesToPixelData'],
+    toconverters = [
+      'Boolean',
+      'Number',
+      'String',
+      'Object',
+      'Integer',
+      'Uint32',
+      'Int32'],
+    tovalues = [
+      ['bool', 'Boolean'],
+      ['double', 'Number'],
+      ['int64_t', 'Integer'],
+      ['uint32_t', 'Uint32'],
+      ['int32_t', 'Int32']],
+    groups = [],
+    length,
+    i;
+
+fs.readFile('package.json', 'utf8', function (err, data) {
+  if (err) {
+    throw err;
+  }
+
+  commander
+      .version(JSON.parse(data).version)
+      .usage('[options] <file ...>')
+      .parse(process.argv);
+
+  if (!process.argv.slice(2).length) {
+    commander.outputHelp();
+  }
+});
+
+groups.push([0, [
+  '_NAN_',
+  'NODE_SET_METHOD',
+  'NODE_SET_PROTOTYPE_METHOD',
+  'NanAsciiString',
+  'NanEscapeScope',
+  'NanReturnValue',
+  'NanUcs2String'].join('|')]);
+
+groups.push([1, ['(', [
+  'NanEscapableScope',
+  'NanReturnNull',
+  'NanReturnUndefined',
+  'NanScope'].join('|'), ')\\(\\)'].join('')]);
+
+groups.push([1, '(?:v8\\:\\:)?(TryCatch)']);
+
+groups.push([1, ['(NanNew)', '(\\("[^\\"]*"[^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
+
+groups.push([1, ['^.*?(', removed.join('|'), ')'].join('')]);
+
+groups.push([2, ['((', callbacks.join('|'), ')\\([^\\)]*\\)\\s*\\{)\\s*NanScope\\(\\)\\s*;'].join('')]);
+
+groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->To(', toconverters.join('|'), ')\\('].join('')]);
+
+groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->(', tovalues.map(function (x) { return x[1]; }).join('|'), 'Value)\\('].join('')]);
+
+groups.push([1, '(NAN_WEAK_CALLBACK)\\(([^\\s\\)]+)\\)']);
+
+groups.push([1, ['(', [
+  'NanDisposePersistent',
+  'NanObjectWrapHandle'].join('|'), ')\\s*\\(\\s*([^\\s\\)]+)'].join('')]);
+
+groups.push([1, '(NanMakeWeakPersistent)\\s*\\(\\s*([^\\s,]+)\\s*,\\s*']);
+
+groups.push([3, ['([\\s])([^\\s]+)->(', [
+  'GetEndColumn',
+  'GetFunction',
+  'GetLineNumber',
+  'NewInstance',
+  'GetPropertyNames',
+  'GetOwnPropertyNames',
+  'GetSourceLine',
+  'GetStartColumn',
+  'ObjectProtoToString',
+  'ToArrayIndex',
+  'ToDetailString',
+  'CallAsConstructor',
+  'CallAsFunction',
+  'CloneElementAt',
+  'Delete',
+  'ForceSet',
+  'Get',
+  'GetPropertyAttributes',
+  'GetRealNamedProperty',
+  'GetRealNamedPropertyInPrototypeChain',
+  'Has',
+  'HasOwnProperty',
+  'HasRealIndexedProperty',
+  'HasRealNamedCallbackProperty',
+  'HasRealNamedProperty',
+  'Set',
+  'SetAccessor',
+  'SetIndexedPropertyHandler',
+  'SetNamedPropertyHandler',
+  'SetPrototype'].join('|'), ')\\('].join('')]);
+
+groups.push([2, ['NanNew(<(?:v8\\:\\:)?(', ['Date', 'String', 'RegExp'].join('|'), ')>)(\\([^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
+
+groups.push([3, '([\\s\\(\\)])([^\\s\\(\\)]+)->(Equals)\\(([^\\s\\)]+)']);
+
+groups.push([1, '(NanAssignPersistent)(?:<v8\\:\\:[^>]+>)?\\(([^,]+),\\s*']);
+
+groups.push([2, '(\\W)(args)(\\W)'])
+
+groups.push([2, '(\\W)(?:node\\:\\:)?(ObjectWrap)(\\W)']);
+
+groups.push([2, '(\\W)(?:v8\\:\\:)?(Persistent)(\\W)']);
+
+function groupcount(s) {
+  var positive = s.match(/\((?!\?)/g),
+      negative = s.match(/\\\(/g);
+  return (positive ? positive.length : 0) - (negative ? negative.length : 0);
+}
+
+var total = 0;
+for (i = 1, length = groups.length; i < length; i++) {
+	total += groupcount(groups[i - 1][1]);
+	groups[i][0] += total;
+}
+
+master = new RegExp(groups.map(function (a) { return a[1]; }).join('|'), 'gm');
+
+function replace() {
+      switch (arguments[groups[0][0]]) {
+        case '_NAN_':
+          return 'NAN_';
+        case 'NODE_SET_METHOD':
+          return 'NanSetMethod';
+        case 'NODE_SET_PROTOTYPE_METHOD':
+          return 'NanSetPrototypeMethod';
+        case 'NanAsciiString':
+          return 'NanUtf8String';
+        case 'NanEscapeScope':
+          return 'scope.Escape';
+        case 'NanReturnNull':
+          return 'info.GetReturnValue().SetNull';
+        case 'NanReturnValue':
+          return 'info.GetReturnValue().Set';
+        case 'NanUcs2String':
+          return 'v8::String::Value';
+        default:
+      }
+
+      switch (arguments[groups[1][0]]) {
+        case 'NanEscapableScope':
+          return 'NanEscapableScope scope'
+        case 'NanReturnUndefined':
+          return 'return';
+        case 'NanScope':
+          return 'NanScope scope';
+        default:
+      }
+
+      if (arguments[groups[2][0]] === 'TryCatch') {
+        return 'NanTryCatch';
+      }
+
+      if (arguments[groups[3][0]] === 'NanNew') {
+        return [arguments[0], '.ToLocalChecked()'].join('');
+      }
+
+      switch (arguments[groups[4][0]]) {
+        case 'GetIndexedPropertiesExternalArrayData':
+        case 'GetIndexedPropertiesExternalArrayDataLength':
+        case 'GetIndexedPropertiesExternalArrayDataType':
+        case 'GetIndexedPropertiesPixelData':
+        case 'GetIndexedPropertiesPixelDataLength':
+        case 'HasIndexedPropertiesInExternalArrayData':
+        case 'HasIndexedPropertiesInPixelData':
+        case 'SetIndexedPropertiesToExternalArrayData':
+        case 'SetIndexedPropertiesToPixelData':
+          return '// ERROR: Rewrite using Buffer\n' +  arguments[0];
+        default:
+      }
+
+      switch (arguments[groups[5][0]]) {
+        case 'NAN_GETTER':
+        case 'NAN_METHOD':
+        case 'NAN_SETTER':
+        case 'NAN_INDEX_DELETER':
+        case 'NAN_INDEX_ENUMERATOR':
+        case 'NAN_INDEX_GETTER':
+        case 'NAN_INDEX_QUERY':
+        case 'NAN_INDEX_SETTER':
+        case 'NAN_PROPERTY_DELETER':
+        case 'NAN_PROPERTY_ENUMERATOR':
+        case 'NAN_PROPERTY_GETTER':
+        case 'NAN_PROPERTY_QUERY':
+        case 'NAN_PROPERTY_SETTER':
+          return arguments[groups[5][0] - 1];
+        default:
+      }
+
+      switch (arguments[groups[6][0]]) {
+        case 'Boolean':
+        case 'Int32':
+        case 'Integer':
+        case 'Number':
+        case 'Object':
+        case 'String':
+        case 'Uint32':
+          return [arguments[groups[6][0] - 2], 'NanTo<v8::', arguments[groups[6][0]], '>(',  arguments[groups[6][0] - 1]].join('');
+        default:
+      }
+
+      switch (arguments[groups[7][0]]) {
+        case 'BooleanValue':
+          return [arguments[groups[7][0] - 2], 'NanTo<bool>(', arguments[groups[7][0] - 1]].join('');
+        case 'Int32Value':
+          return [arguments[groups[7][0] - 2], 'NanTo<int32_t>(', arguments[groups[7][0] - 1]].join('');
+        case 'IntegerValue':
+          return [arguments[groups[7][0] - 2], 'NanTo<int64_t>(', arguments[groups[7][0] - 1]].join('');
+        case 'Uint32Value':
+          return [arguments[groups[7][0] - 2], 'NanTo<uint32_t>(', arguments[groups[7][0] - 1]].join('');
+        default:
+      }
+
+      if (arguments[groups[8][0]] === 'NAN_WEAK_CALLBACK') {
+        return ['template<typename T>\nvoid ',
+          arguments[groups[8][0] + 1], '(const NanWeakCallbackInfo<T> &data)'].join('');
+      }
+
+      switch (arguments[groups[9][0]]) {
+        case 'NanDisposePersistent':
+          return [arguments[groups[9][0] + 1], '.Reset('].join('');
+        case 'NanObjectWrapHandle':
+          return [arguments[groups[9][0] + 1], '->handle('].join('');
+        default:
+      }
+
+      if (arguments[groups[10][0]] === 'NanMakeWeakPersistent') {
+        return arguments[groups[10][0] + 1] + '.SetWeak(';
+      }
+
+      switch (arguments[groups[11][0]]) {
+        case 'GetEndColumn':
+        case 'GetFunction':
+        case 'GetLineNumber':
+        case 'GetOwnPropertyNames':
+        case 'GetPropertyNames':
+        case 'GetSourceLine':
+        case 'GetStartColumn':
+        case 'NewInstance':
+        case 'ObjectProtoToString':
+        case 'ToArrayIndex':
+        case 'ToDetailString':
+          return [arguments[groups[11][0] - 2], 'Nan', arguments[groups[11][0]], '(', arguments[groups[11][0] - 1]].join('');
+        case 'CallAsConstructor':
+        case 'CallAsFunction':
+        case 'CloneElementAt':
+        case 'Delete':
+        case 'ForceSet':
+        case 'Get':
+        case 'GetPropertyAttributes':
+        case 'GetRealNamedProperty':
+        case 'GetRealNamedPropertyInPrototypeChain':
+        case 'Has':
+        case 'HasOwnProperty':
+        case 'HasRealIndexedProperty':
+        case 'HasRealNamedCallbackProperty':
+        case 'HasRealNamedProperty':
+        case 'Set':
+        case 'SetAccessor':
+        case 'SetIndexedPropertyHandler':
+        case 'SetNamedPropertyHandler':
+        case 'SetPrototype':
+          return [arguments[groups[11][0] - 2], 'Nan', arguments[groups[11][0]], '(', arguments[groups[11][0] - 1], ', '].join('');
+        default:
+      }
+
+      switch (arguments[groups[12][0]]) {
+        case 'Date':
+        case 'String':
+        case 'RegExp':
+          return ['NanNew', arguments[groups[12][0] - 1], arguments[groups[12][0] + 1], '.ToLocalChecked()'].join('');
+        default:
+      }
+
+      if (arguments[groups[13][0]] === 'Equals') {
+        return [arguments[groups[13][0] - 1], 'NanEquals(', arguments[groups[13][0] - 1], ', ', arguments[groups[13][0] + 1]].join('');
+      }
+
+      if (arguments[groups[14][0]] === 'NanAssignPersistent') {
+        return [arguments[groups[14][0] + 1], '.Reset('].join('');
+      }
+
+      if (arguments[groups[15][0]] === 'args') {
+        return [arguments[groups[15][0] - 1], 'info', arguments[groups[15][0] + 1]].join('');
+      }
+
+      if (arguments[groups[16][0]] === 'ObjectWrap') {
+        return [arguments[groups[16][0] - 1], 'NanObjectWrap', arguments[groups[16][0] + 1]].join('');
+      }
+
+      if (arguments[groups[17][0]] === 'Persistent') {
+        return [arguments[groups[17][0] - 1], 'NanPersistent', arguments[groups[17][0] + 1]].join('');
+      }
+
+      throw 'Unhandled match: ' + arguments[0];
+}
+function processFile(file) {
+  fs.readFile(file, {encoding: 'utf8'}, function (err, data) {
+    if (err) {
+      throw err;
+    }
+
+    fs.writeFile(file, data.replace(master, replace).replace(master, replace), function (err) {
+      if (err) {
+        throw err;
+      }
+    });
+  });
+}
+
+for (i = 2, length = process.argv.length; i < length; i++) {
+  glob(process.argv[i], function (err, matches) {
+    if (err) {
+      throw err;
+    }
+    matches.forEach(processFile);
+  });
+}
diff --git a/tools/README.md b/tools/README.md
new file mode 100644
index 00000000..5ea50f9a
--- /dev/null
+++ b/tools/README.md
@@ -0,0 +1 @@
+Run the script
diff --git a/tools/package.json b/tools/package.json
new file mode 100644
index 00000000..2dcdd789
--- /dev/null
+++ b/tools/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "1to2",
+  "version": "1.0.0",
+  "description": "NAN 1 -> 2 Migration Script",
+  "main": "1to2.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/nan.git"
+  },
+  "contributors": [
+    "Benjamin Byholm <bbyholm@abo.fi> (https://github.com/kkoopa/)",
+    "Mathias Küsel (https://github.com/mathiask88/)"
+  ],
+  "dependencies": {
+    "glob": "~5.0.10",
+    "commander": "~2.8.1"
+  },
+  "license": "MIT"
+}

From 04da598e624498ba68a8baf797e1152f6d0b65ee Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 30 May 2015 00:38:49 +0300
Subject: [PATCH 24/84] Emulate negative lookups

---
 tools/1to2.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/1to2.js b/tools/1to2.js
index e9399f2f..e4d5cff3 100755
--- a/tools/1to2.js
+++ b/tools/1to2.js
@@ -82,7 +82,7 @@ groups.push([1, ['(', [
   'NanReturnUndefined',
   'NanScope'].join('|'), ')\\(\\)'].join('')]);
 
-groups.push([1, '(?:v8\\:\\:)?(TryCatch)']);
+groups.push([2, '(?:(?:v8\\:\\:)?|(Nan)?)(TryCatch)']);
 
 groups.push([1, ['(NanNew)', '(\\("[^\\"]*"[^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
 
@@ -192,7 +192,7 @@ function replace() {
       }
 
       if (arguments[groups[2][0]] === 'TryCatch') {
-        return 'NanTryCatch';
+        return arguments[groups[2][0] - 1] ? arguments[0] : 'NanTryCatch';
       }
 
       if (arguments[groups[3][0]] === 'NanNew') {

From c3cecf967de7be99013c925c6847ee9d3a50fe0c Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 30 May 2015 01:01:22 +0300
Subject: [PATCH 25/84] cleanup

---
 tools/1to2.js | 80 ++++++++++++++++++++++++---------------------------
 1 file changed, 38 insertions(+), 42 deletions(-)

diff --git a/tools/1to2.js b/tools/1to2.js
index e4d5cff3..164e9a84 100755
--- a/tools/1to2.js
+++ b/tools/1to2.js
@@ -10,44 +10,6 @@
 var commander = require('commander'),
     fs = require('fs'),
     glob = require('glob'),
-    callbacks = [
-      'NAN_METHOD',
-      'NAN_GETTER',
-      'NAN_SETTER',
-      'NAN_PROPERTY_GETTER',
-      'NAN_PROPERTY_SETTER',
-      'NAN_PROPERTY_ENUMERATOR',
-      'NAN_PROPERTY_DELETER',
-      'NAN_PROPERTY_QUERY',
-      'NAN_INDEX_GETTER',
-      'NAN_INDEX_SETTER',
-      'NAN_INDEX_ENUMERATOR',
-      'NAN_INDEX_DELETER',
-      'NAN_INDEX_QUERY'],
-    removed = [
-      'GetIndexedPropertiesExternalArrayDataLength',
-      'GetIndexedPropertiesExternalArrayData',
-      'GetIndexedPropertiesExternalArrayDataType',
-      'GetIndexedPropertiesPixelData',
-      'GetIndexedPropertiesPixelDataLength',
-      'HasIndexedPropertiesInExternalArrayData',
-      'HasIndexedPropertiesInPixelData',
-      'SetIndexedPropertiesToExternalArrayData',
-      'SetIndexedPropertiesToPixelData'],
-    toconverters = [
-      'Boolean',
-      'Number',
-      'String',
-      'Object',
-      'Integer',
-      'Uint32',
-      'Int32'],
-    tovalues = [
-      ['bool', 'Boolean'],
-      ['double', 'Number'],
-      ['int64_t', 'Integer'],
-      ['uint32_t', 'Uint32'],
-      ['int32_t', 'Int32']],
     groups = [],
     length,
     i;
@@ -86,13 +48,47 @@ groups.push([2, '(?:(?:v8\\:\\:)?|(Nan)?)(TryCatch)']);
 
 groups.push([1, ['(NanNew)', '(\\("[^\\"]*"[^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
 
-groups.push([1, ['^.*?(', removed.join('|'), ')'].join('')]);
+groups.push([1, ['^.*?(', [
+      'GetIndexedPropertiesExternalArrayDataLength',
+      'GetIndexedPropertiesExternalArrayData',
+      'GetIndexedPropertiesExternalArrayDataType',
+      'GetIndexedPropertiesPixelData',
+      'GetIndexedPropertiesPixelDataLength',
+      'HasIndexedPropertiesInExternalArrayData',
+      'HasIndexedPropertiesInPixelData',
+      'SetIndexedPropertiesToExternalArrayData',
+      'SetIndexedPropertiesToPixelData'].join('|'), ')'].join('')]);
 
-groups.push([2, ['((', callbacks.join('|'), ')\\([^\\)]*\\)\\s*\\{)\\s*NanScope\\(\\)\\s*;'].join('')]);
+groups.push([2, ['((', [
+      'NAN_METHOD',
+      'NAN_GETTER',
+      'NAN_SETTER',
+      'NAN_PROPERTY_GETTER',
+      'NAN_PROPERTY_SETTER',
+      'NAN_PROPERTY_ENUMERATOR',
+      'NAN_PROPERTY_DELETER',
+      'NAN_PROPERTY_QUERY',
+      'NAN_INDEX_GETTER',
+      'NAN_INDEX_SETTER',
+      'NAN_INDEX_ENUMERATOR',
+      'NAN_INDEX_DELETER',
+      'NAN_INDEX_QUERY'].join('|'), ')\\([^\\)]*\\)\\s*\\{)\\s*NanScope\\(\\)\\s*;'].join('')]);
 
-groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->To(', toconverters.join('|'), ')\\('].join('')]);
+groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->(', [
+      'Boolean',
+      'Number',
+      'String',
+      'Object',
+      'Integer',
+      'Uint32',
+      'Int32'].join('|'), ')\\('].join('')]);
 
-groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->(', tovalues.map(function (x) { return x[1]; }).join('|'), 'Value)\\('].join('')]);
+groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->((?:', [
+      'Boolean',
+      'Number',
+      'Integer',
+      'Uint32',
+      'Int32'].join('|'), ')Value)\\('].join('')]);
 
 groups.push([1, '(NAN_WEAK_CALLBACK)\\(([^\\s\\)]+)\\)']);
 

From edfefdc40b5f2d1cbb49d75662e4ee9f77cef567 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 30 May 2015 01:46:40 +0300
Subject: [PATCH 26/84] Added documentation for 1to2.js

---
 tools/1to2.js   | 52 +++++++++++++++++++++++++++++++++++++++++++++++++
 tools/README.md | 15 +++++++++++++-
 2 files changed, 66 insertions(+), 1 deletion(-)

diff --git a/tools/1to2.js b/tools/1to2.js
index 164e9a84..d62f2d0a 100755
--- a/tools/1to2.js
+++ b/tools/1to2.js
@@ -29,6 +29,12 @@ fs.readFile('package.json', 'utf8', function (err, data) {
   }
 });
 
+/* construct strings representing regular expressions
+   each expression contains a unique group allowing for identification of the match
+   the index of this key group, relative to the regular expression in question,
+    is indicated by the first array member */
+
+/* simple substistutions, key group is the entire match, 0 */
 groups.push([0, [
   '_NAN_',
   'NODE_SET_METHOD',
@@ -38,16 +44,20 @@ groups.push([0, [
   'NanReturnValue',
   'NanUcs2String'].join('|')]);
 
+/* substitutions of parameterless macros, key group is 1 */
 groups.push([1, ['(', [
   'NanEscapableScope',
   'NanReturnNull',
   'NanReturnUndefined',
   'NanScope'].join('|'), ')\\(\\)'].join('')]);
 
+/* replace TryCatch with NanTryCatch once, gobbling possible namespace, key group 2 */
 groups.push([2, '(?:(?:v8\\:\\:)?|(Nan)?)(TryCatch)']);
 
+/* NanNew("string") will likely not fail a ToLocalChecked(), key group 1 */ 
 groups.push([1, ['(NanNew)', '(\\("[^\\"]*"[^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
 
+/* Removed v8 APIs, warn that the code needs rewriting using node::Buffer, key group 1 */
 groups.push([1, ['^.*?(', [
       'GetIndexedPropertiesExternalArrayDataLength',
       'GetIndexedPropertiesExternalArrayData',
@@ -59,6 +69,7 @@ groups.push([1, ['^.*?(', [
       'SetIndexedPropertiesToExternalArrayData',
       'SetIndexedPropertiesToPixelData'].join('|'), ')'].join('')]);
 
+/* No need for NanScope in V8-exposed methods, key group 2 */
 groups.push([2, ['((', [
       'NAN_METHOD',
       'NAN_GETTER',
@@ -74,6 +85,7 @@ groups.push([2, ['((', [
       'NAN_INDEX_DELETER',
       'NAN_INDEX_QUERY'].join('|'), ')\\([^\\)]*\\)\\s*\\{)\\s*NanScope\\(\\)\\s*;'].join('')]);
 
+/* v8::Value::ToXXXXXXX returns v8::MaybeLocal<T>, key group 3 */
 groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->(', [
       'Boolean',
       'Number',
@@ -83,6 +95,7 @@ groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->(', [
       'Uint32',
       'Int32'].join('|'), ')\\('].join('')]);
 
+/* v8::Value::XXXXXXXValue returns v8::Maybe<T>, key group 3 */
 groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->((?:', [
       'Boolean',
       'Number',
@@ -90,14 +103,18 @@ groups.push([3, ['([\\s\\(\\)])([^\\s\\(\\)]+)->((?:', [
       'Uint32',
       'Int32'].join('|'), ')Value)\\('].join('')]);
 
+/* NAN_WEAK_CALLBACK macro was removed, write out callback definition, key group 1 */
 groups.push([1, '(NAN_WEAK_CALLBACK)\\(([^\\s\\)]+)\\)']);
 
+/* node::ObjectWrap and v8::Persistent have been replaced with Nan implementations, key group 1 */
 groups.push([1, ['(', [
   'NanDisposePersistent',
   'NanObjectWrapHandle'].join('|'), ')\\s*\\(\\s*([^\\s\\)]+)'].join('')]);
 
+/* Since NanPersistent there is no need for NanMakeWeakPersistent, key group 1 */
 groups.push([1, '(NanMakeWeakPersistent)\\s*\\(\\s*([^\\s,]+)\\s*,\\s*']);
 
+/* Many methods of v8::Object and others now return v8::MaybeLocal<T>, key group 3 */
 groups.push([3, ['([\\s])([^\\s]+)->(', [
   'GetEndColumn',
   'GetFunction',
@@ -130,33 +147,46 @@ groups.push([3, ['([\\s])([^\\s]+)->(', [
   'SetNamedPropertyHandler',
   'SetPrototype'].join('|'), ')\\('].join('')]);
 
+/* You should get an error if any of these fail anyways,
+   or handle the error better, it is indicated either way, key group 2 */
 groups.push([2, ['NanNew(<(?:v8\\:\\:)?(', ['Date', 'String', 'RegExp'].join('|'), ')>)(\\([^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
 
+/* v8::Value::Equals now returns a v8::Maybe, key group 3 */
 groups.push([3, '([\\s\\(\\)])([^\\s\\(\\)]+)->(Equals)\\(([^\\s\\)]+)']);
 
+/* NanPersistent makes this unnecessary, key group 1 */
 groups.push([1, '(NanAssignPersistent)(?:<v8\\:\\:[^>]+>)?\\(([^,]+),\\s*']);
 
+/* args has been renamed to info, key group 2 */
 groups.push([2, '(\\W)(args)(\\W)'])
 
+/* node::ObjectWrap was replaced with NanObjectWrap, key group 2 */
 groups.push([2, '(\\W)(?:node\\:\\:)?(ObjectWrap)(\\W)']);
 
+/* v8::Persistent was replaced with NanPersistent, key group 2 */
 groups.push([2, '(\\W)(?:v8\\:\\:)?(Persistent)(\\W)']);
 
+/* counts the number of capturing groups in a well-formed regular expression,
+   ignoring non-capturing groups and escaped parentheses */
 function groupcount(s) {
   var positive = s.match(/\((?!\?)/g),
       negative = s.match(/\\\(/g);
   return (positive ? positive.length : 0) - (negative ? negative.length : 0);
 }
 
+/* compute the absolute position of each key group in the joined master RegExp */
 var total = 0;
 for (i = 1, length = groups.length; i < length; i++) {
 	total += groupcount(groups[i - 1][1]);
 	groups[i][0] += total;
 }
 
+/* create the master RegExp, whis is the union of all the groups' expressions */
 master = new RegExp(groups.map(function (a) { return a[1]; }).join('|'), 'gm');
 
+/* replacement function for String.replace, receives 21 arguments */
 function replace() {
+	/* simple expressions */
       switch (arguments[groups[0][0]]) {
         case '_NAN_':
           return 'NAN_';
@@ -177,6 +207,7 @@ function replace() {
         default:
       }
 
+      /* macros without arguments */
       switch (arguments[groups[1][0]]) {
         case 'NanEscapableScope':
           return 'NanEscapableScope scope'
@@ -187,14 +218,17 @@ function replace() {
         default:
       }
 
+      /* TryCatch, emulate negative backref */
       if (arguments[groups[2][0]] === 'TryCatch') {
         return arguments[groups[2][0] - 1] ? arguments[0] : 'NanTryCatch';
       }
 
+      /* NanNew("foo") --> NanNew("foo").ToLocalChecked() */
       if (arguments[groups[3][0]] === 'NanNew') {
         return [arguments[0], '.ToLocalChecked()'].join('');
       }
 
+      /* insert warning for removed functions as comment on new line above */
       switch (arguments[groups[4][0]]) {
         case 'GetIndexedPropertiesExternalArrayData':
         case 'GetIndexedPropertiesExternalArrayDataLength':
@@ -209,6 +243,7 @@ function replace() {
         default:
       }
 
+     /* remove unnecessary NanScope() */
       switch (arguments[groups[5][0]]) {
         case 'NAN_GETTER':
         case 'NAN_METHOD':
@@ -227,6 +262,7 @@ function replace() {
         default:
       }
 
+      /* Value converstion */
       switch (arguments[groups[6][0]]) {
         case 'Boolean':
         case 'Int32':
@@ -239,6 +275,7 @@ function replace() {
         default:
       }
 
+      /* other value conversion */
       switch (arguments[groups[7][0]]) {
         case 'BooleanValue':
           return [arguments[groups[7][0] - 2], 'NanTo<bool>(', arguments[groups[7][0] - 1]].join('');
@@ -251,11 +288,13 @@ function replace() {
         default:
       }
 
+      /* NAN_WEAK_CALLBACK */
       if (arguments[groups[8][0]] === 'NAN_WEAK_CALLBACK') {
         return ['template<typename T>\nvoid ',
           arguments[groups[8][0] + 1], '(const NanWeakCallbackInfo<T> &data)'].join('');
       }
 
+      /* use methods on NAN classes instead */
       switch (arguments[groups[9][0]]) {
         case 'NanDisposePersistent':
           return [arguments[groups[9][0] + 1], '.Reset('].join('');
@@ -264,10 +303,12 @@ function replace() {
         default:
       }
 
+      /* use method on NanPersistent instead */
       if (arguments[groups[10][0]] === 'NanMakeWeakPersistent') {
         return arguments[groups[10][0] + 1] + '.SetWeak(';
       }
 
+      /* These return Maybes, the upper ones take no arguments */
       switch (arguments[groups[11][0]]) {
         case 'GetEndColumn':
         case 'GetFunction':
@@ -304,6 +345,7 @@ function replace() {
         default:
       }
 
+      /* Automatic ToLocalChecked(), take it or leave it */
       switch (arguments[groups[12][0]]) {
         case 'Date':
         case 'String':
@@ -312,34 +354,43 @@ function replace() {
         default:
       }
 
+      /* NanEquals is now required for uniformity */
       if (arguments[groups[13][0]] === 'Equals') {
         return [arguments[groups[13][0] - 1], 'NanEquals(', arguments[groups[13][0] - 1], ', ', arguments[groups[13][0] + 1]].join('');
       }
 
+      /* use method on replacement class instead */
       if (arguments[groups[14][0]] === 'NanAssignPersistent') {
         return [arguments[groups[14][0] + 1], '.Reset('].join('');
       }
 
+      /* args --> info */
       if (arguments[groups[15][0]] === 'args') {
         return [arguments[groups[15][0] - 1], 'info', arguments[groups[15][0] + 1]].join('');
       }
 
+      /* ObjectWrap --> NanObjectWrap */
       if (arguments[groups[16][0]] === 'ObjectWrap') {
         return [arguments[groups[16][0] - 1], 'NanObjectWrap', arguments[groups[16][0] + 1]].join('');
       }
 
+      /* Persistent --> NanPersistent */
       if (arguments[groups[17][0]] === 'Persistent') {
         return [arguments[groups[17][0] - 1], 'NanPersistent', arguments[groups[17][0] + 1]].join('');
       }
 
+      /* This should not happen. A switch is probably missing a case if it does. */
       throw 'Unhandled match: ' + arguments[0];
 }
+
+/* reads a file, runs replacement and writes it back */
 function processFile(file) {
   fs.readFile(file, {encoding: 'utf8'}, function (err, data) {
     if (err) {
       throw err;
     }
 
+    /* run replacement twice, might need more runs */
     fs.writeFile(file, data.replace(master, replace).replace(master, replace), function (err) {
       if (err) {
         throw err;
@@ -348,6 +399,7 @@ function processFile(file) {
   });
 }
 
+/* process file names from command line and process the identified files */
 for (i = 2, length = process.argv.length; i < length; i++) {
   glob(process.argv[i], function (err, matches) {
     if (err) {
diff --git a/tools/README.md b/tools/README.md
index 5ea50f9a..7f07e4b8 100644
--- a/tools/README.md
+++ b/tools/README.md
@@ -1 +1,14 @@
-Run the script
+1to2 naively converts source code files from NAN 1 to NAN 2. There will be erroneous conversions,
+false positives and missed opportunities. The input files are rewritten in place. Make sure that
+you have backups. You will have to manually review the changes afterwards and do some touchups.
+
+```sh
+$ tools/1to2.js
+
+  Usage: 1to2 [options] <file ...>
+
+  Options:
+
+    -h, --help     output usage information
+    -V, --version  output the version number
+```

From 621bc30f6bcd4b515be701cd933f00cb9c469a0b Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 30 May 2015 03:37:56 +0300
Subject: [PATCH 27/84] Avoid duplicate warnings

---
 tools/1to2.js | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/tools/1to2.js b/tools/1to2.js
index d62f2d0a..3c29575e 100755
--- a/tools/1to2.js
+++ b/tools/1to2.js
@@ -11,6 +11,9 @@ var commander = require('commander'),
     fs = require('fs'),
     glob = require('glob'),
     groups = [],
+    total = 0,
+    warning1 = '/* ERROR: Rewrite using Buffer */\n',
+    warning2 = '\\/\\* ERROR\\: Rewrite using Buffer \\*\\/\\n',
     length,
     i;
 
@@ -57,8 +60,8 @@ groups.push([2, '(?:(?:v8\\:\\:)?|(Nan)?)(TryCatch)']);
 /* NanNew("string") will likely not fail a ToLocalChecked(), key group 1 */ 
 groups.push([1, ['(NanNew)', '(\\("[^\\"]*"[^\\)]*\\))(?!\\.ToLocalChecked\\(\\))'].join('')]);
 
-/* Removed v8 APIs, warn that the code needs rewriting using node::Buffer, key group 1 */
-groups.push([1, ['^.*?(', [
+/* Removed v8 APIs, warn that the code needs rewriting using node::Buffer, key group 2 */
+groups.push([2, ['(', warning2, ')?', '^.*?(', [
       'GetIndexedPropertiesExternalArrayDataLength',
       'GetIndexedPropertiesExternalArrayData',
       'GetIndexedPropertiesExternalArrayDataType',
@@ -175,7 +178,6 @@ function groupcount(s) {
 }
 
 /* compute the absolute position of each key group in the joined master RegExp */
-var total = 0;
 for (i = 1, length = groups.length; i < length; i++) {
 	total += groupcount(groups[i - 1][1]);
 	groups[i][0] += total;
@@ -239,7 +241,7 @@ function replace() {
         case 'HasIndexedPropertiesInPixelData':
         case 'SetIndexedPropertiesToExternalArrayData':
         case 'SetIndexedPropertiesToPixelData':
-          return '// ERROR: Rewrite using Buffer\n' +  arguments[0];
+          return arguments[groups[4][0] - 1] ? arguments[0] : [warning1, arguments[0]].join('');
         default:
       }
 

From 72d1f6703eebdac1317569882f1986067cb4d758 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 19 Jun 2015 02:45:09 +0300
Subject: [PATCH 28/84] Remove Nan prefix from all names

---
 nan.h                               | 818 ++++++++++++++--------------
 nan_callbacks.h                     |  62 +--
 nan_callbacks_12_inl.h              |  66 +--
 nan_callbacks_pre_12_inl.h          | 132 ++---
 nan_converters.h                    |   8 +-
 nan_converters_43_inl.h             |  12 +-
 nan_converters_pre_43_inl.h         |  12 +-
 nan_implementation_12_inl.h         |  52 +-
 nan_implementation_pre_12_inl.h     |  26 +-
 nan_maybe_43_inl.h                  | 142 ++---
 nan_maybe_pre_43_inl.h              | 162 +++---
 nan_new.h                           | 132 ++---
 nan_persistent_12_inl.h             |  44 +-
 nan_persistent_pre_12_inl.h         |  96 ++--
 nan_string_bytes.h                  |  18 +-
 nan_weak.h                          | 184 +++----
 test/cpp/accessors.cpp              |  42 +-
 test/cpp/accessors2.cpp             |  40 +-
 test/cpp/asyncprogressworker.cpp    |  32 +-
 test/cpp/asyncworker.cpp            |  18 +-
 test/cpp/asyncworkererror.cpp       |  14 +-
 test/cpp/buffer.cpp                 |  32 +-
 test/cpp/bufferworkerpersistent.cpp |  24 +-
 test/cpp/converters.cpp             | 116 ++--
 test/cpp/error.cpp                  |  14 +-
 test/cpp/gc.cpp                     |  20 +-
 test/cpp/indexedinterceptors.cpp    |  36 +-
 test/cpp/isolatedata.cpp            |  12 +-
 test/cpp/makecallback.cpp           |  18 +-
 test/cpp/morenews.cpp               |  66 +--
 test/cpp/multifile1.cpp             |   6 +-
 test/cpp/multifile2.cpp             |   2 +-
 test/cpp/namedinterceptors.cpp      |  36 +-
 test/cpp/nancallback.cpp            |  58 +-
 test/cpp/nannew.cpp                 | 240 ++++----
 test/cpp/news.cpp                   | 238 ++++----
 test/cpp/objectwraphandle.cpp       |  18 +-
 test/cpp/persistent.cpp             |  50 +-
 test/cpp/returnemptystring.cpp      |   6 +-
 test/cpp/returnnull.cpp             |   6 +-
 test/cpp/returnundefined.cpp        |   6 +-
 test/cpp/returnvalue.cpp            |  30 +-
 test/cpp/settemplate.cpp            |  46 +-
 test/cpp/strings.cpp                |  38 +-
 test/cpp/symbols.cpp                |   6 +-
 test/cpp/threadlocal.cpp            |  18 +-
 test/cpp/trycatch.cpp               |  14 +-
 test/cpp/weak.cpp                   |  22 +-
 test/cpp/weak2.cpp                  |  26 +-
 49 files changed, 1658 insertions(+), 1658 deletions(-)

diff --git a/nan.h b/nan.h
index a85ad9ae..9c02911c 100644
--- a/nan.h
+++ b/nan.h
@@ -130,41 +130,41 @@ namespace Nan {
 //==============================================================================
 
 #if (NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION)
-typedef v8::Script             NanUnboundScript;
-typedef v8::Script             NanBoundScript;
+typedef v8::Script             UnboundScript;
+typedef v8::Script             BoundScript;
 #else
-typedef v8::UnboundScript      NanUnboundScript;
-typedef v8::Script             NanBoundScript;
+typedef v8::UnboundScript      UnboundScript;
+typedef v8::Script             BoundScript;
 #endif
 
 #if (NODE_MODULE_VERSION < ATOM_0_21_MODULE_VERSION)
 typedef v8::String::ExternalAsciiStringResource
-    NanExternalOneByteStringResource;
+    ExternalOneByteStringResource;
 #else
 typedef v8::String::ExternalOneByteStringResource
-    NanExternalOneByteStringResource;
+    ExternalOneByteStringResource;
 #endif
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
 template<typename T>
-class NanNonCopyablePersistentTraits :
+class NonCopyablePersistentTraits :
     public v8::NonCopyablePersistentTraits<T> {};
 template<typename T>
-class NanCopyablePersistentTraits :
+class CopyablePersistentTraits :
     public v8::CopyablePersistentTraits<T> {};
 
 template<typename T>
-class NanPersistentBase :
+class PersistentBase :
     public v8::PersistentBase<T> {};
 
 template<typename T, typename M = v8::NonCopyablePersistentTraits<T> >
-class NanPersistent;
+class Persistent;
 #else
-template<typename T> class NanNonCopyablePersistentTraits;
-template<typename T> class NanPersistentBase;
-template<typename T, typename P> class NanWeakCallbackData;
-template<typename T, typename M = NanNonCopyablePersistentTraits<T> >
-class NanPersistent;
+template<typename T> class NonCopyablePersistentTraits;
+template<typename T> class PersistentBase;
+template<typename T, typename P> class WeakCallbackData;
+template<typename T, typename M = NonCopyablePersistentTraits<T> >
+class Persistent;
 #endif  // NODE_MODULE_VERSION
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
@@ -270,22 +270,22 @@ inline void nauv_key_set(nauv_key_t* key, void* value) {
 #endif
 
 template<typename T>
-v8::Local<T> NanNew(v8::Handle<T>);
+v8::Local<T> New(v8::Handle<T>);
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
-  typedef v8::WeakCallbackType NanWeakCallbackType;
+  typedef v8::WeakCallbackType WeakCallbackType;
 #else
-struct NanWeakCallbackType {
+struct WeakCallbackType {
   enum E {kParameter, kInternalFields};
   E type;
-  NanWeakCallbackType(E other) : type(other) {}  // NOLINT(runtime/explicit)
+  WeakCallbackType(E other) : type(other) {}  // NOLINT(runtime/explicit)
   inline bool operator==(E other) { return other == this->type; }
   inline bool operator!=(E other) { return !operator==(other); }
 };
 #endif
 
-template<typename P> class NanWeakCallbackInfo;
+template<typename P> class WeakCallbackInfo;
 
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
 # include "nan_persistent_12_inl.h"  // NOLINT(build/include)
@@ -298,75 +298,75 @@ namespace imp {
   template<typename T>
   NAN_INLINE
   v8::Local<T>
-  NanUnwrap(NanMaybeLocal<T> maybe) {
+  Unwrap(MaybeLocal<T> maybe) {
     return maybe.ToLocalChecked();
   }
 
   template<typename T>
   NAN_INLINE
-  v8::Local<T> NanUnwrap(v8::Local<T> val) {
+  v8::Local<T> Unwrap(v8::Local<T> val) {
     return val;
   }
 
   template<typename T>
-  NAN_INLINE v8::Persistent<T> &NanEnsureHandleOrPersistent(
+  NAN_INLINE v8::Persistent<T> &EnsureHandleOrPersistent(
       v8::Persistent<T> &val) {  // NOLINT(runtime/references)
     return val;
   }
 
   template<typename T>
   NAN_INLINE
-  v8::Handle<T> NanEnsureHandleOrPersistent(const v8::Handle<T> &val) {
+  v8::Handle<T> EnsureHandleOrPersistent(const v8::Handle<T> &val) {
     return val;
   }
 
   template<typename T>
-  NAN_INLINE v8::Local<T> NanEnsureHandleOrPersistent(const v8::Local<T> &val) {
+  NAN_INLINE v8::Local<T> EnsureHandleOrPersistent(const v8::Local<T> &val) {
     return val;
   }
 
   template<typename T>
   NAN_INLINE
   v8::Local<v8::Value>
-  NanEnsureHandleOrPersistent(T val) {
-    return NanUnwrap(NanNew(val));
+  EnsureHandleOrPersistent(T val) {
+    return Unwrap(New(val));
   }
 
   template<typename T>
-  NAN_INLINE v8::Local<T> NanEnsureLocal(const v8::Local<T> &val) {
+  NAN_INLINE v8::Local<T> EnsureLocal(const v8::Local<T> &val) {
     return val;
   }
 
   template<typename T>
-  NAN_INLINE v8::Local<T> NanEnsureLocal(const v8::Persistent<T> &val) {
-    return NanNew(val);
+  NAN_INLINE v8::Local<T> EnsureLocal(const v8::Persistent<T> &val) {
+    return New(val);
   }
 
   template<typename T>
-  NAN_INLINE v8::Local<T> NanEnsureLocal(const v8::Handle<T> &val) {
-    return NanNew(val);
+  NAN_INLINE v8::Local<T> EnsureLocal(const v8::Handle<T> &val) {
+    return New(val);
   }
 
   template<typename T>
   NAN_INLINE
-  v8::Local<v8::Value> NanEnsureLocal(T val) {
-    return NanUnwrap(NanNew(val));
+  v8::Local<v8::Value> EnsureLocal(T val) {
+    return Unwrap(New(val));
   }
 }  // end of namespace imp
 
 //=== HandleScope ==============================================================
 
-class NanScope {
+class Scope {
   v8::HandleScope scope;
 
  public:
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
-  inline NanScope() : scope(v8::Isolate::GetCurrent()) {}
+  inline Scope() : scope(v8::Isolate::GetCurrent()) {}
   inline static int NumberOfHandles() {
     return v8::HandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
   }
 #else
-  inline NanScope() : scope() {}
+  inline Scope() : scope() {}
   inline static int NumberOfHandles() {
     return v8::HandleScope::NumberOfHandles();
   }
@@ -375,16 +375,16 @@ class NanScope {
  private:
   // Make it hard to create heap-allocated or illegal handle scopes by
   // disallowing certain operations.
-  NanScope(const NanScope &);
-  void operator=(const NanScope &);
+  Scope(const Scope &);
+  void operator=(const Scope &);
   void *operator new(size_t size);
   void operator delete(void *, size_t);
 };
 
-class NanEscapableScope {
+class EscapableScope {
  public:
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
-  inline NanEscapableScope() : scope(v8::Isolate::GetCurrent()) {}
+  inline EscapableScope() : scope(v8::Isolate::GetCurrent()) {}
 
   inline static int NumberOfHandles() {
     return v8::EscapableHandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
@@ -398,7 +398,7 @@ class NanEscapableScope {
  private:
   v8::EscapableHandleScope scope;
 #else
-  inline NanEscapableScope() : scope() {}
+  inline EscapableScope() : scope() {}
 
   inline static int NumberOfHandles() {
     return v8::HandleScope::NumberOfHandles();
@@ -416,21 +416,21 @@ class NanEscapableScope {
  private:
   // Make it hard to create heap-allocated or illegal handle scopes by
   // disallowing certain operations.
-  NanEscapableScope(const NanEscapableScope &);
-  void operator=(const NanEscapableScope &);
+  EscapableScope(const EscapableScope &);
+  void operator=(const EscapableScope &);
   void *operator new(size_t size);
   void operator delete(void *, size_t);
 };
 
 //=== TryCatch =================================================================
 
-class NanTryCatch {
+class TryCatch {
   v8::TryCatch try_catch_;
-  friend void NanFatalException(const NanTryCatch&);
+  friend void FatalException(const TryCatch&);
 
  public:
 #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
-  NanTryCatch() : try_catch_(v8::Isolate::GetCurrent()) {}
+  TryCatch() : try_catch_(v8::Isolate::GetCurrent()) {}
 #endif
 
   NAN_INLINE bool HasCaught() const { return try_catch_.HasCaught(); }
@@ -446,11 +446,11 @@ class NanTryCatch {
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
   NAN_INLINE v8::MaybeLocal<v8::Value> StackTrace() const {
-    return try_catch_.StackTrace(NanGetCurrentContext());
+    return try_catch_.StackTrace(GetCurrentContext());
   }
 #else
-  NAN_INLINE NanMaybeLocal<v8::Value> StackTrace() const {
-    return NanMaybeLocal<v8::Value>(try_catch_.StackTrace());
+  NAN_INLINE MaybeLocal<v8::Value> StackTrace() const {
+    return MaybeLocal<v8::Value>(try_catch_.StackTrace());
   }
 #endif
 
@@ -472,106 +472,106 @@ class NanTryCatch {
 /* node 0.12  */
 #if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
   NAN_INLINE
-  void NanSetCounterFunction(v8::CounterLookupCallback cb) {
+  void SetCounterFunction(v8::CounterLookupCallback cb) {
     v8::Isolate::GetCurrent()->SetCounterFunction(cb);
   }
 
   NAN_INLINE
-  void NanSetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
+  void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
     v8::Isolate::GetCurrent()->SetCreateHistogramFunction(cb);
   }
 
   NAN_INLINE
-  void NanSetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) {
+  void SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) {
     v8::Isolate::GetCurrent()->SetAddHistogramSampleFunction(cb);
   }
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
-  NAN_INLINE bool NanIdleNotification(int idle_time_in_ms) {
+  NAN_INLINE bool IdleNotification(int idle_time_in_ms) {
     return v8::Isolate::GetCurrent()->IdleNotificationDeadline(
         idle_time_in_ms * 0.001);
   }
 # else
-  NAN_INLINE bool NanIdleNotification(int idle_time_in_ms) {
+  NAN_INLINE bool IdleNotification(int idle_time_in_ms) {
     return v8::Isolate::GetCurrent()->IdleNotification(idle_time_in_ms);
   }
 #endif
 
-  NAN_INLINE void NanLowMemoryNotification() {
+  NAN_INLINE void LowMemoryNotification() {
     v8::Isolate::GetCurrent()->LowMemoryNotification();
   }
 
-  NAN_INLINE void NanContextDisposedNotification() {
+  NAN_INLINE void ContextDisposedNotification() {
     v8::Isolate::GetCurrent()->ContextDisposedNotification();
   }
 #else
   NAN_INLINE
-  void NanSetCounterFunction(v8::CounterLookupCallback cb) {
+  void SetCounterFunction(v8::CounterLookupCallback cb) {
     v8::V8::SetCounterFunction(cb);
   }
 
   NAN_INLINE
-  void NanSetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
+  void SetCreateHistogramFunction(v8::CreateHistogramCallback cb) {
     v8::V8::SetCreateHistogramFunction(cb);
   }
 
   NAN_INLINE
-  void NanSetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) {
+  void SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) {
     v8::V8::SetAddHistogramSampleFunction(cb);
   }
 
-  NAN_INLINE bool NanIdleNotification(int idle_time_in_ms) {
+  NAN_INLINE bool IdleNotification(int idle_time_in_ms) {
     return v8::V8::IdleNotification(idle_time_in_ms);
   }
 
-  NAN_INLINE void NanLowMemoryNotification() {
+  NAN_INLINE void LowMemoryNotification() {
     v8::V8::LowMemoryNotification();
   }
 
-  NAN_INLINE void NanContextDisposedNotification() {
+  NAN_INLINE void ContextDisposedNotification() {
     v8::V8::ContextDisposedNotification();
   }
 #endif
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)  // Node 0.12
-  NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::Undefined(v8::Isolate::GetCurrent())));
+  NAN_INLINE v8::Local<v8::Primitive> Undefined() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::Undefined(v8::Isolate::GetCurrent())));
   }
 
-  NAN_INLINE v8::Local<v8::Primitive> NanNull() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::Null(v8::Isolate::GetCurrent())));
+  NAN_INLINE v8::Local<v8::Primitive> Null() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::Null(v8::Isolate::GetCurrent())));
   }
 
-  NAN_INLINE v8::Local<v8::Boolean> NanTrue() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::True(v8::Isolate::GetCurrent())));
+  NAN_INLINE v8::Local<v8::Boolean> True() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::True(v8::Isolate::GetCurrent())));
   }
 
-  NAN_INLINE v8::Local<v8::Boolean> NanFalse() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::False(v8::Isolate::GetCurrent())));
+  NAN_INLINE v8::Local<v8::Boolean> False() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::False(v8::Isolate::GetCurrent())));
   }
 
-  NAN_INLINE v8::Local<v8::String> NanEmptyString() {
+  NAN_INLINE v8::Local<v8::String> EmptyString() {
     return v8::String::Empty(v8::Isolate::GetCurrent());
   }
 
-  NAN_INLINE int NanAdjustExternalMemory(int bc) {
+  NAN_INLINE int AdjustExternalMemory(int bc) {
     return static_cast<int>(
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(bc));
   }
 
-  NAN_INLINE void NanSetTemplate(
+  NAN_INLINE void SetTemplate(
       v8::Handle<v8::Template> templ
     , const char *name
     , v8::Handle<v8::Data> value) {
     templ->Set(v8::Isolate::GetCurrent(), name, value);
   }
 
-  NAN_INLINE void NanSetTemplate(
+  NAN_INLINE void SetTemplate(
       v8::Handle<v8::Template> templ
     , v8::Handle<v8::String> name
     , v8::Handle<v8::Data> value
@@ -579,17 +579,17 @@ class NanTryCatch {
     templ->Set(name, value, attributes);
   }
 
-  NAN_INLINE v8::Local<v8::Context> NanGetCurrentContext() {
+  NAN_INLINE v8::Local<v8::Context> GetCurrentContext() {
     return v8::Isolate::GetCurrent()->GetCurrentContext();
   }
 
-  NAN_INLINE void* NanGetInternalFieldPointer(
+  NAN_INLINE void* GetInternalFieldPointer(
       v8::Handle<v8::Object> object
     , int index) {
     return object->GetAlignedPointerFromInternalField(index);
   }
 
-  NAN_INLINE void NanSetInternalFieldPointer(
+  NAN_INLINE void SetInternalFieldPointer(
       v8::Handle<v8::Object> object
     , int index
     , void* value) {
@@ -599,54 +599,54 @@ class NanTryCatch {
 # define NAN_GC_CALLBACK(name)                                                 \
     void name(v8::Isolate *isolate, v8::GCType type, v8::GCCallbackFlags flags)
 
-  NAN_INLINE void NanAddGCEpilogueCallback(
+  NAN_INLINE void AddGCEpilogueCallback(
       v8::Isolate::GCEpilogueCallback callback
     , v8::GCType gc_type_filter = v8::kGCTypeAll) {
     v8::Isolate::GetCurrent()->AddGCEpilogueCallback(callback, gc_type_filter);
   }
 
-  NAN_INLINE void NanRemoveGCEpilogueCallback(
+  NAN_INLINE void RemoveGCEpilogueCallback(
       v8::Isolate::GCEpilogueCallback callback) {
     v8::Isolate::GetCurrent()->RemoveGCEpilogueCallback(callback);
   }
 
-  NAN_INLINE void NanAddGCPrologueCallback(
+  NAN_INLINE void AddGCPrologueCallback(
       v8::Isolate::GCPrologueCallback callback
     , v8::GCType gc_type_filter = v8::kGCTypeAll) {
     v8::Isolate::GetCurrent()->AddGCPrologueCallback(callback, gc_type_filter);
   }
 
-  NAN_INLINE void NanRemoveGCPrologueCallback(
+  NAN_INLINE void RemoveGCPrologueCallback(
       v8::Isolate::GCPrologueCallback callback) {
     v8::Isolate::GetCurrent()->RemoveGCPrologueCallback(callback);
   }
 
-  NAN_INLINE void NanGetHeapStatistics(
+  NAN_INLINE void GetHeapStatistics(
       v8::HeapStatistics *heap_statistics) {
     v8::Isolate::GetCurrent()->GetHeapStatistics(heap_statistics);
   }
 
 # define X(NAME)                                                               \
-    NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *msg) {             \
-      NanEscapableScope scope;                                                 \
-      return scope.Escape(v8::Exception::NAME(NanNew(msg).ToLocalChecked()));  \
+    NAN_INLINE v8::Local<v8::Value> NAME(const char *msg) {                    \
+      EscapableScope scope;                                                    \
+      return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked()));     \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    v8::Local<v8::Value> Nan ## NAME(v8::Handle<v8::String> msg) {             \
+    v8::Local<v8::Value> NAME(v8::Handle<v8::String> msg) {                    \
       return v8::Exception::NAME(msg);                                         \
     }                                                                          \
                                                                                \
-    NAN_INLINE void NanThrow ## NAME(const char *msg) {                        \
-      NanScope scope;                                                          \
+    NAN_INLINE void Throw ## NAME(const char *msg) {                           \
+      Scope scope;                                                             \
       v8::Isolate::GetCurrent()->ThrowException(                               \
-          v8::Exception::NAME(NanNew(msg).ToLocalChecked()));                  \
+          v8::Exception::NAME(New(msg).ToLocalChecked()));                     \
     }                                                                          \
                                                                                \
-    NAN_INLINE void NanThrow ## NAME(v8::Handle<v8::String> msg) {             \
-      NanScope scope;                                                          \
+    NAN_INLINE void Throw ## NAME(v8::Handle<v8::String> msg) {                \
+      Scope scope;                                                             \
       v8::Isolate::GetCurrent()->ThrowException(                               \
-          v8::Exception::NAME(NanNew(msg)));                                   \
+          v8::Exception::NAME(New(msg)));                                      \
     }
 
   X(Error)
@@ -657,11 +657,11 @@ class NanTryCatch {
 
 # undef X
 
-  NAN_INLINE void NanThrowError(v8::Handle<v8::Value> error) {
+  NAN_INLINE void ThrowError(v8::Handle<v8::Value> error) {
     v8::Isolate::GetCurrent()->ThrowException(error);
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(
+  NAN_INLINE MaybeLocal<v8::Object> NewBuffer(
       char *data
     , size_t length
     , node::smalloc::FreeCallback callback
@@ -669,164 +669,164 @@ class NanTryCatch {
   ) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(length <= Nan::imp::kMaxLength && "too large buffer");
+    assert(length <= imp::kMaxLength && "too large buffer");
 #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
     return node::Buffer::New(
         v8::Isolate::GetCurrent(), data, length, callback, hint);
 #else
-    return NanMaybeLocal<v8::Object>(node::Buffer::New(
+    return MaybeLocal<v8::Object>(node::Buffer::New(
         v8::Isolate::GetCurrent(), data, length, callback, hint));
 #endif
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Object> NanCopyBuffer(
+  NAN_INLINE MaybeLocal<v8::Object> CopyBuffer(
       const char *data
     , uint32_t size
   ) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+    assert(size <= imp::kMaxLength && "too large buffer");
 #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
     return node::Buffer::New(
         v8::Isolate::GetCurrent(), data, size);
 #else
-    return NanMaybeLocal<v8::Object>(node::Buffer::New(
+    return MaybeLocal<v8::Object>(node::Buffer::New(
         v8::Isolate::GetCurrent(), data, size));
 #endif
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(uint32_t size) {
+  NAN_INLINE MaybeLocal<v8::Object> NewBuffer(uint32_t size) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+    assert(size <= imp::kMaxLength && "too large buffer");
 #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
     return node::Buffer::New(
         v8::Isolate::GetCurrent(), size);
 #else
-    return NanMaybeLocal<v8::Object>(node::Buffer::New(
+    return MaybeLocal<v8::Object>(node::Buffer::New(
         v8::Isolate::GetCurrent(), size));
 #endif
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
+  NAN_INLINE v8::Local<v8::Object> NewBuffer(
       char* data
     , uint32_t size
   ) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+    assert(size <= imp::kMaxLength && "too large buffer");
     return node::Buffer::Use(v8::Isolate::GetCurrent(), data, size);
   }
 
-  NAN_INLINE bool NanHasInstance(
+  NAN_INLINE bool HasInstance(
       const v8::Persistent<v8::FunctionTemplate>& function_template
     , v8::Handle<v8::Value> value
   ) {
-    return NanNew(function_template)->HasInstance(value);
+    return New(function_template)->HasInstance(value);
   }
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
-  NAN_INLINE NanMaybeLocal<v8::String>
-  NanNewOneByteString(const uint8_t * value, int length = -1) {
+  NAN_INLINE MaybeLocal<v8::String>
+  NewOneByteString(const uint8_t * value, int length = -1) {
     return v8::String::NewFromOneByte(v8::Isolate::GetCurrent(), value,
           v8::NewStringType::kNormal, length);
   }
 
-  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+  NAN_INLINE MaybeLocal<BoundScript> CompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
   ) {
     v8::ScriptCompiler::Source source(s, origin);
-    return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &source);
+    return v8::ScriptCompiler::Compile(GetCurrentContext(), &source);
   }
 
-  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+  NAN_INLINE MaybeLocal<BoundScript> CompileScript(
       v8::Local<v8::String> s
   ) {
     v8::ScriptCompiler::Source source(s);
-    return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &source);
+    return v8::ScriptCompiler::Compile(GetCurrentContext(), &source);
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
-      v8::Handle<NanUnboundScript> script
+  NAN_INLINE MaybeLocal<v8::Value> RunScript(
+      v8::Handle<UnboundScript> script
   ) {
-    return script->BindToCurrentContext()->Run(NanGetCurrentContext());
+    return script->BindToCurrentContext()->Run(GetCurrentContext());
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
-      v8::Handle<NanBoundScript> script
+  NAN_INLINE MaybeLocal<v8::Value> RunScript(
+      v8::Handle<BoundScript> script
   ) {
-    return script->Run(NanGetCurrentContext());
+    return script->Run(GetCurrentContext());
   }
 #else
-  NAN_INLINE NanMaybeLocal<v8::String>
-  NanNewOneByteString(const uint8_t * value, int length = -1) {
-    return NanMaybeLocal<v8::String>(
+  NAN_INLINE MaybeLocal<v8::String>
+  NewOneByteString(const uint8_t * value, int length = -1) {
+    return MaybeLocal<v8::String>(
         v8::String::NewFromOneByte(
             v8::Isolate::GetCurrent()
           , value
           , v8::String::kNormalString, length));
   }
 
-  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+  NAN_INLINE MaybeLocal<BoundScript> CompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
   ) {
     v8::ScriptCompiler::Source source(s, origin);
-    return NanMaybeLocal<NanBoundScript>(
+    return MaybeLocal<BoundScript>(
         v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
   }
 
-  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+  NAN_INLINE MaybeLocal<BoundScript> CompileScript(
       v8::Local<v8::String> s
   ) {
     v8::ScriptCompiler::Source source(s);
-    return NanMaybeLocal<NanBoundScript>(
+    return MaybeLocal<BoundScript>(
         v8::ScriptCompiler::Compile(v8::Isolate::GetCurrent(), &source));
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
-      v8::Handle<NanUnboundScript> script
+  NAN_INLINE MaybeLocal<v8::Value> RunScript(
+      v8::Handle<UnboundScript> script
   ) {
-    return NanMaybeLocal<v8::Value>(script->BindToCurrentContext()->Run());
+    return MaybeLocal<v8::Value>(script->BindToCurrentContext()->Run());
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Value> NanRunScript(
-      v8::Handle<NanBoundScript> script
+  NAN_INLINE MaybeLocal<v8::Value> RunScript(
+      v8::Handle<BoundScript> script
   ) {
-    return NanMaybeLocal<v8::Value>(script->Run());
+    return MaybeLocal<v8::Value>(script->Run());
   }
 #endif
 
-  NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
+  NAN_INLINE v8::Local<v8::Value> MakeCallback(
       v8::Handle<v8::Object> target
     , v8::Handle<v8::Function> func
     , int argc
     , v8::Handle<v8::Value>* argv) {
-    return NanNew(node::MakeCallback(
+    return New(node::MakeCallback(
         v8::Isolate::GetCurrent(), target, func, argc, argv));
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
+  NAN_INLINE v8::Local<v8::Value> MakeCallback(
       v8::Handle<v8::Object> target
     , v8::Handle<v8::String> symbol
     , int argc
     , v8::Handle<v8::Value>* argv) {
-    return NanNew(node::MakeCallback(
+    return New(node::MakeCallback(
         v8::Isolate::GetCurrent(), target, symbol, argc, argv));
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
+  NAN_INLINE v8::Local<v8::Value> MakeCallback(
       v8::Handle<v8::Object> target
     , const char* method
     , int argc
     , v8::Handle<v8::Value>* argv) {
-    return NanNew(node::MakeCallback(
+    return New(node::MakeCallback(
         v8::Isolate::GetCurrent(), target, method, argc, argv));
   }
 
-  NAN_INLINE void NanFatalException(const NanTryCatch& try_catch) {
+  NAN_INLINE void FatalException(const TryCatch& try_catch) {
     node::FatalException(v8::Isolate::GetCurrent(), try_catch.try_catch_);
   }
 
@@ -840,7 +840,7 @@ class NanTryCatch {
   }
 
   template<typename T>
-  NAN_INLINE void NanSetIsolateData(
+  NAN_INLINE void SetIsolateData(
       v8::Isolate *isolate
     , T *data
   ) {
@@ -848,15 +848,15 @@ class NanTryCatch {
   }
 
   template<typename T>
-  NAN_INLINE T *NanGetIsolateData(
+  NAN_INLINE T *GetIsolateData(
       v8::Isolate *isolate
   ) {
       return static_cast<T*>(isolate->GetData(0));
   }
 
-class NanUtf8String {
+class Utf8String {
  public:
-  NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) :
+  NAN_INLINE explicit Utf8String(v8::Handle<v8::Value> from) :
       length_(0), str_(str_st_) {
     if (!from.IsEmpty()) {
       v8::Local<v8::String> string = from->ToString();
@@ -882,14 +882,14 @@ class NanUtf8String {
   NAN_INLINE char* operator*() { return str_; }
   NAN_INLINE const char* operator*() const { return str_; }
 
-  NAN_INLINE ~NanUtf8String() {
+  NAN_INLINE ~Utf8String() {
     if (str_ != str_st_) {
       free(str_);
     }
   }
 
  private:
-  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUtf8String)
+  NAN_DISALLOW_ASSIGN_COPY_MOVE(Utf8String)
 
   int length_;
   char *str_;
@@ -897,42 +897,42 @@ class NanUtf8String {
 };
 
 #else  // Node 0.8 and 0.10
-  NAN_INLINE v8::Local<v8::Primitive> NanUndefined() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::Undefined()));
+  NAN_INLINE v8::Local<v8::Primitive> Undefined() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::Undefined()));
   }
 
-  NAN_INLINE v8::Local<v8::Primitive> NanNull() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::Null()));
+  NAN_INLINE v8::Local<v8::Primitive> Null() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::Null()));
   }
 
-  NAN_INLINE v8::Local<v8::Boolean> NanTrue() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::True()));
+  NAN_INLINE v8::Local<v8::Boolean> True() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::True()));
   }
 
-  NAN_INLINE v8::Local<v8::Boolean> NanFalse() {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(v8::False()));
+  NAN_INLINE v8::Local<v8::Boolean> False() {
+    EscapableScope scope;
+    return scope.Escape(New(v8::False()));
   }
 
-  NAN_INLINE v8::Local<v8::String> NanEmptyString() {
+  NAN_INLINE v8::Local<v8::String> EmptyString() {
     return v8::String::Empty();
   }
 
-  NAN_INLINE int NanAdjustExternalMemory(int bc) {
+  NAN_INLINE int AdjustExternalMemory(int bc) {
     return static_cast<int>(v8::V8::AdjustAmountOfExternalAllocatedMemory(bc));
   }
 
-  NAN_INLINE void NanSetTemplate(
+  NAN_INLINE void SetTemplate(
       v8::Handle<v8::Template> templ
     , const char *name
     , v8::Handle<v8::Data> value) {
     templ->Set(name, value);
   }
 
-  NAN_INLINE void NanSetTemplate(
+  NAN_INLINE void SetTemplate(
       v8::Handle<v8::Template> templ
     , v8::Handle<v8::String> name
     , v8::Handle<v8::Data> value
@@ -940,17 +940,17 @@ class NanUtf8String {
     templ->Set(name, value, attributes);
   }
 
-  NAN_INLINE v8::Local<v8::Context> NanGetCurrentContext() {
+  NAN_INLINE v8::Local<v8::Context> GetCurrentContext() {
     return v8::Context::GetCurrent();
   }
 
-  NAN_INLINE void* NanGetInternalFieldPointer(
+  NAN_INLINE void* GetInternalFieldPointer(
       v8::Handle<v8::Object> object
     , int index) {
     return object->GetPointerFromInternalField(index);
   }
 
-  NAN_INLINE void NanSetInternalFieldPointer(
+  NAN_INLINE void SetInternalFieldPointer(
       v8::Handle<v8::Object> object
     , int index
     , void* value) {
@@ -960,47 +960,47 @@ class NanUtf8String {
 # define NAN_GC_CALLBACK(name)                                                 \
     void name(v8::GCType type, v8::GCCallbackFlags flags)
 
-  NAN_INLINE void NanAddGCEpilogueCallback(
+  NAN_INLINE void AddGCEpilogueCallback(
     v8::GCEpilogueCallback callback
   , v8::GCType gc_type_filter = v8::kGCTypeAll) {
     v8::V8::AddGCEpilogueCallback(callback, gc_type_filter);
   }
-  NAN_INLINE void NanRemoveGCEpilogueCallback(
+  NAN_INLINE void RemoveGCEpilogueCallback(
     v8::GCEpilogueCallback callback) {
     v8::V8::RemoveGCEpilogueCallback(callback);
   }
-  NAN_INLINE void NanAddGCPrologueCallback(
+  NAN_INLINE void AddGCPrologueCallback(
     v8::GCPrologueCallback callback
   , v8::GCType gc_type_filter = v8::kGCTypeAll) {
     v8::V8::AddGCPrologueCallback(callback, gc_type_filter);
   }
-  NAN_INLINE void NanRemoveGCPrologueCallback(
+  NAN_INLINE void RemoveGCPrologueCallback(
     v8::GCPrologueCallback callback) {
     v8::V8::RemoveGCPrologueCallback(callback);
   }
-  NAN_INLINE void NanGetHeapStatistics(
+  NAN_INLINE void GetHeapStatistics(
     v8::HeapStatistics *heap_statistics) {
     v8::V8::GetHeapStatistics(heap_statistics);
   }
 
 # define X(NAME)                                                               \
-    NAN_INLINE v8::Local<v8::Value> Nan ## NAME(const char *msg) {             \
-      NanEscapableScope scope;                                                 \
-      return scope.Escape(v8::Exception::NAME(NanNew(msg).ToLocalChecked()));  \
+    NAN_INLINE v8::Local<v8::Value> NAME(const char *msg) {                    \
+      EscapableScope scope;                                                    \
+      return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked()));     \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    v8::Local<v8::Value> Nan ## NAME(v8::Handle<v8::String> msg) {             \
+    v8::Local<v8::Value> NAME(v8::Handle<v8::String> msg) {                    \
       return v8::Exception::NAME(msg);                                         \
     }                                                                          \
                                                                                \
-    NAN_INLINE void NanThrow ## NAME(const char *msg) {                        \
-      NanScope scope;                                                          \
-      v8::ThrowException(v8::Exception::NAME(NanNew(msg).ToLocalChecked()));   \
+    NAN_INLINE void Throw ## NAME(const char *msg) {                           \
+      Scope scope;                                                             \
+      v8::ThrowException(v8::Exception::NAME(New(msg).ToLocalChecked()));      \
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    void NanThrow ## NAME(v8::Handle<v8::String> errmsg) {                     \
+    void Throw ## NAME(v8::Handle<v8::String> errmsg) {                        \
       v8::ThrowException(v8::Exception::NAME(errmsg));                         \
     }
 
@@ -1012,48 +1012,48 @@ class NanUtf8String {
 
 # undef X
 
-  NAN_INLINE void NanThrowError(v8::Handle<v8::Value> error) {
+  NAN_INLINE void ThrowError(v8::Handle<v8::Value> error) {
     v8::ThrowException(error);
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(
+  NAN_INLINE MaybeLocal<v8::Object> NewBuffer(
       char *data
     , size_t length
     , node::Buffer::free_callback callback
     , void *hint
   ) {
-    NanScope scope;
+    Scope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(length <= Nan::imp::kMaxLength && "too large buffer");
-    return NanMaybeLocal<v8::Object>(
-        NanNew(node::Buffer::New(data, length, callback, hint)->handle_));
+    assert(length <= imp::kMaxLength && "too large buffer");
+    return MaybeLocal<v8::Object>(
+        New(node::Buffer::New(data, length, callback, hint)->handle_));
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Object> NanCopyBuffer(
+  NAN_INLINE MaybeLocal<v8::Object> CopyBuffer(
       const char *data
     , uint32_t size
   ) {
-    NanEscapableScope scope;
+    EscapableScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= Nan::imp::kMaxLength && "too large buffer");
+    assert(size <= imp::kMaxLength && "too large buffer");
 #if NODE_MODULE_VERSION >= NODE_0_10_MODULE_VERSION
-    return NanMaybeLocal<v8::Object>(
-        scope.Escape(NanNew(node::Buffer::New(data, size)->handle_)));
+    return MaybeLocal<v8::Object>(
+        scope.Escape(New(node::Buffer::New(data, size)->handle_)));
 #else
-    return NanMaybeLocal<v8::Object>(scope.Escape(
-        NanNew(node::Buffer::New(const_cast<char*>(data), size)->handle_)));
+    return MaybeLocal<v8::Object>(scope.Escape(
+        New(node::Buffer::New(const_cast<char*>(data), size)->handle_)));
 #endif
   }
 
-  NAN_INLINE NanMaybeLocal<v8::Object> NanNewBuffer(uint32_t size) {
+  NAN_INLINE MaybeLocal<v8::Object> NewBuffer(uint32_t size) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    NanEscapableScope scope;
-    assert(size <= Nan::imp::kMaxLength && "too large buffer");
-    return NanMaybeLocal<v8::Object>(
-        scope.Escape(NanNew(node::Buffer::New(size)->handle_)));
+    EscapableScope scope;
+    assert(size <= imp::kMaxLength && "too large buffer");
+    return MaybeLocal<v8::Object>(
+        scope.Escape(New(node::Buffer::New(size)->handle_)));
   }
 
   NAN_INLINE void FreeData(char *data, void *hint) {
@@ -1061,19 +1061,19 @@ class NanUtf8String {
     delete[] data;
   }
 
-  NAN_INLINE v8::Local<v8::Object> NanNewBuffer(
+  NAN_INLINE v8::Local<v8::Object> NewBuffer(
       char* data
     , uint32_t size
   ) {
-    NanEscapableScope scope;
+    EscapableScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    assert(size <= Nan::imp::kMaxLength && "too large buffer");
-    return scope.Escape(NanNew(
+    assert(size <= imp::kMaxLength && "too large buffer");
+    return scope.Escape(New(
         node::Buffer::New(data, size, FreeData, NULL)->handle_));
   }
 
-  NAN_INLINE bool NanHasInstance(
+  NAN_INLINE bool HasInstance(
       const v8::Persistent<v8::FunctionTemplate>& function_template
     , v8::Handle<v8::Value> value
   ) {
@@ -1093,58 +1093,58 @@ widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
 }
 }  // end of namespace imp
 
-  NAN_INLINE NanMaybeLocal<v8::String>
-  NanNewOneByteString(const uint8_t * value, int length = -1) {
+  NAN_INLINE MaybeLocal<v8::String>
+  NewOneByteString(const uint8_t * value, int length = -1) {
     std::vector<uint16_t> wideString;  // NOLINT(build/include_what_you_use)
-    Nan::imp::widenString(&wideString, value, length);
+    imp::widenString(&wideString, value, length);
     return imp::Factory<v8::String>::return_t(v8::String::New(
         &wideString.front(), static_cast<int>(wideString.size())));
   }
 
-  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+  NAN_INLINE MaybeLocal<BoundScript> CompileScript(
       v8::Local<v8::String> s
     , const v8::ScriptOrigin& origin
   ) {
-    return NanMaybeLocal<NanBoundScript>(
+    return MaybeLocal<BoundScript>(
         v8::Script::Compile(s, const_cast<v8::ScriptOrigin *>(&origin)));
   }
 
-  NAN_INLINE NanMaybeLocal<NanBoundScript> NanCompileScript(
+  NAN_INLINE MaybeLocal<BoundScript> CompileScript(
     v8::Local<v8::String> s
   ) {
-    return NanMaybeLocal<NanBoundScript>(v8::Script::Compile(s));
+    return MaybeLocal<BoundScript>(v8::Script::Compile(s));
   }
 
   NAN_INLINE
-  NanMaybeLocal<v8::Value> NanRunScript(v8::Handle<v8::Script> script) {
-    return NanMaybeLocal<v8::Value>(script->Run());
+  MaybeLocal<v8::Value> RunScript(v8::Handle<v8::Script> script) {
+    return MaybeLocal<v8::Value>(script->Run());
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
+  NAN_INLINE v8::Local<v8::Value> MakeCallback(
       v8::Handle<v8::Object> target
     , v8::Handle<v8::Function> func
     , int argc
     , v8::Handle<v8::Value>* argv) {
-    return NanNew(node::MakeCallback(target, func, argc, argv));
+    return New(node::MakeCallback(target, func, argc, argv));
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
+  NAN_INLINE v8::Local<v8::Value> MakeCallback(
       v8::Handle<v8::Object> target
     , v8::Handle<v8::String> symbol
     , int argc
     , v8::Handle<v8::Value>* argv) {
-    return NanNew(node::MakeCallback(target, symbol, argc, argv));
+    return New(node::MakeCallback(target, symbol, argc, argv));
   }
 
-  NAN_INLINE v8::Local<v8::Value> NanMakeCallback(
+  NAN_INLINE v8::Local<v8::Value> MakeCallback(
       v8::Handle<v8::Object> target
     , const char* method
     , int argc
     , v8::Handle<v8::Value>* argv) {
-    return NanNew(node::MakeCallback(target, method, argc, argv));
+    return New(node::MakeCallback(target, method, argc, argv));
   }
 
-  NAN_INLINE void NanFatalException(const NanTryCatch& try_catch) {
+  NAN_INLINE void FatalException(const TryCatch& try_catch) {
     node::FatalException(const_cast<v8::TryCatch &>(try_catch.try_catch_));
   }
 
@@ -1158,7 +1158,7 @@ widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
 
 
   template<typename T>
-  NAN_INLINE void NanSetIsolateData(
+  NAN_INLINE void SetIsolateData(
       v8::Isolate *isolate
     , T *data
   ) {
@@ -1166,15 +1166,15 @@ widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
   }
 
   template<typename T>
-  NAN_INLINE T *NanGetIsolateData(
+  NAN_INLINE T *GetIsolateData(
       v8::Isolate *isolate
   ) {
       return static_cast<T*>(isolate->GetData());
   }
 
-class NanUtf8String {
+class Utf8String {
  public:
-  NAN_INLINE explicit NanUtf8String(v8::Handle<v8::Value> from) :
+  NAN_INLINE explicit Utf8String(v8::Handle<v8::Value> from) :
       length_(0), str_(str_st_) {
     if (!from.IsEmpty()) {
       v8::Local<v8::String> string = from->ToString();
@@ -1200,14 +1200,14 @@ class NanUtf8String {
   NAN_INLINE char* operator*() { return str_; }
   NAN_INLINE const char* operator*() const { return str_; }
 
-  NAN_INLINE ~NanUtf8String() {
+  NAN_INLINE ~Utf8String() {
     if (str_ != str_st_) {
       free(str_);
     }
   }
 
  private:
-  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanUtf8String)
+  NAN_DISALLOW_ASSIGN_COPY_MOVE(Utf8String)
 
   int length_;
   char *str_;
@@ -1216,52 +1216,52 @@ class NanUtf8String {
 
 #endif  // NODE_MODULE_VERSION
 
-typedef void (*NanFreeCallback)(char *data, void *hint);
+typedef void (*FreeCallback)(char *data, void *hint);
 
-typedef const NanFunctionCallbackInfo<v8::Value>& NAN_METHOD_ARGS_TYPE;
+typedef const FunctionCallbackInfo<v8::Value>& NAN_METHOD_ARGS_TYPE;
 typedef void NAN_METHOD_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Value>& NAN_GETTER_ARGS_TYPE;
+typedef const PropertyCallbackInfo<v8::Value>& NAN_GETTER_ARGS_TYPE;
 typedef void NAN_GETTER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<void>& NAN_SETTER_ARGS_TYPE;
+typedef const PropertyCallbackInfo<void>& NAN_SETTER_ARGS_TYPE;
 typedef void NAN_SETTER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Value>&
+typedef const PropertyCallbackInfo<v8::Value>&
     NAN_PROPERTY_GETTER_ARGS_TYPE;
 typedef void NAN_PROPERTY_GETTER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Value>&
+typedef const PropertyCallbackInfo<v8::Value>&
     NAN_PROPERTY_SETTER_ARGS_TYPE;
 typedef void NAN_PROPERTY_SETTER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Array>&
+typedef const PropertyCallbackInfo<v8::Array>&
     NAN_PROPERTY_ENUMERATOR_ARGS_TYPE;
 typedef void NAN_PROPERTY_ENUMERATOR_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Boolean>&
+typedef const PropertyCallbackInfo<v8::Boolean>&
     NAN_PROPERTY_DELETER_ARGS_TYPE;
 typedef void NAN_PROPERTY_DELETER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Integer>&
+typedef const PropertyCallbackInfo<v8::Integer>&
     NAN_PROPERTY_QUERY_ARGS_TYPE;
 typedef void NAN_PROPERTY_QUERY_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Value>& NAN_INDEX_GETTER_ARGS_TYPE;
+typedef const PropertyCallbackInfo<v8::Value>& NAN_INDEX_GETTER_ARGS_TYPE;
 typedef void NAN_INDEX_GETTER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Value>& NAN_INDEX_SETTER_ARGS_TYPE;
+typedef const PropertyCallbackInfo<v8::Value>& NAN_INDEX_SETTER_ARGS_TYPE;
 typedef void NAN_INDEX_SETTER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Array>&
+typedef const PropertyCallbackInfo<v8::Array>&
     NAN_INDEX_ENUMERATOR_ARGS_TYPE;
 typedef void NAN_INDEX_ENUMERATOR_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Boolean>&
+typedef const PropertyCallbackInfo<v8::Boolean>&
     NAN_INDEX_DELETER_ARGS_TYPE;
 typedef void NAN_INDEX_DELETER_RETURN_TYPE;
 
-typedef const NanPropertyCallbackInfo<v8::Integer>&
+typedef const PropertyCallbackInfo<v8::Integer>&
     NAN_INDEX_QUERY_ARGS_TYPE;
 typedef void NAN_INDEX_QUERY_RETURN_TYPE;
 
@@ -1315,34 +1315,34 @@ typedef void NAN_INDEX_QUERY_RETURN_TYPE;
         uint32_t index                                                         \
       , NAN_INDEX_QUERY_ARGS_TYPE info)
 
-class NanCallback {
+class Callback {
  public:
-  NanCallback() {
-    NanScope scope;
-    v8::Local<v8::Object> obj = NanNew<v8::Object>();
+  Callback() {
+    Scope scope;
+    v8::Local<v8::Object> obj = New<v8::Object>();
     handle.Reset(obj);
   }
 
-  explicit NanCallback(const v8::Handle<v8::Function> &fn) {
-    NanScope scope;
-    v8::Local<v8::Object> obj = NanNew<v8::Object>();
+  explicit Callback(const v8::Handle<v8::Function> &fn) {
+    Scope scope;
+    v8::Local<v8::Object> obj = New<v8::Object>();
     handle.Reset(obj);
     SetFunction(fn);
   }
 
-  ~NanCallback() {
+  ~Callback() {
     if (handle.IsEmpty()) return;
     handle.Reset();
   }
 
-  bool operator==(const NanCallback &other) const {
-    NanScope scope;
-    v8::Local<v8::Value> a = NanNew(handle)->Get(kCallbackIndex);
-    v8::Local<v8::Value> b = NanNew(other.handle)->Get(kCallbackIndex);
+  bool operator==(const Callback &other) const {
+    Scope scope;
+    v8::Local<v8::Value> a = New(handle)->Get(kCallbackIndex);
+    v8::Local<v8::Value> b = New(other.handle)->Get(kCallbackIndex);
     return a->StrictEquals(b);
   }
 
-  bool operator!=(const NanCallback &other) const {
+  bool operator!=(const Callback &other) const {
     return !this->operator==(other);
   }
 
@@ -1363,19 +1363,19 @@ class NanCallback {
   }
 
   NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
-    NanScope scope;
-    NanSet(NanNew(handle), kCallbackIndex, fn);
+    Scope scope;
+    Set(New(handle), kCallbackIndex, fn);
   }
 
   NAN_INLINE v8::Local<v8::Function> GetFunction() const {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(handle)->Get(kCallbackIndex)
+    EscapableScope scope;
+    return scope.Escape(New(handle)->Get(kCallbackIndex)
         .As<v8::Function>());
   }
 
   NAN_INLINE bool IsEmpty() const {
-    NanScope scope;
-    return NanNew(handle)->Get(kCallbackIndex)->IsUndefined();
+    Scope scope;
+    return New(handle)->Get(kCallbackIndex)->IsUndefined();
   }
 
   NAN_INLINE v8::Local<v8::Value>
@@ -1401,8 +1401,8 @@ class NanCallback {
   }
 
  private:
-  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanCallback)
-  NanPersistent<v8::Object> handle;
+  NAN_DISALLOW_ASSIGN_COPY_MOVE(Callback)
+  Persistent<v8::Object> handle;
   static const uint32_t kCallbackIndex = 0;
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
@@ -1410,11 +1410,11 @@ class NanCallback {
                            , v8::Handle<v8::Object> target
                            , int argc
                            , v8::Handle<v8::Value> argv[]) const {
-    NanEscapableScope scope;
+    EscapableScope scope;
 
-    v8::Local<v8::Function> callback = NanNew(handle)->
+    v8::Local<v8::Function> callback = New(handle)->
         Get(kCallbackIndex).As<v8::Function>();
-    return scope.Escape(imp::NanEnsureLocal(node::MakeCallback(
+    return scope.Escape(imp::EnsureLocal(node::MakeCallback(
         isolate
       , target
       , callback
@@ -1426,11 +1426,11 @@ class NanCallback {
   v8::Local<v8::Value> Call_(v8::Handle<v8::Object> target
                            , int argc
                            , v8::Handle<v8::Value> argv[]) const {
-    NanEscapableScope scope;
+    EscapableScope scope;
 
-    v8::Local<v8::Function> callback = NanNew(handle)->
+    v8::Local<v8::Function> callback = New(handle)->
         Get(kCallbackIndex).As<v8::Function>();
-    return scope.Escape(imp::NanEnsureLocal(node::MakeCallback(
+    return scope.Escape(imp::EnsureLocal(node::MakeCallback(
         target
       , callback
       , argc
@@ -1440,19 +1440,19 @@ class NanCallback {
 #endif
 };
 
-/* abstract */ class NanAsyncWorker {
+/* abstract */ class AsyncWorker {
  public:
-  explicit NanAsyncWorker(NanCallback *callback_)
+  explicit AsyncWorker(Callback *callback_)
       : callback(callback_), errmsg_(NULL) {
     request.data = this;
 
-    NanScope scope;
-    v8::Local<v8::Object> obj = NanNew<v8::Object>();
+    Scope scope;
+    v8::Local<v8::Object> obj = New<v8::Object>();
     persistentHandle.Reset(obj);
   }
 
-  virtual ~NanAsyncWorker() {
-    NanScope scope;
+  virtual ~AsyncWorker() {
+    Scope scope;
 
     if (!persistentHandle.IsEmpty())
       persistentHandle.Reset();
@@ -1463,7 +1463,7 @@ class NanCallback {
   }
 
   virtual void WorkComplete() {
-    NanScope scope;
+    Scope scope;
 
     if (errmsg_ == NULL)
       HandleOKCallback();
@@ -1475,37 +1475,37 @@ class NanCallback {
 
   NAN_INLINE void SaveToPersistent(
       const char *key, const v8::Local<v8::Value> &value) {
-    NanScope scope;
-    NanNew(persistentHandle)->Set(NanNew(key).ToLocalChecked(), value);
+    Scope scope;
+    New(persistentHandle)->Set(New(key).ToLocalChecked(), value);
   }
 
   NAN_INLINE void SaveToPersistent(
       const v8::Handle<v8::String> &key, const v8::Local<v8::Value> &value) {
-    NanScope scope;
-    NanNew(persistentHandle)->Set(key, value);
+    Scope scope;
+    New(persistentHandle)->Set(key, value);
   }
 
   NAN_INLINE void SaveToPersistent(
       uint32_t index, const v8::Local<v8::Value> &value) {
-    NanScope scope;
-    NanNew(persistentHandle)->Set(index, value);
+    Scope scope;
+    New(persistentHandle)->Set(index, value);
   }
 
   NAN_INLINE v8::Local<v8::Value> GetFromPersistent(const char *key) const {
-    NanEscapableScope scope;
+    EscapableScope scope;
     return scope.Escape(
-        NanNew(persistentHandle)->Get(NanNew(key).ToLocalChecked()));
+        New(persistentHandle)->Get(New(key).ToLocalChecked()));
   }
 
   NAN_INLINE v8::Local<v8::Object>
   GetFromPersistent(const v8::Local<v8::String> &key) const {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(persistentHandle)->Get(key));
+    EscapableScope scope;
+    return scope.Escape(New(persistentHandle)->Get(key));
   }
 
   NAN_INLINE v8::Local<v8::Value> GetFromPersistent(uint32_t index) const {
-    NanEscapableScope scope;
-    return scope.Escape(NanNew(persistentHandle)->Get(index));
+    EscapableScope scope;
+    return scope.Escape(New(persistentHandle)->Get(index));
   }
 
   virtual void Execute() = 0;
@@ -1517,18 +1517,18 @@ class NanCallback {
   }
 
  protected:
-  NanPersistent<v8::Object> persistentHandle;
-  NanCallback *callback;
+  Persistent<v8::Object> persistentHandle;
+  Callback *callback;
 
   virtual void HandleOKCallback() {
     callback->Call(0, NULL);
   }
 
   virtual void HandleErrorCallback() {
-    NanScope scope;
+    Scope scope;
 
     v8::Local<v8::Value> argv[] = {
-      v8::Exception::Error(NanNew<v8::String>(ErrorMessage()).ToLocalChecked())
+      v8::Exception::Error(New<v8::String>(ErrorMessage()).ToLocalChecked())
     };
     callback->Call(1, argv);
   }
@@ -1548,14 +1548,14 @@ class NanCallback {
   }
 
  private:
-  NAN_DISALLOW_ASSIGN_COPY_MOVE(NanAsyncWorker)
+  NAN_DISALLOW_ASSIGN_COPY_MOVE(AsyncWorker)
   char *errmsg_;
 };
 
-/* abstract */ class NanAsyncProgressWorker : public NanAsyncWorker {
+/* abstract */ class AsyncProgressWorker : public AsyncWorker {
  public:
-  explicit NanAsyncProgressWorker(NanCallback *callback_)
-      : NanAsyncWorker(callback_), asyncdata_(NULL), asyncsize_(0) {
+  explicit AsyncProgressWorker(Callback *callback_)
+      : AsyncWorker(callback_), asyncdata_(NULL), asyncsize_(0) {
     async = new uv_async_t;
     uv_async_init(
         uv_default_loop()
@@ -1567,7 +1567,7 @@ class NanCallback {
     uv_mutex_init(&async_lock);
   }
 
-  virtual ~NanAsyncProgressWorker() {
+  virtual ~AsyncProgressWorker() {
     uv_mutex_destroy(&async_lock);
 
     if (asyncdata_) {
@@ -1590,7 +1590,7 @@ class NanCallback {
   }
 
   class ExecutionProgress {
-    friend class NanAsyncProgressWorker;
+    friend class AsyncProgressWorker;
    public:
     // You could do fancy generics with templates here.
     void Send(const char* data, size_t size) const {
@@ -1598,9 +1598,9 @@ class NanCallback {
     }
 
    private:
-    explicit ExecutionProgress(NanAsyncProgressWorker* that) : that_(that) {}
+    explicit ExecutionProgress(AsyncProgressWorker* that) : that_(that) {}
     NAN_DISALLOW_ASSIGN_COPY_MOVE(ExecutionProgress)
-    NanAsyncProgressWorker* const that_;
+    AsyncProgressWorker* const that_;
   };
 
   virtual void Execute(const ExecutionProgress& progress) = 0;
@@ -1633,14 +1633,14 @@ class NanCallback {
   }
 
   NAN_INLINE static NAUV_WORK_CB(AsyncProgress_) {
-    NanAsyncProgressWorker *worker =
-            static_cast<NanAsyncProgressWorker*>(async->data);
+    AsyncProgressWorker *worker =
+            static_cast<AsyncProgressWorker*>(async->data);
     worker->WorkProgress();
   }
 
   NAN_INLINE static void AsyncClose_(uv_handle_t* handle) {
-    NanAsyncProgressWorker *worker =
-            static_cast<NanAsyncProgressWorker*>(handle->data);
+    AsyncProgressWorker *worker =
+            static_cast<AsyncProgressWorker*>(handle->data);
     delete reinterpret_cast<uv_async_t*>(handle);
     delete worker;
   }
@@ -1651,30 +1651,30 @@ class NanCallback {
   size_t asyncsize_;
 };
 
-NAN_INLINE void NanAsyncExecute (uv_work_t* req) {
-  NanAsyncWorker *worker = static_cast<NanAsyncWorker*>(req->data);
+NAN_INLINE void AsyncExecute (uv_work_t* req) {
+  AsyncWorker *worker = static_cast<AsyncWorker*>(req->data);
   worker->Execute();
 }
 
-NAN_INLINE void NanAsyncExecuteComplete (uv_work_t* req) {
-  NanAsyncWorker* worker = static_cast<NanAsyncWorker*>(req->data);
+NAN_INLINE void AsyncExecuteComplete (uv_work_t* req) {
+  AsyncWorker* worker = static_cast<AsyncWorker*>(req->data);
   worker->WorkComplete();
   worker->Destroy();
 }
 
-NAN_INLINE void NanAsyncQueueWorker (NanAsyncWorker* worker) {
+NAN_INLINE void AsyncQueueWorker (AsyncWorker* worker) {
   uv_queue_work(
       uv_default_loop()
     , &worker->request
-    , NanAsyncExecute
-    , (uv_after_work_cb)NanAsyncExecuteComplete
+    , AsyncExecute
+    , (uv_after_work_cb)AsyncExecuteComplete
   );
 }
 
 namespace imp {
 
 inline
-NanExternalOneByteStringResource const*
+ExternalOneByteStringResource const*
 GetExternalResource(v8::Local<v8::String> str) {
 #if NODE_MODULE_VERSION < ATOM_0_21_MODULE_VERSION
     return str->GetExternalAsciiStringResource();
@@ -1701,7 +1701,7 @@ enum Encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER};
 # include "nan_string_bytes.h"  // NOLINT(build/include)
 #endif
 
-NAN_INLINE v8::Local<v8::Value> NanEncode(
+NAN_INLINE v8::Local<v8::Value> Encode(
     const void *buf, size_t len, enum Encoding encoding = BINARY) {
 #if (NODE_MODULE_VERSION >= ATOM_0_21_MODULE_VERSION)
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
@@ -1733,7 +1733,7 @@ NAN_INLINE v8::Local<v8::Value> NanEncode(
 #endif
 }
 
-NAN_INLINE ssize_t NanDecodeBytes(
+NAN_INLINE ssize_t DecodeBytes(
     v8::Handle<v8::Value> val, enum Encoding encoding = BINARY) {
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
   return node::DecodeBytes(
@@ -1750,7 +1750,7 @@ NAN_INLINE ssize_t NanDecodeBytes(
 #endif
 }
 
-NAN_INLINE ssize_t NanDecodeWrite(
+NAN_INLINE ssize_t DecodeWrite(
     char *buf
   , size_t len
   , v8::Handle<v8::Value> val
@@ -1776,98 +1776,98 @@ NAN_INLINE ssize_t NanDecodeWrite(
 #endif
 }
 
-NAN_INLINE void NanSetPrototypeTemplate(
+NAN_INLINE void SetPrototypeTemplate(
     v8::Local<v8::FunctionTemplate> templ
   , const char *name
   , v8::Handle<v8::Data> value
 ) {
-  NanSetTemplate(templ->PrototypeTemplate(), name, value);
+  SetTemplate(templ->PrototypeTemplate(), name, value);
 }
 
-NAN_INLINE void NanSetPrototypeTemplate(
+NAN_INLINE void SetPrototypeTemplate(
     v8::Local<v8::FunctionTemplate> templ
   , v8::Handle<v8::String> name
   , v8::Handle<v8::Data> value
   , v8::PropertyAttribute attributes
 ) {
-  NanSetTemplate(templ->PrototypeTemplate(), name, value, attributes);
+  SetTemplate(templ->PrototypeTemplate(), name, value, attributes);
 }
 
-NAN_INLINE void NanSetInstanceTemplate(
+NAN_INLINE void SetInstanceTemplate(
     v8::Local<v8::FunctionTemplate> templ
   , const char *name
   , v8::Handle<v8::Data> value
 ) {
-  NanSetTemplate(templ->InstanceTemplate(), name, value);
+  SetTemplate(templ->InstanceTemplate(), name, value);
 }
 
-NAN_INLINE void NanSetInstanceTemplate(
+NAN_INLINE void SetInstanceTemplate(
     v8::Local<v8::FunctionTemplate> templ
   , v8::Handle<v8::String> name
   , v8::Handle<v8::Data> value
   , v8::PropertyAttribute attributes
 ) {
-  NanSetTemplate(templ->InstanceTemplate(), name, value, attributes);
+  SetTemplate(templ->InstanceTemplate(), name, value, attributes);
 }
 
 template<typename T>
-NAN_INLINE void NanSetMethod(
+NAN_INLINE void SetMethod(
     const T &recv
   , const char *name
-  , NanFunctionCallback callback) {
-  NanScope scope;
-  v8::Local<v8::Function> fn = NanNew<v8::FunctionTemplate>(
+  , FunctionCallback callback) {
+  Scope scope;
+  v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
       callback)->GetFunction();
-  v8::Local<v8::String> fn_name = NanNew(name);
+  v8::Local<v8::String> fn_name = New(name);
   fn->SetName(fn_name);
   recv->Set(fn_name, fn);
 }
 
-NAN_INLINE void NanSetPrototypeMethod(
+NAN_INLINE void SetPrototypeMethod(
     v8::Handle<v8::FunctionTemplate> recv
-  , const char* name, NanFunctionCallback callback) {
-  NanScope scope;
-  v8::Local<v8::Function> fn = NanNew<v8::FunctionTemplate>(
+  , const char* name, FunctionCallback callback) {
+  Scope scope;
+  v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
       callback
     , v8::Handle<v8::Value>()
-    , NanNew<v8::Signature>(recv))->GetFunction();
-  v8::Local<v8::String> fn_name = NanNew(name).ToLocalChecked();
+    , New<v8::Signature>(recv))->GetFunction();
+  v8::Local<v8::String> fn_name = New(name).ToLocalChecked();
   recv->PrototypeTemplate()->Set(fn_name, fn);
   fn->SetName(fn_name);
 }
 
 //=== Accessors and Such =======================================================
 
-inline void NanSetAccessor(
+inline void SetAccessor(
     v8::Handle<v8::ObjectTemplate> tpl
   , v8::Handle<v8::String> name
-  , NanGetterCallback getter
-  , NanSetterCallback setter = 0
+  , GetterCallback getter
+  , SetterCallback setter = 0
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
   , v8::AccessControl settings = v8::DEFAULT
   , v8::PropertyAttribute attribute = v8::None
   , imp::Sig signature = imp::Sig()) {
-  NanScope scope;
+  Scope scope;
 
   imp::NativeGetter getter_ =
       imp::GetterCallbackWrapper;
   imp::NativeSetter setter_ =
       setter ? imp::SetterCallbackWrapper : 0;
 
-  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>();
   otpl->SetInternalFieldCount(imp::kAccessorFieldCount);
   v8::Local<v8::Object> obj = otpl->NewInstance();
-  NanSetInternalFieldPointer(
+  SetInternalFieldPointer(
       obj
     , imp::kGetterIndex
-    , imp::GetWrapper<NanGetterCallback, imp::GetterWrapper>(getter));
-  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+    , imp::GetWrapper<GetterCallback, imp::GetterWrapper>(getter));
+  v8::Local<v8::Value> val = New<v8::Value>(data);
 
   if (setter != 0) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kSetterIndex
-      , imp::GetWrapper<NanSetterCallback,
+      , imp::GetWrapper<SetterCallback,
             imp::SetterWrapper>(setter));
   }
 
@@ -1885,39 +1885,39 @@ inline void NanSetAccessor(
     , signature);
 }
 
-inline bool NanSetAccessor(
+inline bool SetAccessor(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> name
-  , NanGetterCallback getter
-  , NanSetterCallback setter = 0
+  , GetterCallback getter
+  , SetterCallback setter = 0
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
   , v8::AccessControl settings = v8::DEFAULT
   , v8::PropertyAttribute attribute = v8::None) {
-  NanEscapableScope scope;
+  EscapableScope scope;
 
   imp::NativeGetter getter_ =
       imp::GetterCallbackWrapper;
   imp::NativeSetter setter_ =
       setter ? imp::SetterCallbackWrapper : 0;
 
-  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>();
   otpl->SetInternalFieldCount(imp::kAccessorFieldCount);
   v8::Local<v8::Object> dataobj = otpl->NewInstance();
-  NanSetInternalFieldPointer(
+  SetInternalFieldPointer(
       dataobj
     , imp::kGetterIndex
-    , imp::GetWrapper<NanGetterCallback, imp::GetterWrapper>(getter));
-  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+    , imp::GetWrapper<GetterCallback, imp::GetterWrapper>(getter));
+  v8::Local<v8::Value> val = New<v8::Value>(data);
 
   if (!val.IsEmpty()) {
     dataobj->SetInternalField(imp::kDataIndex, val);
   }
 
   if (setter) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         dataobj
       , imp::kPropertySetterIndex
-      , imp::GetWrapper<NanSetterCallback,
+      , imp::GetWrapper<SetterCallback,
             imp::SetterWrapper>(setter));
   }
 
@@ -1930,15 +1930,15 @@ inline bool NanSetAccessor(
     , attribute);
 }
 
-inline void NanSetNamedPropertyHandler(
+inline void SetNamedPropertyHandler(
     v8::Handle<v8::ObjectTemplate> tpl
-  , NanPropertyGetterCallback getter
-  , NanPropertySetterCallback setter = 0
-  , NanPropertyQueryCallback query = 0
-  , NanPropertyDeleterCallback deleter = 0
-  , NanPropertyEnumeratorCallback enumerator = 0
+  , PropertyGetterCallback getter
+  , PropertySetterCallback setter = 0
+  , PropertyQueryCallback query = 0
+  , PropertyDeleterCallback deleter = 0
+  , PropertyEnumeratorCallback enumerator = 0
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
-  NanScope scope;
+  Scope scope;
 
   imp::NativePropertyGetter getter_ =
       imp::PropertyGetterCallbackWrapper;
@@ -1951,45 +1951,45 @@ inline void NanSetNamedPropertyHandler(
   imp::NativePropertyEnumerator enumerator_ =
       enumerator ? imp::PropertyEnumeratorCallbackWrapper : 0;
 
-  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>();
   otpl->SetInternalFieldCount(imp::kPropertyFieldCount);
   v8::Local<v8::Object> obj = otpl->NewInstance();
-  NanSetInternalFieldPointer(
+  SetInternalFieldPointer(
       obj
     , imp::kPropertyGetterIndex
-    , imp::GetWrapper<NanPropertyGetterCallback,
+    , imp::GetWrapper<PropertyGetterCallback,
           imp::PropertyGetterWrapper>(getter));
-  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+  v8::Local<v8::Value> val = New<v8::Value>(data);
 
   if (setter) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kPropertySetterIndex
-      , imp::GetWrapper<NanPropertySetterCallback,
+      , imp::GetWrapper<PropertySetterCallback,
             imp::PropertySetterWrapper>(setter));
   }
 
   if (query) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kPropertyQueryIndex
-      , imp::GetWrapper<NanPropertyQueryCallback,
+      , imp::GetWrapper<PropertyQueryCallback,
             imp::PropertyQueryWrapper>(query));
   }
 
   if (deleter) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kPropertyDeleterIndex
-      , imp::GetWrapper<NanPropertyDeleterCallback,
+      , imp::GetWrapper<PropertyDeleterCallback,
             imp::PropertyDeleterWrapper>(deleter));
   }
 
   if (enumerator) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kPropertyEnumeratorIndex
-      , imp::GetWrapper<NanPropertyEnumeratorCallback,
+      , imp::GetWrapper<PropertyEnumeratorCallback,
             imp::PropertyEnumeratorWrapper>(enumerator));
   }
 
@@ -2011,15 +2011,15 @@ inline void NanSetNamedPropertyHandler(
 #endif
 }
 
-inline void NanSetIndexedPropertyHandler(
+inline void SetIndexedPropertyHandler(
     v8::Handle<v8::ObjectTemplate> tpl
-  , NanIndexGetterCallback getter
-  , NanIndexSetterCallback setter = 0
-  , NanIndexQueryCallback query = 0
-  , NanIndexDeleterCallback deleter = 0
-  , NanIndexEnumeratorCallback enumerator = 0
+  , IndexGetterCallback getter
+  , IndexSetterCallback setter = 0
+  , IndexQueryCallback query = 0
+  , IndexDeleterCallback deleter = 0
+  , IndexEnumeratorCallback enumerator = 0
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
-  NanScope scope;
+  Scope scope;
 
   imp::NativeIndexGetter getter_ =
       imp::IndexGetterCallbackWrapper;
@@ -2032,45 +2032,45 @@ inline void NanSetIndexedPropertyHandler(
   imp::NativeIndexEnumerator enumerator_ =
       enumerator ? imp::IndexEnumeratorCallbackWrapper : 0;
 
-  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>();
   otpl->SetInternalFieldCount(imp::kIndexPropertyFieldCount);
   v8::Local<v8::Object> obj = otpl->NewInstance();
-  NanSetInternalFieldPointer(
+  SetInternalFieldPointer(
       obj
     , imp::kIndexPropertyGetterIndex
-    , imp::GetWrapper<NanIndexGetterCallback,
+    , imp::GetWrapper<IndexGetterCallback,
           imp::IndexGetterWrapper>(getter));
-  v8::Local<v8::Value> val = NanNew<v8::Value>(data);
+  v8::Local<v8::Value> val = New<v8::Value>(data);
 
   if (setter) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kIndexPropertySetterIndex
-      , imp::GetWrapper<NanIndexSetterCallback,
+      , imp::GetWrapper<IndexSetterCallback,
             imp::IndexSetterWrapper>(setter));
   }
 
   if (query) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kIndexPropertyQueryIndex
-      , imp::GetWrapper<NanIndexQueryCallback,
+      , imp::GetWrapper<IndexQueryCallback,
             imp::IndexQueryWrapper>(query));
   }
 
   if (deleter) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kIndexPropertyDeleterIndex
-      , imp::GetWrapper<NanIndexDeleterCallback,
+      , imp::GetWrapper<IndexDeleterCallback,
             imp::IndexDeleterWrapper>(deleter));
   }
 
   if (enumerator) {
-    NanSetInternalFieldPointer(
+    SetInternalFieldPointer(
         obj
       , imp::kIndexPropertyEnumeratorIndex
-      , imp::GetWrapper<NanIndexEnumeratorCallback,
+      , imp::GetWrapper<IndexEnumeratorCallback,
             imp::IndexEnumeratorWrapper>(enumerator));
   }
 
@@ -2094,10 +2094,10 @@ inline void NanSetIndexedPropertyHandler(
 
 //=== ObjectWrap ===============================================================
 
-class NanObjectWrap : public node::ObjectWrap {
+class ObjectWrap : public node::ObjectWrap {
 #if NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION
  public:
-  inline v8::Local<v8::Object> handle() { return NanNew(handle_); }
+  inline v8::Local<v8::Object> handle() { return New(handle_); }
   inline v8::Persistent<v8::Object> &persistent() { return handle_; }
 #endif
 };
@@ -2110,41 +2110,41 @@ class NanObjectWrap : public node::ObjectWrap {
 
 inline
 void
-NanExport(v8::Handle<v8::Object> target, const char *name,
-    NanFunctionCallback f) {
-  NanSet(target, NanNew<v8::String>(name).ToLocalChecked(),
-      NanNew<v8::FunctionTemplate>(f)->GetFunction());
+Export(v8::Handle<v8::Object> target, const char *name,
+    FunctionCallback f) {
+  Set(target, New<v8::String>(name).ToLocalChecked(),
+      New<v8::FunctionTemplate>(f)->GetFunction());
 }
 
 //=== Tap Reverse Binding =====================================================
 
-struct NanTap {
-  explicit NanTap(v8::Handle<v8::Value> t) : t_() {
-    t_.Reset(NanTo<v8::Object>(t).ToLocalChecked());
+struct Tap {
+  explicit Tap(v8::Handle<v8::Value> t) : t_() {
+    t_.Reset(To<v8::Object>(t).ToLocalChecked());
   }
 
-  ~NanTap() { t_.Reset(); }  // not sure if neccessary
+  ~Tap() { t_.Reset(); }  // not sure if neccessary
 
   inline void plan(int i) {
-    v8::Handle<v8::Value> arg = NanNew(i);
-    NanMakeCallback(NanNew(t_), "plan", 1, &arg);
+    v8::Handle<v8::Value> arg = New(i);
+    MakeCallback(New(t_), "plan", 1, &arg);
   }
 
   inline void ok(bool isOk, const char *msg = NULL) {
     v8::Handle<v8::Value> args[2];
-    args[0] = NanNew(isOk);
-    if (msg) args[1] = NanNew(msg).ToLocalChecked();
-    NanMakeCallback(NanNew(t_), "ok", msg ? 2 : 1, args);
+    args[0] = New(isOk);
+    if (msg) args[1] = New(msg).ToLocalChecked();
+    MakeCallback(New(t_), "ok", msg ? 2 : 1, args);
   }
 
   inline void pass(const char * msg = NULL) {
     v8::Handle<v8::Value> hmsg;
-    if (msg) hmsg = NanNew(msg).ToLocalChecked();
-    NanMakeCallback(NanNew(t_), "pass", msg ? 1 : 0, &hmsg);
+    if (msg) hmsg = New(msg).ToLocalChecked();
+    MakeCallback(New(t_), "pass", msg ? 1 : 0, &hmsg);
   }
 
  private:
-  NanPersistent<v8::Object> t_;
+  Persistent<v8::Object> t_;
 };
 
 #define NAN_STRINGIZE2(x) #x
@@ -2152,7 +2152,7 @@ struct NanTap {
 #define NAN_TEST_EXPRESSION(expression) \
   ( expression ), __FILE__ ":" NAN_STRINGIZE(__LINE__) ": " #expression
 
-#define NAN_EXPORT(target, function) NanExport(target, #function, function)
+#define NAN_EXPORT(target, function) Export(target, #function, function)
 
 #undef TYPE_CHECK
 
diff --git a/nan_callbacks.h b/nan_callbacks.h
index e2dccb34..9577eebc 100644
--- a/nan_callbacks.h
+++ b/nan_callbacks.h
@@ -9,56 +9,56 @@
 #ifndef NAN_CALLBACKS_H_
 #define NAN_CALLBACKS_H_
 
-template<typename T> class NanFunctionCallbackInfo;
-template<typename T> class NanPropertyCallbackInfo;
-template<typename T> class NanGlobal;
-
-typedef void(*NanFunctionCallback)(const NanFunctionCallbackInfo<v8::Value>&);
-typedef void(*NanGetterCallback)
-    (v8::Local<v8::String>, const NanPropertyCallbackInfo<v8::Value>&);
-typedef void(*NanSetterCallback)(
+template<typename T> class FunctionCallbackInfo;
+template<typename T> class PropertyCallbackInfo;
+template<typename T> class Global;
+
+typedef void(*FunctionCallback)(const FunctionCallbackInfo<v8::Value>&);
+typedef void(*GetterCallback)
+    (v8::Local<v8::String>, const PropertyCallbackInfo<v8::Value>&);
+typedef void(*SetterCallback)(
     v8::Local<v8::String>,
     v8::Local<v8::Value>,
-    const NanPropertyCallbackInfo<void>&);
-typedef void(*NanPropertyGetterCallback)(
+    const PropertyCallbackInfo<void>&);
+typedef void(*PropertyGetterCallback)(
     v8::Local<v8::String>,
-    const NanPropertyCallbackInfo<v8::Value>&);
-typedef void(*NanPropertySetterCallback)(
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*PropertySetterCallback)(
     v8::Local<v8::String>,
     v8::Local<v8::Value>,
-    const NanPropertyCallbackInfo<v8::Value>&);
-typedef void(*NanPropertyEnumeratorCallback)
-    (const NanPropertyCallbackInfo<v8::Array>&);
-typedef void(*NanPropertyDeleterCallback)(
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*PropertyEnumeratorCallback)
+    (const PropertyCallbackInfo<v8::Array>&);
+typedef void(*PropertyDeleterCallback)(
     v8::Local<v8::String>,
-    const NanPropertyCallbackInfo<v8::Boolean>&);
-typedef void(*NanPropertyQueryCallback)(
+    const PropertyCallbackInfo<v8::Boolean>&);
+typedef void(*PropertyQueryCallback)(
     v8::Local<v8::String>,
-    const NanPropertyCallbackInfo<v8::Integer>&);
-typedef void(*NanIndexGetterCallback)(
+    const PropertyCallbackInfo<v8::Integer>&);
+typedef void(*IndexGetterCallback)(
     uint32_t,
-    const NanPropertyCallbackInfo<v8::Value>&);
-typedef void(*NanIndexSetterCallback)(
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*IndexSetterCallback)(
     uint32_t,
     v8::Local<v8::Value>,
-    const NanPropertyCallbackInfo<v8::Value>&);
-typedef void(*NanIndexEnumeratorCallback)
-    (const NanPropertyCallbackInfo<v8::Array>&);
-typedef void(*NanIndexDeleterCallback)(
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*IndexEnumeratorCallback)
+    (const PropertyCallbackInfo<v8::Array>&);
+typedef void(*IndexDeleterCallback)(
     uint32_t,
-    const NanPropertyCallbackInfo<v8::Boolean>&);
-typedef void(*NanIndexQueryCallback)(
+    const PropertyCallbackInfo<v8::Boolean>&);
+typedef void(*IndexQueryCallback)(
     uint32_t,
-    const NanPropertyCallbackInfo<v8::Integer>&);
+    const PropertyCallbackInfo<v8::Integer>&);
 
 namespace imp {
 typedef v8::Handle<v8::AccessorSignature> Sig;
 
 #define X(NAME)                                                                \
 struct NAME ## Wrapper {                                                       \
-  explicit NAME ## Wrapper(Nan ## NAME ## Callback callback_) :                \
+  explicit NAME ## Wrapper(NAME ## Callback callback_) :                       \
       callback(callback_) {}                                                   \
-  Nan ## NAME ## Callback callback;                                            \
+   NAME ## Callback callback;                                                  \
 };
 
 X(Function)
diff --git a/nan_callbacks_12_inl.h b/nan_callbacks_12_inl.h
index e38d9b8c..da6cbee7 100644
--- a/nan_callbacks_12_inl.h
+++ b/nan_callbacks_12_inl.h
@@ -10,15 +10,15 @@
 #define NAN_CALLBACKS_12_INL_H_
 
 template<typename T>
-class NanReturnValue {
+class ReturnValue {
   v8::ReturnValue<T> value_;
 
  public:
   template <class S>
-  explicit inline NanReturnValue(const v8::ReturnValue<S> &value) :
+  explicit inline ReturnValue(const v8::ReturnValue<S> &value) :
       value_(value) {}
   template <class S>
-  explicit inline NanReturnValue(const NanReturnValue<S>& that)
+  explicit inline ReturnValue(const ReturnValue<S>& that)
       : value_(that.value_) {
     TYPE_CHECK(T, S);
   }
@@ -29,7 +29,7 @@ class NanReturnValue {
     value_.Set(handle);
   }
 
-  template <typename S> inline void Set(const NanGlobal<S> &handle) {
+  template <typename S> inline void Set(const Global<S> &handle) {
     TYPE_CHECK(T, S);
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) &&                       \
@@ -38,7 +38,7 @@ class NanReturnValue {
     value_.Set(handle);
 #else
     value_.Set(*reinterpret_cast<const v8::Persistent<S>*>(&handle));
-    const_cast<NanGlobal<S> &>(handle).Reset();
+    const_cast<Global<S> &>(handle).Reset();
 #endif
   }
 
@@ -90,19 +90,19 @@ class NanReturnValue {
 };
 
 template<typename T>
-class NanFunctionCallbackInfo {
+class FunctionCallbackInfo {
   const v8::FunctionCallbackInfo<T> &info_;
   const v8::Local<v8::Value> data_;
 
  public:
-  explicit inline NanFunctionCallbackInfo(
+  explicit inline FunctionCallbackInfo(
       const v8::FunctionCallbackInfo<T> &info
     , v8::Local<v8::Value> data) :
           info_(info)
         , data_(data) {}
 
-  inline NanReturnValue<T> GetReturnValue() const {
-    return NanReturnValue<T>(info_.GetReturnValue());
+  inline ReturnValue<T> GetReturnValue() const {
+    return ReturnValue<T>(info_.GetReturnValue());
   }
 
   inline v8::Local<v8::Function> Callee() const { return info_.Callee(); }
@@ -127,12 +127,12 @@ class NanFunctionCallbackInfo {
 };
 
 template<typename T>
-class NanPropertyCallbackInfo {
+class PropertyCallbackInfo {
   const v8::PropertyCallbackInfo<T> &info_;
   const v8::Local<v8::Value> data_;
 
  public:
-  explicit inline NanPropertyCallbackInfo(
+  explicit inline PropertyCallbackInfo(
       const v8::PropertyCallbackInfo<T> &info
     , const v8::Local<v8::Value> &data) :
           info_(info)
@@ -142,8 +142,8 @@ class NanPropertyCallbackInfo {
   inline v8::Local<v8::Value> Data() const { return data_; }
   inline v8::Local<v8::Object> This() const { return info_.This(); }
   inline v8::Local<v8::Object> Holder() const { return info_.Holder(); }
-  inline NanReturnValue<T> GetReturnValue() const {
-    return NanReturnValue<T>(info_.GetReturnValue());
+  inline ReturnValue<T> GetReturnValue() const {
+    return ReturnValue<T>(info_.GetReturnValue());
   }
 
  protected:
@@ -162,7 +162,7 @@ void FunctionCallbackWrapper(const v8::FunctionCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
   FunctionWrapper *wrapper = static_cast<FunctionWrapper*>(
       obj->GetAlignedPointerFromInternalField(kFunctionIndex));
-  NanFunctionCallbackInfo<v8::Value>
+  FunctionCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   wrapper->callback(cbinfo);
 }
@@ -175,7 +175,7 @@ void GetterCallbackWrapper(
     v8::Local<v8::Name> property
   , const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   GetterWrapper *wrapper = static_cast<GetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kGetterIndex));
@@ -191,7 +191,7 @@ void SetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::PropertyCallbackInfo<void> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<void>
+  PropertyCallbackInfo<void>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   SetterWrapper *wrapper = static_cast<SetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kSetterIndex));
@@ -208,7 +208,7 @@ void GetterCallbackWrapper(
     v8::Local<v8::String> property
   , const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   GetterWrapper *wrapper = static_cast<GetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kGetterIndex));
@@ -224,7 +224,7 @@ void SetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::PropertyCallbackInfo<void> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<void>
+  PropertyCallbackInfo<void>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   SetterWrapper *wrapper = static_cast<SetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kSetterIndex));
@@ -243,7 +243,7 @@ void PropertyGetterCallbackWrapper(
     v8::Local<v8::Name> property
   , const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyGetterWrapper *wrapper = static_cast<PropertyGetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyGetterIndex));
@@ -259,7 +259,7 @@ void PropertySetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertySetterWrapper *wrapper = static_cast<PropertySetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertySetterIndex));
@@ -275,7 +275,7 @@ static
 void PropertyEnumeratorCallbackWrapper(
     const v8::PropertyCallbackInfo<v8::Array> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Array>
+  PropertyCallbackInfo<v8::Array>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyEnumeratorWrapper *wrapper = static_cast<PropertyEnumeratorWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyEnumeratorIndex));
@@ -290,7 +290,7 @@ void PropertyDeleterCallbackWrapper(
     v8::Local<v8::Name> property
   , const v8::PropertyCallbackInfo<v8::Boolean> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Boolean>
+  PropertyCallbackInfo<v8::Boolean>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyDeleterWrapper *wrapper = static_cast<PropertyDeleterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyDeleterIndex));
@@ -305,7 +305,7 @@ void PropertyQueryCallbackWrapper(
     v8::Local<v8::Name> property
   , const v8::PropertyCallbackInfo<v8::Integer> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Integer>
+  PropertyCallbackInfo<v8::Integer>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyQueryWrapper *wrapper = static_cast<PropertyQueryWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyQueryIndex));
@@ -320,7 +320,7 @@ void PropertyGetterCallbackWrapper(
     v8::Local<v8::String> property
   , const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyGetterWrapper *wrapper = static_cast<PropertyGetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyGetterIndex));
@@ -336,7 +336,7 @@ void PropertySetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertySetterWrapper *wrapper = static_cast<PropertySetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertySetterIndex));
@@ -352,7 +352,7 @@ static
 void PropertyEnumeratorCallbackWrapper(
     const v8::PropertyCallbackInfo<v8::Array> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Array>
+  PropertyCallbackInfo<v8::Array>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyEnumeratorWrapper *wrapper = static_cast<PropertyEnumeratorWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyEnumeratorIndex));
@@ -367,7 +367,7 @@ void PropertyDeleterCallbackWrapper(
     v8::Local<v8::String> property
   , const v8::PropertyCallbackInfo<v8::Boolean> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Boolean>
+  PropertyCallbackInfo<v8::Boolean>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyDeleterWrapper *wrapper = static_cast<PropertyDeleterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyDeleterIndex));
@@ -382,7 +382,7 @@ void PropertyQueryCallbackWrapper(
     v8::Local<v8::String> property
   , const v8::PropertyCallbackInfo<v8::Integer> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Integer>
+  PropertyCallbackInfo<v8::Integer>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyQueryWrapper *wrapper = static_cast<PropertyQueryWrapper*>(
       obj->GetAlignedPointerFromInternalField(kPropertyQueryIndex));
@@ -397,7 +397,7 @@ static
 void IndexGetterCallbackWrapper(
     uint32_t index, const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexGetterWrapper *wrapper = static_cast<IndexGetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kIndexPropertyGetterIndex));
@@ -413,7 +413,7 @@ void IndexSetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::PropertyCallbackInfo<v8::Value> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexSetterWrapper *wrapper = static_cast<IndexSetterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kIndexPropertySetterIndex));
@@ -429,7 +429,7 @@ static
 void IndexEnumeratorCallbackWrapper(
     const v8::PropertyCallbackInfo<v8::Array> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Array>
+  PropertyCallbackInfo<v8::Array>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexEnumeratorWrapper *wrapper = static_cast<IndexEnumeratorWrapper*>(
       obj->GetAlignedPointerFromInternalField(kIndexPropertyEnumeratorIndex));
@@ -443,7 +443,7 @@ static
 void IndexDeleterCallbackWrapper(
     uint32_t index, const v8::PropertyCallbackInfo<v8::Boolean> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Boolean>
+  PropertyCallbackInfo<v8::Boolean>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexDeleterWrapper *wrapper = static_cast<IndexDeleterWrapper*>(
       obj->GetAlignedPointerFromInternalField(kIndexPropertyDeleterIndex));
@@ -457,7 +457,7 @@ static
 void IndexQueryCallbackWrapper(
     uint32_t index, const v8::PropertyCallbackInfo<v8::Integer> &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Integer>
+  PropertyCallbackInfo<v8::Integer>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexQueryWrapper *wrapper = static_cast<IndexQueryWrapper*>(
       obj->GetAlignedPointerFromInternalField(kIndexPropertyQueryIndex));
diff --git a/nan_callbacks_pre_12_inl.h b/nan_callbacks_pre_12_inl.h
index 2477087c..2144038d 100644
--- a/nan_callbacks_pre_12_inl.h
+++ b/nan_callbacks_pre_12_inl.h
@@ -10,21 +10,21 @@
 #define NAN_CALLBACKS_PRE_12_INL_H_
 
 namespace imp {
-template<typename T> class NanReturnValueImp;
+template<typename T> class ReturnValueImp;
 }  // end of namespace imp
 
 template<typename T>
-class NanReturnValue {
+class ReturnValue {
   v8::Isolate *isolate_;
   v8::Persistent<T> *value_;
-  friend class Nan::imp::NanReturnValueImp<T>;
+  friend class imp::ReturnValueImp<T>;
 
  public:
   template <class S>
-  explicit inline NanReturnValue(v8::Isolate *isolate, v8::Persistent<S> *p) :
+  explicit inline ReturnValue(v8::Isolate *isolate, v8::Persistent<S> *p) :
       isolate_(isolate), value_(p) {}
   template <class S>
-  explicit inline NanReturnValue(const NanReturnValue<S>& that)
+  explicit inline ReturnValue(const ReturnValue<S>& that)
       : isolate_(that.isolate_), value_(that.value_) {
     TYPE_CHECK(T, S);
   }
@@ -36,11 +36,11 @@ class NanReturnValue {
     *value_ = v8::Persistent<T>::New(handle);
   }
 
-  template <typename S> inline void Set(const NanGlobal<S> &handle) {
+  template <typename S> inline void Set(const Global<S> &handle) {
     TYPE_CHECK(T, S);
     value_->Dispose();
     *value_ = v8::Persistent<T>::New(handle.persistent);
-    const_cast<NanGlobal<S> &>(handle).Reset();
+    const_cast<Global<S> &>(handle).Reset();
   }
 
   // Fast primitive setters
@@ -98,14 +98,14 @@ class NanReturnValue {
 };
 
 template<typename T>
-class NanFunctionCallbackInfo {
+class FunctionCallbackInfo {
   const v8::Arguments &args_;
   v8::Local<v8::Value> data_;
-  NanReturnValue<T> return_value_;
+  ReturnValue<T> return_value_;
   v8::Persistent<T> retval_;
 
  public:
-  explicit inline NanFunctionCallbackInfo(
+  explicit inline FunctionCallbackInfo(
       const v8::Arguments &args
     , v8::Local<v8::Value> data) :
           args_(args)
@@ -113,8 +113,8 @@ class NanFunctionCallbackInfo {
         , return_value_(args.GetIsolate(), &retval_)
         , retval_(v8::Persistent<T>::New(v8::Undefined())) {}
 
-  inline NanReturnValue<T> GetReturnValue() const {
-    return NanReturnValue<T>(return_value_);
+  inline ReturnValue<T> GetReturnValue() const {
+    return ReturnValue<T>(return_value_);
   }
 
   inline v8::Local<v8::Function> Callee() const { return args_.Callee(); }
@@ -139,12 +139,12 @@ class NanFunctionCallbackInfo {
 };
 
 template<typename T>
-class NanPropertyCallbackInfoBase {
+class PropertyCallbackInfoBase {
   const v8::AccessorInfo &info_;
   const v8::Local<v8::Value> &data_;
 
  public:
-  explicit inline NanPropertyCallbackInfoBase(
+  explicit inline PropertyCallbackInfoBase(
       const v8::AccessorInfo &info
     , const v8::Local<v8::Value> &data) :
           info_(info)
@@ -166,82 +166,82 @@ class NanPropertyCallbackInfoBase {
 };
 
 template<typename T>
-class NanPropertyCallbackInfo : public NanPropertyCallbackInfoBase<T> {
-  NanReturnValue<T> return_value_;
+class PropertyCallbackInfo : public PropertyCallbackInfoBase<T> {
+  ReturnValue<T> return_value_;
   v8::Persistent<T> retval_;
 
  public:
-  explicit inline NanPropertyCallbackInfo(
+  explicit inline PropertyCallbackInfo(
       const v8::AccessorInfo &info
     , const v8::Local<v8::Value> &data) :
-          NanPropertyCallbackInfoBase<T>(info, data)
+          PropertyCallbackInfoBase<T>(info, data)
         , return_value_(info.GetIsolate(), &retval_)
         , retval_(v8::Persistent<T>::New(v8::Undefined())) {}
-  inline NanReturnValue<T> GetReturnValue() const { return return_value_; }
+  inline ReturnValue<T> GetReturnValue() const { return return_value_; }
 };
 
 template<>
-class NanPropertyCallbackInfo<v8::Array> :
-    public NanPropertyCallbackInfoBase<v8::Array> {
-  NanReturnValue<v8::Array> return_value_;
+class PropertyCallbackInfo<v8::Array> :
+    public PropertyCallbackInfoBase<v8::Array> {
+  ReturnValue<v8::Array> return_value_;
   v8::Persistent<v8::Array> retval_;
 
  public:
-  explicit inline NanPropertyCallbackInfo(
+  explicit inline PropertyCallbackInfo(
       const v8::AccessorInfo &info
     , const v8::Local<v8::Value> &data) :
-          NanPropertyCallbackInfoBase<v8::Array>(info, data)
+          PropertyCallbackInfoBase<v8::Array>(info, data)
         , return_value_(info.GetIsolate(), &retval_)
         , retval_(v8::Persistent<v8::Array>::New(v8::Local<v8::Array>())) {}
-  inline NanReturnValue<v8::Array> GetReturnValue() const {
+  inline ReturnValue<v8::Array> GetReturnValue() const {
     return return_value_;
   }
 };
 
 template<>
-class NanPropertyCallbackInfo<v8::Boolean> :
-    public NanPropertyCallbackInfoBase<v8::Boolean> {
-  NanReturnValue<v8::Boolean> return_value_;
+class PropertyCallbackInfo<v8::Boolean> :
+    public PropertyCallbackInfoBase<v8::Boolean> {
+  ReturnValue<v8::Boolean> return_value_;
   v8::Persistent<v8::Boolean> retval_;
 
  public:
-  explicit inline NanPropertyCallbackInfo(
+  explicit inline PropertyCallbackInfo(
       const v8::AccessorInfo &info
     , const v8::Local<v8::Value> &data) :
-          NanPropertyCallbackInfoBase<v8::Boolean>(info, data)
+          PropertyCallbackInfoBase<v8::Boolean>(info, data)
         , return_value_(info.GetIsolate(), &retval_)
         , retval_(v8::Persistent<v8::Boolean>::New(v8::Local<v8::Boolean>())) {}
-  inline NanReturnValue<v8::Boolean> GetReturnValue() const {
+  inline ReturnValue<v8::Boolean> GetReturnValue() const {
     return return_value_;
   }
 };
 
 template<>
-class NanPropertyCallbackInfo<v8::Integer> :
-    public NanPropertyCallbackInfoBase<v8::Integer> {
-  NanReturnValue<v8::Integer> return_value_;
+class PropertyCallbackInfo<v8::Integer> :
+    public PropertyCallbackInfoBase<v8::Integer> {
+  ReturnValue<v8::Integer> return_value_;
   v8::Persistent<v8::Integer> retval_;
 
  public:
-  explicit inline NanPropertyCallbackInfo(
+  explicit inline PropertyCallbackInfo(
       const v8::AccessorInfo &info
     , const v8::Local<v8::Value> &data) :
-          NanPropertyCallbackInfoBase<v8::Integer>(info, data)
+          PropertyCallbackInfoBase<v8::Integer>(info, data)
         , return_value_(info.GetIsolate(), &retval_)
         , retval_(v8::Persistent<v8::Integer>::New(v8::Local<v8::Integer>())) {}
-  inline NanReturnValue<v8::Integer> GetReturnValue() const {
+  inline ReturnValue<v8::Integer> GetReturnValue() const {
     return return_value_;
   }
 };
 
 namespace imp {
 template<typename T>
-class NanReturnValueImp : public NanReturnValue<T> {
+class ReturnValueImp : public ReturnValue<T> {
  public:
-  explicit NanReturnValueImp(NanReturnValue<T> that) :
-      NanReturnValue<T>(that) {}
+  explicit ReturnValueImp(ReturnValue<T> that) :
+      ReturnValue<T>(that) {}
   NAN_INLINE v8::Handle<T> Value() {
-      return *NanReturnValue<T>::value_;
+      return *ReturnValue<T>::value_;
   }
 };
 
@@ -250,10 +250,10 @@ v8::Handle<v8::Value> FunctionCallbackWrapper(const v8::Arguments &args) {
   v8::Local<v8::Object> obj = args.Data().As<v8::Object>();
   FunctionWrapper *wrapper = static_cast<FunctionWrapper*>(
       obj->GetPointerFromInternalField(kFunctionIndex));
-  NanFunctionCallbackInfo<v8::Value>
+  FunctionCallbackInfo<v8::Value>
       cbinfo(args, obj->GetInternalField(kDataIndex));
   wrapper->callback(cbinfo);
-  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Value> (*NativeFunction)(const v8::Arguments &);
@@ -262,12 +262,12 @@ static
 v8::Handle<v8::Value> GetterCallbackWrapper(
     v8::Local<v8::String> property, const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   GetterWrapper *wrapper = static_cast<GetterWrapper*>(
       obj->GetPointerFromInternalField(kGetterIndex));
   wrapper->callback(property, cbinfo);
-  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Value> (*NativeGetter)
@@ -279,7 +279,7 @@ void SetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<void>
+  PropertyCallbackInfo<void>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   SetterWrapper *wrapper = static_cast<SetterWrapper*>(
       obj->GetPointerFromInternalField(kSetterIndex));
@@ -293,12 +293,12 @@ static
 v8::Handle<v8::Value> PropertyGetterCallbackWrapper(
     v8::Local<v8::String> property, const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyGetterWrapper *wrapper = static_cast<PropertyGetterWrapper*>(
       obj->GetPointerFromInternalField(kPropertyGetterIndex));
   wrapper->callback(property, cbinfo);
-  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Value> (*NativePropertyGetter)
@@ -310,12 +310,12 @@ v8::Handle<v8::Value> PropertySetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertySetterWrapper *wrapper = static_cast<PropertySetterWrapper*>(
       obj->GetPointerFromInternalField(kPropertySetterIndex));
   wrapper->callback(property, value, cbinfo);
-  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Value> (*NativePropertySetter)
@@ -325,12 +325,12 @@ static
 v8::Handle<v8::Array> PropertyEnumeratorCallbackWrapper(
     const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Array>
+  PropertyCallbackInfo<v8::Array>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyEnumeratorWrapper *wrapper = static_cast<PropertyEnumeratorWrapper*>(
       obj->GetPointerFromInternalField(kPropertyEnumeratorIndex));
   wrapper->callback(cbinfo);
-  return NanReturnValueImp<v8::Array>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Array>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Array> (*NativePropertyEnumerator)
@@ -341,12 +341,12 @@ v8::Handle<v8::Boolean> PropertyDeleterCallbackWrapper(
     v8::Local<v8::String> property
   , const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Boolean>
+  PropertyCallbackInfo<v8::Boolean>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyDeleterWrapper *wrapper = static_cast<PropertyDeleterWrapper*>(
       obj->GetPointerFromInternalField(kPropertyDeleterIndex));
   wrapper->callback(property, cbinfo);
-  return NanReturnValueImp<v8::Boolean>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Boolean>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Boolean> (NativePropertyDeleter)
@@ -356,12 +356,12 @@ static
 v8::Handle<v8::Integer> PropertyQueryCallbackWrapper(
     v8::Local<v8::String> property, const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Integer>
+  PropertyCallbackInfo<v8::Integer>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   PropertyQueryWrapper *wrapper = static_cast<PropertyQueryWrapper*>(
       obj->GetPointerFromInternalField(kPropertyQueryIndex));
   wrapper->callback(property, cbinfo);
-  return NanReturnValueImp<v8::Integer>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Integer>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Integer> (*NativePropertyQuery)
@@ -371,12 +371,12 @@ static
 v8::Handle<v8::Value> IndexGetterCallbackWrapper(
     uint32_t index, const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexGetterWrapper *wrapper = static_cast<IndexGetterWrapper*>(
       obj->GetPointerFromInternalField(kIndexPropertyGetterIndex));
   wrapper->callback(index, cbinfo);
-  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Value> (*NativeIndexGetter)
@@ -388,12 +388,12 @@ v8::Handle<v8::Value> IndexSetterCallbackWrapper(
   , v8::Local<v8::Value> value
   , const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Value>
+  PropertyCallbackInfo<v8::Value>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexSetterWrapper *wrapper = static_cast<IndexSetterWrapper*>(
       obj->GetPointerFromInternalField(kIndexPropertySetterIndex));
   wrapper->callback(index, value, cbinfo);
-  return NanReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Value>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Value> (*NativeIndexSetter)
@@ -403,12 +403,12 @@ static
 v8::Handle<v8::Array> IndexEnumeratorCallbackWrapper(
     const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Array>
+  PropertyCallbackInfo<v8::Array>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexEnumeratorWrapper *wrapper = static_cast<IndexEnumeratorWrapper*>(
       obj->GetPointerFromInternalField(kIndexPropertyEnumeratorIndex));
   wrapper->callback(cbinfo);
-  return NanReturnValueImp<v8::Array>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Array>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Array> (*NativeIndexEnumerator)
@@ -418,12 +418,12 @@ static
 v8::Handle<v8::Boolean> IndexDeleterCallbackWrapper(
     uint32_t index, const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Boolean>
+  PropertyCallbackInfo<v8::Boolean>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexDeleterWrapper *wrapper = static_cast<IndexDeleterWrapper*>(
       obj->GetPointerFromInternalField(kIndexPropertyDeleterIndex));
   wrapper->callback(index, cbinfo);
-  return NanReturnValueImp<v8::Boolean>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Boolean>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Boolean> (*NativeIndexDeleter)
@@ -433,12 +433,12 @@ static
 v8::Handle<v8::Integer> IndexQueryCallbackWrapper(
     uint32_t index, const v8::AccessorInfo &info) {
   v8::Local<v8::Object> obj = info.Data().As<v8::Object>();
-  NanPropertyCallbackInfo<v8::Integer>
+  PropertyCallbackInfo<v8::Integer>
       cbinfo(info, obj->GetInternalField(kDataIndex));
   IndexQueryWrapper *wrapper = static_cast<IndexQueryWrapper*>(
       obj->GetPointerFromInternalField(kIndexPropertyQueryIndex));
   wrapper->callback(index, cbinfo);
-  return NanReturnValueImp<v8::Integer>(cbinfo.GetReturnValue()).Value();
+  return ReturnValueImp<v8::Integer>(cbinfo.GetReturnValue()).Value();
 }
 
 typedef v8::Handle<v8::Integer> (*NativeIndexQuery)
diff --git a/nan_converters.h b/nan_converters.h
index c1ebd203..ea0b68b8 100644
--- a/nan_converters.h
+++ b/nan_converters.h
@@ -11,9 +11,9 @@
 
 namespace imp {
 template<typename T> struct ToFactoryBase {
-  typedef NanMaybeLocal<T> return_t;
+  typedef MaybeLocal<T> return_t;
 };
-template<typename T> struct ValueFactoryBase { typedef NanMaybe<T> return_t; };
+template<typename T> struct ValueFactoryBase { typedef Maybe<T> return_t; };
 
 template<typename T> struct ToFactory;
 
@@ -50,8 +50,8 @@ X(int32_t)
 
 template<typename T>
 NAN_INLINE
-typename Nan::imp::ToFactory<T>::return_t NanTo(v8::Handle<v8::Value> val) {
-  return Nan::imp::ToFactory<T>::convert(val);
+typename imp::ToFactory<T>::return_t To(v8::Handle<v8::Value> val) {
+  return imp::ToFactory<T>::convert(val);
 }
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
diff --git a/nan_converters_43_inl.h b/nan_converters_43_inl.h
index ba5fe776..1f132ba6 100644
--- a/nan_converters_43_inl.h
+++ b/nan_converters_43_inl.h
@@ -10,9 +10,9 @@
 #define NAN_CONVERTERS_43_INL_H_
 
 #define X(TYPE)                                                                \
-Nan::imp::ToFactory<v8::TYPE>::return_t                                        \
-Nan::imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {            \
-  return val->To ## TYPE(NanGetCurrentContext());                              \
+imp::ToFactory<v8::TYPE>::return_t                                             \
+imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {                 \
+  return val->To ## TYPE(GetCurrentContext());                                 \
 }
 
 X(Boolean)
@@ -26,9 +26,9 @@ X(Int32)
 #undef X
 
 #define X(TYPE, NAME)                                                          \
-Nan::imp::ToFactory<TYPE>::return_t                                            \
-Nan::imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                \
-  return val->NAME ##Value(NanGetCurrentContext());                            \
+imp::ToFactory<TYPE>::return_t                                                 \
+imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                     \
+  return val->NAME ## Value(GetCurrentContext());                              \
 }
 
 X(bool, Boolean)
diff --git a/nan_converters_pre_43_inl.h b/nan_converters_pre_43_inl.h
index f3772da7..94a1ecca 100644
--- a/nan_converters_pre_43_inl.h
+++ b/nan_converters_pre_43_inl.h
@@ -10,9 +10,9 @@
 #define NAN_CONVERTERS_PRE_43_INL_H_
 
 #define X(TYPE)                                                                \
-Nan::imp::ToFactory<v8::TYPE>::return_t                                        \
-Nan::imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {            \
-  return NanMaybeLocal<v8::TYPE>(val->To ## TYPE());                           \
+imp::ToFactory<v8::TYPE>::return_t                                             \
+imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {                 \
+  return MaybeLocal<v8::TYPE>(val->To ## TYPE());                              \
 }
 
 X(Boolean)
@@ -26,9 +26,9 @@ X(Int32)
 #undef X
 
 #define X(TYPE, NAME)                                                          \
-Nan::imp::ToFactory<TYPE>::return_t                                            \
-Nan::imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                \
-  return NanJust<TYPE>(val->NAME ##Value());                                   \
+imp::ToFactory<TYPE>::return_t                                                 \
+imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                     \
+  return Just<TYPE>(val->NAME ##Value());                                      \
 }
 
 X(bool, Boolean)
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index a1a7ab77..fb5d7810 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -56,7 +56,7 @@ Factory<v8::Context>::New( v8::ExtensionConfiguration* extensions
 Factory<v8::Date>::return_t
 Factory<v8::Date>::New(double value) {
   v8::Local<v8::Date> ret;
-  if (v8::Date::New(NanGetCurrentContext(), value).
+  if (v8::Date::New(GetCurrentContext(), value).
       ToLocal(reinterpret_cast<v8::Local<v8::Value>*>(&ret))) {
     return v8::MaybeLocal<v8::Date>(ret);
   } else {
@@ -81,13 +81,13 @@ Factory<v8::External>::New(void * value) {
 //=== Function =================================================================
 
 Factory<v8::Function>::return_t
-Factory<v8::Function>::New( NanFunctionCallback callback
+Factory<v8::Function>::New( FunctionCallback callback
                           , v8::Handle<v8::Value> data) {
   v8::Isolate *isolate = v8::Isolate::GetCurrent();
   v8::EscapableHandleScope scope(isolate);
-  static std::map<NanFunctionCallback, Nan::imp::FunctionWrapper*> cbmap;
+  static std::map<FunctionCallback, imp::FunctionWrapper*> cbmap;
   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
-  tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+  tpl->SetInternalFieldCount(imp::kFunctionFieldCount);
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
   v8::Local<v8::Object> obj =
@@ -97,32 +97,32 @@ Factory<v8::Function>::New( NanFunctionCallback callback
 #endif
 
   obj->SetAlignedPointerInInternalField(
-      Nan::imp::kFunctionIndex
-    , Nan::imp::GetWrapper<NanFunctionCallback,
-          Nan::imp::FunctionWrapper>(callback));
+      imp::kFunctionIndex
+    , imp::GetWrapper<FunctionCallback,
+          imp::FunctionWrapper>(callback));
   v8::Local<v8::Value> val = v8::Local<v8::Value>::New(isolate, data);
 
   if (!val.IsEmpty()) {
-    obj->SetInternalField(Nan::imp::kDataIndex, val);
+    obj->SetInternalField(imp::kDataIndex, val);
   }
 
   return scope.Escape(v8::Function::New( isolate
-                          , Nan::imp::FunctionCallbackWrapper
+                          , imp::FunctionCallbackWrapper
                           , obj));
 }
 
 //=== Function Template ========================================================
 
 Factory<v8::FunctionTemplate>::return_t
-Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
+Factory<v8::FunctionTemplate>::New( FunctionCallback callback
                                   , v8::Handle<v8::Value> data
                                   , v8::Handle<v8::Signature> signature) {
   v8::Isolate *isolate = v8::Isolate::GetCurrent();
   v8::EscapableHandleScope scope(isolate);
-  static std::map<NanFunctionCallback,  // NOLINT(build/include_what_you_use)
-      Nan::imp::FunctionWrapper*> cbmap;
+  static std::map<FunctionCallback,  // NOLINT(build/include_what_you_use)
+      imp::FunctionWrapper*> cbmap;
   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New(isolate);
-  tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+  tpl->SetInternalFieldCount(imp::kFunctionFieldCount);
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
   v8::Local<v8::Object> obj =
@@ -132,17 +132,17 @@ Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
 #endif
 
   obj->SetAlignedPointerInInternalField(
-      Nan::imp::kFunctionIndex
-    , Nan::imp::GetWrapper<NanFunctionCallback,
-          Nan::imp::FunctionWrapper>(callback));
+      imp::kFunctionIndex
+    , imp::GetWrapper<FunctionCallback,
+          imp::FunctionWrapper>(callback));
   v8::Local<v8::Value> val = v8::Local<v8::Value>::New(isolate, data);
 
   if (!val.IsEmpty()) {
-    obj->SetInternalField(Nan::imp::kDataIndex, val);
+    obj->SetInternalField(imp::kDataIndex, val);
   }
 
   return scope.Escape(v8::FunctionTemplate::New( isolate
-                                  , Nan::imp::FunctionCallbackWrapper
+                                  , imp::FunctionCallbackWrapper
                                   , obj
                                   , signature));
 }
@@ -210,7 +210,7 @@ Factory<v8::RegExp>::return_t
 Factory<v8::RegExp>::New(
     v8::Handle<v8::String> pattern
   , v8::RegExp::Flags flags) {
-  return v8::RegExp::New(NanGetCurrentContext(), pattern, flags);
+  return v8::RegExp::New(GetCurrentContext(), pattern, flags);
 }
 #else
 Factory<v8::RegExp>::return_t
@@ -228,14 +228,14 @@ Factory<v8::RegExp>::New(
 Factory<v8::Script>::return_t
 Factory<v8::Script>::New( v8::Local<v8::String> source) {
   v8::ScriptCompiler::Source src(source);
-  return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &src);
+  return v8::ScriptCompiler::Compile(GetCurrentContext(), &src);
 }
 
 Factory<v8::Script>::return_t
 Factory<v8::Script>::New( v8::Local<v8::String> source
                         , v8::ScriptOrigin const& origin) {
   v8::ScriptCompiler::Source src(source, origin);
-  return v8::ScriptCompiler::Compile(NanGetCurrentContext(), &src);
+  return v8::ScriptCompiler::Compile(GetCurrentContext(), &src);
 }
 #else
 Factory<v8::Script>::return_t
@@ -296,7 +296,7 @@ Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
 }
 
 Factory<v8::String>::return_t
-Factory<v8::String>::New(NanExternalOneByteStringResource * value) {
+Factory<v8::String>::New(ExternalOneByteStringResource * value) {
   return v8::String::NewExternalOneByte(v8::Isolate::GetCurrent(), value);
 }
 #else
@@ -339,7 +339,7 @@ Factory<v8::String>::New(v8::String::ExternalStringResource * value) {
 }
 
 Factory<v8::String>::return_t
-Factory<v8::String>::New(NanExternalOneByteStringResource * value) {
+Factory<v8::String>::New(ExternalOneByteStringResource * value) {
   return Factory<v8::String>::return_t(
       v8::String::NewExternal(v8::Isolate::GetCurrent(), value));
 }
@@ -392,17 +392,17 @@ Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
 //=== Presistents and Handles ==================================================
 
 template <typename T>
-inline v8::Local<T> NanNew(v8::Handle<T> h) {
+inline v8::Local<T> New(v8::Handle<T> h) {
   return v8::Local<T>::New(v8::Isolate::GetCurrent(), h);
 }
 
 template <typename T, typename M>
-inline v8::Local<T> NanNew(v8::Persistent<T, M> const& p) {
+inline v8::Local<T> New(v8::Persistent<T, M> const& p) {
   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 }
 
 template <typename T, typename M>
-inline v8::Local<T> NanNew(NanPersistent<T, M> const& p) {
+inline v8::Local<T> New(Persistent<T, M> const& p) {
   return v8::Local<T>::New(v8::Isolate::GetCurrent(), p);
 }
 
diff --git a/nan_implementation_pre_12_inl.h b/nan_implementation_pre_12_inl.h
index 11475762..94605fea 100644
--- a/nan_implementation_pre_12_inl.h
+++ b/nan_implementation_pre_12_inl.h
@@ -70,7 +70,7 @@ Factory<v8::External>::New(void * value) {
 //=== Function =================================================================
 
 Factory<v8::Function>::return_t
-Factory<v8::Function>::New( NanFunctionCallback callback
+Factory<v8::Function>::New( FunctionCallback callback
                           , v8::Handle<v8::Value> data) {
   return Factory<v8::FunctionTemplate>::New( callback
                                            , data
@@ -82,31 +82,31 @@ Factory<v8::Function>::New( NanFunctionCallback callback
 //=== FunctionTemplate =========================================================
 
 Factory<v8::FunctionTemplate>::return_t
-Factory<v8::FunctionTemplate>::New( NanFunctionCallback callback
+Factory<v8::FunctionTemplate>::New( FunctionCallback callback
                                   , v8::Handle<v8::Value> data
                                   , v8::Handle<v8::Signature> signature) {
   v8::HandleScope scope;
 
-  static std::map<NanFunctionCallback,  // NOLINT(build/include_what_you_use)
-      Nan::imp::FunctionWrapper*> cbmap;
+  static std::map<FunctionCallback,  // NOLINT(build/include_what_you_use)
+      imp::FunctionWrapper*> cbmap;
   v8::Local<v8::ObjectTemplate> tpl = v8::ObjectTemplate::New();
-  tpl->SetInternalFieldCount(Nan::imp::kFunctionFieldCount);
+  tpl->SetInternalFieldCount(imp::kFunctionFieldCount);
   v8::Local<v8::Object> obj = tpl->NewInstance();
 
   obj->SetPointerInInternalField(
-      Nan::imp::kFunctionIndex
-    , Nan::imp::GetWrapper<NanFunctionCallback,
-          Nan::imp::FunctionWrapper>(callback));
+      imp::kFunctionIndex
+    , imp::GetWrapper<FunctionCallback,
+          imp::FunctionWrapper>(callback));
   v8::Local<v8::Value> val = v8::Local<v8::Value>::New(data);
 
   if (!val.IsEmpty()) {
-    obj->SetInternalField(Nan::imp::kDataIndex, val);
+    obj->SetInternalField(imp::kDataIndex, val);
   }
 
   // Note(agnat): Emulate length argument here. Unfortunately, I couldn't find
   // a way. Have at it though...
   return scope.Close(
-      v8::FunctionTemplate::New( Nan::imp::FunctionCallbackWrapper
+      v8::FunctionTemplate::New(imp::FunctionCallbackWrapper
                                , obj
                                , signature));
 }
@@ -240,17 +240,17 @@ Factory<v8::StringObject>::New(v8::Handle<v8::String> value) {
 //=== Presistents and Handles ==================================================
 
 template <typename T>
-inline v8::Local<T> NanNew(v8::Handle<T> h) {
+inline v8::Local<T> New(v8::Handle<T> h) {
   return v8::Local<T>::New(h);
 }
 
 template <typename T>
-inline v8::Local<T> NanNew(v8::Persistent<T> const& p) {
+inline v8::Local<T> New(v8::Persistent<T> const& p) {
   return v8::Local<T>::New(p);
 }
 
 template <typename T, typename M>
-inline v8::Local<T> NanNew(NanPersistent<T, M> const& p) {
+inline v8::Local<T> New(Persistent<T, M> const& p) {
   return v8::Local<T>::New(p.persistent);
 }
 
diff --git a/nan_maybe_43_inl.h b/nan_maybe_43_inl.h
index dd8d47bc..b8611749 100644
--- a/nan_maybe_43_inl.h
+++ b/nan_maybe_43_inl.h
@@ -10,206 +10,206 @@
 #define NAN_MAYBE_43_INL_H_
 
 template<typename T>
-using NanMaybeLocal = v8::MaybeLocal<T>;
+using MaybeLocal = v8::MaybeLocal<T>;
 
 template<typename T>
-using NanMaybe = v8::Maybe<T>;
+using Maybe = v8::Maybe<T>;
 
 template<typename T>
-NAN_INLINE NanMaybe<T> NanNothing() {
+NAN_INLINE Maybe<T> Nothing() {
   return v8::Nothing<T>();
 }
 
 template<typename T>
-NAN_INLINE NanMaybe<T> NanJust(const T& t) {
+NAN_INLINE Maybe<T> Just(const T& t) {
   return v8::Just<T>(t);
 }
 
-v8::Local<v8::Context> NanGetCurrentContext();
+v8::Local<v8::Context> GetCurrentContext();
 
 NAN_INLINE
-NanMaybeLocal<v8::String> NanToDetailString(v8::Handle<v8::Value> val) {
-  return val->ToDetailString(NanGetCurrentContext());
+MaybeLocal<v8::String> ToDetailString(v8::Handle<v8::Value> val) {
+  return val->ToDetailString(GetCurrentContext());
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Uint32> NanToArrayIndex(v8::Handle<v8::Value> val) {
-  return val->ToArrayIndex(NanGetCurrentContext());
+MaybeLocal<v8::Uint32> ToArrayIndex(v8::Handle<v8::Value> val) {
+  return val->ToArrayIndex(GetCurrentContext());
 }
 
 NAN_INLINE
-NanMaybe<bool> NanEquals(v8::Handle<v8::Value> a, v8::Handle<v8::Value>(b)) {
-  return a->Equals(NanGetCurrentContext(), b);
+Maybe<bool> Equals(v8::Handle<v8::Value> a, v8::Handle<v8::Value>(b)) {
+  return a->Equals(GetCurrentContext(), b);
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::Function> h) {
-  return NanMaybeLocal<v8::Object>(h->NewInstance(NanGetCurrentContext()));
+MaybeLocal<v8::Object> NewInstance(v8::Handle<v8::Function> h) {
+  return MaybeLocal<v8::Object>(h->NewInstance(GetCurrentContext()));
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::ObjectTemplate> h) {
-  return NanMaybeLocal<v8::Object>(h->NewInstance(NanGetCurrentContext()));
+MaybeLocal<v8::Object> NewInstance(v8::Handle<v8::ObjectTemplate> h) {
+  return MaybeLocal<v8::Object>(h->NewInstance(GetCurrentContext()));
 }
 
 
-NAN_INLINE NanMaybeLocal<v8::Function> NanGetFunction(
+NAN_INLINE MaybeLocal<v8::Function> GetFunction(
     v8::Handle<v8::FunctionTemplate> t) {
-  return t->GetFunction(NanGetCurrentContext());
+  return t->GetFunction(GetCurrentContext());
 }
 
-NAN_INLINE NanMaybe<bool> NanSet(
+NAN_INLINE Maybe<bool> Set(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key
   , v8::Handle<v8::Value> value) {
-  return obj->Set(NanGetCurrentContext(), key, value);
+  return obj->Set(GetCurrentContext(), key, value);
 }
 
-NAN_INLINE NanMaybe<bool> NanSet(
+NAN_INLINE Maybe<bool> Set(
     v8::Handle<v8::Object> obj
   , uint32_t index
   , v8::Handle<v8::Value> value) {
-  return obj->Set(NanGetCurrentContext(), index, value);
+  return obj->Set(GetCurrentContext(), index, value);
 }
 
-NAN_INLINE NanMaybe<bool> NanForceSet(
+NAN_INLINE Maybe<bool> ForceSet(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key
   , v8::Handle<v8::Value> value
   , v8::PropertyAttribute attribs = v8::None) {
-  return obj->ForceSet(NanGetCurrentContext(), key, value, attribs);
+  return obj->ForceSet(GetCurrentContext(), key, value, attribs);
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanGet(
+NAN_INLINE MaybeLocal<v8::Value> Get(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key) {
-  return obj->Get(NanGetCurrentContext(), key);
+  return obj->Get(GetCurrentContext(), key);
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Value> NanGet(v8::Handle<v8::Object> obj, uint32_t index) {
-  return obj->Get(NanGetCurrentContext(), index);
+MaybeLocal<v8::Value> Get(v8::Handle<v8::Object> obj, uint32_t index) {
+  return obj->Get(GetCurrentContext(), index);
 }
 
-NAN_INLINE v8::PropertyAttribute NanGetPropertyAttributes(
+NAN_INLINE v8::PropertyAttribute GetPropertyAttributes(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key) {
-  return obj->GetPropertyAttributes(NanGetCurrentContext(), key).FromJust();
+  return obj->GetPropertyAttributes(GetCurrentContext(), key).FromJust();
 }
 
-NAN_INLINE NanMaybe<bool> NanHas(
+NAN_INLINE Maybe<bool> Has(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return obj->Has(NanGetCurrentContext(), key);
+  return obj->Has(GetCurrentContext(), key);
 }
 
-NAN_INLINE NanMaybe<bool> NanHas(v8::Handle<v8::Object> obj, uint32_t index) {
-  return obj->Has(NanGetCurrentContext(), index);
+NAN_INLINE Maybe<bool> Has(v8::Handle<v8::Object> obj, uint32_t index) {
+  return obj->Has(GetCurrentContext(), index);
 }
 
-NAN_INLINE NanMaybe<bool> NanDelete(
+NAN_INLINE Maybe<bool> Delete(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return obj->Delete(NanGetCurrentContext(), key);
+  return obj->Delete(GetCurrentContext(), key);
 }
 
 NAN_INLINE
-NanMaybe<bool> NanDelete(v8::Handle<v8::Object> obj, uint32_t index) {
-  return obj->Delete(NanGetCurrentContext(), index);
+Maybe<bool> Delete(v8::Handle<v8::Object> obj, uint32_t index) {
+  return obj->Delete(GetCurrentContext(), index);
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Array> NanGetPropertyNames(v8::Handle<v8::Object> obj) {
-  return obj->GetPropertyNames(NanGetCurrentContext());
+MaybeLocal<v8::Array> GetPropertyNames(v8::Handle<v8::Object> obj) {
+  return obj->GetPropertyNames(GetCurrentContext());
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Array> NanGetOwnPropertyNames(v8::Handle<v8::Object> obj) {
-  return obj->GetOwnPropertyNames(NanGetCurrentContext());
+MaybeLocal<v8::Array> GetOwnPropertyNames(v8::Handle<v8::Object> obj) {
+  return obj->GetOwnPropertyNames(GetCurrentContext());
 }
 
-NAN_INLINE NanMaybe<bool> NanSetPrototype(
+NAN_INLINE Maybe<bool> SetPrototype(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> prototype) {
-  return obj->SetPrototype(NanGetCurrentContext(), prototype);
+  return obj->SetPrototype(GetCurrentContext(), prototype);
 }
 
-NAN_INLINE NanMaybeLocal<v8::String> NanObjectProtoToString(
+NAN_INLINE MaybeLocal<v8::String> ObjectProtoToString(
     v8::Handle<v8::Object> obj) {
-  return obj->ObjectProtoToString(NanGetCurrentContext());
+  return obj->ObjectProtoToString(GetCurrentContext());
 }
 
-NAN_INLINE NanMaybe<bool> NanHasOwnProperty(
+NAN_INLINE Maybe<bool> HasOwnProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return obj->HasOwnProperty(NanGetCurrentContext(), key);
+  return obj->HasOwnProperty(GetCurrentContext(), key);
 }
 
-NAN_INLINE NanMaybe<bool> NanHasRealNamedProperty(
+NAN_INLINE Maybe<bool> HasRealNamedProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return obj->HasRealNamedProperty(NanGetCurrentContext(), key);
+  return obj->HasRealNamedProperty(GetCurrentContext(), key);
 }
 
-NAN_INLINE NanMaybe<bool> NanHasRealIndexedProperty(
+NAN_INLINE Maybe<bool> HasRealIndexedProperty(
     v8::Handle<v8::Object> obj
   , uint32_t index) {
-  return obj->HasRealIndexedProperty(NanGetCurrentContext(), index);
+  return obj->HasRealIndexedProperty(GetCurrentContext(), index);
 }
 
-NAN_INLINE NanMaybe<bool> NanHasRealNamedCallbackProperty(
+NAN_INLINE Maybe<bool> HasRealNamedCallbackProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return obj->HasRealNamedCallbackProperty(NanGetCurrentContext(), key);
+  return obj->HasRealNamedCallbackProperty(GetCurrentContext(), key);
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedPropertyInPrototypeChain(
+NAN_INLINE MaybeLocal<v8::Value> GetRealNamedPropertyInPrototypeChain(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return obj->GetRealNamedPropertyInPrototypeChain(NanGetCurrentContext(), key);
+  return obj->GetRealNamedPropertyInPrototypeChain(GetCurrentContext(), key);
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedProperty(
+NAN_INLINE MaybeLocal<v8::Value> GetRealNamedProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return obj->GetRealNamedProperty(NanGetCurrentContext(), key);
+  return obj->GetRealNamedProperty(GetCurrentContext(), key);
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsFunction(
+NAN_INLINE MaybeLocal<v8::Value> CallAsFunction(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Object> recv
   , int argc
   , v8::Handle<v8::Value> argv[]) {
-  return obj->CallAsFunction(NanGetCurrentContext(), recv, argc, argv);
+  return obj->CallAsFunction(GetCurrentContext(), recv, argc, argv);
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsConstructor(
+NAN_INLINE MaybeLocal<v8::Value> CallAsConstructor(
     v8::Handle<v8::Object> obj
   , int argc, v8::Local<v8::Value> argv[]) {
-  return obj->CallAsConstructor(NanGetCurrentContext(), argc, argv);
+  return obj->CallAsConstructor(GetCurrentContext(), argc, argv);
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::String> NanGetSourceLine(v8::Handle<v8::Message> msg) {
-  return msg->GetSourceLine(NanGetCurrentContext());
+MaybeLocal<v8::String> GetSourceLine(v8::Handle<v8::Message> msg) {
+  return msg->GetSourceLine(GetCurrentContext());
 }
 
-NAN_INLINE NanMaybe<int> NanGetLineNumber(v8::Handle<v8::Message> msg) {
-  return msg->GetLineNumber(NanGetCurrentContext());
+NAN_INLINE Maybe<int> GetLineNumber(v8::Handle<v8::Message> msg) {
+  return msg->GetLineNumber(GetCurrentContext());
 }
 
-NAN_INLINE NanMaybe<int> NanGetStartColumn(v8::Handle<v8::Message> msg) {
-  return msg->GetStartColumn(NanGetCurrentContext());
+NAN_INLINE Maybe<int> GetStartColumn(v8::Handle<v8::Message> msg) {
+  return msg->GetStartColumn(GetCurrentContext());
 }
 
-NAN_INLINE NanMaybe<int> NanGetEndColumn(v8::Handle<v8::Message> msg) {
-  return msg->GetEndColumn(NanGetCurrentContext());
+NAN_INLINE Maybe<int> GetEndColumn(v8::Handle<v8::Message> msg) {
+  return msg->GetEndColumn(GetCurrentContext());
 }
 
-NAN_INLINE NanMaybeLocal<v8::Object> NanCloneElementAt(
+NAN_INLINE MaybeLocal<v8::Object> CloneElementAt(
     v8::Handle<v8::Array> array
   , uint32_t index) {
-  return array->CloneElementAt(NanGetCurrentContext(), index);
+  return array->CloneElementAt(GetCurrentContext(), index);
 }
 
 #endif  // NAN_MAYBE_43_INL_H_
diff --git a/nan_maybe_pre_43_inl.h b/nan_maybe_pre_43_inl.h
index ef096da3..742f11e6 100644
--- a/nan_maybe_pre_43_inl.h
+++ b/nan_maybe_pre_43_inl.h
@@ -10,15 +10,15 @@
 #define NAN_MAYBE_PRE_43_INL_H_
 
 template<typename T>
-class NanMaybeLocal {
+class MaybeLocal {
  public:
-  NAN_INLINE NanMaybeLocal() : val_(v8::Local<T>()) {}
+  NAN_INLINE MaybeLocal() : val_(v8::Local<T>()) {}
 
   template<typename S>
 # if NODE_MODULE_VERSION >= NODE_0_12_MODULE_VERSION
-  NAN_INLINE NanMaybeLocal(v8::Local<S> that) : val_(that) {}
+  NAN_INLINE MaybeLocal(v8::Local<S> that) : val_(that) {}
 # else
-  NAN_INLINE NanMaybeLocal(v8::Local<S> that) :
+  NAN_INLINE MaybeLocal(v8::Local<S> that) :
       val_(*reinterpret_cast<v8::Local<T>*>(&that)) {}
 # endif
 
@@ -47,7 +47,7 @@ class NanMaybeLocal {
 };
 
 template<typename T>
-class NanMaybe {
+class Maybe {
  public:
   NAN_INLINE bool IsNothing() const { return !has_value_; }
   NAN_INLINE bool IsJust() const { return has_value_; }
@@ -63,225 +63,225 @@ class NanMaybe {
     return has_value_ ? value_ : default_value;
   }
 
-  NAN_INLINE bool operator==(const NanMaybe &other) const {
+  NAN_INLINE bool operator==(const Maybe &other) const {
     return (IsJust() == other.IsJust()) &&
         (!IsJust() || FromJust() == other.FromJust());
   }
 
-  NAN_INLINE bool operator!=(const NanMaybe &other) const {
+  NAN_INLINE bool operator!=(const Maybe &other) const {
     return !operator==(other);
   }
 
  private:
-  NanMaybe() : has_value_(false) {}
-  explicit NanMaybe(const T& t) : has_value_(true), value_(t) {}
+  Maybe() : has_value_(false) {}
+  explicit Maybe(const T& t) : has_value_(true), value_(t) {}
   bool has_value_;
   T value_;
 
   template<typename U>
-  friend NanMaybe<U> NanNothing();
+  friend Maybe<U> Nothing();
   template<typename U>
-  friend NanMaybe<U> NanJust(const U& u);
+  friend Maybe<U> Just(const U& u);
 };
 
 template<typename T>
-inline NanMaybe<T> NanNothing() {
-  return NanMaybe<T>();
+inline Maybe<T> Nothing() {
+  return Maybe<T>();
 }
 
 template<typename T>
-inline NanMaybe<T> NanJust(const T& t) {
-  return NanMaybe<T>(t);
+inline Maybe<T> Just(const T& t) {
+  return Maybe<T>(t);
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::String> NanToDetailString(v8::Handle<v8::Value> val) {
-  return NanMaybeLocal<v8::String>(val->ToDetailString());
+MaybeLocal<v8::String> ToDetailString(v8::Handle<v8::Value> val) {
+  return MaybeLocal<v8::String>(val->ToDetailString());
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Uint32> NanToArrayIndex(v8::Handle<v8::Value> val) {
-  return NanMaybeLocal<v8::Uint32>(val->ToArrayIndex());
+MaybeLocal<v8::Uint32> ToArrayIndex(v8::Handle<v8::Value> val) {
+  return MaybeLocal<v8::Uint32>(val->ToArrayIndex());
 }
 
 NAN_INLINE
-NanMaybe<bool> NanEquals(v8::Handle<v8::Value> a, v8::Handle<v8::Value>(b)) {
-  return NanJust<bool>(a->Equals(b));
+Maybe<bool> Equals(v8::Handle<v8::Value> a, v8::Handle<v8::Value>(b)) {
+  return Just<bool>(a->Equals(b));
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::Function> h) {
-  return NanMaybeLocal<v8::Object>(h->NewInstance());
+MaybeLocal<v8::Object> NewInstance(v8::Handle<v8::Function> h) {
+  return MaybeLocal<v8::Object>(h->NewInstance());
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Object> NanNewInstance(v8::Handle<v8::ObjectTemplate> h) {
-  return NanMaybeLocal<v8::Object>(h->NewInstance());
+MaybeLocal<v8::Object> NewInstance(v8::Handle<v8::ObjectTemplate> h) {
+  return MaybeLocal<v8::Object>(h->NewInstance());
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Function> NanGetFunction(v8::Handle<v8::FunctionTemplate> t) {
-  return NanMaybeLocal<v8::Function>(t->GetFunction());
+MaybeLocal<v8::Function> GetFunction(v8::Handle<v8::FunctionTemplate> t) {
+  return MaybeLocal<v8::Function>(t->GetFunction());
 }
 
-NAN_INLINE NanMaybe<bool> NanSet(
+NAN_INLINE Maybe<bool> Set(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key
   , v8::Handle<v8::Value> value) {
-  return NanJust<bool>(obj->Set(key, value));
+  return Just<bool>(obj->Set(key, value));
 }
 
-NAN_INLINE NanMaybe<bool> NanSet(
+NAN_INLINE Maybe<bool> Set(
     v8::Handle<v8::Object> obj
   , uint32_t index
   , v8::Handle<v8::Value> value) {
-  return NanJust<bool>(obj->Set(index, value));
+  return Just<bool>(obj->Set(index, value));
 }
 
-NAN_INLINE NanMaybe<bool> NanForceSet(
+NAN_INLINE Maybe<bool> ForceSet(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key
   , v8::Handle<v8::Value> value
   , v8::PropertyAttribute attribs = v8::None) {
-  return NanJust<bool>(obj->ForceSet(key, value, attribs));
+  return Just<bool>(obj->ForceSet(key, value, attribs));
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanGet(
+NAN_INLINE MaybeLocal<v8::Value> Get(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key) {
-  return NanMaybeLocal<v8::Value>(obj->Get(key));
+  return MaybeLocal<v8::Value>(obj->Get(key));
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanGet(
+NAN_INLINE MaybeLocal<v8::Value> Get(
     v8::Handle<v8::Object> obj
   , uint32_t index) {
-  return NanMaybeLocal<v8::Value>(obj->Get(index));
+  return MaybeLocal<v8::Value>(obj->Get(index));
 }
 
-NAN_INLINE NanMaybe<v8::PropertyAttribute> NanGetPropertyAttributes(
+NAN_INLINE Maybe<v8::PropertyAttribute> GetPropertyAttributes(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> key) {
-  return NanJust<v8::PropertyAttribute>(obj->GetPropertyAttributes(key));
+  return Just<v8::PropertyAttribute>(obj->GetPropertyAttributes(key));
 }
 
-NAN_INLINE NanMaybe<bool> NanHas(
+NAN_INLINE Maybe<bool> Has(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return NanJust<bool>(obj->Has(key));
+  return Just<bool>(obj->Has(key));
 }
 
-NAN_INLINE NanMaybe<bool> NanHas(
+NAN_INLINE Maybe<bool> Has(
     v8::Handle<v8::Object> obj
   , uint32_t index) {
-  return NanJust<bool>(obj->Has(index));
+  return Just<bool>(obj->Has(index));
 }
 
-NAN_INLINE NanMaybe<bool> NanDelete(
+NAN_INLINE Maybe<bool> Delete(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return NanJust<bool>(obj->Delete(key));
+  return Just<bool>(obj->Delete(key));
 }
 
-NAN_INLINE NanMaybe<bool> NanDelete(
+NAN_INLINE Maybe<bool> Delete(
     v8::Handle<v8::Object> obj
   , uint32_t index) {
-  return NanJust<bool>(obj->Delete(index));
+  return Just<bool>(obj->Delete(index));
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Array> NanGetPropertyNames(v8::Handle<v8::Object> obj) {
-  return NanMaybeLocal<v8::Array>(obj->GetPropertyNames());
+MaybeLocal<v8::Array> GetPropertyNames(v8::Handle<v8::Object> obj) {
+  return MaybeLocal<v8::Array>(obj->GetPropertyNames());
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::Array> NanGetOwnPropertyNames(v8::Handle<v8::Object> obj) {
-  return NanMaybeLocal<v8::Array>(obj->GetOwnPropertyNames());
+MaybeLocal<v8::Array> GetOwnPropertyNames(v8::Handle<v8::Object> obj) {
+  return MaybeLocal<v8::Array>(obj->GetOwnPropertyNames());
 }
 
-NAN_INLINE NanMaybe<bool> NanSetPrototype(
+NAN_INLINE Maybe<bool> SetPrototype(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Value> prototype) {
-  return NanJust<bool>(obj->SetPrototype(prototype));
+  return Just<bool>(obj->SetPrototype(prototype));
 }
 
-NAN_INLINE NanMaybeLocal<v8::String> NanObjectProtoToString(
+NAN_INLINE MaybeLocal<v8::String> ObjectProtoToString(
     v8::Handle<v8::Object> obj) {
-  return NanMaybeLocal<v8::String>(obj->ObjectProtoToString());
+  return MaybeLocal<v8::String>(obj->ObjectProtoToString());
 }
 
-NAN_INLINE NanMaybe<bool> NanHasOwnProperty(
+NAN_INLINE Maybe<bool> HasOwnProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return NanJust<bool>(obj->HasOwnProperty(key));
+  return Just<bool>(obj->HasOwnProperty(key));
 }
 
-NAN_INLINE NanMaybe<bool> NanHasRealNamedProperty(
+NAN_INLINE Maybe<bool> HasRealNamedProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return NanJust<bool>(obj->HasRealNamedProperty(key));
+  return Just<bool>(obj->HasRealNamedProperty(key));
 }
 
-NAN_INLINE NanMaybe<bool> NanHasRealIndexedProperty(
+NAN_INLINE Maybe<bool> HasRealIndexedProperty(
     v8::Handle<v8::Object> obj
   , uint32_t index) {
-  return NanJust<bool>(obj->HasRealIndexedProperty(index));
+  return Just<bool>(obj->HasRealIndexedProperty(index));
 }
 
-NAN_INLINE NanMaybe<bool> NanHasRealNamedCallbackProperty(
+NAN_INLINE Maybe<bool> HasRealNamedCallbackProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return NanJust<bool>(obj->HasRealNamedCallbackProperty(key));
+  return Just<bool>(obj->HasRealNamedCallbackProperty(key));
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedPropertyInPrototypeChain(
+NAN_INLINE MaybeLocal<v8::Value> GetRealNamedPropertyInPrototypeChain(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return NanMaybeLocal<v8::Value>(
+  return MaybeLocal<v8::Value>(
       obj->GetRealNamedPropertyInPrototypeChain(key));
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanGetRealNamedProperty(
+NAN_INLINE MaybeLocal<v8::Value> GetRealNamedProperty(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::String> key) {
-  return NanMaybeLocal<v8::Value>(obj->GetRealNamedProperty(key));
+  return MaybeLocal<v8::Value>(obj->GetRealNamedProperty(key));
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsFunction(
+NAN_INLINE MaybeLocal<v8::Value> CallAsFunction(
     v8::Handle<v8::Object> obj
   , v8::Handle<v8::Object> recv
   , int argc
   , v8::Handle<v8::Value> argv[]) {
-  return NanMaybeLocal<v8::Value>(obj->CallAsFunction(recv, argc, argv));
+  return MaybeLocal<v8::Value>(obj->CallAsFunction(recv, argc, argv));
 }
 
-NAN_INLINE NanMaybeLocal<v8::Value> NanCallAsConstructor(
+NAN_INLINE MaybeLocal<v8::Value> CallAsConstructor(
     v8::Handle<v8::Object> obj
   , int argc
   , v8::Local<v8::Value> argv[]) {
-  return NanMaybeLocal<v8::Value>(obj->CallAsConstructor(argc, argv));
+  return MaybeLocal<v8::Value>(obj->CallAsConstructor(argc, argv));
 }
 
 NAN_INLINE
-NanMaybeLocal<v8::String> NanGetSourceLine(v8::Handle<v8::Message> msg) {
-  return NanMaybeLocal<v8::String>(msg->GetSourceLine());
+MaybeLocal<v8::String> GetSourceLine(v8::Handle<v8::Message> msg) {
+  return MaybeLocal<v8::String>(msg->GetSourceLine());
 }
 
-NAN_INLINE NanMaybe<int> NanGetLineNumber(v8::Handle<v8::Message> msg) {
-  return NanJust<int>(msg->GetLineNumber());
+NAN_INLINE Maybe<int> GetLineNumber(v8::Handle<v8::Message> msg) {
+  return Just<int>(msg->GetLineNumber());
 }
 
-NAN_INLINE NanMaybe<int> NanGetStartColumn(v8::Handle<v8::Message> msg) {
-  return NanJust<int>(msg->GetStartColumn());
+NAN_INLINE Maybe<int> GetStartColumn(v8::Handle<v8::Message> msg) {
+  return Just<int>(msg->GetStartColumn());
 }
 
-NAN_INLINE NanMaybe<int> NanGetEndColumn(v8::Handle<v8::Message> msg) {
-  return NanJust<int>(msg->GetEndColumn());
+NAN_INLINE Maybe<int> GetEndColumn(v8::Handle<v8::Message> msg) {
+  return Just<int>(msg->GetEndColumn());
 }
 
-NAN_INLINE NanMaybeLocal<v8::Object> NanCloneElementAt(
+NAN_INLINE MaybeLocal<v8::Object> CloneElementAt(
     v8::Handle<v8::Array> array
   , uint32_t index) {
-  return NanMaybeLocal<v8::Object>(array->CloneElementAt(index));
+  return MaybeLocal<v8::Object>(array->CloneElementAt(index));
 }
 
 #endif  // NAN_MAYBE_PRE_43_INL_H_
diff --git a/nan_new.h b/nan_new.h
index cfd91177..22e54548 100644
--- a/nan_new.h
+++ b/nan_new.h
@@ -18,21 +18,21 @@ template <>
 inline
 v8::Local<v8::Integer>
 To<v8::Integer>(v8::Handle<v8::Integer> i) {
-  return NanTo<v8::Integer>(i).ToLocalChecked();
+  return Nan::To<v8::Integer>(i).ToLocalChecked();
 }
 
 template <>
 inline
 v8::Local<v8::Int32>
 To<v8::Int32>(v8::Handle<v8::Integer> i) {
-  return NanTo<v8::Int32>(i).ToLocalChecked();
+  return Nan::To<v8::Int32>(i).ToLocalChecked();
 }
 
 template <>
 inline
 v8::Local<v8::Uint32>
 To<v8::Uint32>(v8::Handle<v8::Integer> i) {
-  return NanTo<v8::Uint32>(i).ToLocalChecked();
+  return Nan::To<v8::Uint32>(i).ToLocalChecked();
 }
 
 template <typename T> struct FactoryBase {
@@ -40,7 +40,7 @@ template <typename T> struct FactoryBase {
 };
 
 template <typename T> struct MaybeFactoryBase {
-  typedef NanMaybeLocal<T> return_t;
+  typedef MaybeLocal<T> return_t;
 };
 
 template <typename T> struct Factory;
@@ -84,7 +84,7 @@ template <>
 struct Factory<v8::Function> : FactoryBase<v8::Function> {
   static inline
   return_t
-  New( NanFunctionCallback callback
+  New( FunctionCallback callback
      , v8::Handle<v8::Value> data = v8::Handle<v8::Value>());
 };
 
@@ -92,7 +92,7 @@ template <>
 struct Factory<v8::FunctionTemplate> : FactoryBase<v8::FunctionTemplate> {
   static inline
   return_t
-  New( NanFunctionCallback callback = NULL
+  New( FunctionCallback callback = NULL
      , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
      , v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>());
 };
@@ -163,7 +163,7 @@ struct Factory<v8::String> : MaybeFactoryBase<v8::String> {
   static inline return_t New(std::string const& value);
 
   static inline return_t New(v8::String::ExternalStringResource * value);
-  static inline return_t New(NanExternalOneByteStringResource * value);
+  static inline return_t New(ExternalOneByteStringResource * value);
 };
 
 template <>
@@ -197,133 +197,133 @@ struct Factory<v8::UnboundScript> : MaybeFactoryBase<v8::UnboundScript> {
 //=== API ======================================================================
 
 template <typename T>
-typename Nan::imp::Factory<T>::return_t
-NanNew() {
-  return Nan::imp::Factory<T>::New();
+typename imp::Factory<T>::return_t
+New() {
+  return imp::Factory<T>::New();
 }
 
 template <typename T, typename A0>
-typename Nan::imp::Factory<T>::return_t
-NanNew(A0 arg0) {
-  return Nan::imp::Factory<T>::New(arg0);
+typename imp::Factory<T>::return_t
+New(A0 arg0) {
+  return imp::Factory<T>::New(arg0);
 }
 
 template <typename T, typename A0, typename A1>
-typename Nan::imp::Factory<T>::return_t
-NanNew(A0 arg0, A1 arg1) {
-  return Nan::imp::Factory<T>::New(arg0, arg1);
+typename imp::Factory<T>::return_t
+New(A0 arg0, A1 arg1) {
+  return imp::Factory<T>::New(arg0, arg1);
 }
 
 template <typename T, typename A0, typename A1, typename A2>
-typename Nan::imp::Factory<T>::return_t
-NanNew(A0 arg0, A1 arg1, A2 arg2) {
-  return Nan::imp::Factory<T>::New(arg0, arg1, arg2);
+typename imp::Factory<T>::return_t
+New(A0 arg0, A1 arg1, A2 arg2) {
+  return imp::Factory<T>::New(arg0, arg1, arg2);
 }
 
 template <typename T, typename A0, typename A1, typename A2, typename A3>
-typename Nan::imp::Factory<T>::return_t
-NanNew(A0 arg0, A1 arg1, A2 arg2, A3 arg3) {
-  return Nan::imp::Factory<T>::New(arg0, arg1, arg2, arg3);
+typename imp::Factory<T>::return_t
+New(A0 arg0, A1 arg1, A2 arg2, A3 arg3) {
+  return imp::Factory<T>::New(arg0, arg1, arg2, arg3);
 }
 
 // Note(agnat): When passing overloaded function pointers to template functions
 // as generic arguments the compiler needs help in picking the right overload.
-// These two functions handle NanNew<Function> and NanNew<FunctionTemplate> with
+// These two functions handle New<Function> and New<FunctionTemplate> with
 // all argument variations.
 
 // v8::Function and v8::FunctionTemplate with one or two arguments
 template <typename T>
-typename Nan::imp::Factory<T>::return_t
-NanNew( NanFunctionCallback callback
+typename imp::Factory<T>::return_t
+New( FunctionCallback callback
       , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
-    return Nan::imp::Factory<T>::New(callback, data);
+    return imp::Factory<T>::New(callback, data);
 }
 
 // v8::Function and v8::FunctionTemplate with three arguments
 template <typename T, typename A2>
-typename Nan::imp::Factory<T>::return_t
-NanNew( NanFunctionCallback callback
+typename imp::Factory<T>::return_t
+New( FunctionCallback callback
       , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
       , A2 a2 = A2()) {
-    return Nan::imp::Factory<T>::New(callback, data, a2);
+    return imp::Factory<T>::New(callback, data, a2);
 }
 
 // Convenience
 
-template <typename T> inline v8::Local<T> NanNew(v8::Handle<T> h);
+template <typename T> inline v8::Local<T> New(v8::Handle<T> h);
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
 template <typename T, typename M>
-    inline v8::Local<T> NanNew(v8::Persistent<T, M> const& p);
+    inline v8::Local<T> New(v8::Persistent<T, M> const& p);
 #else
-template <typename T> inline v8::Local<T> NanNew(v8::Persistent<T> const& p);
+template <typename T> inline v8::Local<T> New(v8::Persistent<T> const& p);
 #endif
 template <typename T, typename M>
-inline v8::Local<T> NanNew(NanPersistent<T, M> const& p);
+inline v8::Local<T> New(Persistent<T, M> const& p);
 
 inline
-Nan::imp::Factory<v8::Boolean>::return_t
-NanNew(bool value) {
-  return NanNew<v8::Boolean>(value);
+imp::Factory<v8::Boolean>::return_t
+New(bool value) {
+  return New<v8::Boolean>(value);
 }
 
 inline
-Nan::imp::Factory<v8::Int32>::return_t
-NanNew(int32_t value) {
-  return NanNew<v8::Int32>(value);
+imp::Factory<v8::Int32>::return_t
+New(int32_t value) {
+  return New<v8::Int32>(value);
 }
 
 inline
-Nan::imp::Factory<v8::Uint32>::return_t
-NanNew(uint32_t value) {
-  return NanNew<v8::Uint32>(value);
+imp::Factory<v8::Uint32>::return_t
+New(uint32_t value) {
+  return New<v8::Uint32>(value);
 }
 
 inline
-Nan::imp::Factory<v8::Number>::return_t
-NanNew(double value) {
-  return NanNew<v8::Number>(value);
+imp::Factory<v8::Number>::return_t
+New(double value) {
+  return New<v8::Number>(value);
 }
 
 inline
-Nan::imp::Factory<v8::String>::return_t
-NanNew(std::string const& value) {  // NOLINT(build/include_what_you_use)
-  return NanNew<v8::String>(value);
+imp::Factory<v8::String>::return_t
+New(std::string const& value) {  // NOLINT(build/include_what_you_use)
+  return New<v8::String>(value);
 }
 
 inline
-Nan::imp::Factory<v8::String>::return_t
-NanNew(const char * value, int length) {
-  return NanNew<v8::String>(value, length);
+imp::Factory<v8::String>::return_t
+New(const char * value, int length) {
+  return New<v8::String>(value, length);
 }
 
 inline
-Nan::imp::Factory<v8::String>::return_t
-NanNew(const char * value) {
-  return NanNew<v8::String>(value);
+imp::Factory<v8::String>::return_t
+New(const char * value) {
+  return New<v8::String>(value);
 }
 
 inline
-Nan::imp::Factory<v8::String>::return_t
-NanNew(const uint16_t * value) {
-  return NanNew<v8::String>(value);
+imp::Factory<v8::String>::return_t
+New(const uint16_t * value) {
+  return New<v8::String>(value);
 }
 
 inline
-Nan::imp::Factory<v8::String>::return_t
-NanNew(v8::String::ExternalStringResource * value) {
-  return NanNew<v8::String>(value);
+imp::Factory<v8::String>::return_t
+New(v8::String::ExternalStringResource * value) {
+  return New<v8::String>(value);
 }
 
 inline
-Nan::imp::Factory<v8::String>::return_t
-NanNew(NanExternalOneByteStringResource * value) {
-  return NanNew<v8::String>(value);
+imp::Factory<v8::String>::return_t
+New(ExternalOneByteStringResource * value) {
+  return New<v8::String>(value);
 }
 
 inline
-Nan::imp::Factory<v8::RegExp>::return_t
-NanNew(v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
-  return NanNew<v8::RegExp>(pattern, flags);
+imp::Factory<v8::RegExp>::return_t
+New(v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
+  return New<v8::RegExp>(pattern, flags);
 }
 
 #endif  // NAN_NEW_H_
diff --git a/nan_persistent_12_inl.h b/nan_persistent_12_inl.h
index 23a6cc16..eb008562 100644
--- a/nan_persistent_12_inl.h
+++ b/nan_persistent_12_inl.h
@@ -9,16 +9,16 @@
 #ifndef NAN_PERSISTENT_12_INL_H_
 #define NAN_PERSISTENT_12_INL_H_
 
-template<typename T, typename M> class NanPersistent :
+template<typename T, typename M> class Persistent :
     public v8::Persistent<T, M> {
  public:
-  NAN_INLINE NanPersistent() : v8::Persistent<T, M>() {}
+  NAN_INLINE Persistent() : v8::Persistent<T, M>() {}
 
-  template<typename S> NAN_INLINE NanPersistent(v8::Handle<S> that) :
+  template<typename S> NAN_INLINE Persistent(v8::Handle<S> that) :
       v8::Persistent<T, M>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S, typename M2>
-  NAN_INLINE NanPersistent(const v8::Persistent<S, M2> &that) :
+  NAN_INLINE Persistent(const v8::Persistent<S, M2> &that) :
       v8::Persistent<T, M2>(v8::Isolate::GetCurrent(), that) {}
 
   NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
@@ -36,14 +36,14 @@ template<typename T, typename M> class NanPersistent :
   template<typename P>
   NAN_INLINE void SetWeak(
     P *parameter
-    , typename NanWeakCallbackInfo<P>::Callback callback
-    , NanWeakCallbackType type);
+    , typename WeakCallbackInfo<P>::Callback callback
+    , WeakCallbackType type);
 
  private:
-  NAN_INLINE T *operator*() const { return *NanPersistentBase<T>::persistent; }
+  NAN_INLINE T *operator*() const { return *PersistentBase<T>::persistent; }
 
   template<typename S, typename M2>
-  NAN_INLINE void Copy(const NanPersistent<S, M2> &that) {
+  NAN_INLINE void Copy(const Persistent<S, M2> &that) {
     TYPE_CHECK(T, S);
 
     this->Reset();
@@ -58,15 +58,15 @@ template<typename T, typename M> class NanPersistent :
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 template<typename T>
-class NanGlobal : public v8::Global<T> {
+class Global : public v8::Global<T> {
  public:
-  NAN_INLINE NanGlobal() : v8::Global<T>() {}
+  NAN_INLINE Global() : v8::Global<T>() {}
 
-  template<typename S> NAN_INLINE NanGlobal(v8::Handle<S> that) :
+  template<typename S> NAN_INLINE Global(v8::Handle<S> that) :
     v8::Global<T>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S>
-  NAN_INLINE NanGlobal(const v8::PersistentBase<S> &that) :
+  NAN_INLINE Global(const v8::PersistentBase<S> &that) :
       v8::Global<S>(v8::Isolate::GetCurrent(), that) {}
 
   NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
@@ -84,23 +84,23 @@ class NanGlobal : public v8::Global<T> {
   template<typename P>
   NAN_INLINE void SetWeak(
     P *parameter
-    , typename NanWeakCallbackInfo<P>::Callback callback
-    , NanWeakCallbackType type) {
-    reinterpret_cast<NanPersistent<T>*>(this)->SetWeak(
+    , typename WeakCallbackInfo<P>::Callback callback
+    , WeakCallbackType type) {
+    reinterpret_cast<Persistent<T>*>(this)->SetWeak(
         parameter, callback, type);
   }
 };
 #else
 template<typename T>
-class NanGlobal : public v8::UniquePersistent<T> {
+class Global : public v8::UniquePersistent<T> {
  public:
-  NAN_INLINE NanGlobal() : v8::UniquePersistent<T>() {}
+  NAN_INLINE Global() : v8::UniquePersistent<T>() {}
 
-  template<typename S> NAN_INLINE NanGlobal(v8::Handle<S> that) :
+  template<typename S> NAN_INLINE Global(v8::Handle<S> that) :
     v8::UniquePersistent<T>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S>
-  NAN_INLINE NanGlobal(const v8::PersistentBase<S> &that) :
+  NAN_INLINE Global(const v8::PersistentBase<S> &that) :
       v8::UniquePersistent<S>(v8::Isolate::GetCurrent(), that) {}
 
   NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
@@ -118,9 +118,9 @@ class NanGlobal : public v8::UniquePersistent<T> {
   template<typename P>
   NAN_INLINE void SetWeak(
     P *parameter
-    , typename NanWeakCallbackInfo<P>::Callback callback
-    , NanWeakCallbackType type) {
-    reinterpret_cast<NanPersistent<T>*>(this)->SetWeak(
+    , typename WeakCallbackInfo<P>::Callback callback
+    , WeakCallbackType type) {
+    reinterpret_cast<Persistent<T>*>(this)->SetWeak(
         parameter, callback, type);
   }
 };
diff --git a/nan_persistent_pre_12_inl.h b/nan_persistent_pre_12_inl.h
index 51d4e4af..13a6921e 100644
--- a/nan_persistent_pre_12_inl.h
+++ b/nan_persistent_pre_12_inl.h
@@ -10,14 +10,14 @@
 #define NAN_PERSISTENT_PRE_12_INL_H_
 
 template<typename T>
-class NanPersistentBase {
+class PersistentBase {
   v8::Persistent<T> persistent;
   template<typename U, typename M>
-  friend v8::Local<U> NanNew(const NanPersistent<U, M> &p);
-  template<typename S> friend class NanReturnValue;
+  friend v8::Local<U> New(const Persistent<U, M> &p);
+  template<typename S> friend class ReturnValue;
 
  public:
-  NAN_INLINE NanPersistentBase() :
+  NAN_INLINE PersistentBase() :
       persistent() {}
 
   NAN_INLINE void Reset() {
@@ -41,7 +41,7 @@ class NanPersistentBase {
   }
 
   template<typename S>
-  NAN_INLINE void Reset(const NanPersistentBase<S> &other) {
+  NAN_INLINE void Reset(const PersistentBase<S> &other) {
     TYPE_CHECK(T, S);
 
     if (!persistent.IsEmpty()) {
@@ -60,7 +60,7 @@ class NanPersistentBase {
   NAN_INLINE void Empty() { persistent.Clear(); }
 
   template<typename S>
-  NAN_INLINE bool operator==(const NanPersistentBase<S> &that) {
+  NAN_INLINE bool operator==(const PersistentBase<S> &that) {
     return this->persistent == that.persistent;
   }
 
@@ -70,7 +70,7 @@ class NanPersistentBase {
   }
 
   template<typename S>
-  NAN_INLINE bool operator!=(const NanPersistentBase<S> &that) {
+  NAN_INLINE bool operator!=(const PersistentBase<S> &that) {
     return !operator==(that);
   }
 
@@ -82,8 +82,8 @@ class NanPersistentBase {
   template<typename P>
   NAN_INLINE void SetWeak(
     P *parameter
-    , typename NanWeakCallbackInfo<P>::Callback callback
-    , NanWeakCallbackType type);
+    , typename WeakCallbackInfo<P>::Callback callback
+    , WeakCallbackType type);
 
   NAN_INLINE void ClearWeak() { persistent.ClearWeak(); }
 
@@ -96,21 +96,21 @@ class NanPersistentBase {
   NAN_INLINE bool IsWeak() const { return persistent.IsWeak(); }
 
  private:
-  NAN_INLINE explicit NanPersistentBase(v8::Persistent<T> that) :
+  NAN_INLINE explicit PersistentBase(v8::Persistent<T> that) :
       persistent(that) { }
-  NAN_INLINE explicit NanPersistentBase(T *val) : persistent(val) {}
-  template<typename S, typename M> friend class NanPersistent;
-  template<typename S> friend class NanGlobal;
+  NAN_INLINE explicit PersistentBase(T *val) : persistent(val) {}
+  template<typename S, typename M> friend class Persistent;
+  template<typename S> friend class Global;
 };
 
 template<typename T>
-class NanNonCopyablePersistentTraits {
+class NonCopyablePersistentTraits {
  public:
-  typedef NanPersistent<T, NanNonCopyablePersistentTraits<T> >
+  typedef Persistent<T, NonCopyablePersistentTraits<T> >
       NonCopyablePersistent;
   static const bool kResetInDestructor = false;
   template<typename S, typename M>
-  NAN_INLINE static void Copy(const NanPersistent<S, M> &source,
+  NAN_INLINE static void Copy(const Persistent<S, M> &source,
                              NonCopyablePersistent *dest) {
     Uncompilable<v8::Object>();
   }
@@ -121,54 +121,54 @@ class NanNonCopyablePersistentTraits {
 };
 
 template<typename T>
-struct NanCopyablePersistentTraits {
-  typedef NanPersistent<T, NanCopyablePersistentTraits<T> > CopyablePersistent;
+struct CopyablePersistentTraits {
+  typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
   static const bool kResetInDestructor = true;
   template<typename S, typename M>
-  static NAN_INLINE void Copy(const NanPersistent<S, M> &source,
+  static NAN_INLINE void Copy(const Persistent<S, M> &source,
                              CopyablePersistent *dest) {}
 };
 
-template<typename T, typename M> class NanPersistent :
-    public NanPersistentBase<T> {
+template<typename T, typename M> class Persistent :
+    public PersistentBase<T> {
  public:
-  NAN_INLINE NanPersistent() {}
+  NAN_INLINE Persistent() {}
 
-  template<typename S> NAN_INLINE NanPersistent(v8::Handle<S> that)
-      : NanPersistentBase<T>(v8::Persistent<T>::New(that)) {
+  template<typename S> NAN_INLINE Persistent(v8::Handle<S> that)
+      : PersistentBase<T>(v8::Persistent<T>::New(that)) {
     TYPE_CHECK(T, S);
   }
 
-  NAN_INLINE NanPersistent(const NanPersistent &that) : NanPersistentBase<T>() {
+  NAN_INLINE Persistent(const Persistent &that) : PersistentBase<T>() {
     Copy(that);
   }
 
   template<typename S, typename M2>
-  NAN_INLINE NanPersistent(const NanPersistent<S, M2> &that) :
-      NanPersistentBase<T>() {
+  NAN_INLINE Persistent(const Persistent<S, M2> &that) :
+      PersistentBase<T>() {
     Copy(that);
   }
 
-  NAN_INLINE NanPersistent &operator=(const NanPersistent &that) {
+  NAN_INLINE Persistent &operator=(const Persistent &that) {
     Copy(that);
     return *this;
   }
 
   template <class S, class M2>
-  NAN_INLINE NanPersistent &operator=(const NanPersistent<S, M2> &that) {
+  NAN_INLINE Persistent &operator=(const Persistent<S, M2> &that) {
     Copy(that);
     return *this;
   }
 
-  NAN_INLINE ~NanPersistent() {
+  NAN_INLINE ~Persistent() {
     if (M::kResetInDestructor) this->Reset();
   }
 
  private:
-  NAN_INLINE T *operator*() const { return *NanPersistentBase<T>::persistent; }
+  NAN_INLINE T *operator*() const { return *PersistentBase<T>::persistent; }
 
   template<typename S, typename M2>
-  NAN_INLINE void Copy(const NanPersistent<S, M2> &that) {
+  NAN_INLINE void Copy(const Persistent<S, M2> &that) {
     TYPE_CHECK(T, S);
 
     this->Reset();
@@ -181,39 +181,39 @@ template<typename T, typename M> class NanPersistent :
 };
 
 template<typename T>
-class NanGlobal : public NanPersistentBase<T> {
+class Global : public PersistentBase<T> {
   struct RValue {
-    NAN_INLINE explicit RValue(NanGlobal* obj) : object(obj) {}
-    NanGlobal* object;
+    NAN_INLINE explicit RValue(Global* obj) : object(obj) {}
+    Global* object;
   };
 
  public:
-  NAN_INLINE NanGlobal() : NanPersistentBase<T>(0) { }
+  NAN_INLINE Global() : PersistentBase<T>(0) { }
 
   template <typename S>
-  NAN_INLINE NanGlobal(v8::Handle<S> that)
-      : NanPersistentBase<T>(v8::Persistent<T>::New(that)) {
+  NAN_INLINE Global(v8::Handle<S> that)
+      : PersistentBase<T>(v8::Persistent<T>::New(that)) {
     TYPE_CHECK(T, S);
   }
 
   template <typename S>
-  NAN_INLINE NanGlobal(const NanPersistentBase<S> &that)
-    : NanPersistentBase<T>(that) {
+  NAN_INLINE Global(const PersistentBase<S> &that)
+    : PersistentBase<T>(that) {
     TYPE_CHECK(T, S);
   }
   /**
    * Move constructor.
    */
-  NAN_INLINE NanGlobal(RValue rvalue)
-    : NanPersistentBase<T>(rvalue.object.persistent) {
+  NAN_INLINE Global(RValue rvalue)
+    : PersistentBase<T>(rvalue.object.persistent) {
     rvalue.object->Reset();
   }
-  NAN_INLINE ~NanGlobal() { this->Reset(); }
+  NAN_INLINE ~Global() { this->Reset(); }
   /**
    * Move via assignment.
    */
   template<typename S>
-  NAN_INLINE NanGlobal &operator=(NanGlobal<S> rhs) {
+  NAN_INLINE Global &operator=(Global<S> rhs) {
     TYPE_CHECK(T, S);
     this->Reset(rhs.persistent);
     rhs.Reset();
@@ -226,12 +226,12 @@ class NanGlobal : public NanPersistentBase<T> {
   /**
    * Pass allows returning uniques from functions, etc.
    */
-  NanGlobal Pass() { return NanGlobal(RValue(this)); }
+  Global Pass() { return Global(RValue(this)); }
 
  private:
-  NanGlobal(NanGlobal &);
-  void operator=(NanGlobal &);
-  template<typename S> friend class NanReturnValue;
+  Global(Global &);
+  void operator=(Global &);
+  template<typename S> friend class ReturnValue;
 };
 
 #endif  // NAN_PERSISTENT_PRE_12_INL_H_
diff --git a/nan_string_bytes.h b/nan_string_bytes.h
index 2b8dcb84..e11f1d0a 100644
--- a/nan_string_bytes.h
+++ b/nan_string_bytes.h
@@ -227,26 +227,26 @@ static Local<Value> Encode(const char* buf,
                            enum Encoding encoding) {
   assert(buflen <= node::Buffer::kMaxLength);
   if (!buflen && encoding != BUFFER)
-    return NanNew("").ToLocalChecked();
+    return New("").ToLocalChecked();
 
   Local<String> val;
   switch (encoding) {
     case BUFFER:
-      return NanCopyBuffer(buf, buflen).ToLocalChecked();
+      return CopyBuffer(buf, buflen).ToLocalChecked();
 
     case ASCII:
       if (contains_non_ascii(buf, buflen)) {
         char* out = new char[buflen];
         force_ascii(buf, out, buflen);
-        val = NanNew<String>(out, buflen).ToLocalChecked();
+        val = New<String>(out, buflen).ToLocalChecked();
         delete[] out;
       } else {
-        val = NanNew<String>(buf, buflen).ToLocalChecked();
+        val = New<String>(buf, buflen).ToLocalChecked();
       }
       break;
 
     case UTF8:
-      val = NanNew<String>(buf, buflen).ToLocalChecked();
+      val = New<String>(buf, buflen).ToLocalChecked();
       break;
 
     case BINARY: {
@@ -257,7 +257,7 @@ static Local<Value> Encode(const char* buf,
         // XXX is the following line platform independent?
         twobytebuf[i] = cbuf[i];
       }
-      val = NanNew<String>(twobytebuf, buflen).ToLocalChecked();
+      val = New<String>(twobytebuf, buflen).ToLocalChecked();
       delete[] twobytebuf;
       break;
     }
@@ -269,14 +269,14 @@ static Local<Value> Encode(const char* buf,
       size_t written = base64_encode(buf, buflen, dst, dlen);
       assert(written == dlen);
 
-      val = NanNew<String>(dst, dlen).ToLocalChecked();
+      val = New<String>(dst, dlen).ToLocalChecked();
       delete[] dst;
       break;
     }
 
     case UCS2: {
       const uint16_t* data = reinterpret_cast<const uint16_t*>(buf);
-      val = NanNew<String>(data, buflen / 2).ToLocalChecked();
+      val = New<String>(data, buflen / 2).ToLocalChecked();
       break;
     }
 
@@ -286,7 +286,7 @@ static Local<Value> Encode(const char* buf,
       size_t written = hex_encode(buf, buflen, dst, dlen);
       assert(written == dlen);
 
-      val = NanNew<String>(dst, dlen).ToLocalChecked();
+      val = New<String>(dst, dlen).ToLocalChecked();
       delete[] dst;
       break;
     }
diff --git a/nan_weak.h b/nan_weak.h
index d34137e1..b22fc266 100644
--- a/nan_weak.h
+++ b/nan_weak.h
@@ -15,28 +15,28 @@ static const int kNoInternalFieldIndex = -1;
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 # define NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ \
-    v8::WeakCallbackInfo<NanWeakCallbackInfo<T> > const&
+    v8::WeakCallbackInfo<WeakCallbackInfo<T> > const&
 # define NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ \
     NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
 # define NAN_WEAK_PARAMETER_CALLBACK_SIG_ NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
 # define NAN_WEAK_TWOFIELD_CALLBACK_SIG_ NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
 #elif NODE_MODULE_VERSION > IOJS_1_1_MODULE_VERSION
 # define NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ \
-    v8::PhantomCallbackData<NanWeakCallbackInfo<T> > const&
+    v8::PhantomCallbackData<WeakCallbackInfo<T> > const&
 # define NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ \
     NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
 # define NAN_WEAK_PARAMETER_CALLBACK_SIG_ NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
 # define NAN_WEAK_TWOFIELD_CALLBACK_SIG_ NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
 #elif NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
 # define NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ \
-    v8::PhantomCallbackData<NanWeakCallbackInfo<T> > const&
+    v8::PhantomCallbackData<WeakCallbackInfo<T> > const&
 # define NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ \
-    v8::InternalFieldsCallbackData<NanWeakCallbackInfo<T>, void> const&
+    v8::InternalFieldsCallbackData<WeakCallbackInfo<T>, void> const&
 # define NAN_WEAK_PARAMETER_CALLBACK_SIG_ NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_
 # define NAN_WEAK_TWOFIELD_CALLBACK_SIG_ NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_
 #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
 # define NAN_WEAK_CALLBACK_DATA_TYPE_ \
-    v8::WeakCallbackData<S, NanWeakCallbackInfo<T> > const&
+    v8::WeakCallbackData<S, WeakCallbackInfo<T> > const&
 # define NAN_WEAK_CALLBACK_SIG_ NAN_WEAK_CALLBACK_DATA_TYPE_
 #else
 # define NAN_WEAK_CALLBACK_DATA_TYPE_ void *
@@ -45,11 +45,11 @@ static const int kNoInternalFieldIndex = -1;
 #endif
 
 template<typename T>
-class NanWeakCallbackInfo {
+class WeakCallbackInfo {
  public:
-  typedef void (*Callback)(const NanWeakCallbackInfo<T>& data);
-  NanWeakCallbackInfo(
-      NanPersistent<v8::Value> *persistent
+  typedef void (*Callback)(const WeakCallbackInfo<T>& data);
+  WeakCallbackInfo(
+      Persistent<v8::Value> *persistent
     , Callback callback
     , void *parameter
     , void *field1 = 0
@@ -76,24 +76,24 @@ class NanWeakCallbackInfo {
   void *parameter_;
   void *internal_fields_[kInternalFieldsInWeakCallback];
   v8::Persistent<v8::Value> persistent_;
-  template<typename S, typename M> friend class NanPersistent;
-  template<typename S> friend class NanPersistentBase;
+  template<typename S, typename M> friend class Persistent;
+  template<typename S> friend class PersistentBase;
 #if NODE_MODULE_VERSION <= NODE_0_12_MODULE_VERSION
 # if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
   template<typename S>
   static void invoke(NAN_WEAK_CALLBACK_SIG_ data);
   template<typename S>
-  static NanWeakCallbackInfo *unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
+  static WeakCallbackInfo *unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
 # else
   static void invoke(NAN_WEAK_CALLBACK_SIG_ data);
-  static NanWeakCallbackInfo *unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
+  static WeakCallbackInfo *unwrap(NAN_WEAK_CALLBACK_DATA_TYPE_ data);
 # endif
 #else
   static void invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data);
   static void invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data);
-  static NanWeakCallbackInfo *unwrapparameter(
+  static WeakCallbackInfo *unwrapparameter(
       NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ data);
-  static NanWeakCallbackInfo *unwraptwofield(
+  static WeakCallbackInfo *unwraptwofield(
       NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ data);
 #endif
 };
@@ -104,8 +104,8 @@ class NanWeakCallbackInfo {
 
 template<typename T>
 void
-NanWeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
-  NanWeakCallbackInfo<T> *cbinfo = unwrapparameter(data);
+WeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
+  WeakCallbackInfo<T> *cbinfo = unwrapparameter(data);
   if (data.IsFirstPass()) {
     cbinfo->persistent_.Reset();
     data.SetSecondPassCallback(invokeparameter);
@@ -117,8 +117,8 @@ NanWeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
 
 template<typename T>
 void
-NanWeakCallbackInfo<T>::invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data) {
-  NanWeakCallbackInfo<T> *cbinfo = unwraptwofield(data);
+WeakCallbackInfo<T>::invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data) {
+  WeakCallbackInfo<T> *cbinfo = unwraptwofield(data);
   if (data.IsFirstPass()) {
     cbinfo->persistent_.Reset();
     data.SetSecondPassCallback(invoketwofield);
@@ -129,19 +129,19 @@ NanWeakCallbackInfo<T>::invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data) {
 }
 
 template<typename T>
-NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrapparameter(
+WeakCallbackInfo<T> *WeakCallbackInfo<T>::unwrapparameter(
     NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ data) {
-  NanWeakCallbackInfo<T> *cbinfo =
-      static_cast<NanWeakCallbackInfo<T>*>(data.GetParameter());
+  WeakCallbackInfo<T> *cbinfo =
+      static_cast<WeakCallbackInfo<T>*>(data.GetParameter());
   cbinfo->isolate_ = data.GetIsolate();
   return cbinfo;
 }
 
 template<typename T>
-NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwraptwofield(
+WeakCallbackInfo<T> *WeakCallbackInfo<T>::unwraptwofield(
     NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ data) {
-  NanWeakCallbackInfo<T> *cbinfo =
-      static_cast<NanWeakCallbackInfo<T>*>(data.GetInternalField(0));
+  WeakCallbackInfo<T> *cbinfo =
+      static_cast<WeakCallbackInfo<T>*>(data.GetInternalField(0));
   cbinfo->isolate_ = data.GetIsolate();
   return cbinfo;
 }
@@ -154,8 +154,8 @@ NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwraptwofield(
 
 template<typename T>
 void
-NanWeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
-  NanWeakCallbackInfo<T> *cbinfo = unwrapparameter(data);
+WeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
+  WeakCallbackInfo<T> *cbinfo = unwrapparameter(data);
   cbinfo->persistent_.Reset();
   cbinfo->callback_(*cbinfo);
   delete cbinfo;
@@ -163,27 +163,27 @@ NanWeakCallbackInfo<T>::invokeparameter(NAN_WEAK_PARAMETER_CALLBACK_SIG_ data) {
 
 template<typename T>
 void
-NanWeakCallbackInfo<T>::invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data) {
-  NanWeakCallbackInfo<T> *cbinfo = unwraptwofield(data);
+WeakCallbackInfo<T>::invoketwofield(NAN_WEAK_TWOFIELD_CALLBACK_SIG_ data) {
+  WeakCallbackInfo<T> *cbinfo = unwraptwofield(data);
   cbinfo->persistent_.Reset();
   cbinfo->callback_(*cbinfo);
   delete cbinfo;
 }
 
 template<typename T>
-NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrapparameter(
+WeakCallbackInfo<T> *WeakCallbackInfo<T>::unwrapparameter(
     NAN_WEAK_PARAMETER_CALLBACK_DATA_TYPE_ data) {
-  NanWeakCallbackInfo<T> *cbinfo =
-       static_cast<NanWeakCallbackInfo<T>*>(data.GetParameter());
+  WeakCallbackInfo<T> *cbinfo =
+       static_cast<WeakCallbackInfo<T>*>(data.GetParameter());
   cbinfo->isolate_ = data.GetIsolate();
   return cbinfo;
 }
 
 template<typename T>
-NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwraptwofield(
+WeakCallbackInfo<T> *WeakCallbackInfo<T>::unwraptwofield(
     NAN_WEAK_TWOFIELD_CALLBACK_DATA_TYPE_ data) {
-  NanWeakCallbackInfo<T> *cbinfo =
-       static_cast<NanWeakCallbackInfo<T>*>(data.GetInternalField1());
+  WeakCallbackInfo<T> *cbinfo =
+       static_cast<WeakCallbackInfo<T>*>(data.GetInternalField1());
   cbinfo->isolate_ = data.GetIsolate();
   return cbinfo;
 }
@@ -196,8 +196,8 @@ NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwraptwofield(
 
 template<typename T>
 template<typename S>
-void NanWeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
-  NanWeakCallbackInfo<T> *cbinfo = unwrap(data);
+void WeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
+  WeakCallbackInfo<T> *cbinfo = unwrap(data);
   cbinfo->persistent_.Reset();
   cbinfo->callback_(*cbinfo);
   delete cbinfo;
@@ -205,11 +205,11 @@ void NanWeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
 
 template<typename T>
 template<typename S>
-NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrap(
+WeakCallbackInfo<T> *WeakCallbackInfo<T>::unwrap(
     NAN_WEAK_CALLBACK_DATA_TYPE_ data) {
   void *parameter = data.GetParameter();
-  NanWeakCallbackInfo<T> *cbinfo =
-      static_cast<NanWeakCallbackInfo<T>*>(parameter);
+  WeakCallbackInfo<T> *cbinfo =
+      static_cast<WeakCallbackInfo<T>*>(parameter);
   cbinfo->isolate_ = data.GetIsolate();
   return cbinfo;
 }
@@ -219,8 +219,8 @@ NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrap(
 #else
 
 template<typename T>
-void NanWeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
-  NanWeakCallbackInfo<T> *cbinfo = unwrap(data);
+void WeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
+  WeakCallbackInfo<T> *cbinfo = unwrap(data);
   cbinfo->persistent_.Dispose();
   cbinfo->persistent_.Clear();
   cbinfo->callback_(*cbinfo);
@@ -228,10 +228,10 @@ void NanWeakCallbackInfo<T>::invoke(NAN_WEAK_CALLBACK_SIG_ data) {
 }
 
 template<typename T>
-NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrap(
+WeakCallbackInfo<T> *WeakCallbackInfo<T>::unwrap(
     NAN_WEAK_CALLBACK_DATA_TYPE_ data) {
-  NanWeakCallbackInfo<T> *cbinfo =
-      static_cast<NanWeakCallbackInfo<T>*>(data);
+  WeakCallbackInfo<T> *cbinfo =
+      static_cast<WeakCallbackInfo<T>*>(data);
   cbinfo->isolate_ = v8::Isolate::GetCurrent();
   return cbinfo;
 }
@@ -244,14 +244,14 @@ NanWeakCallbackInfo<T> *NanWeakCallbackInfo<T>::unwrap(
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 template<typename T, typename M>
 template<typename P>
-NAN_INLINE void NanPersistent<T, M>::SetWeak(
+NAN_INLINE void Persistent<T, M>::SetWeak(
     P *parameter
-  , typename NanWeakCallbackInfo<P>::Callback callback
-  , NanWeakCallbackType type) {
-  NanWeakCallbackInfo<P> *wcbd;
-  if (type == NanWeakCallbackType::kParameter) {
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+  , typename WeakCallbackInfo<P>::Callback callback
+  , WeakCallbackType type) {
+  WeakCallbackInfo<P> *wcbd;
+  if (type == WeakCallbackType::kParameter) {
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
     v8::PersistentBase<T>::SetWeak(wcbd, wcbd->invokeparameter, type);
@@ -263,15 +263,15 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
     for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
       internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
     }
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , 0
       , internal_fields[0]
       , internal_fields[1]);
     (*self)->SetAlignedPointerInInternalField(0, wcbd);
     v8::PersistentBase<T>::SetWeak(
-        static_cast<NanWeakCallbackInfo<P>*>(0)
+        static_cast<WeakCallbackInfo<P>*>(0)
       , wcbd->invoketwofield
       , type);
   }
@@ -279,14 +279,14 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
 #elif NODE_MODULE_VERSION > IOJS_1_1_MODULE_VERSION
 template<typename T, typename M>
 template<typename P>
-NAN_INLINE void NanPersistent<T, M>::SetWeak(
+NAN_INLINE void Persistent<T, M>::SetWeak(
     P *parameter
-  , typename NanWeakCallbackInfo<P>::Callback callback
-  , NanWeakCallbackType type) {
-  NanWeakCallbackInfo<P> *wcbd;
-  if (type == NanWeakCallbackType::kParameter) {
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+  , typename WeakCallbackInfo<P>::Callback callback
+  , WeakCallbackType type) {
+  WeakCallbackInfo<P> *wcbd;
+  if (type == WeakCallbackType::kParameter) {
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
     v8::PersistentBase<T>::SetPhantom(wcbd, wcbd->invokeparameter);
@@ -298,15 +298,15 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
     for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
       internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
     }
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , 0
       , internal_fields[0]
       , internal_fields[1]);
     (*self)->SetAlignedPointerInInternalField(0, wcbd);
     v8::PersistentBase<T>::SetPhantom(
-        static_cast<NanWeakCallbackInfo<P>*>(0)
+        static_cast<WeakCallbackInfo<P>*>(0)
       , wcbd->invoketwofield
       , 0
       , count > 1 ? 1 : kNoInternalFieldIndex);
@@ -315,14 +315,14 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
 #elif NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
 template<typename T, typename M>
 template<typename P>
-NAN_INLINE void NanPersistent<T, M>::SetWeak(
+NAN_INLINE void Persistent<T, M>::SetWeak(
     P *parameter
-  , typename NanWeakCallbackInfo<P>::Callback callback
-  , NanWeakCallbackType type) {
-  NanWeakCallbackInfo<P> *wcbd;
-  if (type == NanWeakCallbackType::kParameter) {
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+  , typename WeakCallbackInfo<P>::Callback callback
+  , WeakCallbackType type) {
+  WeakCallbackInfo<P> *wcbd;
+  if (type == WeakCallbackType::kParameter) {
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
     v8::PersistentBase<T>::SetPhantom(wcbd, wcbd->invokeparameter);
@@ -334,8 +334,8 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
     for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
       internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
     }
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , 0
       , internal_fields[0]
@@ -350,14 +350,14 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
 #elif NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
 template<typename T, typename M>
 template<typename P>
-NAN_INLINE void NanPersistent<T, M>::SetWeak(
+NAN_INLINE void Persistent<T, M>::SetWeak(
     P *parameter
-  , typename NanWeakCallbackInfo<P>::Callback callback
-  , NanWeakCallbackType type) {
-  NanWeakCallbackInfo<P> *wcbd;
-  if (type == NanWeakCallbackType::kParameter) {
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+  , typename WeakCallbackInfo<P>::Callback callback
+  , WeakCallbackType type) {
+  WeakCallbackInfo<P> *wcbd;
+  if (type == WeakCallbackType::kParameter) {
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
     v8::PersistentBase<T>::SetWeak(wcbd, wcbd->invoke);
@@ -369,8 +369,8 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
     for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
       internal_fields[i] = (*self)->GetAlignedPointerFromInternalField(i);
     }
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , 0
       , internal_fields[0]
@@ -381,14 +381,14 @@ NAN_INLINE void NanPersistent<T, M>::SetWeak(
 #else
 template<typename T>
 template<typename P>
-NAN_INLINE void NanPersistentBase<T>::SetWeak(
+NAN_INLINE void PersistentBase<T>::SetWeak(
     P *parameter
-  , typename NanWeakCallbackInfo<P>::Callback callback
-  , NanWeakCallbackType type) {
-  NanWeakCallbackInfo<P> *wcbd;
-  if (type == NanWeakCallbackType::kParameter) {
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+  , typename WeakCallbackInfo<P>::Callback callback
+  , WeakCallbackType type) {
+  WeakCallbackInfo<P> *wcbd;
+  if (type == WeakCallbackType::kParameter) {
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , parameter);
     persistent.MakeWeak(wcbd, wcbd->invoke);
@@ -400,8 +400,8 @@ NAN_INLINE void NanPersistentBase<T>::SetWeak(
     for (int i = 0; i < count && i < kInternalFieldsInWeakCallback; i++) {
       internal_fields[i] = (*self)->GetPointerFromInternalField(i);
     }
-    wcbd = new NanWeakCallbackInfo<P>(
-        reinterpret_cast<NanPersistent<v8::Value>*>(this)
+    wcbd = new WeakCallbackInfo<P>(
+        reinterpret_cast<Persistent<v8::Value>*>(this)
       , callback
       , 0
       , internal_fields[0]
diff --git a/test/cpp/accessors.cpp b/test/cpp/accessors.cpp
index 5b3ad91b..a743b52c 100644
--- a/test/cpp/accessors.cpp
+++ b/test/cpp/accessors.cpp
@@ -11,7 +11,7 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class SetterGetter : public NanObjectWrap {
+class SetterGetter : public ObjectWrap {
  public:
   static void Init (v8::Handle<v8::Object> target);
   static v8::Handle<v8::Value> NewInstance ();
@@ -28,7 +28,7 @@ class SetterGetter : public NanObjectWrap {
   char prop2[256];
 };
 
-static NanPersistent<v8::FunctionTemplate> settergetter_constructor;
+static Persistent<v8::FunctionTemplate> settergetter_constructor;
 
 NAN_METHOD(CreateNew) {
   info.GetReturnValue().Set(SetterGetter::NewInstance());
@@ -43,32 +43,32 @@ SetterGetter::SetterGetter() {
 
 void SetterGetter::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
-    NanNew<v8::FunctionTemplate>(SetterGetter::New);
+    Nan::New<v8::FunctionTemplate>(SetterGetter::New);
   settergetter_constructor.Reset(tpl);
-  tpl->SetClassName(NanNew<v8::String>("SetterGetter").ToLocalChecked());
+  tpl->SetClassName(Nan::New<v8::String>("SetterGetter").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  NanSetPrototypeMethod(tpl, "log", SetterGetter::Log);
+  SetPrototypeMethod(tpl, "log", SetterGetter::Log);
   v8::Local<v8::ObjectTemplate> proto = tpl->PrototypeTemplate();
-  NanSetAccessor(
+  SetAccessor(
       proto
-    , NanNew("prop1").ToLocalChecked()
+    , Nan::New("prop1").ToLocalChecked()
     , SetterGetter::GetProp1);
-  NanSetAccessor(
+  SetAccessor(
       proto
-    , NanNew<v8::String>("prop2").ToLocalChecked()
+    , Nan::New<v8::String>("prop2").ToLocalChecked()
     , SetterGetter::GetProp2
     , SetterGetter::SetProp2
   );
 
   v8::Local<v8::Function> createnew =
-    NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
-  NanSet(target, NanNew<v8::String>("create").ToLocalChecked(), createnew);
+    Nan::New<v8::FunctionTemplate>(CreateNew)->GetFunction();
+  Set(target, Nan::New<v8::String>("create").ToLocalChecked(), createnew);
 }
 
 v8::Handle<v8::Value> SetterGetter::NewInstance () {
-  NanEscapableScope scope;
+  EscapableScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
-      NanNew(settergetter_constructor);
+      Nan::New(settergetter_constructor);
   v8::Local<v8::Object> instance =
     constructorHandle->GetFunction()->NewInstance(0, NULL);
   return scope.Escape(instance);
@@ -88,7 +88,7 @@ NAN_METHOD(SetterGetter::New) {
 
 NAN_GETTER(SetterGetter::GetProp1) {
   SetterGetter* settergetter =
-    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+    ObjectWrap::Unwrap<SetterGetter>(info.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
   strncat(
       settergetter->log
@@ -105,12 +105,12 @@ NAN_GETTER(SetterGetter::GetProp1) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  info.GetReturnValue().Set(NanNew(settergetter->prop1).ToLocalChecked());
+  info.GetReturnValue().Set(Nan::New(settergetter->prop1).ToLocalChecked());
 }
 
 NAN_GETTER(SetterGetter::GetProp2) {
   SetterGetter* settergetter =
-    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+    ObjectWrap::Unwrap<SetterGetter>(info.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
   strncat(
       settergetter->log
@@ -127,15 +127,15 @@ NAN_GETTER(SetterGetter::GetProp2) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  info.GetReturnValue().Set(NanNew(settergetter->prop2).ToLocalChecked());
+  info.GetReturnValue().Set(Nan::New(settergetter->prop2).ToLocalChecked());
 }
 
 NAN_SETTER(SetterGetter::SetProp2) {
   SetterGetter* settergetter =
-      NanObjectWrap::Unwrap<SetterGetter>(info.This());
+      ObjectWrap::Unwrap<SetterGetter>(info.This());
   strncpy(
       settergetter->prop2
-    , *NanUtf8String(value)
+    , *Utf8String(value)
     , sizeof (settergetter->prop2));
   settergetter->prop2[sizeof (settergetter->prop2) - 1] = '\0';
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
@@ -157,9 +157,9 @@ NAN_SETTER(SetterGetter::SetProp2) {
 
 NAN_METHOD(SetterGetter::Log) {
   SetterGetter* settergetter =
-    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+    ObjectWrap::Unwrap<SetterGetter>(info.This());
 
-  info.GetReturnValue().Set(NanNew(settergetter->log).ToLocalChecked());
+  info.GetReturnValue().Set(Nan::New(settergetter->log).ToLocalChecked());
 }
 
 NODE_MODULE(accessors, SetterGetter::Init)
diff --git a/test/cpp/accessors2.cpp b/test/cpp/accessors2.cpp
index 09920e7c..0c5c9e48 100644
--- a/test/cpp/accessors2.cpp
+++ b/test/cpp/accessors2.cpp
@@ -11,7 +11,7 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class SetterGetter : public NanObjectWrap {
+class SetterGetter : public ObjectWrap {
  public:
   static void Init (v8::Handle<v8::Object> target);
   static v8::Handle<v8::Value> NewInstance ();
@@ -28,7 +28,7 @@ class SetterGetter : public NanObjectWrap {
   char prop2[256];
 };
 
-static NanPersistent<v8::FunctionTemplate> settergetter_constructor;
+static Persistent<v8::FunctionTemplate> settergetter_constructor;
 
 NAN_METHOD(CreateNew) {
   info.GetReturnValue().Set(SetterGetter::NewInstance());
@@ -43,29 +43,29 @@ SetterGetter::SetterGetter() {
 
 void SetterGetter::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
-    NanNew<v8::FunctionTemplate>(SetterGetter::New);
+    Nan::New<v8::FunctionTemplate>(SetterGetter::New);
   settergetter_constructor.Reset(tpl);
-  tpl->SetClassName(NanNew<v8::String>("SetterGetter").ToLocalChecked());
+  tpl->SetClassName(Nan::New<v8::String>("SetterGetter").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
-  NanSetPrototypeMethod(tpl, "log", SetterGetter::Log);
+  SetPrototypeMethod(tpl, "log", SetterGetter::Log);
   v8::Local<v8::Function> createnew =
-    NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
-  NanSet(target, NanNew<v8::String>("create").ToLocalChecked(), createnew);
+    Nan::New<v8::FunctionTemplate>(CreateNew)->GetFunction();
+  Set(target, Nan::New<v8::String>("create").ToLocalChecked(), createnew);
 }
 
 v8::Handle<v8::Value> SetterGetter::NewInstance () {
-  NanEscapableScope scope;
+  EscapableScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
-      NanNew(settergetter_constructor);
+      Nan::New(settergetter_constructor);
   v8::Local<v8::Object> instance =
     constructorHandle->GetFunction()->NewInstance(0, NULL);
-  NanSetAccessor(
+  SetAccessor(
       instance
-    , NanNew("prop1").ToLocalChecked()
+    , Nan::New("prop1").ToLocalChecked()
     , SetterGetter::GetProp1);
-  NanSetAccessor(
+  SetAccessor(
       instance
-    , NanNew<v8::String>("prop2").ToLocalChecked()
+    , Nan::New<v8::String>("prop2").ToLocalChecked()
     , SetterGetter::GetProp2
     , SetterGetter::SetProp2
   );
@@ -86,7 +86,7 @@ NAN_METHOD(SetterGetter::New) {
 
 NAN_GETTER(SetterGetter::GetProp1) {
   SetterGetter* settergetter =
-    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+    ObjectWrap::Unwrap<SetterGetter>(info.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
   strncat(
       settergetter->log
@@ -103,12 +103,12 @@ NAN_GETTER(SetterGetter::GetProp1) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  info.GetReturnValue().Set(NanNew(settergetter->prop1).ToLocalChecked());
+  info.GetReturnValue().Set(Nan::New(settergetter->prop1).ToLocalChecked());
 }
 
 NAN_GETTER(SetterGetter::GetProp2) {
   SetterGetter* settergetter =
-    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+    ObjectWrap::Unwrap<SetterGetter>(info.This());
   assert(strlen(settergetter->log) < sizeof (settergetter->log));
   strncat(
       settergetter->log
@@ -125,12 +125,12 @@ NAN_GETTER(SetterGetter::GetProp2) {
     , ")\n"
     , sizeof (settergetter->log) - 1 - strlen(settergetter->log));
 
-  info.GetReturnValue().Set(NanNew(settergetter->prop2).ToLocalChecked());
+  info.GetReturnValue().Set(Nan::New(settergetter->prop2).ToLocalChecked());
 }
 
 NAN_SETTER(SetterGetter::SetProp2) {
   SetterGetter* settergetter =
-      NanObjectWrap::Unwrap<SetterGetter>(info.This());
+      ObjectWrap::Unwrap<SetterGetter>(info.This());
   strncpy(
       settergetter->prop2
     , *v8::String::Utf8Value(value)
@@ -155,9 +155,9 @@ NAN_SETTER(SetterGetter::SetProp2) {
 
 NAN_METHOD(SetterGetter::Log) {
   SetterGetter* settergetter =
-    NanObjectWrap::Unwrap<SetterGetter>(info.This());
+    ObjectWrap::Unwrap<SetterGetter>(info.This());
 
-  info.GetReturnValue().Set(NanNew(settergetter->log).ToLocalChecked());
+  info.GetReturnValue().Set(Nan::New(settergetter->log).ToLocalChecked());
 }
 
 NODE_MODULE(accessors2, SetterGetter::Init)
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index 1e6c2ac2..d69bcd8e 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -14,18 +14,18 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class ProgressWorker : public NanAsyncProgressWorker {
+class ProgressWorker : public AsyncProgressWorker {
  public:
   ProgressWorker(
-      NanCallback *callback
-    , NanCallback *progress
+      Callback *callback
+    , Callback *progress
     , int milliseconds
     , int iters)
-    : NanAsyncProgressWorker(callback), progress(progress)
+    : AsyncProgressWorker(callback), progress(progress)
     , milliseconds(milliseconds), iters(iters) {}
   ~ProgressWorker() {}
 
-  void Execute (const NanAsyncProgressWorker::ExecutionProgress& progress) {
+  void Execute (const AsyncProgressWorker::ExecutionProgress& progress) {
     for (int i = 0; i < iters; ++i) {
       progress.Send(reinterpret_cast<const char*>(&i), sizeof(int));
       Sleep(milliseconds);
@@ -33,34 +33,34 @@ class ProgressWorker : public NanAsyncProgressWorker {
   }
 
   void HandleProgressCallback(const char *data, size_t size) {
-    NanScope scope;
+    Scope scope;
 
     v8::Local<v8::Value> argv[] = {
-        NanNew<v8::Integer>(*reinterpret_cast<int*>(const_cast<char*>(data)))
+        New<v8::Integer>(*reinterpret_cast<int*>(const_cast<char*>(data)))
     };
     progress->Call(1, argv);
   }
 
  private:
-  NanCallback *progress;
+  Callback *progress;
   int milliseconds;
   int iters;
 };
 
 NAN_METHOD(DoProgress) {
-  NanCallback *progress = new NanCallback(info[2].As<v8::Function>());
-  NanCallback *callback = new NanCallback(info[3].As<v8::Function>());
-  NanAsyncQueueWorker(new ProgressWorker(
+  Callback *progress = new Callback(info[2].As<v8::Function>());
+  Callback *callback = new Callback(info[3].As<v8::Function>());
+  AsyncQueueWorker(new ProgressWorker(
       callback
     , progress
-    , NanTo<uint32_t>(info[0]).FromJust()
-    , NanTo<uint32_t>(info[1]).FromJust()));
+    , To<uint32_t>(info[0]).FromJust()
+    , To<uint32_t>(info[1]).FromJust()));
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  NanSet(exports
-    , NanNew<v8::String>("a").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(DoProgress)->GetFunction());
+  Set(exports
+    , New<v8::String>("a").ToLocalChecked()
+    , New<v8::FunctionTemplate>(DoProgress)->GetFunction());
 }
 
 NODE_MODULE(asyncprogressworker, Init)
diff --git a/test/cpp/asyncworker.cpp b/test/cpp/asyncworker.cpp
index 1d269549..ef5e7d81 100644
--- a/test/cpp/asyncworker.cpp
+++ b/test/cpp/asyncworker.cpp
@@ -14,10 +14,10 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class SleepWorker : public NanAsyncWorker {
+class SleepWorker : public AsyncWorker {
  public:
-  SleepWorker(NanCallback *callback, int milliseconds)
-    : NanAsyncWorker(callback), milliseconds(milliseconds) {}
+  SleepWorker(Callback *callback, int milliseconds)
+    : AsyncWorker(callback), milliseconds(milliseconds) {}
   ~SleepWorker() {}
 
   void Execute () {
@@ -29,15 +29,15 @@ class SleepWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(DoSleep) {
-  NanCallback *callback = new NanCallback(info[1].As<v8::Function>());
-  NanAsyncQueueWorker(
-      new SleepWorker(callback, NanTo<uint32_t>(info[0]).FromJust()));
+  Callback *callback = new Callback(info[1].As<v8::Function>());
+  AsyncQueueWorker(
+      new SleepWorker(callback, To<uint32_t>(info[0]).FromJust()));
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  NanSet(exports
-    , NanNew<v8::String>("a").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(DoSleep)->GetFunction());
+  Set(exports
+    , New<v8::String>("a").ToLocalChecked()
+    , New<v8::FunctionTemplate>(DoSleep)->GetFunction());
 }
 
 NODE_MODULE(asyncworker, Init)
diff --git a/test/cpp/asyncworkererror.cpp b/test/cpp/asyncworkererror.cpp
index 80f9ffa4..8bf47f87 100644
--- a/test/cpp/asyncworkererror.cpp
+++ b/test/cpp/asyncworkererror.cpp
@@ -10,9 +10,9 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class ErrorWorker : public NanAsyncWorker {
+class ErrorWorker : public AsyncWorker {
  public:
-  explicit ErrorWorker(NanCallback *callback) : NanAsyncWorker(callback) {}
+  explicit ErrorWorker(Callback *callback) : AsyncWorker(callback) {}
   ~ErrorWorker() {}
 
   void Execute () {
@@ -21,15 +21,15 @@ class ErrorWorker : public NanAsyncWorker {
 };
 
 NAN_METHOD(Work) {
-  NanCallback *callback = new NanCallback(info[0].As<v8::Function>());
-  NanAsyncQueueWorker(new ErrorWorker(callback));
+  Callback *callback = new Callback(info[0].As<v8::Function>());
+  AsyncQueueWorker(new ErrorWorker(callback));
   info.GetReturnValue().SetUndefined();
 }
 
 void Init (v8::Handle<v8::Object> exports) {
-  NanSet(exports
-    , NanNew("a").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Work)->GetFunction());
+  Set(exports
+    , New("a").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Work)->GetFunction());
 }
 
 NODE_MODULE(asyncworkererror, Init)
diff --git a/test/cpp/buffer.cpp b/test/cpp/buffer.cpp
index 2ad2c5d4..438a8ff8 100644
--- a/test/cpp/buffer.cpp
+++ b/test/cpp/buffer.cpp
@@ -24,11 +24,11 @@ NAN_METHOD(New1) {
     dynamic_data[i] = 'a' + i;
   }
   info.GetReturnValue().Set(
-      NanNewBuffer(dynamic_data, DATA_SIZE, callback, 0).ToLocalChecked());
+      NewBuffer(dynamic_data, DATA_SIZE, callback, 0).ToLocalChecked());
 }
 
 NAN_METHOD(New2) {
-  v8::Local<v8::Object> buf = NanNewBuffer(DATA_SIZE).ToLocalChecked();
+  v8::Local<v8::Object> buf = NewBuffer(DATA_SIZE).ToLocalChecked();
   char* pbuf = node::Buffer::Data(buf);
   for (unsigned char i = 0; i < DATA_SIZE; i++) {
     pbuf[i] = 'a' + i;
@@ -41,11 +41,11 @@ NAN_METHOD(New3) {
   for (unsigned char i = 0; i < DATA_SIZE; i++) {
     dynamic_data[i] = 'a' + i;
   }
-  info.GetReturnValue().Set(NanNewBuffer(dynamic_data, DATA_SIZE));
+  info.GetReturnValue().Set(NewBuffer(dynamic_data, DATA_SIZE));
 }
 
 NAN_METHOD(Copy) {
-  info.GetReturnValue().Set(NanCopyBuffer(data, DATA_SIZE).ToLocalChecked());
+  info.GetReturnValue().Set(CopyBuffer(data, DATA_SIZE).ToLocalChecked());
 }
 
 
@@ -53,21 +53,21 @@ void Init (v8::Handle<v8::Object> target) {
   for (unsigned char i = 0; i < DATA_SIZE; i++) {
     data[i] = 'a' + i;
   }
-  NanSet(target
-    , NanNew<v8::String>("new1").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(New1)->GetFunction()
+  Set(target
+    , New<v8::String>("new1").ToLocalChecked()
+    , New<v8::FunctionTemplate>(New1)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("new2").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(New2)->GetFunction()
+  Set(target
+    , New<v8::String>("new2").ToLocalChecked()
+    , New<v8::FunctionTemplate>(New2)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("new3").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(New3)->GetFunction()
+  Set(target
+    , New<v8::String>("new3").ToLocalChecked()
+    , New<v8::FunctionTemplate>(New3)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("copy").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Copy)->GetFunction()
+  Set(target
+    , New<v8::String>("copy").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Copy)->GetFunction()
   );
 }
 
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index 851fa290..e35fc4be 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -14,16 +14,16 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class BufferWorker : public NanAsyncWorker {
+class BufferWorker : public AsyncWorker {
  public:
   BufferWorker(
-          NanCallback *callback
+          Callback *callback
         , int milliseconds
         , v8::Local<v8::Object> &bufferHandle
       )
-    : NanAsyncWorker(callback), milliseconds(milliseconds) {
+    : AsyncWorker(callback), milliseconds(milliseconds) {
       SaveToPersistent("buffer", bufferHandle);
-      SaveToPersistent(NanNew("puffer").ToLocalChecked(), bufferHandle);
+      SaveToPersistent(New("puffer").ToLocalChecked(), bufferHandle);
       SaveToPersistent(0u, bufferHandle);
     }
 
@@ -34,12 +34,12 @@ class BufferWorker : public NanAsyncWorker {
   }
 
   void HandleOKCallback () {
-    NanScope scope;
+    Scope scope;
 
     v8::Local<v8::Value> handle = GetFromPersistent("buffer");
     callback->Call(1, &handle);
 
-    handle = GetFromPersistent(NanNew("puffer").ToLocalChecked());
+    handle = GetFromPersistent(New("puffer").ToLocalChecked());
     callback->Call(1, &handle);
 
     handle = GetFromPersistent(0u);
@@ -52,18 +52,18 @@ class BufferWorker : public NanAsyncWorker {
 
 NAN_METHOD(DoSleep) {
   v8::Local<v8::Object> bufferHandle = info[1].As<v8::Object>();
-  NanCallback *callback = new NanCallback(info[2].As<v8::Function>());
+  Callback *callback = new Callback(info[2].As<v8::Function>());
   assert(!callback->IsEmpty() && "Callback shoud not be empty");
-  NanAsyncQueueWorker(new BufferWorker(
+  AsyncQueueWorker(new BufferWorker(
       callback
-    , NanTo<uint32_t>(info[0]).FromJust()
+    , To<uint32_t>(info[0]).FromJust()
     , bufferHandle));
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  NanSet(exports
-    , NanNew<v8::String>("a").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(DoSleep)->GetFunction());
+  Set(exports
+    , New<v8::String>("a").ToLocalChecked()
+    , New<v8::FunctionTemplate>(DoSleep)->GetFunction());
 }
 
 NODE_MODULE(bufferworkerpersistent, Init)
diff --git a/test/cpp/converters.cpp b/test/cpp/converters.cpp
index 182a209a..188ee5eb 100644
--- a/test/cpp/converters.cpp
+++ b/test/cpp/converters.cpp
@@ -11,119 +11,119 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 NAN_METHOD(ToBoolean) {
-  info.GetReturnValue().Set(NanTo<v8::Boolean>(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(To<v8::Boolean>(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToNumber) {
-  info.GetReturnValue().Set(NanTo<v8::Number>(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(To<v8::Number>(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToString) {
-  info.GetReturnValue().Set(NanTo<v8::String>(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(To<v8::String>(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToDetailString) {
-  info.GetReturnValue().Set(NanToDetailString(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(ToDetailString(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToObject) {
-  info.GetReturnValue().Set(NanTo<v8::Object>(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(To<v8::Object>(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToInteger) {
-  info.GetReturnValue().Set(NanTo<v8::Integer>(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(To<v8::Integer>(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToUint32) {
-  info.GetReturnValue().Set(NanTo<v8::Uint32>(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(To<v8::Uint32>(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToInt32) {
-  info.GetReturnValue().Set(NanTo<v8::Int32>(info[0]).ToLocalChecked());
+  info.GetReturnValue().Set(To<v8::Int32>(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(ToArrayIndex) {
-  NanScope();
-  info.GetReturnValue().Set(NanToArrayIndex(info[0]).ToLocalChecked());
+  Scope();
+  info.GetReturnValue().Set(ToArrayIndex(info[0]).ToLocalChecked());
 }
 
 NAN_METHOD(BooleanValue) {
-  info.GetReturnValue().Set(NanNew(NanTo<bool>(info[0]).FromJust()));
+  info.GetReturnValue().Set(New(To<bool>(info[0]).FromJust()));
 }
 
 NAN_METHOD(NumberValue) {
-  info.GetReturnValue().Set(NanNew(NanTo<double>(info[0]).FromJust()));
+  info.GetReturnValue().Set(New(To<double>(info[0]).FromJust()));
 }
 
 NAN_METHOD(IntegerValue) {
-  info.GetReturnValue().Set(NanNew<v8::Integer>(static_cast<int32_t>(
-      NanTo<int64_t>(info[0]).FromJust())));
+  info.GetReturnValue().Set(New<v8::Integer>(static_cast<int32_t>(
+      To<int64_t>(info[0]).FromJust())));
 }
 
 NAN_METHOD(Uint32Value) {
-  info.GetReturnValue().Set(NanNew(NanTo<uint32_t>(info[0]).FromJust()));
+  info.GetReturnValue().Set(New(To<uint32_t>(info[0]).FromJust()));
 }
 
 NAN_METHOD(Int32Value) {
-  info.GetReturnValue().Set(NanNew(NanTo<int32_t>(info[0]).FromJust()));
+  info.GetReturnValue().Set(New(To<int32_t>(info[0]).FromJust()));
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("toBoolean").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToBoolean)->GetFunction()
+  Set(target
+    , New<v8::String>("toBoolean").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToBoolean)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toNumber").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToNumber)->GetFunction()
+  Set(target
+    , New<v8::String>("toNumber").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToNumber)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toString").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToString)->GetFunction()
+  Set(target
+    , New<v8::String>("toString").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToString)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toDetailString").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToDetailString)->GetFunction()
+  Set(target
+    , New<v8::String>("toDetailString").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToDetailString)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toObject").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToObject)->GetFunction()
+  Set(target
+    , New<v8::String>("toObject").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToObject)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toInteger").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToInteger)->GetFunction()
+  Set(target
+    , New<v8::String>("toInteger").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToInteger)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toUint32").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToUint32)->GetFunction()
+  Set(target
+    , New<v8::String>("toUint32").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToUint32)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toInt32").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToInt32)->GetFunction()
+  Set(target
+    , New<v8::String>("toInt32").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToInt32)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toArrayIndex").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToArrayIndex)->GetFunction()
+  Set(target
+    , New<v8::String>("toArrayIndex").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToArrayIndex)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("booleanValue").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(BooleanValue)->GetFunction()
+  Set(target
+    , New<v8::String>("booleanValue").ToLocalChecked()
+    , New<v8::FunctionTemplate>(BooleanValue)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("numberValue").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NumberValue)->GetFunction()
+  Set(target
+    , New<v8::String>("numberValue").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NumberValue)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("integerValue").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(IntegerValue)->GetFunction()
+  Set(target
+    , New<v8::String>("integerValue").ToLocalChecked()
+    , New<v8::FunctionTemplate>(IntegerValue)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("uint32Value").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Uint32Value)->GetFunction()
+  Set(target
+    , New<v8::String>("uint32Value").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Uint32Value)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("int32Value").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Int32Value)->GetFunction()
+  Set(target
+    , New<v8::String>("int32Value").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Int32Value)->GetFunction()
   );
 }
 
diff --git a/test/cpp/error.cpp b/test/cpp/error.cpp
index a6ab8f12..921e3e10 100644
--- a/test/cpp/error.cpp
+++ b/test/cpp/error.cpp
@@ -12,19 +12,19 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 #define X(NAME)                                                                \
   NAN_METHOD(Throw ## NAME ## 1) {                                             \
-    return NanThrow ## NAME("errmsg");                                         \
+    return Nan::Throw ## NAME("errmsg");                                       \
   }                                                                            \
                                                                                \
   NAN_METHOD(Throw ## NAME ## 2) {                                             \
-    return NanThrow ## NAME(NanNew("errmsg").ToLocalChecked());                \
+    return Nan::Throw ## NAME(Nan::New("errmsg").ToLocalChecked());            \
   }                                                                            \
                                                                                \
   NAN_METHOD(Throw ## NAME ## 3) {                                             \
-    return NanThrowError(Nan ## NAME("errmsg"));                               \
+    return Nan::ThrowError(NAME("errmsg"));                                    \
   }                                                                            \
                                                                                \
   NAN_METHOD(Throw ## NAME ## 4) {                                             \
-    return NanThrowError(Nan ## NAME(NanNew("errmsg").ToLocalChecked()));      \
+    return Nan::ThrowError(NAME(Nan::New("errmsg").ToLocalChecked()));         \
   }
 
 X(Error)
@@ -42,10 +42,10 @@ X(TypeError)
   X(Throw ## NAME ## 4)
 
 #define X(NAME)                                                                \
-  NanSet(                                                                      \
+  Nan::Set(                                                                    \
       target                                                                   \
-    , NanNew(#NAME).ToLocalChecked()                                           \
-    , NanNew<v8::FunctionTemplate>(NAME)->GetFunction());
+    , Nan::New(#NAME).ToLocalChecked()                                         \
+    , Nan::New<v8::FunctionTemplate>(NAME)->GetFunction());
 
 
 void Init (v8::Handle<v8::Object> target) {
diff --git a/test/cpp/gc.cpp b/test/cpp/gc.cpp
index 078fd626..0512600b 100644
--- a/test/cpp/gc.cpp
+++ b/test/cpp/gc.cpp
@@ -22,25 +22,25 @@ NAN_GC_CALLBACK(gcEpilogueCallback) {
 }
 
 NAN_METHOD(Hook) {
-  NanAddGCPrologueCallback(gcPrologueCallback);
-  NanAddGCEpilogueCallback(gcEpilogueCallback);
+  AddGCPrologueCallback(gcPrologueCallback);
+  AddGCEpilogueCallback(gcEpilogueCallback);
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(Check) {
-  NanScope();
+  Scope();
   info.GetReturnValue().Set(
-      NanNew(prologue_called && epilogue_called));
+      New(prologue_called && epilogue_called));
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("hook").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Hook)->GetFunction()
+  Set(target
+    , New<v8::String>("hook").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Hook)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("check").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Check)->GetFunction()
+  Set(target
+    , New<v8::String>("check").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Check)->GetFunction()
   );
 }
 
diff --git a/test/cpp/indexedinterceptors.cpp b/test/cpp/indexedinterceptors.cpp
index 40a93f54..865bf064 100644
--- a/test/cpp/indexedinterceptors.cpp
+++ b/test/cpp/indexedinterceptors.cpp
@@ -11,7 +11,7 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class IndexedInterceptor : public NanObjectWrap {
+class IndexedInterceptor : public ObjectWrap {
   char buf[256];
 
  public:
@@ -27,7 +27,7 @@ class IndexedInterceptor : public NanObjectWrap {
   static NAN_INDEX_QUERY(PropertyQuery);
 };
 
-static NanPersistent<v8::FunctionTemplate> indexedinterceptors_constructor;
+static Persistent<v8::FunctionTemplate> indexedinterceptors_constructor;
 
 NAN_METHOD(CreateNew) {
   info.GetReturnValue().Set(IndexedInterceptor::NewInstance());
@@ -35,13 +35,13 @@ NAN_METHOD(CreateNew) {
 
 void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
-    NanNew<v8::FunctionTemplate>(IndexedInterceptor::New);
+    Nan::New<v8::FunctionTemplate>(IndexedInterceptor::New);
   indexedinterceptors_constructor.Reset(tpl);
-  tpl->SetClassName(NanNew("IndexedInterceptor").ToLocalChecked());
+  tpl->SetClassName(Nan::New("IndexedInterceptor").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   v8::Local<v8::ObjectTemplate> inst = tpl->InstanceTemplate();
 
-  NanSetIndexedPropertyHandler(
+  SetIndexedPropertyHandler(
       inst
     , IndexedInterceptor::PropertyGetter
     , IndexedInterceptor::PropertySetter
@@ -50,14 +50,14 @@ void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
     , IndexedInterceptor::PropertyEnumerator);
 
   v8::Local<v8::Function> createnew =
-    NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
-  NanSet(target, NanNew("create").ToLocalChecked(), createnew);
+    Nan::New<v8::FunctionTemplate>(CreateNew)->GetFunction();
+  Set(target, Nan::New("create").ToLocalChecked(), createnew);
 }
 
 v8::Handle<v8::Value> IndexedInterceptor::NewInstance () {
-  NanEscapableScope scope;
+  EscapableScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
-      NanNew(indexedinterceptors_constructor);
+      Nan::New(indexedinterceptors_constructor);
   v8::Local<v8::Object> instance =
     constructorHandle->GetFunction()->NewInstance(0, NULL);
   return scope.Escape(instance);
@@ -72,17 +72,17 @@ NAN_METHOD(IndexedInterceptor::New) {
 
 NAN_INDEX_GETTER(IndexedInterceptor::PropertyGetter) {
   IndexedInterceptor* interceptor =
-    NanObjectWrap::Unwrap<IndexedInterceptor>(info.This());
+    ObjectWrap::Unwrap<IndexedInterceptor>(info.This());
   if (index == 0) {
-    info.GetReturnValue().Set(NanNew(interceptor->buf).ToLocalChecked());
+    info.GetReturnValue().Set(Nan::New(interceptor->buf).ToLocalChecked());
   } else {
-    info.GetReturnValue().Set(NanNew("bar").ToLocalChecked());
+    info.GetReturnValue().Set(Nan::New("bar").ToLocalChecked());
   }
 }
 
 NAN_INDEX_SETTER(IndexedInterceptor::PropertySetter) {
   IndexedInterceptor* interceptor =
-    NanObjectWrap::Unwrap<IndexedInterceptor>(info.This());
+    ObjectWrap::Unwrap<IndexedInterceptor>(info.This());
   if (index == 0) {
     std::strncpy(
         interceptor->buf
@@ -95,21 +95,21 @@ NAN_INDEX_SETTER(IndexedInterceptor::PropertySetter) {
 }
 
 NAN_INDEX_ENUMERATOR(IndexedInterceptor::PropertyEnumerator) {
-  v8::Local<v8::Array> arr = NanNew<v8::Array>();
-  NanSet(arr, 0, NanNew("whee").ToLocalChecked());
+  v8::Local<v8::Array> arr = Nan::New<v8::Array>();
+  Set(arr, 0, Nan::New("whee").ToLocalChecked());
   info.GetReturnValue().Set(arr);
 }
 
 NAN_INDEX_DELETER(IndexedInterceptor::PropertyDeleter) {
   IndexedInterceptor* interceptor =
-    NanObjectWrap::Unwrap<IndexedInterceptor>(info.This());
+    ObjectWrap::Unwrap<IndexedInterceptor>(info.This());
   std::strncpy(interceptor->buf, "goober", sizeof (interceptor->buf));
-  info.GetReturnValue().Set(NanTrue());
+  info.GetReturnValue().Set(True());
 }
 
 NAN_INDEX_QUERY(IndexedInterceptor::PropertyQuery) {
   if (index == 1) {
-    info.GetReturnValue().Set(NanNew<v8::Integer>(v8::DontEnum));
+    info.GetReturnValue().Set(Nan::New<v8::Integer>(v8::DontEnum));
   }
 }
 
diff --git a/test/cpp/isolatedata.cpp b/test/cpp/isolatedata.cpp
index d4d024ac..f39b1495 100644
--- a/test/cpp/isolatedata.cpp
+++ b/test/cpp/isolatedata.cpp
@@ -20,18 +20,18 @@ NAN_METHOD(SetAndGet) {
 
   v8::Isolate *isolate = v8::Isolate::GetCurrent();
 
-  NanSetIsolateData<Dummy>(isolate, d0);
-  d1 = NanGetIsolateData<Dummy>(isolate);
+  SetIsolateData<Dummy>(isolate, d0);
+  d1 = GetIsolateData<Dummy>(isolate);
 
   delete d1;
 
-  info.GetReturnValue().Set(NanNew<v8::Boolean>(d0 == d1));
+  info.GetReturnValue().Set(New<v8::Boolean>(d0 == d1));
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("setAndGet").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(SetAndGet)->GetFunction()
+  Set(target
+    , New<v8::String>("setAndGet").ToLocalChecked()
+    , New<v8::FunctionTemplate>(SetAndGet)->GetFunction()
   );
 }
 
diff --git a/test/cpp/makecallback.cpp b/test/cpp/makecallback.cpp
index d4297f5a..c29e278f 100644
--- a/test/cpp/makecallback.cpp
+++ b/test/cpp/makecallback.cpp
@@ -20,10 +20,10 @@ class MyObject : public node::ObjectWrap {
 
   static NAN_METHOD(New);
   static NAN_METHOD(CallEmit);
-  static NanPersistent<v8::Function> constructor;
+  static Persistent<v8::Function> constructor;
 };
 
-NanPersistent<v8::Function> MyObject::constructor;
+Persistent<v8::Function> MyObject::constructor;
 
 MyObject::MyObject() {
 }
@@ -33,14 +33,14 @@ MyObject::~MyObject() {
 
 void MyObject::Init(v8::Handle<v8::Object> exports) {
   // Prepare constructor template
-  v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
-  tpl->SetClassName(NanNew<v8::String>("MyObject").ToLocalChecked());
+  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+  tpl->SetClassName(Nan::New<v8::String>("MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
-  NanSetPrototypeMethod(tpl, "call_emit", CallEmit);
+  SetPrototypeMethod(tpl, "call_emit", CallEmit);
 
   constructor.Reset(tpl->GetFunction());
-  NanSet(exports, NanNew("MyObject").ToLocalChecked(), tpl->GetFunction());
+  Set(exports, Nan::New("MyObject").ToLocalChecked(), tpl->GetFunction());
 }
 
 NAN_METHOD(MyObject::New) {
@@ -49,17 +49,17 @@ NAN_METHOD(MyObject::New) {
     obj->Wrap(info.This());
     info.GetReturnValue().Set(info.This());
   } else {
-    v8::Local<v8::Function> cons = NanNew<v8::Function>(constructor);
+    v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
     info.GetReturnValue().Set(cons->NewInstance());
   }
 }
 
 NAN_METHOD(MyObject::CallEmit) {
   v8::Handle<v8::Value> argv[1] = {
-    NanNew("event").ToLocalChecked(),  // event name
+    Nan::New("event").ToLocalChecked(),  // event name
   };
 
-  NanMakeCallback(info.This(), "emit", 1, argv);
+  MakeCallback(info.This(), "emit", 1, argv);
   info.GetReturnValue().SetUndefined();
 }
 
diff --git a/test/cpp/morenews.cpp b/test/cpp/morenews.cpp
index 53f609e3..0a57d121 100644
--- a/test/cpp/morenews.cpp
+++ b/test/cpp/morenews.cpp
@@ -11,30 +11,30 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 NAN_METHOD(NewNumber) {
-  info.GetReturnValue().Set(NanNew(0.5));
+  info.GetReturnValue().Set(New(0.5));
 }
 
 NAN_METHOD(NewNegativeInteger) {
-  info.GetReturnValue().Set(NanNew(-1));
+  info.GetReturnValue().Set(New(-1));
 }
 
 NAN_METHOD(NewPositiveInteger) {
-  info.GetReturnValue().Set(NanNew(1));
+  info.GetReturnValue().Set(New(1));
 }
 
 NAN_METHOD(NewUtf8String) {
   const char s[] = "strïng";
-  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
+  info.GetReturnValue().Set(New(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  info.GetReturnValue().Set(NanNewOneByteString(s).ToLocalChecked());
+  info.GetReturnValue().Set(NewOneByteString(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewUcs2String) {
   uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
-  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
+  info.GetReturnValue().Set(New(s).ToLocalChecked());
 }
 
 static const uint16_t ws[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
@@ -48,7 +48,7 @@ class ExtString : public v8::String::ExternalStringResource {
 };
 
 
-class ExtAsciiString : public NanExternalOneByteStringResource {
+class ExtAsciiString : public ExternalOneByteStringResource {
  public:
   ~ExtAsciiString() { }
   const char *data() const { return s; }
@@ -56,47 +56,47 @@ class ExtAsciiString : public NanExternalOneByteStringResource {
 };
 
 NAN_METHOD(NewExternalStringResource) {
-  v8::Local<v8::String> ext = NanNew(new ExtString()).ToLocalChecked();
+  v8::Local<v8::String> ext = New(new ExtString()).ToLocalChecked();
   info.GetReturnValue().Set(ext);
 }
 
 NAN_METHOD(NewExternalAsciiStringResource) {
-  v8::Local<v8::String> ext = NanNew(new ExtAsciiString()).ToLocalChecked();
+  v8::Local<v8::String> ext = New(new ExtAsciiString()).ToLocalChecked();
   info.GetReturnValue().Set(ext);
 }
 
 void Init(v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew("newNumber").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewNumber)->GetFunction()
+  Set(target
+    , New("newNumber").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewNumber)->GetFunction()
   );
-  NanSet(target
-    , NanNew("newNegativeInteger").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewNegativeInteger)->GetFunction()
+  Set(target
+    , New("newNegativeInteger").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewNegativeInteger)->GetFunction()
   );
-  NanSet(target
-    , NanNew("newPositiveInteger").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewPositiveInteger)->GetFunction()
+  Set(target
+    , New("newPositiveInteger").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewPositiveInteger)->GetFunction()
   );
-  NanSet(target
-    , NanNew("newUtf8String").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewUtf8String)->GetFunction()
+  Set(target
+    , New("newUtf8String").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewUtf8String)->GetFunction()
   );
-  NanSet(target
-    , NanNew("newLatin1String").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewLatin1String)->GetFunction()
+  Set(target
+    , New("newLatin1String").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewLatin1String)->GetFunction()
   );
-  NanSet(target
-    , NanNew("newUcs2String").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewUcs2String)->GetFunction()
+  Set(target
+    , New("newUcs2String").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewUcs2String)->GetFunction()
   );
-  NanSet(target
-    , NanNew("newExternalStringResource").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewExternalStringResource)->GetFunction()
+  Set(target
+    , New("newExternalStringResource").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewExternalStringResource)->GetFunction()
   );
-  NanSet(target
-    , NanNew("newExternalAsciiStringResource").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewExternalAsciiStringResource)
+  Set(target
+    , New("newExternalAsciiStringResource").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewExternalAsciiStringResource)
     ->GetFunction()
   );
 }
diff --git a/test/cpp/multifile1.cpp b/test/cpp/multifile1.cpp
index 43640e67..7ee79678 100644
--- a/test/cpp/multifile1.cpp
+++ b/test/cpp/multifile1.cpp
@@ -12,9 +12,9 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("r").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ReturnString)->GetFunction()
+  Set(target
+    , New<v8::String>("r").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ReturnString)->GetFunction()
   );
 }
 
diff --git a/test/cpp/multifile2.cpp b/test/cpp/multifile2.cpp
index b754644e..e779ac10 100644
--- a/test/cpp/multifile2.cpp
+++ b/test/cpp/multifile2.cpp
@@ -11,6 +11,6 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 NAN_METHOD(ReturnString) {
-  v8::Local<v8::String> s = NanNew(*NanUtf8String(info[0])).ToLocalChecked();
+  v8::Local<v8::String> s = New(*Utf8String(info[0])).ToLocalChecked();
   info.GetReturnValue().Set(s);
 }
diff --git a/test/cpp/namedinterceptors.cpp b/test/cpp/namedinterceptors.cpp
index 1aaf60c3..c7311644 100644
--- a/test/cpp/namedinterceptors.cpp
+++ b/test/cpp/namedinterceptors.cpp
@@ -11,7 +11,7 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class NamedInterceptor : public NanObjectWrap {
+class NamedInterceptor : public ObjectWrap {
   char buf[256];
 
  public:
@@ -27,7 +27,7 @@ class NamedInterceptor : public NanObjectWrap {
   static NAN_PROPERTY_QUERY(PropertyQuery);
 };
 
-static NanPersistent<v8::FunctionTemplate> namedinterceptors_constructor;
+static Persistent<v8::FunctionTemplate> namedinterceptors_constructor;
 
 NAN_METHOD(CreateNew) {
   info.GetReturnValue().Set(NamedInterceptor::NewInstance());
@@ -35,13 +35,13 @@ NAN_METHOD(CreateNew) {
 
 void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> tpl =
-    NanNew<v8::FunctionTemplate>(NamedInterceptor::New);
+    Nan::New<v8::FunctionTemplate>(NamedInterceptor::New);
   namedinterceptors_constructor.Reset(tpl);
-  tpl->SetClassName(NanNew("NamedInterceptor").ToLocalChecked());
+  tpl->SetClassName(Nan::New("NamedInterceptor").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
   v8::Local<v8::ObjectTemplate> inst = tpl->InstanceTemplate();
 
-  NanSetNamedPropertyHandler(
+  SetNamedPropertyHandler(
       inst
     , NamedInterceptor::PropertyGetter
     , NamedInterceptor::PropertySetter
@@ -50,14 +50,14 @@ void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
     , NamedInterceptor::PropertyEnumerator);
 
   v8::Local<v8::Function> createnew =
-    NanNew<v8::FunctionTemplate>(CreateNew)->GetFunction();
-  NanSet(target, NanNew("create").ToLocalChecked(), createnew);
+    Nan::New<v8::FunctionTemplate>(CreateNew)->GetFunction();
+  Set(target, Nan::New("create").ToLocalChecked(), createnew);
 }
 
 v8::Handle<v8::Value> NamedInterceptor::NewInstance () {
-  NanEscapableScope scope;
+  EscapableScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
-      NanNew(namedinterceptors_constructor);
+      Nan::New(namedinterceptors_constructor);
   v8::Local<v8::Object> instance =
     constructorHandle->GetFunction()->NewInstance(0, NULL);
   return scope.Escape(instance);
@@ -72,17 +72,17 @@ NAN_METHOD(NamedInterceptor::New) {
 
 NAN_PROPERTY_GETTER(NamedInterceptor::PropertyGetter) {
   NamedInterceptor* interceptor =
-    NanObjectWrap::Unwrap<NamedInterceptor>(info.This());
+    ObjectWrap::Unwrap<NamedInterceptor>(info.This());
   if (!std::strcmp(*v8::String::Utf8Value(property), "prop")) {
-    info.GetReturnValue().Set(NanNew(interceptor->buf).ToLocalChecked());
+    info.GetReturnValue().Set(Nan::New(interceptor->buf).ToLocalChecked());
   } else {
-    info.GetReturnValue().Set(NanNew("bar").ToLocalChecked());
+    info.GetReturnValue().Set(Nan::New("bar").ToLocalChecked());
   }
 }
 
 NAN_PROPERTY_SETTER(NamedInterceptor::PropertySetter) {
   NamedInterceptor* interceptor =
-    NanObjectWrap::Unwrap<NamedInterceptor>(info.This());
+    ObjectWrap::Unwrap<NamedInterceptor>(info.This());
   if (!std::strcmp(*v8::String::Utf8Value(property), "prop")) {
     std::strncpy(
         interceptor->buf
@@ -95,21 +95,21 @@ NAN_PROPERTY_SETTER(NamedInterceptor::PropertySetter) {
 }
 
 NAN_PROPERTY_ENUMERATOR(NamedInterceptor::PropertyEnumerator) {
-  v8::Local<v8::Array> arr = NanNew<v8::Array>();
-  NanSet(arr, 0, NanNew("value").ToLocalChecked());
+  v8::Local<v8::Array> arr = Nan::New<v8::Array>();
+  Set(arr, 0, Nan::New("value").ToLocalChecked());
   info.GetReturnValue().Set(arr);
 }
 
 NAN_PROPERTY_DELETER(NamedInterceptor::PropertyDeleter) {
   NamedInterceptor* interceptor =
-    NanObjectWrap::Unwrap<NamedInterceptor>(info.This());
+    ObjectWrap::Unwrap<NamedInterceptor>(info.This());
   std::strncpy(interceptor->buf, "goober", sizeof (interceptor->buf));
-  info.GetReturnValue().Set(NanTrue());
+  info.GetReturnValue().Set(True());
 }
 
 NAN_PROPERTY_QUERY(NamedInterceptor::PropertyQuery) {
   if (!std::strcmp(*v8::String::Utf8Value(property), "thing")) {
-    info.GetReturnValue().Set(NanNew<v8::Integer>(v8::DontEnum));
+    info.GetReturnValue().Set(Nan::New<v8::Integer>(v8::DontEnum));
   }
 }
 
diff --git a/test/cpp/nancallback.cpp b/test/cpp/nancallback.cpp
index eabcf92b..70545c81 100644
--- a/test/cpp/nancallback.cpp
+++ b/test/cpp/nancallback.cpp
@@ -11,60 +11,60 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 NAN_METHOD(GlobalContext) {
-  NanCallback(info[0].As<v8::Function>()).Call(0, NULL);
+  Callback(info[0].As<v8::Function>()).Call(0, NULL);
 }
 
 NAN_METHOD(SpecificContext) {
-  NanCallback cb(info[0].As<v8::Function>());
-  cb.Call(NanGetCurrentContext()->Global(), 0, NULL);
+  Callback cb(info[0].As<v8::Function>());
+  cb.Call(GetCurrentContext()->Global(), 0, NULL);
 }
 
 NAN_METHOD(CustomReceiver) {
-  NanCallback cb(info[0].As<v8::Function>());
+  Callback cb(info[0].As<v8::Function>());
   cb.Call(info[1].As<v8::Object>(), 0, NULL);
 }
 
 NAN_METHOD(CompareCallbacks) {
-  NanCallback cb1(info[0].As<v8::Function>());
-  NanCallback cb2(info[1].As<v8::Function>());
-  NanCallback cb3(info[2].As<v8::Function>());
+  Callback cb1(info[0].As<v8::Function>());
+  Callback cb2(info[1].As<v8::Function>());
+  Callback cb3(info[2].As<v8::Function>());
 
-  info.GetReturnValue().Set(NanNew<v8::Boolean>(cb1 == cb2 && cb1 != cb3));
+  info.GetReturnValue().Set(New<v8::Boolean>(cb1 == cb2 && cb1 != cb3));
 }
 
 NAN_METHOD(CallDirect) {
-  NanCallback cb(info[0].As<v8::Function>());
-  (*cb)->Call(NanGetCurrentContext()->Global(), 0, NULL);
+  Callback cb(info[0].As<v8::Function>());
+  (*cb)->Call(GetCurrentContext()->Global(), 0, NULL);
 }
 
 NAN_METHOD(CallAsFunction) {
-  NanCallback(info[0].As<v8::Function>())();
+  Callback(info[0].As<v8::Function>())();
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("globalContext").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(GlobalContext)->GetFunction()
+  Set(target
+    , New<v8::String>("globalContext").ToLocalChecked()
+    , New<v8::FunctionTemplate>(GlobalContext)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("specificContext").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(SpecificContext)->GetFunction()
+  Set(target
+    , New<v8::String>("specificContext").ToLocalChecked()
+    , New<v8::FunctionTemplate>(SpecificContext)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("customReceiver").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(CustomReceiver)->GetFunction()
+  Set(target
+    , New<v8::String>("customReceiver").ToLocalChecked()
+    , New<v8::FunctionTemplate>(CustomReceiver)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("compareCallbacks").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(CompareCallbacks)->GetFunction()
+  Set(target
+    , New<v8::String>("compareCallbacks").ToLocalChecked()
+    , New<v8::FunctionTemplate>(CompareCallbacks)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("callDirect").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(CallDirect)->GetFunction()
+  Set(target
+    , New<v8::String>("callDirect").ToLocalChecked()
+    , New<v8::FunctionTemplate>(CallDirect)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("callAsFunction").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(CallAsFunction)->GetFunction()
+  Set(target
+    , New<v8::String>("callAsFunction").ToLocalChecked()
+    , New<v8::FunctionTemplate>(CallAsFunction)->GetFunction()
   );
 }
 
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index 7ede8bff..b5b6c733 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -54,29 +54,29 @@ stringMatches(Local<Value> value, const char * match) {
 #define _(e) NAN_TEST_EXPRESSION(e)
 
 NAN_METHOD(testArray) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(3);
 
-  t.ok(_( NanNew<Array>()->Length() == 0));
-  t.ok(_( NanNew<Array>(7)->Length() == 7));
-  t.ok(_( assertType<Array>(NanNew<Array>(7))));
+  t.ok(_( New<Array>()->Length() == 0));
+  t.ok(_( New<Array>(7)->Length() == 7));
+  t.ok(_( assertType<Array>(New<Array>(7))));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testBoolean) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(6);
 
-  t.ok(_( NanNew<Boolean>(true)->Value() == true));
-  t.ok(_( NanNew<Boolean>(false)->Value() == false));
-  t.ok(_( assertType<Boolean>( NanNew<Boolean>(true))));
+  t.ok(_( New<Boolean>(true)->Value() == true));
+  t.ok(_( New<Boolean>(false)->Value() == false));
+  t.ok(_( assertType<Boolean>( New<Boolean>(true))));
 
-  t.ok(_( NanNew(true)->Value() == true));
-  t.ok(_( NanNew(false)->Value() == false));
-  t.ok(_( assertType<Boolean>( NanNew(true))));
+  t.ok(_( New(true)->Value() == true));
+  t.ok(_( New(false)->Value() == false));
+  t.ok(_( assertType<Boolean>( New(true))));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -87,44 +87,44 @@ NAN_METHOD(testBoolean) {
 # define V(x) x->ValueOf()
 #endif
 NAN_METHOD(testBooleanObject) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(3);
 
-  t.ok(_( assertType<BooleanObject>( NanNew<BooleanObject>(true))));
-  t.ok(_( V(NanNew<BooleanObject>(true)) == true));
-  t.ok(_( V(NanNew<BooleanObject>(false)) == false));
+  t.ok(_( assertType<BooleanObject>( New<BooleanObject>(true))));
+  t.ok(_( V(New<BooleanObject>(true)) == true));
+  t.ok(_( V(New<BooleanObject>(false)) == false));
 
   info.GetReturnValue().SetUndefined();
 }
 #undef V
 
 NAN_METHOD(testContext) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(5);
-  t.ok(_( assertType<Context>( NanNew<Context>())));
+  t.ok(_( assertType<Context>( New<Context>())));
   ExtensionConfiguration extensions(0, NULL);
-  t.ok(_( assertType<Context>( NanNew<Context>(&extensions))));
+  t.ok(_( assertType<Context>( New<Context>(&extensions))));
   t.ok(_( assertType<Context>(
-          NanNew<Context>(static_cast<ExtensionConfiguration *>(NULL)
+          New<Context>(static_cast<ExtensionConfiguration *>(NULL)
           , Handle<ObjectTemplate>()))));
   t.ok(_( assertType<Context>(
-          NanNew<Context>(&extensions, Handle<ObjectTemplate>()))));
+          New<Context>(&extensions, Handle<ObjectTemplate>()))));
   t.ok(_( assertType<Context>(
-          NanNew<Context>(&extensions
+          New<Context>(&extensions
           , Handle<ObjectTemplate>(), Handle<Value>()))));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testDate) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(1);
 
   t.ok(_( assertType<Date>(
-      NanNew<Date>(static_cast<double>(time(NULL))).ToLocalChecked())));
+      New<Date>(static_cast<double>(time(NULL))).ToLocalChecked())));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -132,41 +132,41 @@ NAN_METHOD(testDate) {
 int ttt = 23;
 
 NAN_METHOD(testExternal) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(2);
 
-  t.ok(_(NanNew<External>(&ttt)->Value() == &ttt));
-  t.ok(_( assertType<External>(NanNew<External>(&ttt))));
+  t.ok(_(New<External>(&ttt)->Value() == &ttt));
+  t.ok(_( assertType<External>(New<External>(&ttt))));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testFunction) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
   t.plan(2);
 
-  t.ok(_( assertType<Function>(NanNew<Function>(testFunction))));
-  v8::Local<String> data = NanNew("plonk").ToLocalChecked();
-  t.ok(_( assertType<Function>(NanNew<Function>(testFunction, data))));
+  t.ok(_( assertType<Function>(New<Function>(testFunction))));
+  v8::Local<String> data = New("plonk").ToLocalChecked();
+  t.ok(_( assertType<Function>(New<Function>(testFunction, data))));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testFunctionTemplate) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(4);
 
-  t.ok(_( assertType<FunctionTemplate>( NanNew<FunctionTemplate>())));
+  t.ok(_( assertType<FunctionTemplate>( New<FunctionTemplate>())));
   t.ok(_( assertType<FunctionTemplate>(
-          NanNew<FunctionTemplate>(testFunctionTemplate))));
-  v8::Local<String> data = NanNew("plonk").ToLocalChecked();
+          New<FunctionTemplate>(testFunctionTemplate))));
+  v8::Local<String> data = New("plonk").ToLocalChecked();
   t.ok(_( assertType<FunctionTemplate>(
-          NanNew<FunctionTemplate>( testFunctionTemplate, data))));
-  v8::Local<Signature> signature = NanNew<Signature>();
+          New<FunctionTemplate>( testFunctionTemplate, data))));
+  v8::Local<Signature> signature = New<Signature>();
   t.ok(_( assertType<FunctionTemplate>(
-          NanNew<FunctionTemplate>( testFunctionTemplate, data, signature))));
+          New<FunctionTemplate>( testFunctionTemplate, data, signature))));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -174,153 +174,153 @@ NAN_METHOD(testFunctionTemplate) {
 const double epsilon = 1e-9;
 
 NAN_METHOD(testNumber) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(17);
 
-  t.ok(_( NanNew<Int32>(5)->Value() == 5 ));
-  t.ok(_( NanNew<Int32>(-42)->Value() == -42 ));
-  t.ok(_( assertType<Int32>( NanNew<Int32>(23) )));
+  t.ok(_( New<Int32>(5)->Value() == 5 ));
+  t.ok(_( New<Int32>(-42)->Value() == -42 ));
+  t.ok(_( assertType<Int32>( New<Int32>(23) )));
 
-  t.ok(_( NanNew<Uint32>(5u)->Value() == 5u ));
-  t.ok(_( assertType<Uint32>( NanNew<Uint32>(23u) )));
+  t.ok(_( New<Uint32>(5u)->Value() == 5u ));
+  t.ok(_( assertType<Uint32>( New<Uint32>(23u) )));
 
-  t.ok(_( NanNew<Integer>(5)->Value() == 5 ));
-  t.ok(_( NanNew<Integer>(-1337)->Value() == -1337 ));
-  t.ok(_( assertType<Integer>( NanNew<Integer>(-42) )));
+  t.ok(_( New<Integer>(5)->Value() == 5 ));
+  t.ok(_( New<Integer>(-1337)->Value() == -1337 ));
+  t.ok(_( assertType<Integer>( New<Integer>(-42) )));
 
-  t.ok(_( fabs(NanNew<Number>(M_PI)->Value() - M_PI) < epsilon));
-  t.ok(_( fabs(NanNew<Number>(-M_PI)->Value() + M_PI) < epsilon));
-  t.ok(_( assertType<Number>( NanNew<Number>(M_E) )));
+  t.ok(_( fabs(New<Number>(M_PI)->Value() - M_PI) < epsilon));
+  t.ok(_( fabs(New<Number>(-M_PI)->Value() + M_PI) < epsilon));
+  t.ok(_( assertType<Number>( New<Number>(M_E) )));
 
   // === Convenience
 
-  t.ok(_( NanNew(5)->Value() == 5 ));
-  t.ok(_( assertType<Int32>( NanNew(23) )));
+  t.ok(_( New(5)->Value() == 5 ));
+  t.ok(_( assertType<Int32>( New(23) )));
 
-  t.ok(_( NanNew(5u)->Value() == 5u ));
-  t.ok(_( assertType<Uint32>( NanNew(23u) )));
+  t.ok(_( New(5u)->Value() == 5u ));
+  t.ok(_( assertType<Uint32>( New(23u) )));
 
-  t.ok(_( fabs(NanNew(M_PI)->Value() - M_PI) < epsilon));
-  t.ok(_( assertType<Number>( NanNew(M_E) )));
+  t.ok(_( fabs(New(M_PI)->Value() - M_PI) < epsilon));
+  t.ok(_( assertType<Number>( New(M_E) )));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testNumberObject) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(2);
 
-  t.ok(_( assertType<NumberObject>( NanNew<NumberObject>(M_PI))));
+  t.ok(_( assertType<NumberObject>( New<NumberObject>(M_PI))));
   t.ok(_(
       fabs(
-          NanTo<double>(NanNew<NumberObject>(M_PI)).FromJust() - M_PI
+          To<double>(New<NumberObject>(M_PI)).FromJust() - M_PI
       ) < epsilon));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testObject) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(1);
 
-  t.ok(_(assertType<Object>( NanNew<Object>())));
+  t.ok(_(assertType<Object>( New<Object>())));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testObjectTemplate) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(1);
 
-  t.ok(_(assertType<ObjectTemplate>( NanNew<ObjectTemplate>())));
+  t.ok(_(assertType<ObjectTemplate>( New<ObjectTemplate>())));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testScript) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(6);
 
-  ScriptOrigin origin(NanNew("foo").ToLocalChecked(), NanNew(5));
-
-  t.ok(_( assertType<Script>(NanNew<Script>(
-      NanNew("2 + 3").ToLocalChecked()).ToLocalChecked())));
-  t.ok(_( assertType<Script>(NanNew<Script>(
-      NanNew("2 + 3").ToLocalChecked(), origin).ToLocalChecked())));
-  t.ok(_( assertType<NanUnboundScript>(NanNew<NanUnboundScript>(
-      NanNew("2 + 3").ToLocalChecked()).ToLocalChecked())));
-  t.ok(_( assertType<NanUnboundScript>(
-      NanNew<NanUnboundScript>(
-          NanNew("2 + 3").ToLocalChecked()
+  ScriptOrigin origin(New("foo").ToLocalChecked(), New(5));
+
+  t.ok(_( assertType<Script>(New<Script>(
+      New("2 + 3").ToLocalChecked()).ToLocalChecked())));
+  t.ok(_( assertType<Script>(New<Script>(
+      New("2 + 3").ToLocalChecked(), origin).ToLocalChecked())));
+  t.ok(_( assertType<Nan::UnboundScript>(New<Nan::UnboundScript>(
+      New("2 + 3").ToLocalChecked()).ToLocalChecked())));
+  t.ok(_( assertType<Nan::UnboundScript>(
+      New<Nan::UnboundScript>(
+          New("2 + 3").ToLocalChecked()
         , origin).ToLocalChecked())));
 
   // for the fans of the bound script
-  t.ok(_( NanTo<int32_t>(NanRunScript(
-      NanNew<NanBoundScript>(NanNew("2 + 3").ToLocalChecked()
+  t.ok(_( To<int32_t>(RunScript(
+      New<BoundScript>(New("2 + 3").ToLocalChecked()
     ).ToLocalChecked()).ToLocalChecked()).FromJust() == 5));
-  t.ok(_( NanTo<int32_t>(NanRunScript(
-      NanNew<NanUnboundScript>(NanNew("2 + 3").ToLocalChecked()
+  t.ok(_( To<int32_t>(RunScript(
+      New<Nan::UnboundScript>(New("2 + 3").ToLocalChecked()
     ).ToLocalChecked()).ToLocalChecked()).FromJust() == 5));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testSignature) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(3);
 
   typedef FunctionTemplate FT;
   typedef Signature Sig;
-  t.ok(_( assertType<Sig>(NanNew<Sig>())));
-  t.ok(_( assertType<Sig>(NanNew<Sig>(NanNew<FT>(testSignature)))));
+  t.ok(_( assertType<Sig>(New<Sig>())));
+  t.ok(_( assertType<Sig>(New<Sig>(New<FT>(testSignature)))));
 
   t.ok(_( assertType<Sig>(
-      NanNew<Sig>(NanNew<FT>(testSignature)))));
+      New<Sig>(New<FT>(testSignature)))));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testString) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(14);
 
   t.ok(_( stringMatches(
-      NanNew<String>("Hello World").ToLocalChecked(), "Hello World")));
+      New<String>("Hello World").ToLocalChecked(), "Hello World")));
   t.ok(_( stringMatches(
-      NanNew<String>("Hello World", 4).ToLocalChecked(), "Hell")));
+      New<String>("Hello World", 4).ToLocalChecked(), "Hell")));
   t.ok(_( stringMatches(
-      NanNew<String>(std::string("foo")).ToLocalChecked(), "foo")));
+      New<String>(std::string("foo")).ToLocalChecked(), "foo")));
   t.ok(_( assertType<String>(
-      NanNew<String>("plonk.").ToLocalChecked())));
+      New<String>("plonk.").ToLocalChecked())));
 
-  t.ok(_( stringMatches( NanNew<String>().ToLocalChecked(), "")));
-  t.ok(_( assertType<String>( NanNew<String>().ToLocalChecked())));
+  t.ok(_( stringMatches( New<String>().ToLocalChecked(), "")));
+  t.ok(_( assertType<String>( New<String>().ToLocalChecked())));
 
   const uint8_t *ustring = reinterpret_cast<const uint8_t *>("unsigned chars");
   t.ok(_( stringMatches(
-      NanNewOneByteString(ustring).ToLocalChecked(), "unsigned chars")));
+      NewOneByteString(ustring).ToLocalChecked(), "unsigned chars")));
   t.ok(_( stringMatches(
-      NanNewOneByteString(ustring, 8).ToLocalChecked(), "unsigned")));
+      NewOneByteString(ustring, 8).ToLocalChecked(), "unsigned")));
 
   // === Convenience
 
   t.ok(_( stringMatches(
-      NanNew("using namespace nan; // is poetry").ToLocalChecked()
+      New("using namespace nan; // is poetry").ToLocalChecked()
     , "using namespace nan; // is poetry")));
-  t.ok(_( assertType<String>( NanNew("plonk.").ToLocalChecked())));
+  t.ok(_( assertType<String>( New("plonk.").ToLocalChecked())));
 
-  t.ok(_( stringMatches( NanNew("Hello World", 4).ToLocalChecked(), "Hell")));
-  t.ok(_( assertType<String>( NanNew("plonk.", 4).ToLocalChecked())));
+  t.ok(_( stringMatches( New("Hello World", 4).ToLocalChecked(), "Hell")));
+  t.ok(_( assertType<String>( New("plonk.", 4).ToLocalChecked())));
 
-  t.ok(_( stringMatches( NanNew(std::string("bar")).ToLocalChecked(), "bar")));
-  t.ok(_( assertType<String>( NanNew(std::string("plonk.")).ToLocalChecked())));
+  t.ok(_( stringMatches( New(std::string("bar")).ToLocalChecked(), "bar")));
+  t.ok(_( assertType<String>( New(std::string("plonk.")).ToLocalChecked())));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -331,15 +331,15 @@ NAN_METHOD(testString) {
 # define V(x) x->ValueOf()
 #endif
 NAN_METHOD(testStringObject) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(2);
 
   t.ok(_( stringMatches(
-          V(NanNew<StringObject>(NanNew<String>("plonk").ToLocalChecked())),
+          V(New<StringObject>(New<String>("plonk").ToLocalChecked())),
           "plonk")));
   t.ok(_( assertType<StringObject>(
-          NanNew<StringObject>(NanNew<String>("plonk").ToLocalChecked()))));
+          New<StringObject>(New<String>("plonk").ToLocalChecked()))));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -347,25 +347,25 @@ NAN_METHOD(testStringObject) {
 
 template <typename T> Handle<T> asHandle(Local<T> l) { return l; }
 NAN_METHOD(testHandles) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(2);
 
   t.ok(_( assertType<String>(
-      NanNew( asHandle(NanNew("foo").ToLocalChecked())))));
-  t.ok(_( assertType<Uint32>( NanNew( asHandle(NanNew(5u))))));
+      New( asHandle(New("foo").ToLocalChecked())))));
+  t.ok(_( assertType<Uint32>( New( asHandle(New(5u))))));
 
   info.GetReturnValue().SetUndefined();
 }
 
 NAN_METHOD(testPersistents) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(1);
 
-  NanPersistent<String> p;
-  p.Reset(NanNew("foo").ToLocalChecked());
-  t.ok(_( assertType<String>( NanNew(p))));
+  Nan::Persistent<String> p;
+  p.Reset(New("foo").ToLocalChecked());
+  t.ok(_( assertType<String>( New(p))));
   p.Reset();
 
   info.GetReturnValue().SetUndefined();
@@ -378,7 +378,7 @@ NAN_METHOD(testPersistents) {
 
 // See https://github.com/nodejs/nan/issues/212
 NAN_METHOD(testRegression212) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   t.plan(1);
 
@@ -388,7 +388,7 @@ NAN_METHOD(testRegression212) {
 # pragma warning( push )
 # pragma warning( disable : 4800 )
 #endif
-  t.ok(_( assertType<Boolean>( NanNew<Boolean>(gboolean(23)))));
+  t.ok(_( assertType<Boolean>( New<Boolean>(gboolean(23)))));
 #if defined(_MSC_VER)
 # pragma warning( pop )
 #endif
@@ -398,7 +398,7 @@ NAN_METHOD(testRegression212) {
 
 /* Compile time regression test for https://github.com/nodejs/nan/issues/242
  * In the presence of overloaded functions NaN should be able to pick the one
- * matching NanFunctionCallback.
+ * matching FunctionCallback.
  */
 void overloaded() {}
 NAN_METHOD(overloaded) {
@@ -407,12 +407,12 @@ NAN_METHOD(overloaded) {
 }
 
 NAN_METHOD(testRegression242) {
-  NanTap t(info[0]);
+  Tap t(info[0]);
 
   // These lines must *compile*. Not much to test at runtime.
-  Local<FunctionTemplate> ft = NanNew<FunctionTemplate>(overloaded);
+  Local<FunctionTemplate> ft = New<FunctionTemplate>(overloaded);
   (void)ft;  // not unused
-  Local<Function> f = NanNew<Function>(overloaded);
+  Local<Function> f = New<Function>(overloaded);
   (void)f;  // not unused
 
   t.plan(1);
@@ -429,31 +429,31 @@ NAN_METHOD(testRegression242) {
 
 NAN_METHOD(newIntegerWithValue) {
   info.GetReturnValue().Set(
-      NanNew(static_cast<int32_t>(NanTo<int64_t>(info[0]).FromJust())));
+      New(static_cast<int32_t>(To<int64_t>(info[0]).FromJust())));
 }
 
 NAN_METHOD(newNumberWithValue) {
-  info.GetReturnValue().Set(NanNew(NanTo<double>(info[0]).FromJust()));
+  info.GetReturnValue().Set(New(To<double>(info[0]).FromJust()));
 }
 
 NAN_METHOD(newUint32WithValue) {
-  info.GetReturnValue().Set(NanNew(NanTo<uint32_t>(info[0]).FromJust()));
+  info.GetReturnValue().Set(New(To<uint32_t>(info[0]).FromJust()));
 }
 
 NAN_METHOD(newStringFromChars) {
-  info.GetReturnValue().Set(NanNew("hello?").ToLocalChecked());
+  info.GetReturnValue().Set(New("hello?").ToLocalChecked());
 }
 
 NAN_METHOD(newStringFromCharsWithLength) {
-  info.GetReturnValue().Set(NanNew("hello?", 4).ToLocalChecked());
+  info.GetReturnValue().Set(New("hello?", 4).ToLocalChecked());
 }
 
 NAN_METHOD(newStringFromStdString) {
-  info.GetReturnValue().Set(NanNew(std::string("hello!")).ToLocalChecked());
+  info.GetReturnValue().Set(New(std::string("hello!")).ToLocalChecked());
 }
 
 NAN_METHOD(newExternal) {
-  info.GetReturnValue().Set(NanNew<External>(&ttt));
+  info.GetReturnValue().Set(New<External>(&ttt));
 }
 
 void Init(Handle<Object> exports) {
diff --git a/test/cpp/news.cpp b/test/cpp/news.cpp
index 3ba97ee5..0bf4d698 100644
--- a/test/cpp/news.cpp
+++ b/test/cpp/news.cpp
@@ -21,133 +21,133 @@ using namespace Nan;  // NOLINT(build/namespaces)
 static int magic = 1337;
 
 NAN_METHOD(NewNumber) {
-  info.GetReturnValue().Set(NanNew<v8::Number>(0.5));
+  info.GetReturnValue().Set(New<v8::Number>(0.5));
 }
 
 NAN_METHOD(NewNegativeInteger) {
-  info.GetReturnValue().Set(NanNew<v8::Integer>(-1));
+  info.GetReturnValue().Set(New<v8::Integer>(-1));
 }
 
 NAN_METHOD(NewPositiveInteger) {
-  info.GetReturnValue().Set(NanNew<v8::Integer>(1));
+  info.GetReturnValue().Set(New<v8::Integer>(1));
 }
 
 NAN_METHOD(NewUnsignedInteger) {
-  info.GetReturnValue().Set(NanNew<v8::Integer>(0xFFFFFFFFu));
+  info.GetReturnValue().Set(New<v8::Integer>(0xFFFFFFFFu));
 }
 
 NAN_METHOD(NewInt32FromPositive) {
-  info.GetReturnValue().Set(NanNew<v8::Int32>(0xFFFFFFFF));
+  info.GetReturnValue().Set(New<v8::Int32>(0xFFFFFFFF));
 }
 
 NAN_METHOD(NewInt32FromNegative) {
-  info.GetReturnValue().Set(NanNew<v8::Int32>(-1));
+  info.GetReturnValue().Set(New<v8::Int32>(-1));
 }
 
 NAN_METHOD(NewUint32FromPositive) {
-  info.GetReturnValue().Set(NanNew<v8::Uint32>(0xFFFFFFFF));
+  info.GetReturnValue().Set(New<v8::Uint32>(0xFFFFFFFF));
 }
 
 NAN_METHOD(NewUint32FromNegative) {
-  info.GetReturnValue().Set(NanNew<v8::Uint32>(-1));
+  info.GetReturnValue().Set(New<v8::Uint32>(-1));
 }
 
 NAN_METHOD(NewUtf8String) {
   const char s[] = "strïng";
-  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
+  info.GetReturnValue().Set(New(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewLatin1String) {
   const uint8_t s[] = "str\xefng";
-  info.GetReturnValue().Set(NanNewOneByteString(s).ToLocalChecked());
+  info.GetReturnValue().Set(NewOneByteString(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewUcs2String) {
   const uint16_t s[] = {'s', 't', 'r', 0xef, 'n', 'g', '\0'};
-  info.GetReturnValue().Set(NanNew(s).ToLocalChecked());
+  info.GetReturnValue().Set(New(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewStdString) {
   const std::string s = "strïng";
-  info.GetReturnValue().Set(NanNew<v8::String>(s).ToLocalChecked());
+  info.GetReturnValue().Set(New<v8::String>(s).ToLocalChecked());
 }
 
 NAN_METHOD(NewRegExp) {
   info.GetReturnValue().Set(
-      NanNew<v8::RegExp>(NanNew("foo").ToLocalChecked()
+      New<v8::RegExp>(New("foo").ToLocalChecked()
     , v8::RegExp::kNone).ToLocalChecked());
 }
 
 NAN_METHOD(NewStringObject) {
   info.GetReturnValue().Set(
-      NanNew<v8::StringObject>(NanNew("foo").ToLocalChecked()));
+      New<v8::StringObject>(New("foo").ToLocalChecked()));
 }
 
 NAN_METHOD(NewNumberObject) {
-  info.GetReturnValue().Set(NanNew<v8::NumberObject>(0.5));
+  info.GetReturnValue().Set(New<v8::NumberObject>(0.5));
 }
 
 NAN_METHOD(NewBooleanObject) {
-  info.GetReturnValue().Set(NanNew<v8::BooleanObject>(true));
+  info.GetReturnValue().Set(New<v8::BooleanObject>(true));
 }
 
 NAN_METHOD(NewExternal) {
-  v8::Local<v8::External> ext = NanNew<v8::External>(&magic);
+  v8::Local<v8::External> ext = New<v8::External>(&magic);
   assert(*static_cast<int *>(ext->Value()) == 1337);
-  info.GetReturnValue().Set(NanNew("passed").ToLocalChecked());
+  info.GetReturnValue().Set(New("passed").ToLocalChecked());
 }
 
 NAN_METHOD(NewSignature) {
   v8::Local<v8::FunctionTemplate> tmpl =
-      NanNew<v8::FunctionTemplate>(NewSignature);
-  v8::Local<v8::Signature> sig = NanNew<v8::Signature>(tmpl);
-  tmpl = NanNew<v8::FunctionTemplate>(
+      New<v8::FunctionTemplate>(NewSignature);
+  v8::Local<v8::Signature> sig = New<v8::Signature>(tmpl);
+  tmpl = New<v8::FunctionTemplate>(
       NewSignature, v8::Handle<v8::Value>(), sig);
-  info.GetReturnValue().Set(NanNew("string").ToLocalChecked());
+  info.GetReturnValue().Set(New("string").ToLocalChecked());
 }
 
 NAN_METHOD(NewScript) {
-  v8::Local<NanUnboundScript> script =
-      NanNew<NanUnboundScript>(NanNew("2+4").ToLocalChecked()).ToLocalChecked();
+  v8::Local<UnboundScript> script =
+      New<UnboundScript>(New("2+4").ToLocalChecked()).ToLocalChecked();
   info.GetReturnValue().Set(
-      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
+      To<v8::Int32>(RunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(NewScript2) {
-  v8::ScriptOrigin origin(NanNew<v8::String>("x").ToLocalChecked());
-  v8::Local<NanUnboundScript> script =
-      NanNew<NanUnboundScript>(
-          NanNew("2+4").ToLocalChecked()
+  v8::ScriptOrigin origin(New<v8::String>("x").ToLocalChecked());
+  v8::Local<UnboundScript> script =
+      New<UnboundScript>(
+          New("2+4").ToLocalChecked()
         , origin).ToLocalChecked();
   info.GetReturnValue().Set(
-      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
+      To<v8::Int32>(RunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(CompileScript) {
-  v8::Local<NanBoundScript> script =
-      NanCompileScript(NanNew("2+4").ToLocalChecked()).ToLocalChecked();
+  v8::Local<BoundScript> script =
+      CompileScript(New("2+4").ToLocalChecked()).ToLocalChecked();
   info.GetReturnValue().Set(
-      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
+      To<v8::Int32>(RunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(CompileScript2) {
-  v8::ScriptOrigin origin(NanNew<v8::String>("x").ToLocalChecked());
-  v8::Local<NanBoundScript> script =
-      NanCompileScript(NanNew("2+4").ToLocalChecked(), origin).ToLocalChecked();
+  v8::ScriptOrigin origin(New<v8::String>("x").ToLocalChecked());
+  v8::Local<BoundScript> script =
+      CompileScript(New("2+4").ToLocalChecked(), origin).ToLocalChecked();
   info.GetReturnValue().Set(
-      NanTo<v8::Int32>(NanRunScript(script).ToLocalChecked()).ToLocalChecked());
+      To<v8::Int32>(RunScript(script).ToLocalChecked()).ToLocalChecked());
 }
 
 NAN_METHOD(NewDate) {
-  info.GetReturnValue().Set(NanNew<v8::Date>(1337).ToLocalChecked());
+  info.GetReturnValue().Set(New<v8::Date>(1337).ToLocalChecked());
 }
 
 NAN_METHOD(NewArray) {
-  info.GetReturnValue().Set(NanNew<v8::Array>());
+  info.GetReturnValue().Set(New<v8::Array>());
 }
 
 NAN_METHOD(NewBoolean) {
-  info.GetReturnValue().Set(NanNew<v8::Boolean>(true));
+  info.GetReturnValue().Set(New<v8::Boolean>(true));
 }
 
 // #212
@@ -156,116 +156,116 @@ NAN_METHOD(NewBoolean2) {
 # pragma warning( push )
 # pragma warning( disable : 4800 )
 #endif
-  info.GetReturnValue().Set(NanNew<v8::Boolean>(1));
+  info.GetReturnValue().Set(New<v8::Boolean>(1));
 #if defined(_MSC_VER)
 # pragma warning( pop )
 #endif
 }
 
 void Init(v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("newNumber").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewNumber)->GetFunction()
+  Set(target
+    , New<v8::String>("newNumber").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewNumber)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newNegativeInteger").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewNegativeInteger)->GetFunction()
+  Set(target
+    , New<v8::String>("newNegativeInteger").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewNegativeInteger)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newPositiveInteger").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewPositiveInteger)->GetFunction()
+  Set(target
+    , New<v8::String>("newPositiveInteger").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewPositiveInteger)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newUnsignedInteger").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewUnsignedInteger)->GetFunction()
+  Set(target
+    , New<v8::String>("newUnsignedInteger").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewUnsignedInteger)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newInt32FromPositive").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewInt32FromPositive)->GetFunction()
+  Set(target
+    , New<v8::String>("newInt32FromPositive").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewInt32FromPositive)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newInt32FromNegative").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewInt32FromNegative)->GetFunction()
+  Set(target
+    , New<v8::String>("newInt32FromNegative").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewInt32FromNegative)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newUint32FromPositive").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewUint32FromPositive)->GetFunction()
+  Set(target
+    , New<v8::String>("newUint32FromPositive").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewUint32FromPositive)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newUint32FromNegative").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewUint32FromNegative)->GetFunction()
+  Set(target
+    , New<v8::String>("newUint32FromNegative").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewUint32FromNegative)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newUtf8String").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewUtf8String)->GetFunction()
+  Set(target
+    , New<v8::String>("newUtf8String").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewUtf8String)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newLatin1String").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewLatin1String)->GetFunction()
+  Set(target
+    , New<v8::String>("newLatin1String").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewLatin1String)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newUcs2String").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewUcs2String)->GetFunction()
+  Set(target
+    , New<v8::String>("newUcs2String").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewUcs2String)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newStdString").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewStdString)->GetFunction()
+  Set(target
+    , New<v8::String>("newStdString").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewStdString)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newRegExp").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewRegExp)->GetFunction()
+  Set(target
+    , New<v8::String>("newRegExp").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewRegExp)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newStringObject").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewStringObject)->GetFunction()
+  Set(target
+    , New<v8::String>("newStringObject").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewStringObject)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newNumberObject").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewNumberObject)->GetFunction()
+  Set(target
+    , New<v8::String>("newNumberObject").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewNumberObject)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newBooleanObject").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewBooleanObject)->GetFunction()
+  Set(target
+    , New<v8::String>("newBooleanObject").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewBooleanObject)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newExternal").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewExternal)->GetFunction()
+  Set(target
+    , New<v8::String>("newExternal").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewExternal)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newSignature").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewSignature)->GetFunction()
+  Set(target
+    , New<v8::String>("newSignature").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewSignature)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newScript").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewScript)->GetFunction()
+  Set(target
+    , New<v8::String>("newScript").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewScript)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newScript2").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewScript2)->GetFunction()
+  Set(target
+    , New<v8::String>("newScript2").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewScript2)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("compileScript").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(CompileScript)->GetFunction()
+  Set(target
+    , New<v8::String>("compileScript").ToLocalChecked()
+    , New<v8::FunctionTemplate>(CompileScript)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("compileScript2").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(CompileScript2)->GetFunction()
+  Set(target
+    , New<v8::String>("compileScript2").ToLocalChecked()
+    , New<v8::FunctionTemplate>(CompileScript2)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newDate").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewDate)->GetFunction()
+  Set(target
+    , New<v8::String>("newDate").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewDate)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newArray").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewArray)->GetFunction()
+  Set(target
+    , New<v8::String>("newArray").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewArray)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newBoolean").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewBoolean)->GetFunction()
+  Set(target
+    , New<v8::String>("newBoolean").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewBoolean)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("newBoolean2").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(NewBoolean2)->GetFunction()
+  Set(target
+    , New<v8::String>("newBoolean2").ToLocalChecked()
+    , New<v8::FunctionTemplate>(NewBoolean2)->GetFunction()
   );
 }
 
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index 09083d3d..a52daf26 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -10,17 +10,17 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-class MyObject : public NanObjectWrap {
+class MyObject : public ObjectWrap {
  public:
   static void Init(v8::Handle<v8::Object> exports) {
-    v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
-    tpl->SetClassName(NanNew("MyObject").ToLocalChecked());
+    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("MyObject").ToLocalChecked());
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
-    NanSetPrototypeMethod(tpl, "getHandle", GetHandle);
+    SetPrototypeMethod(tpl, "getHandle", GetHandle);
 
     constructor.Reset(tpl->GetFunction());
-    NanSet(exports, NanNew("MyObject").ToLocalChecked(), tpl->GetFunction());
+    Set(exports, Nan::New("MyObject").ToLocalChecked(), tpl->GetFunction());
   }
 
  private:
@@ -36,21 +36,21 @@ class MyObject : public NanObjectWrap {
     } else {
       const int argc = 1;
       v8::Local<v8::Value> argv[argc] = {info[0]};
-      v8::Local<v8::Function> cons = NanNew(constructor);
+      v8::Local<v8::Function> cons = Nan::New(constructor);
       info.GetReturnValue().Set(cons->NewInstance(argc, argv));
     }
   }
 
   static NAN_METHOD(GetHandle) {
-    MyObject* obj = NanObjectWrap::Unwrap<MyObject>(info.This());
+    MyObject* obj = ObjectWrap::Unwrap<MyObject>(info.This());
     info.GetReturnValue().Set(obj->handle());
   }
 
-  static NanPersistent<v8::Function> constructor;
+  static Persistent<v8::Function> constructor;
   double value_;
 };
 
-NanPersistent<v8::Function> MyObject::constructor;
+Persistent<v8::Function> MyObject::constructor;
 
 void Init(v8::Handle<v8::Object> exports) {
   MyObject::Init(exports);
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index 9d9dd5c7..89b60488 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -11,7 +11,7 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-static NanPersistent<v8::String> persistentTest1;
+static Persistent<v8::String> persistentTest1;
 
 NAN_METHOD(Save1) {
   persistentTest1.Reset(info[0].As<v8::String>());
@@ -19,7 +19,7 @@ NAN_METHOD(Save1) {
 }
 
 NAN_METHOD(Get1) {
-  info.GetReturnValue().Set(NanNew(persistentTest1));
+  info.GetReturnValue().Set(New(persistentTest1));
 }
 
 NAN_METHOD(Dispose1) {
@@ -28,15 +28,15 @@ NAN_METHOD(Dispose1) {
 }
 
 NAN_METHOD(ToPersistentAndBackAgain) {
-  NanPersistent<v8::Object> persistent(info[0].As<v8::Object>());
-  v8::Local<v8::Object> object = NanNew(persistent);
+  Persistent<v8::Object> persistent(info[0].As<v8::Object>());
+  v8::Local<v8::Object> object = New(persistent);
   persistent.Reset();
   memset(&persistent, -1, sizeof(persistent));  // Clobber it good.
   info.GetReturnValue().Set(object);
 }
 
 NAN_METHOD(PersistentToPersistent) {
-  NanPersistent<v8::String> persistent(info[0].As<v8::String>());
+  Persistent<v8::String> persistent(info[0].As<v8::String>());
   persistentTest1.Reset(persistent);
   persistent.Reset();
   persistentTest1.Reset();
@@ -44,35 +44,35 @@ NAN_METHOD(PersistentToPersistent) {
 }
 
 NAN_METHOD(CopyablePersistent) {
-  NanCopyablePersistentTraits<v8::String>::CopyablePersistent p;
+  CopyablePersistentTraits<v8::String>::CopyablePersistent p;
   p = persistentTest1;
-  info.GetReturnValue().Set(NanNew(p));
+  info.GetReturnValue().Set(New(p));
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("save1").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Save1)->GetFunction()
+  Set(target
+    , New<v8::String>("save1").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Save1)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("get1").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Get1)->GetFunction()
+  Set(target
+    , New<v8::String>("get1").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Get1)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("dispose1").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Dispose1)->GetFunction()
+  Set(target
+    , New<v8::String>("dispose1").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Dispose1)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("toPersistentAndBackAgain").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ToPersistentAndBackAgain)->GetFunction()
+  Set(target
+    , New<v8::String>("toPersistentAndBackAgain").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ToPersistentAndBackAgain)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("persistentToPersistent").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(PersistentToPersistent)->GetFunction()
+  Set(target
+    , New<v8::String>("persistentToPersistent").ToLocalChecked()
+    , New<v8::FunctionTemplate>(PersistentToPersistent)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("copyablePersistent").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(CopyablePersistent)->GetFunction()
+  Set(target
+    , New<v8::String>("copyablePersistent").ToLocalChecked()
+    , New<v8::FunctionTemplate>(CopyablePersistent)->GetFunction()
   );
 }
 
diff --git a/test/cpp/returnemptystring.cpp b/test/cpp/returnemptystring.cpp
index 8e378ebb..7889bdf0 100644
--- a/test/cpp/returnemptystring.cpp
+++ b/test/cpp/returnemptystring.cpp
@@ -15,9 +15,9 @@ NAN_METHOD(ReturnEmptyString) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("r").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ReturnEmptyString)->GetFunction()
+  Set(target
+    , New<v8::String>("r").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ReturnEmptyString)->GetFunction()
   );
 }
 
diff --git a/test/cpp/returnnull.cpp b/test/cpp/returnnull.cpp
index 121111eb..b6cddd66 100644
--- a/test/cpp/returnnull.cpp
+++ b/test/cpp/returnnull.cpp
@@ -15,9 +15,9 @@ NAN_METHOD(ReturnNull) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("r").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ReturnNull)->GetFunction()
+  Set(target
+    , New<v8::String>("r").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ReturnNull)->GetFunction()
   );
 }
 
diff --git a/test/cpp/returnundefined.cpp b/test/cpp/returnundefined.cpp
index b0241de1..661901f7 100644
--- a/test/cpp/returnundefined.cpp
+++ b/test/cpp/returnundefined.cpp
@@ -15,9 +15,9 @@ NAN_METHOD(ReturnUndefined) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("r").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ReturnUndefined)->GetFunction()
+  Set(target
+    , New<v8::String>("r").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ReturnUndefined)->GetFunction()
   );
 }
 
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index b4ba61c7..f0d3c5a2 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -10,15 +10,15 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-NanGlobal<v8::Boolean> global;
+Global<v8::Boolean> global;
 
-NAN_METHOD(ReturnValue) {
-  const NanFunctionCallbackInfo<v8::Value> cbinfo = info;
-  NanReturnValue<v8::Value> ret = cbinfo.GetReturnValue();
+NAN_METHOD(ReturnAValue) {
+  const FunctionCallbackInfo<v8::Value> cbinfo = info;
+  ReturnValue<v8::Value> ret = cbinfo.GetReturnValue();
   if (cbinfo.Length() == 1) {
     ret.Set(info[0].As<v8::String>());
   } else {
-    ret.Set(NanNew("default").ToLocalChecked());
+    ret.Set(New("default").ToLocalChecked());
   }
 }
 
@@ -31,19 +31,19 @@ NAN_METHOD(ReturnGlobal) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  global.Reset(NanNew(true));
+  global.Reset(New(true));
 
-  NanSet(target
-    , NanNew<v8::String>("r").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ReturnValue)->GetFunction()
+  Set(target
+    , New<v8::String>("r").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ReturnAValue)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("p").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ReturnPrimitive)->GetFunction()
+  Set(target
+    , New<v8::String>("p").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ReturnPrimitive)->GetFunction()
   );
-  NanSet(target
-    , NanNew<v8::String>("q").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(ReturnGlobal)->GetFunction()
+  Set(target
+    , New<v8::String>("q").ToLocalChecked()
+    , New<v8::FunctionTemplate>(ReturnGlobal)->GetFunction()
   );
 }
 
diff --git a/test/cpp/settemplate.cpp b/test/cpp/settemplate.cpp
index fc5bf11e..58f70e27 100644
--- a/test/cpp/settemplate.cpp
+++ b/test/cpp/settemplate.cpp
@@ -19,10 +19,10 @@ class MyObject : public node::ObjectWrap {
   ~MyObject();
 
   static NAN_METHOD(New);
-  static NanPersistent<v8::Function> constructor;
+  static Persistent<v8::Function> constructor;
 };
 
-NanPersistent<v8::Function> MyObject::constructor;
+Persistent<v8::Function> MyObject::constructor;
 
 MyObject::MyObject() {
 }
@@ -32,47 +32,47 @@ MyObject::~MyObject() {
 
 void MyObject::Init(v8::Handle<v8::Object> exports) {
   // Prepare constructor template
-  v8::Local<v8::FunctionTemplate> tpl = NanNew<v8::FunctionTemplate>(New);
-  tpl->SetClassName(NanNew<v8::String>("MyObject").ToLocalChecked());
+  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+  tpl->SetClassName(Nan::New<v8::String>("MyObject").ToLocalChecked());
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   // Prototype
-  NanSetPrototypeTemplate(
+  SetPrototypeTemplate(
     tpl
   , "prototypeProp"
-  , NanNew<v8::String>("a prototype property").ToLocalChecked());
+  , Nan::New<v8::String>("a prototype property").ToLocalChecked());
 
   // Instance
-  NanSetInstanceTemplate(
+  SetInstanceTemplate(
     tpl
   , "instanceProp"
-  , NanNew<v8::String>("an instance property").ToLocalChecked());
+  , Nan::New<v8::String>("an instance property").ToLocalChecked());
 
   // PropertyAttributes
-  NanSetInstanceTemplate(
+  SetInstanceTemplate(
     tpl
-  , NanNew<v8::String>("none").ToLocalChecked()
-  , NanNew<v8::String>("none").ToLocalChecked()
+  , Nan::New<v8::String>("none").ToLocalChecked()
+  , Nan::New<v8::String>("none").ToLocalChecked()
   , v8::None);
-  NanSetInstanceTemplate(
+  SetInstanceTemplate(
     tpl
-  , NanNew<v8::String>("readOnly").ToLocalChecked()
-  , NanNew<v8::String>("readOnly").ToLocalChecked()
+  , Nan::New<v8::String>("readOnly").ToLocalChecked()
+  , Nan::New<v8::String>("readOnly").ToLocalChecked()
   , v8::ReadOnly);
-  NanSetInstanceTemplate(
+  SetInstanceTemplate(
     tpl
-  , NanNew<v8::String>("dontEnum").ToLocalChecked()
-  , NanNew<v8::String>("dontEnum").ToLocalChecked()
+  , Nan::New<v8::String>("dontEnum").ToLocalChecked()
+  , Nan::New<v8::String>("dontEnum").ToLocalChecked()
   , v8::DontEnum);
-  NanSetInstanceTemplate(
+  SetInstanceTemplate(
     tpl
-  , NanNew<v8::String>("dontDelete").ToLocalChecked()
-  , NanNew<v8::String>("dontDelete").ToLocalChecked()
+  , Nan::New<v8::String>("dontDelete").ToLocalChecked()
+  , Nan::New<v8::String>("dontDelete").ToLocalChecked()
   , v8::DontDelete);
 
   constructor.Reset(tpl->GetFunction());
-  NanSet(exports
-  , NanNew<v8::String>("MyObject").ToLocalChecked()
+  Set(exports
+  , Nan::New<v8::String>("MyObject").ToLocalChecked()
   , tpl->GetFunction());
 }
 
@@ -82,7 +82,7 @@ NAN_METHOD(MyObject::New) {
     obj->Wrap(info.This());
     info.GetReturnValue().Set(info.This());
   } else {
-    v8::Local<v8::Function> cons = NanNew<v8::Function>(constructor);
+    v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
     info.GetReturnValue().Set(cons->NewInstance());
   }
 }
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index cfc198ed..97872e96 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -11,67 +11,67 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 NAN_METHOD(ReturnUtf8String) {
-  info.GetReturnValue().Set(NanNew(*NanUtf8String(info[0])).ToLocalChecked());
+  info.GetReturnValue().Set(New(*Utf8String(info[0])).ToLocalChecked());
 }
 
 NAN_METHOD(HeapString) {
-  NanUtf8String *s = new NanUtf8String(info[0]);
-  v8::Local<v8::String> res = NanNew(**s).ToLocalChecked();
+  Utf8String *s = new Utf8String(info[0]);
+  v8::Local<v8::String> res = New(**s).ToLocalChecked();
   delete s;
   info.GetReturnValue().Set(res);
 }
 
 NAN_METHOD(EncodeHex) {
-  info.GetReturnValue().Set(NanEncode("hello", 5, HEX));
+  info.GetReturnValue().Set(Encode("hello", 5, HEX));
 }
 
 NAN_METHOD(EncodeUCS2) {
-  info.GetReturnValue().Set(NanEncode("h\0e\0l\0l\0o\0", 10, UCS2));
+  info.GetReturnValue().Set(Encode("h\0e\0l\0l\0o\0", 10, UCS2));
 }
 
-NanPersistent<v8::FunctionTemplate> returnUtf8String_persistent;
-NanPersistent<v8::FunctionTemplate> heapString_persistent;
-NanPersistent<v8::FunctionTemplate> encodeHex_persistent;
-NanPersistent<v8::FunctionTemplate> encodeUCS2_persistent;
+Persistent<v8::FunctionTemplate> returnUtf8String_persistent;
+Persistent<v8::FunctionTemplate> heapString_persistent;
+Persistent<v8::FunctionTemplate> encodeHex_persistent;
+Persistent<v8::FunctionTemplate> encodeUCS2_persistent;
 
 void Init (v8::Handle<v8::Object> target) {
   v8::Local<v8::FunctionTemplate> returnUtf8String =
-    NanNew<v8::FunctionTemplate>(ReturnUtf8String);
+    New<v8::FunctionTemplate>(ReturnUtf8String);
 
   returnUtf8String_persistent.Reset(returnUtf8String);
 
   target->Set(
-      NanNew("returnUtf8String").ToLocalChecked()
+      New("returnUtf8String").ToLocalChecked()
     , returnUtf8String->GetFunction()
   );
 
   v8::Local<v8::FunctionTemplate> heapString =
-    NanNew<v8::FunctionTemplate>(HeapString);
+    New<v8::FunctionTemplate>(HeapString);
 
   heapString_persistent.Reset(heapString);
 
   target->Set(
-      NanNew("heapString").ToLocalChecked()
+      New("heapString").ToLocalChecked()
     , heapString->GetFunction()
   );
 
   v8::Local<v8::FunctionTemplate> encodeHex =
-    NanNew<v8::FunctionTemplate>(EncodeHex);
+    New<v8::FunctionTemplate>(EncodeHex);
 
   encodeHex_persistent.Reset(encodeHex);
 
-  NanSet(target
-    , NanNew("encodeHex").ToLocalChecked()
+  Set(target
+    , New("encodeHex").ToLocalChecked()
     , encodeHex->GetFunction()
   );
 
   v8::Local<v8::FunctionTemplate> encodeUCS2 =
-    NanNew<v8::FunctionTemplate>(EncodeUCS2);
+    New<v8::FunctionTemplate>(EncodeUCS2);
 
   encodeUCS2_persistent.Reset(encodeUCS2);
 
-  NanSet(target
-    , NanNew("encodeUCS2").ToLocalChecked()
+  Set(target
+    , New("encodeUCS2").ToLocalChecked()
     , encodeUCS2->GetFunction()
   );
 }
diff --git a/test/cpp/symbols.cpp b/test/cpp/symbols.cpp
index b889c319..c1a42e3c 100644
--- a/test/cpp/symbols.cpp
+++ b/test/cpp/symbols.cpp
@@ -11,9 +11,9 @@
 using namespace Nan;  // NOLINT(build/namespaces)
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("key").ToLocalChecked()
-    , NanNew<v8::String>("a property").ToLocalChecked()
+  Set(target
+    , New<v8::String>("key").ToLocalChecked()
+    , New<v8::String>("a property").ToLocalChecked()
   );
 }
 
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index ccaa6ed1..5c9ab352 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -14,9 +14,9 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 // Based on test-thread.c from libuv.
 
-class TlsTest : public NanAsyncWorker {
+class TlsTest : public AsyncWorker {
  public:
-  explicit TlsTest(NanTap *t) : NanAsyncWorker(NULL), t(t), i(0) {
+  explicit TlsTest(Tap *t) : AsyncWorker(NULL), t(t), i(0) {
     t->plan(7);
     t->ok(_(0 == nauv_key_create(&tls_key)));
     t->ok(_(NULL == nauv_key_get(&tls_key)));
@@ -31,7 +31,7 @@ class TlsTest : public NanAsyncWorker {
     ok(_(NULL == nauv_key_get(&tls_key)));
   }
   void WorkComplete() {
-    NanScope scope;
+    Scope scope;
     for (unsigned j = 0; j < i; ++j)
       t->ok(res[j].ok, res[j].msg);
     nauv_key_delete(&tls_key);
@@ -42,7 +42,7 @@ class TlsTest : public NanAsyncWorker {
  private:
   nauv_key_t tls_key;
 
-  NanTap *t;
+  Tap *t;
   struct { bool ok; const char* msg; } res[3];
   unsigned i;
   void ok(bool isOk, const char *msg) {
@@ -54,15 +54,15 @@ class TlsTest : public NanAsyncWorker {
 };
 
 NAN_METHOD(thread_local_storage) {
-  NanTap *t = new NanTap(info[0]);
-  NanAsyncQueueWorker(new TlsTest(t));
+  Tap *t = new Tap(info[0]);
+  AsyncQueueWorker(new TlsTest(t));
   info.GetReturnValue().SetUndefined();
 }
 
 void Init(v8::Handle<v8::Object> exports) {
-  NanSet(exports
-    , NanNew<v8::String>("thread_local_storage").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(thread_local_storage)->GetFunction()
+  Set(exports
+    , New<v8::String>("thread_local_storage").ToLocalChecked()
+    , New<v8::FunctionTemplate>(thread_local_storage)->GetFunction()
   );
 }
 
diff --git a/test/cpp/trycatch.cpp b/test/cpp/trycatch.cpp
index 1e35aa06..3d0be691 100644
--- a/test/cpp/trycatch.cpp
+++ b/test/cpp/trycatch.cpp
@@ -10,11 +10,11 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-NAN_METHOD(TryCatch) {
-  NanTryCatch try_catch;
+NAN_METHOD(TryCatchTest) {
+  TryCatch try_catch;
   v8::Local<v8::Value> v =
-      NanRunScript(NanNew<NanUnboundScript>(
-          NanNew("throw 'waaa'").ToLocalChecked()).ToLocalChecked())
+      RunScript(New<UnboundScript>(
+          New("throw 'waaa'").ToLocalChecked()).ToLocalChecked())
               .ToLocalChecked();
   if (v.IsEmpty()) {
     assert(try_catch.HasCaught());
@@ -23,9 +23,9 @@ NAN_METHOD(TryCatch) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("r").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(TryCatch)->GetFunction()
+  Set(target
+    , New<v8::String>("r").ToLocalChecked()
+    , New<v8::FunctionTemplate>(TryCatchTest)->GetFunction()
   );
 }
 
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index 1536b6f2..3167318e 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -10,22 +10,22 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-static NanPersistent<v8::Function> cb;
+static Persistent<v8::Function> cb;
 
 void weakCallback(
-    const NanWeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)
+    const WeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)
   int *parameter = data.GetParameter();
-  v8::Local<v8::Value> val = NanNew(*parameter);
-  NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(cb), 1, &val);
+  v8::Local<v8::Value> val = New(*parameter);
+  MakeCallback(GetCurrentContext()->Global(), New(cb), 1, &val);
   delete parameter;
 }
 
 v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
-  NanEscapableScope scope;
-  v8::Local<v8::String> lstring = NanNew<v8::String>("result").ToLocalChecked();
+  EscapableScope scope;
+  v8::Local<v8::String> lstring = New<v8::String>("result").ToLocalChecked();
   int *parameter = new int(42);
-  NanPersistent<v8::Function> persistent(func);
-  persistent.SetWeak(parameter, weakCallback, NanWeakCallbackType::kParameter);
+  Persistent<v8::Function> persistent(func);
+  persistent.SetWeak(parameter, weakCallback, WeakCallbackType::kParameter);
   assert(persistent.IsWeak());
   return scope.Escape(lstring);
 }
@@ -36,9 +36,9 @@ NAN_METHOD(Hustle) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("hustle").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Hustle)->GetFunction()
+  Set(target
+    , New<v8::String>("hustle").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Hustle)->GetFunction()
   );
 }
 
diff --git a/test/cpp/weak2.cpp b/test/cpp/weak2.cpp
index bcc5a3cb..41c8fb95 100644
--- a/test/cpp/weak2.cpp
+++ b/test/cpp/weak2.cpp
@@ -10,27 +10,27 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-static NanPersistent<v8::Function> cb;
+static Persistent<v8::Function> cb;
 void weakCallback(
-    const NanWeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)
+    const WeakCallbackInfo<int> &data) {  // NOLINT(runtime/references)
   int *parameter = static_cast<int*>(data.GetInternalField(0));
-  v8::Local<v8::Value> val = NanNew(*parameter);
-  NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(cb), 1, &val);
+  v8::Local<v8::Value> val = New(*parameter);
+  MakeCallback(GetCurrentContext()->Global(), New(cb), 1, &val);
   delete parameter;
 }
 
 v8::Handle<v8::String> wrap() {
-  NanEscapableScope scope;
-  v8::Local<v8::String> lstring = NanNew("result").ToLocalChecked();
-  v8::Local<v8::ObjectTemplate> otpl = NanNew<v8::ObjectTemplate>();
+  EscapableScope scope;
+  v8::Local<v8::String> lstring = New("result").ToLocalChecked();
+  v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>();
   otpl->SetInternalFieldCount(1);
   v8::Local<v8::Object> obj = otpl->NewInstance();
-  NanSetInternalFieldPointer(obj, 0, new int(42));
-  NanPersistent<v8::Object> persistent(obj);
+  SetInternalFieldPointer(obj, 0, new int(42));
+  Persistent<v8::Object> persistent(obj);
   persistent.SetWeak(
       static_cast<int*>(0)
     , weakCallback
-    , NanWeakCallbackType::kInternalFields);
+    , WeakCallbackType::kInternalFields);
   assert(persistent.IsWeak());
   return scope.Escape(lstring);
 }
@@ -41,9 +41,9 @@ NAN_METHOD(Hustle) {
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  NanSet(target
-    , NanNew<v8::String>("hustle").ToLocalChecked()
-    , NanNew<v8::FunctionTemplate>(Hustle)->GetFunction()
+  Set(target
+    , New<v8::String>("hustle").ToLocalChecked()
+    , New<v8::FunctionTemplate>(Hustle)->GetFunction()
   );
 }
 

From d5d32913327be05e6aa4d740a5fc26173bb14927 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 21 Jun 2015 16:22:46 +0300
Subject: [PATCH 29/84] Update Buffer API for new upstream changes

---
 nan.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/nan.h b/nan.h
index 9c02911c..7099329f 100644
--- a/nan.h
+++ b/nan.h
@@ -687,7 +687,7 @@ class TryCatch {
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
     assert(size <= imp::kMaxLength && "too large buffer");
 #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
-    return node::Buffer::New(
+    return node::Buffer::Copy(
         v8::Isolate::GetCurrent(), data, size);
 #else
     return MaybeLocal<v8::Object>(node::Buffer::New(
@@ -715,7 +715,11 @@ class TryCatch {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
     assert(size <= imp::kMaxLength && "too large buffer");
+#if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
+    return node::Buffer::New(v8::Isolate::GetCurrent(), data, size);
+#else
     return node::Buffer::Use(v8::Isolate::GetCurrent(), data, size);
+#endif
   }
 
   NAN_INLINE bool HasInstance(

From 21a7a6a3b2f42d00c07340321245a6ff00b75bbc Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 14:22:37 +0300
Subject: [PATCH 30/84] Rename Scope and EscapableScope to HandleScope and
 EscapableHandleScope

---
 nan.h                               | 102 ++++++++++++++--------------
 test/cpp/accessors.cpp              |   2 +-
 test/cpp/accessors2.cpp             |   2 +-
 test/cpp/asyncprogressworker.cpp    |   2 +-
 test/cpp/bufferworkerpersistent.cpp |   2 +-
 test/cpp/converters.cpp             |   2 +-
 test/cpp/gc.cpp                     |   2 +-
 test/cpp/indexedinterceptors.cpp    |   2 +-
 test/cpp/namedinterceptors.cpp      |   2 +-
 test/cpp/threadlocal.cpp            |   2 +-
 test/cpp/weak.cpp                   |   2 +-
 test/cpp/weak2.cpp                  |   2 +-
 12 files changed, 62 insertions(+), 62 deletions(-)

diff --git a/nan.h b/nan.h
index 7099329f..df2b9549 100644
--- a/nan.h
+++ b/nan.h
@@ -356,17 +356,17 @@ namespace imp {
 
 //=== HandleScope ==============================================================
 
-class Scope {
+class HandleScope {
   v8::HandleScope scope;
 
  public:
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
-  inline Scope() : scope(v8::Isolate::GetCurrent()) {}
+  inline HandleScope() : scope(v8::Isolate::GetCurrent()) {}
   inline static int NumberOfHandles() {
     return v8::HandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
   }
 #else
-  inline Scope() : scope() {}
+  inline HandleScope() : scope() {}
   inline static int NumberOfHandles() {
     return v8::HandleScope::NumberOfHandles();
   }
@@ -375,16 +375,16 @@ class Scope {
  private:
   // Make it hard to create heap-allocated or illegal handle scopes by
   // disallowing certain operations.
-  Scope(const Scope &);
-  void operator=(const Scope &);
+  HandleScope(const HandleScope &);
+  void operator=(const HandleScope &);
   void *operator new(size_t size);
   void operator delete(void *, size_t);
 };
 
-class EscapableScope {
+class EscapableHandleScope {
  public:
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
-  inline EscapableScope() : scope(v8::Isolate::GetCurrent()) {}
+  inline EscapableHandleScope() : scope(v8::Isolate::GetCurrent()) {}
 
   inline static int NumberOfHandles() {
     return v8::EscapableHandleScope::NumberOfHandles(v8::Isolate::GetCurrent());
@@ -398,7 +398,7 @@ class EscapableScope {
  private:
   v8::EscapableHandleScope scope;
 #else
-  inline EscapableScope() : scope() {}
+  inline EscapableHandleScope() : scope() {}
 
   inline static int NumberOfHandles() {
     return v8::HandleScope::NumberOfHandles();
@@ -416,8 +416,8 @@ class EscapableScope {
  private:
   // Make it hard to create heap-allocated or illegal handle scopes by
   // disallowing certain operations.
-  EscapableScope(const EscapableScope &);
-  void operator=(const EscapableScope &);
+  EscapableHandleScope(const EscapableHandleScope &);
+  void operator=(const EscapableHandleScope &);
   void *operator new(size_t size);
   void operator delete(void *, size_t);
 };
@@ -536,22 +536,22 @@ class TryCatch {
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)  // Node 0.12
   NAN_INLINE v8::Local<v8::Primitive> Undefined() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::Undefined(v8::Isolate::GetCurrent())));
   }
 
   NAN_INLINE v8::Local<v8::Primitive> Null() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::Null(v8::Isolate::GetCurrent())));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> True() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::True(v8::Isolate::GetCurrent())));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> False() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::False(v8::Isolate::GetCurrent())));
   }
 
@@ -628,7 +628,7 @@ class TryCatch {
 
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> NAME(const char *msg) {                    \
-      EscapableScope scope;                                                    \
+      EscapableHandleScope scope;                                              \
       return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked()));     \
     }                                                                          \
                                                                                \
@@ -638,13 +638,13 @@ class TryCatch {
     }                                                                          \
                                                                                \
     NAN_INLINE void Throw ## NAME(const char *msg) {                           \
-      Scope scope;                                                             \
+      HandleScope scope;                                                       \
       v8::Isolate::GetCurrent()->ThrowException(                               \
           v8::Exception::NAME(New(msg).ToLocalChecked()));                     \
     }                                                                          \
                                                                                \
     NAN_INLINE void Throw ## NAME(v8::Handle<v8::String> msg) {                \
-      Scope scope;                                                             \
+      HandleScope scope;                                                       \
       v8::Isolate::GetCurrent()->ThrowException(                               \
           v8::Exception::NAME(New(msg)));                                      \
     }
@@ -902,22 +902,22 @@ class Utf8String {
 
 #else  // Node 0.8 and 0.10
   NAN_INLINE v8::Local<v8::Primitive> Undefined() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::Undefined()));
   }
 
   NAN_INLINE v8::Local<v8::Primitive> Null() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::Null()));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> True() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::True()));
   }
 
   NAN_INLINE v8::Local<v8::Boolean> False() {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(v8::False()));
   }
 
@@ -989,7 +989,7 @@ class Utf8String {
 
 # define X(NAME)                                                               \
     NAN_INLINE v8::Local<v8::Value> NAME(const char *msg) {                    \
-      EscapableScope scope;                                                    \
+      EscapableHandleScope scope;                                              \
       return scope.Escape(v8::Exception::NAME(New(msg).ToLocalChecked()));     \
     }                                                                          \
                                                                                \
@@ -999,7 +999,7 @@ class Utf8String {
     }                                                                          \
                                                                                \
     NAN_INLINE void Throw ## NAME(const char *msg) {                           \
-      Scope scope;                                                             \
+      HandleScope scope;                                                       \
       v8::ThrowException(v8::Exception::NAME(New(msg).ToLocalChecked()));      \
     }                                                                          \
                                                                                \
@@ -1026,7 +1026,7 @@ class Utf8String {
     , node::Buffer::free_callback callback
     , void *hint
   ) {
-    Scope scope;
+    HandleScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
     assert(length <= imp::kMaxLength && "too large buffer");
@@ -1038,7 +1038,7 @@ class Utf8String {
       const char *data
     , uint32_t size
   ) {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
     assert(size <= imp::kMaxLength && "too large buffer");
@@ -1054,7 +1054,7 @@ class Utf8String {
   NAN_INLINE MaybeLocal<v8::Object> NewBuffer(uint32_t size) {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
-    EscapableScope scope;
+    EscapableHandleScope scope;
     assert(size <= imp::kMaxLength && "too large buffer");
     return MaybeLocal<v8::Object>(
         scope.Escape(New(node::Buffer::New(size)->handle_)));
@@ -1069,7 +1069,7 @@ class Utf8String {
       char* data
     , uint32_t size
   ) {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
     assert(size <= imp::kMaxLength && "too large buffer");
@@ -1322,13 +1322,13 @@ typedef void NAN_INDEX_QUERY_RETURN_TYPE;
 class Callback {
  public:
   Callback() {
-    Scope scope;
+    HandleScope scope;
     v8::Local<v8::Object> obj = New<v8::Object>();
     handle.Reset(obj);
   }
 
   explicit Callback(const v8::Handle<v8::Function> &fn) {
-    Scope scope;
+    HandleScope scope;
     v8::Local<v8::Object> obj = New<v8::Object>();
     handle.Reset(obj);
     SetFunction(fn);
@@ -1340,7 +1340,7 @@ class Callback {
   }
 
   bool operator==(const Callback &other) const {
-    Scope scope;
+    HandleScope scope;
     v8::Local<v8::Value> a = New(handle)->Get(kCallbackIndex);
     v8::Local<v8::Value> b = New(other.handle)->Get(kCallbackIndex);
     return a->StrictEquals(b);
@@ -1367,18 +1367,18 @@ class Callback {
   }
 
   NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
-    Scope scope;
+    HandleScope scope;
     Set(New(handle), kCallbackIndex, fn);
   }
 
   NAN_INLINE v8::Local<v8::Function> GetFunction() const {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(handle)->Get(kCallbackIndex)
         .As<v8::Function>());
   }
 
   NAN_INLINE bool IsEmpty() const {
-    Scope scope;
+    HandleScope scope;
     return New(handle)->Get(kCallbackIndex)->IsUndefined();
   }
 
@@ -1414,7 +1414,7 @@ class Callback {
                            , v8::Handle<v8::Object> target
                            , int argc
                            , v8::Handle<v8::Value> argv[]) const {
-    EscapableScope scope;
+    EscapableHandleScope scope;
 
     v8::Local<v8::Function> callback = New(handle)->
         Get(kCallbackIndex).As<v8::Function>();
@@ -1430,7 +1430,7 @@ class Callback {
   v8::Local<v8::Value> Call_(v8::Handle<v8::Object> target
                            , int argc
                            , v8::Handle<v8::Value> argv[]) const {
-    EscapableScope scope;
+    EscapableHandleScope scope;
 
     v8::Local<v8::Function> callback = New(handle)->
         Get(kCallbackIndex).As<v8::Function>();
@@ -1450,13 +1450,13 @@ class Callback {
       : callback(callback_), errmsg_(NULL) {
     request.data = this;
 
-    Scope scope;
+    HandleScope scope;
     v8::Local<v8::Object> obj = New<v8::Object>();
     persistentHandle.Reset(obj);
   }
 
   virtual ~AsyncWorker() {
-    Scope scope;
+    HandleScope scope;
 
     if (!persistentHandle.IsEmpty())
       persistentHandle.Reset();
@@ -1467,7 +1467,7 @@ class Callback {
   }
 
   virtual void WorkComplete() {
-    Scope scope;
+    HandleScope scope;
 
     if (errmsg_ == NULL)
       HandleOKCallback();
@@ -1479,36 +1479,36 @@ class Callback {
 
   NAN_INLINE void SaveToPersistent(
       const char *key, const v8::Local<v8::Value> &value) {
-    Scope scope;
+    HandleScope scope;
     New(persistentHandle)->Set(New(key).ToLocalChecked(), value);
   }
 
   NAN_INLINE void SaveToPersistent(
       const v8::Handle<v8::String> &key, const v8::Local<v8::Value> &value) {
-    Scope scope;
+    HandleScope scope;
     New(persistentHandle)->Set(key, value);
   }
 
   NAN_INLINE void SaveToPersistent(
       uint32_t index, const v8::Local<v8::Value> &value) {
-    Scope scope;
+    HandleScope scope;
     New(persistentHandle)->Set(index, value);
   }
 
   NAN_INLINE v8::Local<v8::Value> GetFromPersistent(const char *key) const {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(
         New(persistentHandle)->Get(New(key).ToLocalChecked()));
   }
 
   NAN_INLINE v8::Local<v8::Object>
   GetFromPersistent(const v8::Local<v8::String> &key) const {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(persistentHandle)->Get(key));
   }
 
   NAN_INLINE v8::Local<v8::Value> GetFromPersistent(uint32_t index) const {
-    EscapableScope scope;
+    EscapableHandleScope scope;
     return scope.Escape(New(persistentHandle)->Get(index));
   }
 
@@ -1529,7 +1529,7 @@ class Callback {
   }
 
   virtual void HandleErrorCallback() {
-    Scope scope;
+    HandleScope scope;
 
     v8::Local<v8::Value> argv[] = {
       v8::Exception::Error(New<v8::String>(ErrorMessage()).ToLocalChecked())
@@ -1819,7 +1819,7 @@ NAN_INLINE void SetMethod(
     const T &recv
   , const char *name
   , FunctionCallback callback) {
-  Scope scope;
+  HandleScope scope;
   v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
       callback)->GetFunction();
   v8::Local<v8::String> fn_name = New(name);
@@ -1830,7 +1830,7 @@ NAN_INLINE void SetMethod(
 NAN_INLINE void SetPrototypeMethod(
     v8::Handle<v8::FunctionTemplate> recv
   , const char* name, FunctionCallback callback) {
-  Scope scope;
+  HandleScope scope;
   v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
       callback
     , v8::Handle<v8::Value>()
@@ -1851,7 +1851,7 @@ inline void SetAccessor(
   , v8::AccessControl settings = v8::DEFAULT
   , v8::PropertyAttribute attribute = v8::None
   , imp::Sig signature = imp::Sig()) {
-  Scope scope;
+  HandleScope scope;
 
   imp::NativeGetter getter_ =
       imp::GetterCallbackWrapper;
@@ -1897,7 +1897,7 @@ inline bool SetAccessor(
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
   , v8::AccessControl settings = v8::DEFAULT
   , v8::PropertyAttribute attribute = v8::None) {
-  EscapableScope scope;
+  EscapableHandleScope scope;
 
   imp::NativeGetter getter_ =
       imp::GetterCallbackWrapper;
@@ -1942,7 +1942,7 @@ inline void SetNamedPropertyHandler(
   , PropertyDeleterCallback deleter = 0
   , PropertyEnumeratorCallback enumerator = 0
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
-  Scope scope;
+  HandleScope scope;
 
   imp::NativePropertyGetter getter_ =
       imp::PropertyGetterCallbackWrapper;
@@ -2023,7 +2023,7 @@ inline void SetIndexedPropertyHandler(
   , IndexDeleterCallback deleter = 0
   , IndexEnumeratorCallback enumerator = 0
   , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
-  Scope scope;
+  HandleScope scope;
 
   imp::NativeIndexGetter getter_ =
       imp::IndexGetterCallbackWrapper;
diff --git a/test/cpp/accessors.cpp b/test/cpp/accessors.cpp
index a743b52c..054e9b58 100644
--- a/test/cpp/accessors.cpp
+++ b/test/cpp/accessors.cpp
@@ -66,7 +66,7 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
 }
 
 v8::Handle<v8::Value> SetterGetter::NewInstance () {
-  EscapableScope scope;
+  EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(settergetter_constructor);
   v8::Local<v8::Object> instance =
diff --git a/test/cpp/accessors2.cpp b/test/cpp/accessors2.cpp
index 0c5c9e48..da746343 100644
--- a/test/cpp/accessors2.cpp
+++ b/test/cpp/accessors2.cpp
@@ -54,7 +54,7 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
 }
 
 v8::Handle<v8::Value> SetterGetter::NewInstance () {
-  EscapableScope scope;
+  EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(settergetter_constructor);
   v8::Local<v8::Object> instance =
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index d69bcd8e..0d9eb235 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -33,7 +33,7 @@ class ProgressWorker : public AsyncProgressWorker {
   }
 
   void HandleProgressCallback(const char *data, size_t size) {
-    Scope scope;
+    HandleScope scope;
 
     v8::Local<v8::Value> argv[] = {
         New<v8::Integer>(*reinterpret_cast<int*>(const_cast<char*>(data)))
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index e35fc4be..f6cf0407 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -34,7 +34,7 @@ class BufferWorker : public AsyncWorker {
   }
 
   void HandleOKCallback () {
-    Scope scope;
+    HandleScope scope;
 
     v8::Local<v8::Value> handle = GetFromPersistent("buffer");
     callback->Call(1, &handle);
diff --git a/test/cpp/converters.cpp b/test/cpp/converters.cpp
index 188ee5eb..e0b23536 100644
--- a/test/cpp/converters.cpp
+++ b/test/cpp/converters.cpp
@@ -43,7 +43,7 @@ NAN_METHOD(ToInt32) {
 }
 
 NAN_METHOD(ToArrayIndex) {
-  Scope();
+  HandleScope scope;
   info.GetReturnValue().Set(ToArrayIndex(info[0]).ToLocalChecked());
 }
 
diff --git a/test/cpp/gc.cpp b/test/cpp/gc.cpp
index 0512600b..522c043d 100644
--- a/test/cpp/gc.cpp
+++ b/test/cpp/gc.cpp
@@ -28,7 +28,7 @@ NAN_METHOD(Hook) {
 }
 
 NAN_METHOD(Check) {
-  Scope();
+  HandleScope scope;
   info.GetReturnValue().Set(
       New(prologue_called && epilogue_called));
 }
diff --git a/test/cpp/indexedinterceptors.cpp b/test/cpp/indexedinterceptors.cpp
index 865bf064..237df464 100644
--- a/test/cpp/indexedinterceptors.cpp
+++ b/test/cpp/indexedinterceptors.cpp
@@ -55,7 +55,7 @@ void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
 }
 
 v8::Handle<v8::Value> IndexedInterceptor::NewInstance () {
-  EscapableScope scope;
+  EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(indexedinterceptors_constructor);
   v8::Local<v8::Object> instance =
diff --git a/test/cpp/namedinterceptors.cpp b/test/cpp/namedinterceptors.cpp
index c7311644..c97dcc6a 100644
--- a/test/cpp/namedinterceptors.cpp
+++ b/test/cpp/namedinterceptors.cpp
@@ -55,7 +55,7 @@ void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
 }
 
 v8::Handle<v8::Value> NamedInterceptor::NewInstance () {
-  EscapableScope scope;
+  EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(namedinterceptors_constructor);
   v8::Local<v8::Object> instance =
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index 5c9ab352..a8f4676a 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -31,7 +31,7 @@ class TlsTest : public AsyncWorker {
     ok(_(NULL == nauv_key_get(&tls_key)));
   }
   void WorkComplete() {
-    Scope scope;
+    HandleScope scope;
     for (unsigned j = 0; j < i; ++j)
       t->ok(res[j].ok, res[j].msg);
     nauv_key_delete(&tls_key);
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index 3167318e..062bff55 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -21,7 +21,7 @@ void weakCallback(
 }
 
 v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
-  EscapableScope scope;
+  EscapableHandleScope scope;
   v8::Local<v8::String> lstring = New<v8::String>("result").ToLocalChecked();
   int *parameter = new int(42);
   Persistent<v8::Function> persistent(func);
diff --git a/test/cpp/weak2.cpp b/test/cpp/weak2.cpp
index 41c8fb95..0eacbe57 100644
--- a/test/cpp/weak2.cpp
+++ b/test/cpp/weak2.cpp
@@ -20,7 +20,7 @@ void weakCallback(
 }
 
 v8::Handle<v8::String> wrap() {
-  EscapableScope scope;
+  EscapableHandleScope scope;
   v8::Local<v8::String> lstring = New("result").ToLocalChecked();
   v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>();
   otpl->SetInternalFieldCount(1);

From 166ab10a480fb229ac48809e7301d2083d719061 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 14:30:05 +0300
Subject: [PATCH 31/84] Fix missing namespace in callback declaration macros

---
 nan.h                   | 50 +++++++++++++++++++++--------------------
 test/cpp/returnnull.cpp |  8 +++----
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/nan.h b/nan.h
index df2b9549..668b4a29 100644
--- a/nan.h
+++ b/nan.h
@@ -1269,55 +1269,57 @@ typedef const PropertyCallbackInfo<v8::Integer>&
     NAN_INDEX_QUERY_ARGS_TYPE;
 typedef void NAN_INDEX_QUERY_RETURN_TYPE;
 
-#define NAN_METHOD(name) NAN_METHOD_RETURN_TYPE name(NAN_METHOD_ARGS_TYPE info)
+#define NAN_METHOD(name)                                                       \
+    Nan::NAN_METHOD_RETURN_TYPE name(Nan::NAN_METHOD_ARGS_TYPE info)
 #define NAN_GETTER(name)                                                       \
-    NAN_GETTER_RETURN_TYPE name(                                               \
+    Nan::NAN_GETTER_RETURN_TYPE name(                                          \
         v8::Local<v8::String> property                                         \
-      , NAN_GETTER_ARGS_TYPE info)
+      , Nan::NAN_GETTER_ARGS_TYPE info)
 #define NAN_SETTER(name)                                                       \
-    NAN_SETTER_RETURN_TYPE name(                                               \
+    Nan::NAN_SETTER_RETURN_TYPE name(                                          \
         v8::Local<v8::String> property                                         \
       , v8::Local<v8::Value> value                                             \
-      , NAN_SETTER_ARGS_TYPE info)
+      , Nan::NAN_SETTER_ARGS_TYPE info)
 #define NAN_PROPERTY_GETTER(name)                                              \
-    NAN_PROPERTY_GETTER_RETURN_TYPE name(                                      \
+    Nan::NAN_PROPERTY_GETTER_RETURN_TYPE name(                                 \
         v8::Local<v8::String> property                                         \
-      , NAN_PROPERTY_GETTER_ARGS_TYPE info)
+      , Nan::NAN_PROPERTY_GETTER_ARGS_TYPE info)
 #define NAN_PROPERTY_SETTER(name)                                              \
-    NAN_PROPERTY_SETTER_RETURN_TYPE name(                                      \
+    Nan::NAN_PROPERTY_SETTER_RETURN_TYPE name(                                 \
         v8::Local<v8::String> property                                         \
       , v8::Local<v8::Value> value                                             \
-      , NAN_PROPERTY_SETTER_ARGS_TYPE info)
+      , Nan::NAN_PROPERTY_SETTER_ARGS_TYPE info)
 #define NAN_PROPERTY_ENUMERATOR(name)                                          \
-    NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(                                  \
-        NAN_PROPERTY_ENUMERATOR_ARGS_TYPE info)
+    Nan::NAN_PROPERTY_ENUMERATOR_RETURN_TYPE name(                             \
+        Nan::NAN_PROPERTY_ENUMERATOR_ARGS_TYPE info)
 #define NAN_PROPERTY_DELETER(name)                                             \
-    NAN_PROPERTY_DELETER_RETURN_TYPE name(                                     \
+    Nan::NAN_PROPERTY_DELETER_RETURN_TYPE name(                                \
         v8::Local<v8::String> property                                         \
-      , NAN_PROPERTY_DELETER_ARGS_TYPE info)
+      , Nan::NAN_PROPERTY_DELETER_ARGS_TYPE info)
 #define NAN_PROPERTY_QUERY(name)                                               \
-    NAN_PROPERTY_QUERY_RETURN_TYPE name(                                       \
+    Nan::NAN_PROPERTY_QUERY_RETURN_TYPE name(                                  \
         v8::Local<v8::String> property                                         \
-      , NAN_PROPERTY_QUERY_ARGS_TYPE info)
+      , Nan::NAN_PROPERTY_QUERY_ARGS_TYPE info)
 # define NAN_INDEX_GETTER(name)                                                \
-    NAN_INDEX_GETTER_RETURN_TYPE name(                                         \
+    Nan::NAN_INDEX_GETTER_RETURN_TYPE name(                                    \
         uint32_t index                                                         \
-      , NAN_INDEX_GETTER_ARGS_TYPE info)
+      , Nan::NAN_INDEX_GETTER_ARGS_TYPE info)
 #define NAN_INDEX_SETTER(name)                                                 \
-    NAN_INDEX_SETTER_RETURN_TYPE name(                                         \
+    Nan::NAN_INDEX_SETTER_RETURN_TYPE name(                                    \
         uint32_t index                                                         \
       , v8::Local<v8::Value> value                                             \
-      , NAN_INDEX_SETTER_ARGS_TYPE info)
+      , Nan::NAN_INDEX_SETTER_ARGS_TYPE info)
 #define NAN_INDEX_ENUMERATOR(name)                                             \
-    NAN_INDEX_ENUMERATOR_RETURN_TYPE name(NAN_INDEX_ENUMERATOR_ARGS_TYPE info)
+    Nan::NAN_INDEX_ENUMERATOR_RETURN_TYPE                                      \
+    name(Nan::NAN_INDEX_ENUMERATOR_ARGS_TYPE info)
 #define NAN_INDEX_DELETER(name)                                                \
-    NAN_INDEX_DELETER_RETURN_TYPE name(                                        \
+    Nan::NAN_INDEX_DELETER_RETURN_TYPE name(                                   \
         uint32_t index                                                         \
-      , NAN_INDEX_DELETER_ARGS_TYPE info)
+      , Nan::NAN_INDEX_DELETER_ARGS_TYPE info)
 #define NAN_INDEX_QUERY(name)                                                  \
-    NAN_INDEX_QUERY_RETURN_TYPE name(                                          \
+    Nan::NAN_INDEX_QUERY_RETURN_TYPE name(                                     \
         uint32_t index                                                         \
-      , NAN_INDEX_QUERY_ARGS_TYPE info)
+      , Nan::NAN_INDEX_QUERY_ARGS_TYPE info)
 
 class Callback {
  public:
diff --git a/test/cpp/returnnull.cpp b/test/cpp/returnnull.cpp
index b6cddd66..770dc810 100644
--- a/test/cpp/returnnull.cpp
+++ b/test/cpp/returnnull.cpp
@@ -8,16 +8,14 @@
 
 #include <nan.h>
 
-using namespace Nan;  // NOLINT(build/namespaces)
-
 NAN_METHOD(ReturnNull) {
   info.GetReturnValue().SetNull();
 }
 
 void Init (v8::Handle<v8::Object> target) {
-  Set(target
-    , New<v8::String>("r").ToLocalChecked()
-    , New<v8::FunctionTemplate>(ReturnNull)->GetFunction()
+  Nan::Set(target
+    , Nan::New<v8::String>("r").ToLocalChecked()
+    , Nan::New<v8::FunctionTemplate>(ReturnNull)->GetFunction()
   );
 }
 

From 1def641b31fb223e283f8985993a9febedbad8ea Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 14:30:52 +0300
Subject: [PATCH 32/84] Lint

---
 Makefile        | 1 -
 nan_callbacks.h | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index 7f7bf7f4..30f66e3c 100644
--- a/Makefile
+++ b/Makefile
@@ -61,7 +61,6 @@ LINT_SOURCES = \
 	test/cpp/returnundefined.cpp \
 	test/cpp/returnvalue.cpp \
 	test/cpp/settemplate.cpp \
-	test/cpp/settergetter.cpp \
 	test/cpp/strings.cpp \
 	test/cpp/symbols.cpp \
 	test/cpp/threadlocal.cpp \
diff --git a/nan_callbacks.h b/nan_callbacks.h
index 9577eebc..35bbb95f 100644
--- a/nan_callbacks.h
+++ b/nan_callbacks.h
@@ -58,7 +58,7 @@ typedef v8::Handle<v8::AccessorSignature> Sig;
 struct NAME ## Wrapper {                                                       \
   explicit NAME ## Wrapper(NAME ## Callback callback_) :                       \
       callback(callback_) {}                                                   \
-   NAME ## Callback callback;                                                  \
+  NAME ## Callback callback;                                                   \
 };
 
 X(Function)

From fc8de18a0734a83ca08664151d5ded34329d5311 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 16:10:30 +0300
Subject: [PATCH 33/84] Fix bug in trycatch test

---
 test/cpp/trycatch.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/test/cpp/trycatch.cpp b/test/cpp/trycatch.cpp
index 3d0be691..c447e701 100644
--- a/test/cpp/trycatch.cpp
+++ b/test/cpp/trycatch.cpp
@@ -12,11 +12,10 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 NAN_METHOD(TryCatchTest) {
   TryCatch try_catch;
-  v8::Local<v8::Value> v =
-      RunScript(New<UnboundScript>(
-          New("throw 'waaa'").ToLocalChecked()).ToLocalChecked())
-              .ToLocalChecked();
-  if (v.IsEmpty()) {
+  v8::Local<v8::String> s = New("throw 'waaa'").ToLocalChecked();
+  v8::Local<UnboundScript> script = New<UnboundScript>(s).ToLocalChecked();
+  MaybeLocal<v8::Value> result = RunScript(script);
+  if (result.IsEmpty()) {
     assert(try_catch.HasCaught());
     try_catch.ReThrow();
   }

From f3dac4734a1ce3d5de55f19f92b3f5717af8b924 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 16:13:19 +0300
Subject: [PATCH 34/84] Hide overloaded Handle variants in new versions

---
 nan.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/nan.h b/nan.h
index 668b4a29..43084864 100644
--- a/nan.h
+++ b/nan.h
@@ -117,6 +117,7 @@ namespace Nan {
 #define IOJS_1_0_MODULE_VERSION  42
 #define IOJS_1_1_MODULE_VERSION  43
 #define IOJS_2_0_MODULE_VERSION  44
+#define IOJS_3_0_MODULE_VERSION  45
 
 #define TYPE_CHECK(T, S)                                                       \
     while (false) {                                                            \
@@ -314,11 +315,13 @@ namespace imp {
     return val;
   }
 
+# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
   template<typename T>
   NAN_INLINE
   v8::Handle<T> EnsureHandleOrPersistent(const v8::Handle<T> &val) {
     return val;
   }
+#endif
 
   template<typename T>
   NAN_INLINE v8::Local<T> EnsureHandleOrPersistent(const v8::Local<T> &val) {
@@ -342,10 +345,12 @@ namespace imp {
     return New(val);
   }
 
+# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
   template<typename T>
   NAN_INLINE v8::Local<T> EnsureLocal(const v8::Handle<T> &val) {
     return New(val);
   }
+#endif
 
   template<typename T>
   NAN_INLINE

From 7747fd061dd4b28be3154456f2892f23f00afaf2 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 16:14:10 +0300
Subject: [PATCH 35/84] Make new versions of Node use new FreeCallback

---
 nan.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/nan.h b/nan.h
index 43084864..abe4f142 100644
--- a/nan.h
+++ b/nan.h
@@ -669,7 +669,11 @@ class TryCatch {
   NAN_INLINE MaybeLocal<v8::Object> NewBuffer(
       char *data
     , size_t length
+#if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
+    , node::Buffer::FreeCallback callback
+#else
     , node::smalloc::FreeCallback callback
+#endif
     , void *hint
   ) {
     // arbitrary buffer lengths requires

From 3621ab6250e0e53516a4133deb52b0ab6be41f38 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 16:15:09 +0300
Subject: [PATCH 36/84] Update the buffer-reusing constructor to return a
 MaybeLocal

---
 nan.h               | 11 ++++++-----
 test/cpp/buffer.cpp |  3 ++-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/nan.h b/nan.h
index abe4f142..d17693c0 100644
--- a/nan.h
+++ b/nan.h
@@ -717,7 +717,7 @@ class TryCatch {
 #endif
   }
 
-  NAN_INLINE v8::Local<v8::Object> NewBuffer(
+  NAN_INLINE MaybeLocal<v8::Object> NewBuffer(
       char* data
     , uint32_t size
   ) {
@@ -727,7 +727,8 @@ class TryCatch {
 #if NODE_MODULE_VERSION > IOJS_2_0_MODULE_VERSION
     return node::Buffer::New(v8::Isolate::GetCurrent(), data, size);
 #else
-    return node::Buffer::Use(v8::Isolate::GetCurrent(), data, size);
+    return MaybeLocal<v8::Object>(
+        node::Buffer::Use(v8::Isolate::GetCurrent(), data, size));
 #endif
   }
 
@@ -1074,7 +1075,7 @@ class Utf8String {
     delete[] data;
   }
 
-  NAN_INLINE v8::Local<v8::Object> NewBuffer(
+  NAN_INLINE MaybeLocal<v8::Object> NewBuffer(
       char* data
     , uint32_t size
   ) {
@@ -1082,8 +1083,8 @@ class Utf8String {
     // arbitrary buffer lengths requires
     // NODE_MODULE_VERSION >= IOJS_3_0_MODULE_VERSION
     assert(size <= imp::kMaxLength && "too large buffer");
-    return scope.Escape(New(
-        node::Buffer::New(data, size, FreeData, NULL)->handle_));
+    return MaybeLocal<v8::Object>(scope.Escape(New(
+        node::Buffer::New(data, size, FreeData, NULL)->handle_)));
   }
 
   NAN_INLINE bool HasInstance(
diff --git a/test/cpp/buffer.cpp b/test/cpp/buffer.cpp
index 438a8ff8..b2ac9d7e 100644
--- a/test/cpp/buffer.cpp
+++ b/test/cpp/buffer.cpp
@@ -41,7 +41,8 @@ NAN_METHOD(New3) {
   for (unsigned char i = 0; i < DATA_SIZE; i++) {
     dynamic_data[i] = 'a' + i;
   }
-  info.GetReturnValue().Set(NewBuffer(dynamic_data, DATA_SIZE));
+  info.GetReturnValue().Set(
+      NewBuffer(dynamic_data, DATA_SIZE).ToLocalChecked());
 }
 
 NAN_METHOD(Copy) {

From 8327b6d0fea7ccf1ed8a764f19d0c859f5d4f98a Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sat, 4 Jul 2015 16:55:46 +0300
Subject: [PATCH 37/84] Fix GetFromPersistent type, which should be Value

---
 nan.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nan.h b/nan.h
index d17693c0..1a7b4aca 100644
--- a/nan.h
+++ b/nan.h
@@ -1513,7 +1513,7 @@ class Callback {
         New(persistentHandle)->Get(New(key).ToLocalChecked()));
   }
 
-  NAN_INLINE v8::Local<v8::Object>
+  NAN_INLINE v8::Local<v8::Value>
   GetFromPersistent(const v8::Local<v8::String> &key) const {
     EscapableHandleScope scope;
     return scope.Escape(New(persistentHandle)->Get(key));

From 10f258d4a21b9e490d2f7ea0a145590b7ef6cdd0 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 13 Jul 2015 15:14:14 +0300
Subject: [PATCH 38/84] Fix SetMethod

---
 nan.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nan.h b/nan.h
index 1a7b4aca..15b1ea82 100644
--- a/nan.h
+++ b/nan.h
@@ -1834,7 +1834,7 @@ NAN_INLINE void SetMethod(
   HandleScope scope;
   v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
       callback)->GetFunction();
-  v8::Local<v8::String> fn_name = New(name);
+  v8::Local<v8::String> fn_name = New(name).ToLocalChecked();
   fn->SetName(fn_name);
   recv->Set(fn_name, fn);
 }

From 04bd28db706abdbab5797c61a885171ffa62e1f5 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 13 Jul 2015 15:47:27 +0300
Subject: [PATCH 39/84] Remove unused EnsureHandleOrPersistent

---
 nan.h | 26 --------------------------
 1 file changed, 26 deletions(-)

diff --git a/nan.h b/nan.h
index 15b1ea82..eb3368ef 100644
--- a/nan.h
+++ b/nan.h
@@ -309,32 +309,6 @@ namespace imp {
     return val;
   }
 
-  template<typename T>
-  NAN_INLINE v8::Persistent<T> &EnsureHandleOrPersistent(
-      v8::Persistent<T> &val) {  // NOLINT(runtime/references)
-    return val;
-  }
-
-# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
-  template<typename T>
-  NAN_INLINE
-  v8::Handle<T> EnsureHandleOrPersistent(const v8::Handle<T> &val) {
-    return val;
-  }
-#endif
-
-  template<typename T>
-  NAN_INLINE v8::Local<T> EnsureHandleOrPersistent(const v8::Local<T> &val) {
-    return val;
-  }
-
-  template<typename T>
-  NAN_INLINE
-  v8::Local<v8::Value>
-  EnsureHandleOrPersistent(T val) {
-    return Unwrap(New(val));
-  }
-
   template<typename T>
   NAN_INLINE v8::Local<T> EnsureLocal(const v8::Local<T> &val) {
     return val;

From 099f81afe330dfc7eb96566f90a8be10ffd0f65a Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 13 Jul 2015 15:52:12 +0300
Subject: [PATCH 40/84] Remove EnsureLocal

---
 nan.h | 27 ++-------------------------
 1 file changed, 2 insertions(+), 25 deletions(-)

diff --git a/nan.h b/nan.h
index eb3368ef..6124ceee 100644
--- a/nan.h
+++ b/nan.h
@@ -308,29 +308,6 @@ namespace imp {
   v8::Local<T> Unwrap(v8::Local<T> val) {
     return val;
   }
-
-  template<typename T>
-  NAN_INLINE v8::Local<T> EnsureLocal(const v8::Local<T> &val) {
-    return val;
-  }
-
-  template<typename T>
-  NAN_INLINE v8::Local<T> EnsureLocal(const v8::Persistent<T> &val) {
-    return New(val);
-  }
-
-# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
-  template<typename T>
-  NAN_INLINE v8::Local<T> EnsureLocal(const v8::Handle<T> &val) {
-    return New(val);
-  }
-#endif
-
-  template<typename T>
-  NAN_INLINE
-  v8::Local<v8::Value> EnsureLocal(T val) {
-    return Unwrap(New(val));
-  }
 }  // end of namespace imp
 
 //=== HandleScope ==============================================================
@@ -1404,7 +1381,7 @@ class Callback {
 
     v8::Local<v8::Function> callback = New(handle)->
         Get(kCallbackIndex).As<v8::Function>();
-    return scope.Escape(imp::EnsureLocal(node::MakeCallback(
+    return scope.Escape(New(node::MakeCallback(
         isolate
       , target
       , callback
@@ -1420,7 +1397,7 @@ class Callback {
 
     v8::Local<v8::Function> callback = New(handle)->
         Get(kCallbackIndex).As<v8::Function>();
-    return scope.Escape(imp::EnsureLocal(node::MakeCallback(
+    return scope.Escape(New(node::MakeCallback(
         target
       , callback
       , argc

From 9b359f3f4c299d10b3eb74cafd7a74cb7fcd5562 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 13 Jul 2015 15:53:41 +0300
Subject: [PATCH 41/84] Remove unused Unwrap function for Maybes

---
 nan.h | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/nan.h b/nan.h
index 6124ceee..36018857 100644
--- a/nan.h
+++ b/nan.h
@@ -296,18 +296,6 @@ template<typename P> class WeakCallbackInfo;
 
 namespace imp {
   static const size_t kMaxLength = 0x3fffffff;
-  template<typename T>
-  NAN_INLINE
-  v8::Local<T>
-  Unwrap(MaybeLocal<T> maybe) {
-    return maybe.ToLocalChecked();
-  }
-
-  template<typename T>
-  NAN_INLINE
-  v8::Local<T> Unwrap(v8::Local<T> val) {
-    return val;
-  }
 }  // end of namespace imp
 
 //=== HandleScope ==============================================================

From e8f84fe3a7411ae7456a0b14ea73a3d0587c2be1 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 13 Jul 2015 15:56:50 +0300
Subject: [PATCH 42/84] Remove HasInstance

---
 nan.h | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/nan.h b/nan.h
index 36018857..29ae98f0 100644
--- a/nan.h
+++ b/nan.h
@@ -671,13 +671,6 @@ class TryCatch {
 #endif
   }
 
-  NAN_INLINE bool HasInstance(
-      const v8::Persistent<v8::FunctionTemplate>& function_template
-    , v8::Handle<v8::Value> value
-  ) {
-    return New(function_template)->HasInstance(value);
-  }
-
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
   NAN_INLINE MaybeLocal<v8::String>
@@ -1026,13 +1019,6 @@ class Utf8String {
         node::Buffer::New(data, size, FreeData, NULL)->handle_)));
   }
 
-  NAN_INLINE bool HasInstance(
-      const v8::Persistent<v8::FunctionTemplate>& function_template
-    , v8::Handle<v8::Value> value
-  ) {
-    return function_template->HasInstance(value);
-  }
-
 namespace imp {
 NAN_INLINE void
 widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {

From b5b73d6c8faf39874173ebd3f28ebea576dc7e5c Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 13 Jul 2015 16:07:37 +0300
Subject: [PATCH 43/84] Fix Persistent stuff in ObjectWrap

---
 nan.h                       | 14 ++++++++++++--
 nan_persistent_pre_12_inl.h |  1 +
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/nan.h b/nan.h
index 29ae98f0..993b24fc 100644
--- a/nan.h
+++ b/nan.h
@@ -2036,10 +2036,20 @@ inline void SetIndexedPropertyHandler(
 //=== ObjectWrap ===============================================================
 
 class ObjectWrap : public node::ObjectWrap {
-#if NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION
  public:
+#if NODE_MODULE_VERSION < NODE_0_12_MODULE_VERSION
   inline v8::Local<v8::Object> handle() { return New(handle_); }
-  inline v8::Persistent<v8::Object> &persistent() { return handle_; }
+  inline Persistent<v8::Object> &persistent() {
+    Persistent<v8::Object> temp(handle_);
+    std::memcpy(&persistent_, &temp, sizeof(persistent_));
+    return persistent_;
+  }
+ private:
+  Persistent<v8::Object> persistent_;
+#else
+  inline Persistent<v8::Object> &persistent() {
+    return static_cast<Persistent<v8::Object>&>(node::ObjectWrap::persistent());
+  }
 #endif
 };
 
diff --git a/nan_persistent_pre_12_inl.h b/nan_persistent_pre_12_inl.h
index 13a6921e..e46a37da 100644
--- a/nan_persistent_pre_12_inl.h
+++ b/nan_persistent_pre_12_inl.h
@@ -101,6 +101,7 @@ class PersistentBase {
   NAN_INLINE explicit PersistentBase(T *val) : persistent(val) {}
   template<typename S, typename M> friend class Persistent;
   template<typename S> friend class Global;
+  friend class ObjectWrap;
 };
 
 template<typename T>

From e6c0daf75966332771fe87e8574597945c3e87c0 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Mon, 20 Jul 2015 17:56:48 +0300
Subject: [PATCH 44/84] Get rid of Handles

---
 nan.h                               | 246 +++++++++++++++++-----------
 nan_callbacks.h                     |   2 +-
 nan_callbacks_12_inl.h              |   2 +-
 nan_callbacks_pre_12_inl.h          |   2 +-
 nan_converters.h                    |   6 +-
 nan_converters_43_inl.h             |   4 +-
 nan_converters_pre_43_inl.h         |   4 +-
 nan_implementation_12_inl.h         |  18 +-
 nan_implementation_pre_12_inl.h     |  16 +-
 nan_maybe_43_inl.h                  | 100 +++++------
 nan_new.h                           |  33 ++--
 nan_persistent_12_inl.h             |  12 +-
 nan_persistent_pre_12_inl.h         |   8 +-
 nan_string_bytes.h                  |   3 +-
 nan_weak.h                          |  10 +-
 test/cpp/accessors.cpp              |   8 +-
 test/cpp/accessors2.cpp             |   8 +-
 test/cpp/asyncprogressworker.cpp    |   4 +-
 test/cpp/asyncworker.cpp            |   4 +-
 test/cpp/asyncworkererror.cpp       |   4 +-
 test/cpp/buffer.cpp                 |   2 +-
 test/cpp/bufferworkerpersistent.cpp |   4 +-
 test/cpp/converters.cpp             |   2 +-
 test/cpp/error.cpp                  |   2 +-
 test/cpp/gc.cpp                     |   2 +-
 test/cpp/indexedinterceptors.cpp    |   8 +-
 test/cpp/isolatedata.cpp            |   2 +-
 test/cpp/makecallback.cpp           |  14 +-
 test/cpp/morenews.cpp               |   2 +-
 test/cpp/multifile1.cpp             |   2 +-
 test/cpp/namedinterceptors.cpp      |   8 +-
 test/cpp/nancallback.cpp            |   2 +-
 test/cpp/nannew.cpp                 |  82 ++++------
 test/cpp/news.cpp                   |   4 +-
 test/cpp/objectwraphandle.cpp       |  10 +-
 test/cpp/persistent.cpp             |   2 +-
 test/cpp/returnemptystring.cpp      |   2 +-
 test/cpp/returnnull.cpp             |   2 +-
 test/cpp/returnundefined.cpp        |   2 +-
 test/cpp/returnvalue.cpp            |   2 +-
 test/cpp/settemplate.cpp            |  12 +-
 test/cpp/strings.cpp                |   2 +-
 test/cpp/symbols.cpp                |   2 +-
 test/cpp/threadlocal.cpp            |   4 +-
 test/cpp/trycatch.cpp               |   2 +-
 test/cpp/weak.cpp                   |   4 +-
 test/cpp/weak2.cpp                  |   4 +-
 47 files changed, 357 insertions(+), 323 deletions(-)

diff --git a/nan.h b/nan.h
index 993b24fc..0e982cf3 100644
--- a/nan.h
+++ b/nan.h
@@ -124,6 +124,17 @@ namespace Nan {
       *(static_cast<T *volatile *>(0)) = static_cast<S*>(0);                   \
     }
 
+//=== RegistrationFunction =====================================================
+
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
+  typedef v8::Handle<v8::Object> ADDON_REGISTER_FUNCTION_ARGS_TYPE;
+#else
+  typedef v8::Local<v8::Object> ADDON_REGISTER_FUNCTION_ARGS_TYPE;
+#endif
+
+#define NAN_MODULE_INIT(name)                                                  \
+    void name(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target)
+
 //=== CallbackInfo =============================================================
 
 #include "nan_callbacks.h"  // NOLINT(build/include)
@@ -270,8 +281,10 @@ inline void nauv_key_set(nauv_key_t* key, void* value) {
 #endif
 #endif
 
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
 template<typename T>
 v8::Local<T> New(v8::Handle<T>);
+#endif
 
 #if defined(V8_MAJOR_VERSION) && (V8_MAJOR_VERSION > 4 ||                      \
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
@@ -381,7 +394,13 @@ class TryCatch {
 
   NAN_INLINE bool CanContinue() const { return try_catch_.CanContinue(); }
 
-  NAN_INLINE v8::Handle<v8::Value> ReThrow() { return try_catch_.ReThrow(); }
+  NAN_INLINE v8::Local<v8::Value> ReThrow() {
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
+    return New(try_catch_.ReThrow());
+#else
+    return try_catch_.ReThrow();
+#endif
+  }
 
   NAN_INLINE v8::Local<v8::Value> Exception() const {
     return try_catch_.Exception();
@@ -480,23 +499,39 @@ class TryCatch {
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)  // Node 0.12
   NAN_INLINE v8::Local<v8::Primitive> Undefined() {
+# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     EscapableHandleScope scope;
     return scope.Escape(New(v8::Undefined(v8::Isolate::GetCurrent())));
+# else
+    return v8::Undefined(v8::Isolate::GetCurrent());
+# endif
   }
 
   NAN_INLINE v8::Local<v8::Primitive> Null() {
+# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     EscapableHandleScope scope;
     return scope.Escape(New(v8::Null(v8::Isolate::GetCurrent())));
+# else
+    return v8::Null(v8::Isolate::GetCurrent());
+# endif
   }
 
   NAN_INLINE v8::Local<v8::Boolean> True() {
+# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     EscapableHandleScope scope;
     return scope.Escape(New(v8::True(v8::Isolate::GetCurrent())));
+# else
+    return v8::True(v8::Isolate::GetCurrent());
+# endif
   }
 
   NAN_INLINE v8::Local<v8::Boolean> False() {
+# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     EscapableHandleScope scope;
     return scope.Escape(New(v8::False(v8::Isolate::GetCurrent())));
+# else
+    return v8::False(v8::Isolate::GetCurrent());
+# endif
   }
 
   NAN_INLINE v8::Local<v8::String> EmptyString() {
@@ -509,16 +544,16 @@ class TryCatch {
   }
 
   NAN_INLINE void SetTemplate(
-      v8::Handle<v8::Template> templ
+      v8::Local<v8::Template> templ
     , const char *name
-    , v8::Handle<v8::Data> value) {
+    , v8::Local<v8::Data> value) {
     templ->Set(v8::Isolate::GetCurrent(), name, value);
   }
 
   NAN_INLINE void SetTemplate(
-      v8::Handle<v8::Template> templ
-    , v8::Handle<v8::String> name
-    , v8::Handle<v8::Data> value
+      v8::Local<v8::Template> templ
+    , v8::Local<v8::String> name
+    , v8::Local<v8::Data> value
     , v8::PropertyAttribute attributes) {
     templ->Set(name, value, attributes);
   }
@@ -528,13 +563,13 @@ class TryCatch {
   }
 
   NAN_INLINE void* GetInternalFieldPointer(
-      v8::Handle<v8::Object> object
+      v8::Local<v8::Object> object
     , int index) {
     return object->GetAlignedPointerFromInternalField(index);
   }
 
   NAN_INLINE void SetInternalFieldPointer(
-      v8::Handle<v8::Object> object
+      v8::Local<v8::Object> object
     , int index
     , void* value) {
     object->SetAlignedPointerInInternalField(index, value);
@@ -577,7 +612,7 @@ class TryCatch {
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    v8::Local<v8::Value> NAME(v8::Handle<v8::String> msg) {                    \
+    v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) {                     \
       return v8::Exception::NAME(msg);                                         \
     }                                                                          \
                                                                                \
@@ -587,10 +622,10 @@ class TryCatch {
           v8::Exception::NAME(New(msg).ToLocalChecked()));                     \
     }                                                                          \
                                                                                \
-    NAN_INLINE void Throw ## NAME(v8::Handle<v8::String> msg) {                \
+    NAN_INLINE void Throw ## NAME(v8::Local<v8::String> msg) {                 \
       HandleScope scope;                                                       \
       v8::Isolate::GetCurrent()->ThrowException(                               \
-          v8::Exception::NAME(New(msg)));                                      \
+          v8::Exception::NAME(msg));                                           \
     }
 
   X(Error)
@@ -601,7 +636,7 @@ class TryCatch {
 
 # undef X
 
-  NAN_INLINE void ThrowError(v8::Handle<v8::Value> error) {
+  NAN_INLINE void ThrowError(v8::Local<v8::Value> error) {
     v8::Isolate::GetCurrent()->ThrowException(error);
   }
 
@@ -695,13 +730,13 @@ class TryCatch {
   }
 
   NAN_INLINE MaybeLocal<v8::Value> RunScript(
-      v8::Handle<UnboundScript> script
+      v8::Local<UnboundScript> script
   ) {
     return script->BindToCurrentContext()->Run(GetCurrentContext());
   }
 
   NAN_INLINE MaybeLocal<v8::Value> RunScript(
-      v8::Handle<BoundScript> script
+      v8::Local<BoundScript> script
   ) {
     return script->Run(GetCurrentContext());
   }
@@ -733,43 +768,58 @@ class TryCatch {
   }
 
   NAN_INLINE MaybeLocal<v8::Value> RunScript(
-      v8::Handle<UnboundScript> script
+      v8::Local<UnboundScript> script
   ) {
     return MaybeLocal<v8::Value>(script->BindToCurrentContext()->Run());
   }
 
   NAN_INLINE MaybeLocal<v8::Value> RunScript(
-      v8::Handle<BoundScript> script
+      v8::Local<BoundScript> script
   ) {
     return MaybeLocal<v8::Value>(script->Run());
   }
 #endif
 
   NAN_INLINE v8::Local<v8::Value> MakeCallback(
-      v8::Handle<v8::Object> target
-    , v8::Handle<v8::Function> func
+      v8::Local<v8::Object> target
+    , v8::Local<v8::Function> func
     , int argc
-    , v8::Handle<v8::Value>* argv) {
+    , v8::Local<v8::Value>* argv) {
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     return New(node::MakeCallback(
         v8::Isolate::GetCurrent(), target, func, argc, argv));
+#else
+    return node::MakeCallback(
+        v8::Isolate::GetCurrent(), target, func, argc, argv);
+#endif
   }
 
   NAN_INLINE v8::Local<v8::Value> MakeCallback(
-      v8::Handle<v8::Object> target
-    , v8::Handle<v8::String> symbol
+      v8::Local<v8::Object> target
+    , v8::Local<v8::String> symbol
     , int argc
-    , v8::Handle<v8::Value>* argv) {
+    , v8::Local<v8::Value>* argv) {
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     return New(node::MakeCallback(
         v8::Isolate::GetCurrent(), target, symbol, argc, argv));
+#else
+    return node::MakeCallback(
+        v8::Isolate::GetCurrent(), target, symbol, argc, argv);
+#endif
   }
 
   NAN_INLINE v8::Local<v8::Value> MakeCallback(
-      v8::Handle<v8::Object> target
+      v8::Local<v8::Object> target
     , const char* method
     , int argc
-    , v8::Handle<v8::Value>* argv) {
+    , v8::Local<v8::Value>* argv) {
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     return New(node::MakeCallback(
         v8::Isolate::GetCurrent(), target, method, argc, argv));
+#else
+    return node::MakeCallback(
+        v8::Isolate::GetCurrent(), target, method, argc, argv);
+#endif
   }
 
   NAN_INLINE void FatalException(const TryCatch& try_catch) {
@@ -802,7 +852,7 @@ class TryCatch {
 
 class Utf8String {
  public:
-  NAN_INLINE explicit Utf8String(v8::Handle<v8::Value> from) :
+  NAN_INLINE explicit Utf8String(v8::Local<v8::Value> from) :
       length_(0), str_(str_st_) {
     if (!from.IsEmpty()) {
       v8::Local<v8::String> string = from->ToString();
@@ -872,16 +922,16 @@ class Utf8String {
   }
 
   NAN_INLINE void SetTemplate(
-      v8::Handle<v8::Template> templ
+      v8::Local<v8::Template> templ
     , const char *name
-    , v8::Handle<v8::Data> value) {
+    , v8::Local<v8::Data> value) {
     templ->Set(name, value);
   }
 
   NAN_INLINE void SetTemplate(
-      v8::Handle<v8::Template> templ
-    , v8::Handle<v8::String> name
-    , v8::Handle<v8::Data> value
+      v8::Local<v8::Template> templ
+    , v8::Local<v8::String> name
+    , v8::Local<v8::Data> value
     , v8::PropertyAttribute attributes) {
     templ->Set(name, value, attributes);
   }
@@ -891,13 +941,13 @@ class Utf8String {
   }
 
   NAN_INLINE void* GetInternalFieldPointer(
-      v8::Handle<v8::Object> object
+      v8::Local<v8::Object> object
     , int index) {
     return object->GetPointerFromInternalField(index);
   }
 
   NAN_INLINE void SetInternalFieldPointer(
-      v8::Handle<v8::Object> object
+      v8::Local<v8::Object> object
     , int index
     , void* value) {
     object->SetPointerInInternalField(index, value);
@@ -936,7 +986,7 @@ class Utf8String {
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    v8::Local<v8::Value> NAME(v8::Handle<v8::String> msg) {                    \
+    v8::Local<v8::Value> NAME(v8::Local<v8::String> msg) {                     \
       return v8::Exception::NAME(msg);                                         \
     }                                                                          \
                                                                                \
@@ -946,7 +996,7 @@ class Utf8String {
     }                                                                          \
                                                                                \
     NAN_INLINE                                                                 \
-    void Throw ## NAME(v8::Handle<v8::String> errmsg) {                        \
+    void Throw ## NAME(v8::Local<v8::String> errmsg) {                         \
       v8::ThrowException(v8::Exception::NAME(errmsg));                         \
     }
 
@@ -958,7 +1008,7 @@ class Utf8String {
 
 # undef X
 
-  NAN_INLINE void ThrowError(v8::Handle<v8::Value> error) {
+  NAN_INLINE void ThrowError(v8::Local<v8::Value> error) {
     v8::ThrowException(error);
   }
 
@@ -1055,31 +1105,31 @@ widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
   }
 
   NAN_INLINE
-  MaybeLocal<v8::Value> RunScript(v8::Handle<v8::Script> script) {
+  MaybeLocal<v8::Value> RunScript(v8::Local<v8::Script> script) {
     return MaybeLocal<v8::Value>(script->Run());
   }
 
   NAN_INLINE v8::Local<v8::Value> MakeCallback(
-      v8::Handle<v8::Object> target
-    , v8::Handle<v8::Function> func
+      v8::Local<v8::Object> target
+    , v8::Local<v8::Function> func
     , int argc
-    , v8::Handle<v8::Value>* argv) {
+    , v8::Local<v8::Value>* argv) {
     return New(node::MakeCallback(target, func, argc, argv));
   }
 
   NAN_INLINE v8::Local<v8::Value> MakeCallback(
-      v8::Handle<v8::Object> target
-    , v8::Handle<v8::String> symbol
+      v8::Local<v8::Object> target
+    , v8::Local<v8::String> symbol
     , int argc
-    , v8::Handle<v8::Value>* argv) {
+    , v8::Local<v8::Value>* argv) {
     return New(node::MakeCallback(target, symbol, argc, argv));
   }
 
   NAN_INLINE v8::Local<v8::Value> MakeCallback(
-      v8::Handle<v8::Object> target
+      v8::Local<v8::Object> target
     , const char* method
     , int argc
-    , v8::Handle<v8::Value>* argv) {
+    , v8::Local<v8::Value>* argv) {
     return New(node::MakeCallback(target, method, argc, argv));
   }
 
@@ -1113,7 +1163,7 @@ widenString(std::vector<uint16_t> *ws, const uint8_t *s, int l) {
 
 class Utf8String {
  public:
-  NAN_INLINE explicit Utf8String(v8::Handle<v8::Value> from) :
+  NAN_INLINE explicit Utf8String(v8::Local<v8::Value> from) :
       length_(0), str_(str_st_) {
     if (!from.IsEmpty()) {
       v8::Local<v8::String> string = from->ToString();
@@ -1264,7 +1314,7 @@ class Callback {
     handle.Reset(obj);
   }
 
-  explicit Callback(const v8::Handle<v8::Function> &fn) {
+  explicit Callback(const v8::Local<v8::Function> &fn) {
     HandleScope scope;
     v8::Local<v8::Object> obj = New<v8::Object>();
     handle.Reset(obj);
@@ -1291,19 +1341,19 @@ class Callback {
   v8::Local<v8::Function> operator*() const { return this->GetFunction(); }
 
   NAN_INLINE v8::Local<v8::Value> operator()(
-      v8::Handle<v8::Object> target
+      v8::Local<v8::Object> target
     , int argc = 0
-    , v8::Handle<v8::Value> argv[] = 0) const {
+    , v8::Local<v8::Value> argv[] = 0) const {
     return this->Call(target, argc, argv);
   }
 
   NAN_INLINE v8::Local<v8::Value> operator()(
       int argc = 0
-    , v8::Handle<v8::Value> argv[] = 0) const {
+    , v8::Local<v8::Value> argv[] = 0) const {
     return this->Call(argc, argv);
   }
 
-  NAN_INLINE void SetFunction(const v8::Handle<v8::Function> &fn) {
+  NAN_INLINE void SetFunction(const v8::Local<v8::Function> &fn) {
     HandleScope scope;
     Set(New(handle), kCallbackIndex, fn);
   }
@@ -1320,9 +1370,9 @@ class Callback {
   }
 
   NAN_INLINE v8::Local<v8::Value>
-  Call(v8::Handle<v8::Object> target
+  Call(v8::Local<v8::Object> target
      , int argc
-     , v8::Handle<v8::Value> argv[]) const {
+     , v8::Local<v8::Value> argv[]) const {
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
     v8::Isolate *isolate = v8::Isolate::GetCurrent();
     return Call_(isolate, target, argc, argv);
@@ -1332,7 +1382,7 @@ class Callback {
   }
 
   NAN_INLINE v8::Local<v8::Value>
-  Call(int argc, v8::Handle<v8::Value> argv[]) const {
+  Call(int argc, v8::Local<v8::Value> argv[]) const {
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
     v8::Isolate *isolate = v8::Isolate::GetCurrent();
     return Call_(isolate, isolate->GetCurrentContext()->Global(), argc, argv);
@@ -1348,13 +1398,14 @@ class Callback {
 
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
   v8::Local<v8::Value> Call_(v8::Isolate *isolate
-                           , v8::Handle<v8::Object> target
+                           , v8::Local<v8::Object> target
                            , int argc
-                           , v8::Handle<v8::Value> argv[]) const {
+                           , v8::Local<v8::Value> argv[]) const {
     EscapableHandleScope scope;
 
     v8::Local<v8::Function> callback = New(handle)->
         Get(kCallbackIndex).As<v8::Function>();
+# if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
     return scope.Escape(New(node::MakeCallback(
         isolate
       , target
@@ -1362,11 +1413,20 @@ class Callback {
       , argc
       , argv
     )));
+# else
+    return scope.Escape(node::MakeCallback(
+        isolate
+      , target
+      , callback
+      , argc
+      , argv
+    ));
+# endif
   }
 #else
-  v8::Local<v8::Value> Call_(v8::Handle<v8::Object> target
+  v8::Local<v8::Value> Call_(v8::Local<v8::Object> target
                            , int argc
-                           , v8::Handle<v8::Value> argv[]) const {
+                           , v8::Local<v8::Value> argv[]) const {
     EscapableHandleScope scope;
 
     v8::Local<v8::Function> callback = New(handle)->
@@ -1421,7 +1481,7 @@ class Callback {
   }
 
   NAN_INLINE void SaveToPersistent(
-      const v8::Handle<v8::String> &key, const v8::Local<v8::Value> &value) {
+      const v8::Local<v8::String> &key, const v8::Local<v8::Value> &value) {
     HandleScope scope;
     New(persistentHandle)->Set(key, value);
   }
@@ -1675,7 +1735,7 @@ NAN_INLINE v8::Local<v8::Value> Encode(
 }
 
 NAN_INLINE ssize_t DecodeBytes(
-    v8::Handle<v8::Value> val, enum Encoding encoding = BINARY) {
+    v8::Local<v8::Value> val, enum Encoding encoding = BINARY) {
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
   return node::DecodeBytes(
       v8::Isolate::GetCurrent()
@@ -1694,7 +1754,7 @@ NAN_INLINE ssize_t DecodeBytes(
 NAN_INLINE ssize_t DecodeWrite(
     char *buf
   , size_t len
-  , v8::Handle<v8::Value> val
+  , v8::Local<v8::Value> val
   , enum Encoding encoding = BINARY) {
 #if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
   return node::DecodeWrite(
@@ -1720,15 +1780,15 @@ NAN_INLINE ssize_t DecodeWrite(
 NAN_INLINE void SetPrototypeTemplate(
     v8::Local<v8::FunctionTemplate> templ
   , const char *name
-  , v8::Handle<v8::Data> value
+  , v8::Local<v8::Data> value
 ) {
   SetTemplate(templ->PrototypeTemplate(), name, value);
 }
 
 NAN_INLINE void SetPrototypeTemplate(
     v8::Local<v8::FunctionTemplate> templ
-  , v8::Handle<v8::String> name
-  , v8::Handle<v8::Data> value
+  , v8::Local<v8::String> name
+  , v8::Local<v8::Data> value
   , v8::PropertyAttribute attributes
 ) {
   SetTemplate(templ->PrototypeTemplate(), name, value, attributes);
@@ -1737,15 +1797,15 @@ NAN_INLINE void SetPrototypeTemplate(
 NAN_INLINE void SetInstanceTemplate(
     v8::Local<v8::FunctionTemplate> templ
   , const char *name
-  , v8::Handle<v8::Data> value
+  , v8::Local<v8::Data> value
 ) {
   SetTemplate(templ->InstanceTemplate(), name, value);
 }
 
 NAN_INLINE void SetInstanceTemplate(
     v8::Local<v8::FunctionTemplate> templ
-  , v8::Handle<v8::String> name
-  , v8::Handle<v8::Data> value
+  , v8::Local<v8::String> name
+  , v8::Local<v8::Data> value
   , v8::PropertyAttribute attributes
 ) {
   SetTemplate(templ->InstanceTemplate(), name, value, attributes);
@@ -1765,12 +1825,12 @@ NAN_INLINE void SetMethod(
 }
 
 NAN_INLINE void SetPrototypeMethod(
-    v8::Handle<v8::FunctionTemplate> recv
+    v8::Local<v8::FunctionTemplate> recv
   , const char* name, FunctionCallback callback) {
   HandleScope scope;
   v8::Local<v8::Function> fn = New<v8::FunctionTemplate>(
       callback
-    , v8::Handle<v8::Value>()
+    , v8::Local<v8::Value>()
     , New<v8::Signature>(recv))->GetFunction();
   v8::Local<v8::String> fn_name = New(name).ToLocalChecked();
   recv->PrototypeTemplate()->Set(fn_name, fn);
@@ -1780,11 +1840,11 @@ NAN_INLINE void SetPrototypeMethod(
 //=== Accessors and Such =======================================================
 
 inline void SetAccessor(
-    v8::Handle<v8::ObjectTemplate> tpl
-  , v8::Handle<v8::String> name
+    v8::Local<v8::ObjectTemplate> tpl
+  , v8::Local<v8::String> name
   , GetterCallback getter
   , SetterCallback setter = 0
-  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
+  , v8::Local<v8::Value> data = v8::Local<v8::Value>()
   , v8::AccessControl settings = v8::DEFAULT
   , v8::PropertyAttribute attribute = v8::None
   , imp::Sig signature = imp::Sig()) {
@@ -1802,7 +1862,6 @@ inline void SetAccessor(
       obj
     , imp::kGetterIndex
     , imp::GetWrapper<GetterCallback, imp::GetterWrapper>(getter));
-  v8::Local<v8::Value> val = New<v8::Value>(data);
 
   if (setter != 0) {
     SetInternalFieldPointer(
@@ -1812,8 +1871,8 @@ inline void SetAccessor(
             imp::SetterWrapper>(setter));
   }
 
-  if (!val.IsEmpty()) {
-    obj->SetInternalField(imp::kDataIndex, val);
+  if (!data.IsEmpty()) {
+    obj->SetInternalField(imp::kDataIndex, data);
   }
 
   tpl->SetAccessor(
@@ -1827,11 +1886,11 @@ inline void SetAccessor(
 }
 
 inline bool SetAccessor(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> name
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> name
   , GetterCallback getter
   , SetterCallback setter = 0
-  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
+  , v8::Local<v8::Value> data = v8::Local<v8::Value>()
   , v8::AccessControl settings = v8::DEFAULT
   , v8::PropertyAttribute attribute = v8::None) {
   EscapableHandleScope scope;
@@ -1848,10 +1907,9 @@ inline bool SetAccessor(
       dataobj
     , imp::kGetterIndex
     , imp::GetWrapper<GetterCallback, imp::GetterWrapper>(getter));
-  v8::Local<v8::Value> val = New<v8::Value>(data);
 
-  if (!val.IsEmpty()) {
-    dataobj->SetInternalField(imp::kDataIndex, val);
+  if (!data.IsEmpty()) {
+    dataobj->SetInternalField(imp::kDataIndex, data);
   }
 
   if (setter) {
@@ -1872,13 +1930,13 @@ inline bool SetAccessor(
 }
 
 inline void SetNamedPropertyHandler(
-    v8::Handle<v8::ObjectTemplate> tpl
+    v8::Local<v8::ObjectTemplate> tpl
   , PropertyGetterCallback getter
   , PropertySetterCallback setter = 0
   , PropertyQueryCallback query = 0
   , PropertyDeleterCallback deleter = 0
   , PropertyEnumeratorCallback enumerator = 0
-  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
+  , v8::Local<v8::Value> data = v8::Local<v8::Value>()) {
   HandleScope scope;
 
   imp::NativePropertyGetter getter_ =
@@ -1900,7 +1958,6 @@ inline void SetNamedPropertyHandler(
     , imp::kPropertyGetterIndex
     , imp::GetWrapper<PropertyGetterCallback,
           imp::PropertyGetterWrapper>(getter));
-  v8::Local<v8::Value> val = New<v8::Value>(data);
 
   if (setter) {
     SetInternalFieldPointer(
@@ -1934,8 +1991,8 @@ inline void SetNamedPropertyHandler(
             imp::PropertyEnumeratorWrapper>(enumerator));
   }
 
-  if (!val.IsEmpty()) {
-    obj->SetInternalField(imp::kDataIndex, val);
+  if (!data.IsEmpty()) {
+    obj->SetInternalField(imp::kDataIndex, data);
   }
 
 #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
@@ -1953,13 +2010,13 @@ inline void SetNamedPropertyHandler(
 }
 
 inline void SetIndexedPropertyHandler(
-    v8::Handle<v8::ObjectTemplate> tpl
+    v8::Local<v8::ObjectTemplate> tpl
   , IndexGetterCallback getter
   , IndexSetterCallback setter = 0
   , IndexQueryCallback query = 0
   , IndexDeleterCallback deleter = 0
   , IndexEnumeratorCallback enumerator = 0
-  , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
+  , v8::Local<v8::Value> data = v8::Local<v8::Value>()) {
   HandleScope scope;
 
   imp::NativeIndexGetter getter_ =
@@ -1981,7 +2038,6 @@ inline void SetIndexedPropertyHandler(
     , imp::kIndexPropertyGetterIndex
     , imp::GetWrapper<IndexGetterCallback,
           imp::IndexGetterWrapper>(getter));
-  v8::Local<v8::Value> val = New<v8::Value>(data);
 
   if (setter) {
     SetInternalFieldPointer(
@@ -2015,8 +2071,8 @@ inline void SetIndexedPropertyHandler(
             imp::IndexEnumeratorWrapper>(enumerator));
   }
 
-  if (!val.IsEmpty()) {
-    obj->SetInternalField(imp::kDataIndex, val);
+  if (!data.IsEmpty()) {
+    obj->SetInternalField(imp::kDataIndex, data);
   }
 
 #if NODE_MODULE_VERSION > NODE_0_12_MODULE_VERSION
@@ -2061,7 +2117,7 @@ class ObjectWrap : public node::ObjectWrap {
 
 inline
 void
-Export(v8::Handle<v8::Object> target, const char *name,
+Export(ADDON_REGISTER_FUNCTION_ARGS_TYPE target, const char *name,
     FunctionCallback f) {
   Set(target, New<v8::String>(name).ToLocalChecked(),
       New<v8::FunctionTemplate>(f)->GetFunction());
@@ -2070,26 +2126,26 @@ Export(v8::Handle<v8::Object> target, const char *name,
 //=== Tap Reverse Binding =====================================================
 
 struct Tap {
-  explicit Tap(v8::Handle<v8::Value> t) : t_() {
+  explicit Tap(v8::Local<v8::Value> t) : t_() {
     t_.Reset(To<v8::Object>(t).ToLocalChecked());
   }
 
   ~Tap() { t_.Reset(); }  // not sure if neccessary
 
   inline void plan(int i) {
-    v8::Handle<v8::Value> arg = New(i);
+    v8::Local<v8::Value> arg = New(i);
     MakeCallback(New(t_), "plan", 1, &arg);
   }
 
   inline void ok(bool isOk, const char *msg = NULL) {
-    v8::Handle<v8::Value> args[2];
+    v8::Local<v8::Value> args[2];
     args[0] = New(isOk);
     if (msg) args[1] = New(msg).ToLocalChecked();
     MakeCallback(New(t_), "ok", msg ? 2 : 1, args);
   }
 
   inline void pass(const char * msg = NULL) {
-    v8::Handle<v8::Value> hmsg;
+    v8::Local<v8::Value> hmsg;
     if (msg) hmsg = New(msg).ToLocalChecked();
     MakeCallback(New(t_), "pass", msg ? 1 : 0, &hmsg);
   }
diff --git a/nan_callbacks.h b/nan_callbacks.h
index 35bbb95f..e35a6c77 100644
--- a/nan_callbacks.h
+++ b/nan_callbacks.h
@@ -52,7 +52,7 @@ typedef void(*IndexQueryCallback)(
     const PropertyCallbackInfo<v8::Integer>&);
 
 namespace imp {
-typedef v8::Handle<v8::AccessorSignature> Sig;
+typedef v8::Local<v8::AccessorSignature> Sig;
 
 #define X(NAME)                                                                \
 struct NAME ## Wrapper {                                                       \
diff --git a/nan_callbacks_12_inl.h b/nan_callbacks_12_inl.h
index da6cbee7..7178a4ae 100644
--- a/nan_callbacks_12_inl.h
+++ b/nan_callbacks_12_inl.h
@@ -24,7 +24,7 @@ class ReturnValue {
   }
 
   // Handle setters
-  template <typename S> inline void Set(const v8::Handle<S> &handle) {
+  template <typename S> inline void Set(const v8::Local<S> &handle) {
     TYPE_CHECK(T, S);
     value_.Set(handle);
   }
diff --git a/nan_callbacks_pre_12_inl.h b/nan_callbacks_pre_12_inl.h
index 2144038d..08997be5 100644
--- a/nan_callbacks_pre_12_inl.h
+++ b/nan_callbacks_pre_12_inl.h
@@ -30,7 +30,7 @@ class ReturnValue {
   }
 
   // Handle setters
-  template <typename S> inline void Set(const v8::Handle<S> &handle) {
+  template <typename S> inline void Set(const v8::Local<S> &handle) {
     TYPE_CHECK(T, S);
     value_->Dispose();
     *value_ = v8::Persistent<T>::New(handle);
diff --git a/nan_converters.h b/nan_converters.h
index ea0b68b8..6f08e683 100644
--- a/nan_converters.h
+++ b/nan_converters.h
@@ -20,7 +20,7 @@ template<typename T> struct ToFactory;
 #define X(TYPE)                                                                \
     template<>                                                                 \
     struct ToFactory<v8::TYPE> : ToFactoryBase<v8::TYPE> {                     \
-      static inline return_t convert(v8::Handle<v8::Value> val);               \
+      static inline return_t convert(v8::Local<v8::Value> val);                \
     };
 
 X(Boolean)
@@ -36,7 +36,7 @@ X(Int32)
 #define X(TYPE)                                                                \
     template<>                                                                 \
     struct ToFactory<TYPE> : ValueFactoryBase<TYPE> {                          \
-      static inline return_t convert(v8::Handle<v8::Value> val);               \
+      static inline return_t convert(v8::Local<v8::Value> val);                \
     };
 
 X(bool)
@@ -50,7 +50,7 @@ X(int32_t)
 
 template<typename T>
 NAN_INLINE
-typename imp::ToFactory<T>::return_t To(v8::Handle<v8::Value> val) {
+typename imp::ToFactory<T>::return_t To(v8::Local<v8::Value> val) {
   return imp::ToFactory<T>::convert(val);
 }
 
diff --git a/nan_converters_43_inl.h b/nan_converters_43_inl.h
index 1f132ba6..596b8f18 100644
--- a/nan_converters_43_inl.h
+++ b/nan_converters_43_inl.h
@@ -11,7 +11,7 @@
 
 #define X(TYPE)                                                                \
 imp::ToFactory<v8::TYPE>::return_t                                             \
-imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {                 \
+imp::ToFactory<v8::TYPE>::convert(v8::Local<v8::Value> val) {                  \
   return val->To ## TYPE(GetCurrentContext());                                 \
 }
 
@@ -27,7 +27,7 @@ X(Int32)
 
 #define X(TYPE, NAME)                                                          \
 imp::ToFactory<TYPE>::return_t                                                 \
-imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                     \
+imp::ToFactory<TYPE>::convert(v8::Local<v8::Value> val) {                      \
   return val->NAME ## Value(GetCurrentContext());                              \
 }
 
diff --git a/nan_converters_pre_43_inl.h b/nan_converters_pre_43_inl.h
index 94a1ecca..4fe2eb9f 100644
--- a/nan_converters_pre_43_inl.h
+++ b/nan_converters_pre_43_inl.h
@@ -11,7 +11,7 @@
 
 #define X(TYPE)                                                                \
 imp::ToFactory<v8::TYPE>::return_t                                             \
-imp::ToFactory<v8::TYPE>::convert(v8::Handle<v8::Value> val) {                 \
+imp::ToFactory<v8::TYPE>::convert(v8::Local<v8::Value> val) {                  \
   return MaybeLocal<v8::TYPE>(val->To ## TYPE());                              \
 }
 
@@ -27,7 +27,7 @@ X(Int32)
 
 #define X(TYPE, NAME)                                                          \
 imp::ToFactory<TYPE>::return_t                                                 \
-imp::ToFactory<TYPE>::convert(v8::Handle<v8::Value> val) {                     \
+imp::ToFactory<TYPE>::convert(v8::Local<v8::Value> val) {                      \
   return Just<TYPE>(val->NAME ##Value());                                      \
 }
 
diff --git a/nan_implementation_12_inl.h b/nan_implementation_12_inl.h
index fb5d7810..16d01a3a 100644
--- a/nan_implementation_12_inl.h
+++ b/nan_implementation_12_inl.h
@@ -44,8 +44,8 @@ Factory<v8::BooleanObject>::New(bool value) {
 
 Factory<v8::Context>::return_t
 Factory<v8::Context>::New( v8::ExtensionConfiguration* extensions
-                         , v8::Handle<v8::ObjectTemplate> tmpl
-                         , v8::Handle<v8::Value> obj) {
+                         , v8::Local<v8::ObjectTemplate> tmpl
+                         , v8::Local<v8::Value> obj) {
   return v8::Context::New(v8::Isolate::GetCurrent(), extensions, tmpl, obj);
 }
 
@@ -82,7 +82,7 @@ Factory<v8::External>::New(void * value) {
 
 Factory<v8::Function>::return_t
 Factory<v8::Function>::New( FunctionCallback callback
-                          , v8::Handle<v8::Value> data) {
+                          , v8::Local<v8::Value> data) {
   v8::Isolate *isolate = v8::Isolate::GetCurrent();
   v8::EscapableHandleScope scope(isolate);
   static std::map<FunctionCallback, imp::FunctionWrapper*> cbmap;
@@ -115,8 +115,8 @@ Factory<v8::Function>::New( FunctionCallback callback
 
 Factory<v8::FunctionTemplate>::return_t
 Factory<v8::FunctionTemplate>::New( FunctionCallback callback
-                                  , v8::Handle<v8::Value> data
-                                  , v8::Handle<v8::Signature> signature) {
+                                  , v8::Local<v8::Value> data
+                                  , v8::Local<v8::Signature> signature) {
   v8::Isolate *isolate = v8::Isolate::GetCurrent();
   v8::EscapableHandleScope scope(isolate);
   static std::map<FunctionCallback,  // NOLINT(build/include_what_you_use)
@@ -208,14 +208,14 @@ Factory<v8::ObjectTemplate>::New() {
   (V8_MAJOR_VERSION == 4 && defined(V8_MINOR_VERSION) && V8_MINOR_VERSION >= 3))
 Factory<v8::RegExp>::return_t
 Factory<v8::RegExp>::New(
-    v8::Handle<v8::String> pattern
+    v8::Local<v8::String> pattern
   , v8::RegExp::Flags flags) {
   return v8::RegExp::New(GetCurrentContext(), pattern, flags);
 }
 #else
 Factory<v8::RegExp>::return_t
 Factory<v8::RegExp>::New(
-    v8::Handle<v8::String> pattern
+    v8::Local<v8::String> pattern
   , v8::RegExp::Flags flags) {
   return Factory<v8::RegExp>::return_t(v8::RegExp::New(pattern, flags));
 }
@@ -348,7 +348,7 @@ Factory<v8::String>::New(ExternalOneByteStringResource * value) {
 //=== String Object ============================================================
 
 Factory<v8::StringObject>::return_t
-Factory<v8::StringObject>::New(v8::Handle<v8::String> value) {
+Factory<v8::StringObject>::New(v8::Local<v8::String> value) {
   return v8::StringObject::New(value).As<v8::StringObject>();
 }
 
@@ -391,10 +391,12 @@ Factory<v8::UnboundScript>::New( v8::Local<v8::String> source
 
 //=== Presistents and Handles ==================================================
 
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
 template <typename T>
 inline v8::Local<T> New(v8::Handle<T> h) {
   return v8::Local<T>::New(v8::Isolate::GetCurrent(), h);
 }
+#endif
 
 template <typename T, typename M>
 inline v8::Local<T> New(v8::Persistent<T, M> const& p) {
diff --git a/nan_implementation_pre_12_inl.h b/nan_implementation_pre_12_inl.h
index 94605fea..7d9bc7f0 100644
--- a/nan_implementation_pre_12_inl.h
+++ b/nan_implementation_pre_12_inl.h
@@ -45,8 +45,8 @@ Factory<v8::BooleanObject>::New(bool value) {
 
 Factory<v8::Context>::return_t
 Factory<v8::Context>::New( v8::ExtensionConfiguration* extensions
-                         , v8::Handle<v8::ObjectTemplate> tmpl
-                         , v8::Handle<v8::Value> obj) {
+                         , v8::Local<v8::ObjectTemplate> tmpl
+                         , v8::Local<v8::Value> obj) {
   v8::Persistent<v8::Context> ctx = v8::Context::New(extensions, tmpl, obj);
   v8::Local<v8::Context> lctx = v8::Local<v8::Context>::New(ctx);
   ctx.Dispose();
@@ -71,10 +71,10 @@ Factory<v8::External>::New(void * value) {
 
 Factory<v8::Function>::return_t
 Factory<v8::Function>::New( FunctionCallback callback
-                          , v8::Handle<v8::Value> data) {
+                          , v8::Local<v8::Value> data) {
   return Factory<v8::FunctionTemplate>::New( callback
                                            , data
-                                           , v8::Handle<v8::Signature>()
+                                           , v8::Local<v8::Signature>()
                                            )->GetFunction();
 }
 
@@ -83,8 +83,8 @@ Factory<v8::Function>::New( FunctionCallback callback
 
 Factory<v8::FunctionTemplate>::return_t
 Factory<v8::FunctionTemplate>::New( FunctionCallback callback
-                                  , v8::Handle<v8::Value> data
-                                  , v8::Handle<v8::Signature> signature) {
+                                  , v8::Local<v8::Value> data
+                                  , v8::Local<v8::Signature> signature) {
   v8::HandleScope scope;
 
   static std::map<FunctionCallback,  // NOLINT(build/include_what_you_use)
@@ -168,7 +168,7 @@ Factory<v8::ObjectTemplate>::New() {
 
 Factory<v8::RegExp>::return_t
 Factory<v8::RegExp>::New(
-    v8::Handle<v8::String> pattern
+    v8::Local<v8::String> pattern
   , v8::RegExp::Flags flags) {
   return Factory<v8::RegExp>::return_t(v8::RegExp::New(pattern, flags));
 }
@@ -231,7 +231,7 @@ Factory<v8::String>::New(v8::String::ExternalAsciiStringResource * value) {
 //=== String Object ============================================================
 
 Factory<v8::StringObject>::return_t
-Factory<v8::StringObject>::New(v8::Handle<v8::String> value) {
+Factory<v8::StringObject>::New(v8::Local<v8::String> value) {
   return v8::StringObject::New(value).As<v8::StringObject>();
 }
 
diff --git a/nan_maybe_43_inl.h b/nan_maybe_43_inl.h
index b8611749..bcdecb59 100644
--- a/nan_maybe_43_inl.h
+++ b/nan_maybe_43_inl.h
@@ -28,186 +28,186 @@ NAN_INLINE Maybe<T> Just(const T& t) {
 v8::Local<v8::Context> GetCurrentContext();
 
 NAN_INLINE
-MaybeLocal<v8::String> ToDetailString(v8::Handle<v8::Value> val) {
+MaybeLocal<v8::String> ToDetailString(v8::Local<v8::Value> val) {
   return val->ToDetailString(GetCurrentContext());
 }
 
 NAN_INLINE
-MaybeLocal<v8::Uint32> ToArrayIndex(v8::Handle<v8::Value> val) {
+MaybeLocal<v8::Uint32> ToArrayIndex(v8::Local<v8::Value> val) {
   return val->ToArrayIndex(GetCurrentContext());
 }
 
 NAN_INLINE
-Maybe<bool> Equals(v8::Handle<v8::Value> a, v8::Handle<v8::Value>(b)) {
+Maybe<bool> Equals(v8::Local<v8::Value> a, v8::Local<v8::Value>(b)) {
   return a->Equals(GetCurrentContext(), b);
 }
 
 NAN_INLINE
-MaybeLocal<v8::Object> NewInstance(v8::Handle<v8::Function> h) {
+MaybeLocal<v8::Object> NewInstance(v8::Local<v8::Function> h) {
   return MaybeLocal<v8::Object>(h->NewInstance(GetCurrentContext()));
 }
 
 NAN_INLINE
-MaybeLocal<v8::Object> NewInstance(v8::Handle<v8::ObjectTemplate> h) {
+MaybeLocal<v8::Object> NewInstance(v8::Local<v8::ObjectTemplate> h) {
   return MaybeLocal<v8::Object>(h->NewInstance(GetCurrentContext()));
 }
 
 
 NAN_INLINE MaybeLocal<v8::Function> GetFunction(
-    v8::Handle<v8::FunctionTemplate> t) {
+    v8::Local<v8::FunctionTemplate> t) {
   return t->GetFunction(GetCurrentContext());
 }
 
 NAN_INLINE Maybe<bool> Set(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::Value> key
-  , v8::Handle<v8::Value> value) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::Value> key
+  , v8::Local<v8::Value> value) {
   return obj->Set(GetCurrentContext(), key, value);
 }
 
 NAN_INLINE Maybe<bool> Set(
-    v8::Handle<v8::Object> obj
+    v8::Local<v8::Object> obj
   , uint32_t index
-  , v8::Handle<v8::Value> value) {
+  , v8::Local<v8::Value> value) {
   return obj->Set(GetCurrentContext(), index, value);
 }
 
 NAN_INLINE Maybe<bool> ForceSet(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::Value> key
-  , v8::Handle<v8::Value> value
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::Value> key
+  , v8::Local<v8::Value> value
   , v8::PropertyAttribute attribs = v8::None) {
   return obj->ForceSet(GetCurrentContext(), key, value, attribs);
 }
 
 NAN_INLINE MaybeLocal<v8::Value> Get(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::Value> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::Value> key) {
   return obj->Get(GetCurrentContext(), key);
 }
 
 NAN_INLINE
-MaybeLocal<v8::Value> Get(v8::Handle<v8::Object> obj, uint32_t index) {
+MaybeLocal<v8::Value> Get(v8::Local<v8::Object> obj, uint32_t index) {
   return obj->Get(GetCurrentContext(), index);
 }
 
 NAN_INLINE v8::PropertyAttribute GetPropertyAttributes(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::Value> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::Value> key) {
   return obj->GetPropertyAttributes(GetCurrentContext(), key).FromJust();
 }
 
 NAN_INLINE Maybe<bool> Has(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> key) {
   return obj->Has(GetCurrentContext(), key);
 }
 
-NAN_INLINE Maybe<bool> Has(v8::Handle<v8::Object> obj, uint32_t index) {
+NAN_INLINE Maybe<bool> Has(v8::Local<v8::Object> obj, uint32_t index) {
   return obj->Has(GetCurrentContext(), index);
 }
 
 NAN_INLINE Maybe<bool> Delete(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> key) {
   return obj->Delete(GetCurrentContext(), key);
 }
 
 NAN_INLINE
-Maybe<bool> Delete(v8::Handle<v8::Object> obj, uint32_t index) {
+Maybe<bool> Delete(v8::Local<v8::Object> obj, uint32_t index) {
   return obj->Delete(GetCurrentContext(), index);
 }
 
 NAN_INLINE
-MaybeLocal<v8::Array> GetPropertyNames(v8::Handle<v8::Object> obj) {
+MaybeLocal<v8::Array> GetPropertyNames(v8::Local<v8::Object> obj) {
   return obj->GetPropertyNames(GetCurrentContext());
 }
 
 NAN_INLINE
-MaybeLocal<v8::Array> GetOwnPropertyNames(v8::Handle<v8::Object> obj) {
+MaybeLocal<v8::Array> GetOwnPropertyNames(v8::Local<v8::Object> obj) {
   return obj->GetOwnPropertyNames(GetCurrentContext());
 }
 
 NAN_INLINE Maybe<bool> SetPrototype(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::Value> prototype) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::Value> prototype) {
   return obj->SetPrototype(GetCurrentContext(), prototype);
 }
 
 NAN_INLINE MaybeLocal<v8::String> ObjectProtoToString(
-    v8::Handle<v8::Object> obj) {
+    v8::Local<v8::Object> obj) {
   return obj->ObjectProtoToString(GetCurrentContext());
 }
 
 NAN_INLINE Maybe<bool> HasOwnProperty(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> key) {
   return obj->HasOwnProperty(GetCurrentContext(), key);
 }
 
 NAN_INLINE Maybe<bool> HasRealNamedProperty(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> key) {
   return obj->HasRealNamedProperty(GetCurrentContext(), key);
 }
 
 NAN_INLINE Maybe<bool> HasRealIndexedProperty(
-    v8::Handle<v8::Object> obj
+    v8::Local<v8::Object> obj
   , uint32_t index) {
   return obj->HasRealIndexedProperty(GetCurrentContext(), index);
 }
 
 NAN_INLINE Maybe<bool> HasRealNamedCallbackProperty(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> key) {
   return obj->HasRealNamedCallbackProperty(GetCurrentContext(), key);
 }
 
 NAN_INLINE MaybeLocal<v8::Value> GetRealNamedPropertyInPrototypeChain(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> key) {
   return obj->GetRealNamedPropertyInPrototypeChain(GetCurrentContext(), key);
 }
 
 NAN_INLINE MaybeLocal<v8::Value> GetRealNamedProperty(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::String> key) {
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::String> key) {
   return obj->GetRealNamedProperty(GetCurrentContext(), key);
 }
 
 NAN_INLINE MaybeLocal<v8::Value> CallAsFunction(
-    v8::Handle<v8::Object> obj
-  , v8::Handle<v8::Object> recv
+    v8::Local<v8::Object> obj
+  , v8::Local<v8::Object> recv
   , int argc
-  , v8::Handle<v8::Value> argv[]) {
+  , v8::Local<v8::Value> argv[]) {
   return obj->CallAsFunction(GetCurrentContext(), recv, argc, argv);
 }
 
 NAN_INLINE MaybeLocal<v8::Value> CallAsConstructor(
-    v8::Handle<v8::Object> obj
+    v8::Local<v8::Object> obj
   , int argc, v8::Local<v8::Value> argv[]) {
   return obj->CallAsConstructor(GetCurrentContext(), argc, argv);
 }
 
 NAN_INLINE
-MaybeLocal<v8::String> GetSourceLine(v8::Handle<v8::Message> msg) {
+MaybeLocal<v8::String> GetSourceLine(v8::Local<v8::Message> msg) {
   return msg->GetSourceLine(GetCurrentContext());
 }
 
-NAN_INLINE Maybe<int> GetLineNumber(v8::Handle<v8::Message> msg) {
+NAN_INLINE Maybe<int> GetLineNumber(v8::Local<v8::Message> msg) {
   return msg->GetLineNumber(GetCurrentContext());
 }
 
-NAN_INLINE Maybe<int> GetStartColumn(v8::Handle<v8::Message> msg) {
+NAN_INLINE Maybe<int> GetStartColumn(v8::Local<v8::Message> msg) {
   return msg->GetStartColumn(GetCurrentContext());
 }
 
-NAN_INLINE Maybe<int> GetEndColumn(v8::Handle<v8::Message> msg) {
+NAN_INLINE Maybe<int> GetEndColumn(v8::Local<v8::Message> msg) {
   return msg->GetEndColumn(GetCurrentContext());
 }
 
 NAN_INLINE MaybeLocal<v8::Object> CloneElementAt(
-    v8::Handle<v8::Array> array
+    v8::Local<v8::Array> array
   , uint32_t index) {
   return array->CloneElementAt(GetCurrentContext(), index);
 }
diff --git a/nan_new.h b/nan_new.h
index 22e54548..bc799cce 100644
--- a/nan_new.h
+++ b/nan_new.h
@@ -12,26 +12,26 @@
 namespace imp {  // scnr
 
 // TODO(agnat): Generalize
-template <typename T> v8::Local<T> To(v8::Handle<v8::Integer> i);
+template <typename T> v8::Local<T> To(v8::Local<v8::Integer> i);
 
 template <>
 inline
 v8::Local<v8::Integer>
-To<v8::Integer>(v8::Handle<v8::Integer> i) {
+To<v8::Integer>(v8::Local<v8::Integer> i) {
   return Nan::To<v8::Integer>(i).ToLocalChecked();
 }
 
 template <>
 inline
 v8::Local<v8::Int32>
-To<v8::Int32>(v8::Handle<v8::Integer> i) {
+To<v8::Int32>(v8::Local<v8::Integer> i) {
   return Nan::To<v8::Int32>(i).ToLocalChecked();
 }
 
 template <>
 inline
 v8::Local<v8::Uint32>
-To<v8::Uint32>(v8::Handle<v8::Integer> i) {
+To<v8::Uint32>(v8::Local<v8::Integer> i) {
   return Nan::To<v8::Uint32>(i).ToLocalChecked();
 }
 
@@ -66,8 +66,8 @@ struct Factory<v8::Context> : FactoryBase<v8::Context> {
   static inline
   return_t
   New( v8::ExtensionConfiguration* extensions = NULL
-     , v8::Handle<v8::ObjectTemplate> tmpl = v8::Handle<v8::ObjectTemplate>()
-     , v8::Handle<v8::Value> obj = v8::Handle<v8::Value>());
+     , v8::Local<v8::ObjectTemplate> tmpl = v8::Local<v8::ObjectTemplate>()
+     , v8::Local<v8::Value> obj = v8::Local<v8::Value>());
 };
 
 template <>
@@ -85,7 +85,7 @@ struct Factory<v8::Function> : FactoryBase<v8::Function> {
   static inline
   return_t
   New( FunctionCallback callback
-     , v8::Handle<v8::Value> data = v8::Handle<v8::Value>());
+     , v8::Local<v8::Value> data = v8::Local<v8::Value>());
 };
 
 template <>
@@ -93,8 +93,8 @@ struct Factory<v8::FunctionTemplate> : FactoryBase<v8::FunctionTemplate> {
   static inline
   return_t
   New( FunctionCallback callback = NULL
-     , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
-     , v8::Handle<v8::Signature> signature = v8::Handle<v8::Signature>());
+     , v8::Local<v8::Value> data = v8::Local<v8::Value>()
+     , v8::Local<v8::Signature> signature = v8::Local<v8::Signature>());
 };
 
 template <>
@@ -139,7 +139,7 @@ struct Factory<v8::ObjectTemplate> : FactoryBase<v8::ObjectTemplate> {
 template <>
 struct Factory<v8::RegExp> : MaybeFactoryBase<v8::RegExp> {
   static inline return_t New(
-      v8::Handle<v8::String> pattern, v8::RegExp::Flags flags);
+      v8::Local<v8::String> pattern, v8::RegExp::Flags flags);
 };
 
 template <>
@@ -151,7 +151,7 @@ struct Factory<v8::Script> : MaybeFactoryBase<v8::Script> {
 
 template <>
 struct Factory<v8::Signature> : FactoryBase<v8::Signature> {
-  typedef v8::Handle<v8::FunctionTemplate> FTH;
+  typedef v8::Local<v8::FunctionTemplate> FTH;
   static inline return_t New(FTH receiver = FTH());
 };
 
@@ -168,7 +168,7 @@ struct Factory<v8::String> : MaybeFactoryBase<v8::String> {
 
 template <>
 struct Factory<v8::StringObject> : FactoryBase<v8::StringObject> {
-  static inline return_t New(v8::Handle<v8::String> value);
+  static inline return_t New(v8::Local<v8::String> value);
 };
 
 }  // end of namespace imp
@@ -235,7 +235,7 @@ New(A0 arg0, A1 arg1, A2 arg2, A3 arg3) {
 template <typename T>
 typename imp::Factory<T>::return_t
 New( FunctionCallback callback
-      , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()) {
+      , v8::Local<v8::Value> data = v8::Local<v8::Value>()) {
     return imp::Factory<T>::New(callback, data);
 }
 
@@ -243,14 +243,17 @@ New( FunctionCallback callback
 template <typename T, typename A2>
 typename imp::Factory<T>::return_t
 New( FunctionCallback callback
-      , v8::Handle<v8::Value> data = v8::Handle<v8::Value>()
+      , v8::Local<v8::Value> data = v8::Local<v8::Value>()
       , A2 a2 = A2()) {
     return imp::Factory<T>::New(callback, data, a2);
 }
 
 // Convenience
 
+#if NODE_MODULE_VERSION < IOJS_3_0_MODULE_VERSION
 template <typename T> inline v8::Local<T> New(v8::Handle<T> h);
+#endif
+
 #if NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION
 template <typename T, typename M>
     inline v8::Local<T> New(v8::Persistent<T, M> const& p);
@@ -322,7 +325,7 @@ New(ExternalOneByteStringResource * value) {
 
 inline
 imp::Factory<v8::RegExp>::return_t
-New(v8::Handle<v8::String> pattern, v8::RegExp::Flags flags) {
+New(v8::Local<v8::String> pattern, v8::RegExp::Flags flags) {
   return New<v8::RegExp>(pattern, flags);
 }
 
diff --git a/nan_persistent_12_inl.h b/nan_persistent_12_inl.h
index eb008562..f1fa193d 100644
--- a/nan_persistent_12_inl.h
+++ b/nan_persistent_12_inl.h
@@ -14,7 +14,7 @@ template<typename T, typename M> class Persistent :
  public:
   NAN_INLINE Persistent() : v8::Persistent<T, M>() {}
 
-  template<typename S> NAN_INLINE Persistent(v8::Handle<S> that) :
+  template<typename S> NAN_INLINE Persistent(v8::Local<S> that) :
       v8::Persistent<T, M>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S, typename M2>
@@ -24,7 +24,7 @@ template<typename T, typename M> class Persistent :
   NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
 
   template <typename S>
-  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+  NAN_INLINE void Reset(const v8::Local<S> &other) {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
@@ -62,7 +62,7 @@ class Global : public v8::Global<T> {
  public:
   NAN_INLINE Global() : v8::Global<T>() {}
 
-  template<typename S> NAN_INLINE Global(v8::Handle<S> that) :
+  template<typename S> NAN_INLINE Global(v8::Local<S> that) :
     v8::Global<T>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S>
@@ -72,7 +72,7 @@ class Global : public v8::Global<T> {
   NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
 
   template <typename S>
-  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+  NAN_INLINE void Reset(const v8::Local<S> &other) {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
@@ -96,7 +96,7 @@ class Global : public v8::UniquePersistent<T> {
  public:
   NAN_INLINE Global() : v8::UniquePersistent<T>() {}
 
-  template<typename S> NAN_INLINE Global(v8::Handle<S> that) :
+  template<typename S> NAN_INLINE Global(v8::Local<S> that) :
     v8::UniquePersistent<T>(v8::Isolate::GetCurrent(), that) {}
 
   template<typename S>
@@ -106,7 +106,7 @@ class Global : public v8::UniquePersistent<T> {
   NAN_INLINE void Reset() { v8::PersistentBase<T>::Reset(); }
 
   template <typename S>
-  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+  NAN_INLINE void Reset(const v8::Local<S> &other) {
     v8::PersistentBase<T>::Reset(v8::Isolate::GetCurrent(), other);
   }
 
diff --git a/nan_persistent_pre_12_inl.h b/nan_persistent_pre_12_inl.h
index e46a37da..cca1162f 100644
--- a/nan_persistent_pre_12_inl.h
+++ b/nan_persistent_pre_12_inl.h
@@ -26,7 +26,7 @@ class PersistentBase {
   }
 
   template<typename S>
-  NAN_INLINE void Reset(const v8::Handle<S> &other) {
+  NAN_INLINE void Reset(const v8::Local<S> &other) {
     TYPE_CHECK(T, S);
 
     if (!persistent.IsEmpty()) {
@@ -65,7 +65,7 @@ class PersistentBase {
   }
 
   template<typename S>
-  NAN_INLINE bool operator==(const v8::Handle<S> &that) {
+  NAN_INLINE bool operator==(const v8::Local<S> &that) {
     return this->persistent == that;
   }
 
@@ -75,7 +75,7 @@ class PersistentBase {
   }
 
   template<typename S>
-  NAN_INLINE bool operator!=(const v8::Handle<S> &that) {
+  NAN_INLINE bool operator!=(const v8::Local<S> &that) {
     return !operator==(that);
   }
 
@@ -192,7 +192,7 @@ class Global : public PersistentBase<T> {
   NAN_INLINE Global() : PersistentBase<T>(0) { }
 
   template <typename S>
-  NAN_INLINE Global(v8::Handle<S> that)
+  NAN_INLINE Global(v8::Local<S> that)
       : PersistentBase<T>(v8::Persistent<T>::New(that)) {
     TYPE_CHECK(T, S);
   }
diff --git a/nan_string_bytes.h b/nan_string_bytes.h
index e11f1d0a..a2e6437d 100644
--- a/nan_string_bytes.h
+++ b/nan_string_bytes.h
@@ -22,12 +22,11 @@
 #ifndef NAN_STRING_BYTES_H_
 #define NAN_STRING_BYTES_H_
 
-// Decodes a v8::Handle<v8::String> or Buffer to a raw char*
+// Decodes a v8::Local<v8::String> or Buffer to a raw char*
 
 namespace imp {
 
 using v8::Local;
-using v8::Handle;
 using v8::Object;
 using v8::String;
 using v8::Value;
diff --git a/nan_weak.h b/nan_weak.h
index b22fc266..b4811e19 100644
--- a/nan_weak.h
+++ b/nan_weak.h
@@ -256,7 +256,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , parameter);
     v8::PersistentBase<T>::SetWeak(wcbd, wcbd->invokeparameter, type);
   } else {
-    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    v8::Local<T>* self = reinterpret_cast<v8::Local<T>*>(this);
     assert((*self)->IsObject());
     int count = (*self)->InternalFieldCount();
     void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
@@ -291,7 +291,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , parameter);
     v8::PersistentBase<T>::SetPhantom(wcbd, wcbd->invokeparameter);
   } else {
-    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    v8::Local<T>* self = reinterpret_cast<v8::Local<T>*>(this);
     assert((*self)->IsObject());
     int count = (*self)->InternalFieldCount();
     void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
@@ -327,7 +327,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , parameter);
     v8::PersistentBase<T>::SetPhantom(wcbd, wcbd->invokeparameter);
   } else {
-    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    v8::Local<T>* self = reinterpret_cast<v8::Local<T>*>(this);
     assert((*self)->IsObject());
     int count = (*self)->InternalFieldCount();
     void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
@@ -362,7 +362,7 @@ NAN_INLINE void Persistent<T, M>::SetWeak(
       , parameter);
     v8::PersistentBase<T>::SetWeak(wcbd, wcbd->invoke);
   } else {
-    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    v8::Local<T>* self = reinterpret_cast<v8::Local<T>*>(this);
     assert((*self)->IsObject());
     int count = (*self)->InternalFieldCount();
     void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
@@ -393,7 +393,7 @@ NAN_INLINE void PersistentBase<T>::SetWeak(
       , parameter);
     persistent.MakeWeak(wcbd, wcbd->invoke);
   } else {
-    v8::Handle<T>* self = reinterpret_cast<v8::Handle<T>*>(this);
+    v8::Local<T>* self = reinterpret_cast<v8::Local<T>*>(this);
     assert((*self)->IsObject());
     int count = (*self)->InternalFieldCount();
     void *internal_fields[kInternalFieldsInWeakCallback] = {0, 0};
diff --git a/test/cpp/accessors.cpp b/test/cpp/accessors.cpp
index 054e9b58..123cfd0b 100644
--- a/test/cpp/accessors.cpp
+++ b/test/cpp/accessors.cpp
@@ -13,8 +13,8 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 class SetterGetter : public ObjectWrap {
  public:
-  static void Init (v8::Handle<v8::Object> target);
-  static v8::Handle<v8::Value> NewInstance ();
+  static NAN_MODULE_INIT(Init);
+  static v8::Local<v8::Value> NewInstance ();
   static NAN_METHOD(New);
   static NAN_METHOD(Log);
   static NAN_GETTER(GetProp1);
@@ -41,7 +41,7 @@ SetterGetter::SetterGetter() {
   prop2[0] = '\0';
 }
 
-void SetterGetter::Init(v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(SetterGetter::Init) {
   v8::Local<v8::FunctionTemplate> tpl =
     Nan::New<v8::FunctionTemplate>(SetterGetter::New);
   settergetter_constructor.Reset(tpl);
@@ -65,7 +65,7 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
   Set(target, Nan::New<v8::String>("create").ToLocalChecked(), createnew);
 }
 
-v8::Handle<v8::Value> SetterGetter::NewInstance () {
+v8::Local<v8::Value> SetterGetter::NewInstance () {
   EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(settergetter_constructor);
diff --git a/test/cpp/accessors2.cpp b/test/cpp/accessors2.cpp
index da746343..23cc3670 100644
--- a/test/cpp/accessors2.cpp
+++ b/test/cpp/accessors2.cpp
@@ -13,8 +13,8 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 class SetterGetter : public ObjectWrap {
  public:
-  static void Init (v8::Handle<v8::Object> target);
-  static v8::Handle<v8::Value> NewInstance ();
+  static NAN_MODULE_INIT(Init);
+  static v8::Local<v8::Value> NewInstance ();
   static NAN_METHOD(New);
   static NAN_METHOD(Log);
   static NAN_GETTER(GetProp1);
@@ -41,7 +41,7 @@ SetterGetter::SetterGetter() {
   prop2[0] = '\0';
 }
 
-void SetterGetter::Init(v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(SetterGetter::Init) {
   v8::Local<v8::FunctionTemplate> tpl =
     Nan::New<v8::FunctionTemplate>(SetterGetter::New);
   settergetter_constructor.Reset(tpl);
@@ -53,7 +53,7 @@ void SetterGetter::Init(v8::Handle<v8::Object> target) {
   Set(target, Nan::New<v8::String>("create").ToLocalChecked(), createnew);
 }
 
-v8::Handle<v8::Value> SetterGetter::NewInstance () {
+v8::Local<v8::Value> SetterGetter::NewInstance () {
   EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(settergetter_constructor);
diff --git a/test/cpp/asyncprogressworker.cpp b/test/cpp/asyncprogressworker.cpp
index 0d9eb235..7df6e4cd 100644
--- a/test/cpp/asyncprogressworker.cpp
+++ b/test/cpp/asyncprogressworker.cpp
@@ -57,8 +57,8 @@ NAN_METHOD(DoProgress) {
     , To<uint32_t>(info[1]).FromJust()));
 }
 
-void Init(v8::Handle<v8::Object> exports) {
-  Set(exports
+NAN_MODULE_INIT(Init) {
+  Set(target
     , New<v8::String>("a").ToLocalChecked()
     , New<v8::FunctionTemplate>(DoProgress)->GetFunction());
 }
diff --git a/test/cpp/asyncworker.cpp b/test/cpp/asyncworker.cpp
index ef5e7d81..2876a649 100644
--- a/test/cpp/asyncworker.cpp
+++ b/test/cpp/asyncworker.cpp
@@ -34,8 +34,8 @@ NAN_METHOD(DoSleep) {
       new SleepWorker(callback, To<uint32_t>(info[0]).FromJust()));
 }
 
-void Init(v8::Handle<v8::Object> exports) {
-  Set(exports
+NAN_MODULE_INIT(Init) {
+  Set(target
     , New<v8::String>("a").ToLocalChecked()
     , New<v8::FunctionTemplate>(DoSleep)->GetFunction());
 }
diff --git a/test/cpp/asyncworkererror.cpp b/test/cpp/asyncworkererror.cpp
index 8bf47f87..ea026ffc 100644
--- a/test/cpp/asyncworkererror.cpp
+++ b/test/cpp/asyncworkererror.cpp
@@ -26,8 +26,8 @@ NAN_METHOD(Work) {
   info.GetReturnValue().SetUndefined();
 }
 
-void Init (v8::Handle<v8::Object> exports) {
-  Set(exports
+NAN_MODULE_INIT(Init) {
+  Set(target
     , New("a").ToLocalChecked()
     , New<v8::FunctionTemplate>(Work)->GetFunction());
 }
diff --git a/test/cpp/buffer.cpp b/test/cpp/buffer.cpp
index b2ac9d7e..26b2a18a 100644
--- a/test/cpp/buffer.cpp
+++ b/test/cpp/buffer.cpp
@@ -50,7 +50,7 @@ NAN_METHOD(Copy) {
 }
 
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   for (unsigned char i = 0; i < DATA_SIZE; i++) {
     data[i] = 'a' + i;
   }
diff --git a/test/cpp/bufferworkerpersistent.cpp b/test/cpp/bufferworkerpersistent.cpp
index f6cf0407..38849cf7 100644
--- a/test/cpp/bufferworkerpersistent.cpp
+++ b/test/cpp/bufferworkerpersistent.cpp
@@ -60,8 +60,8 @@ NAN_METHOD(DoSleep) {
     , bufferHandle));
 }
 
-void Init(v8::Handle<v8::Object> exports) {
-  Set(exports
+NAN_MODULE_INIT(Init) {
+  Set(target
     , New<v8::String>("a").ToLocalChecked()
     , New<v8::FunctionTemplate>(DoSleep)->GetFunction());
 }
diff --git a/test/cpp/converters.cpp b/test/cpp/converters.cpp
index e0b23536..fcb5389e 100644
--- a/test/cpp/converters.cpp
+++ b/test/cpp/converters.cpp
@@ -68,7 +68,7 @@ NAN_METHOD(Int32Value) {
   info.GetReturnValue().Set(New(To<int32_t>(info[0]).FromJust()));
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("toBoolean").ToLocalChecked()
     , New<v8::FunctionTemplate>(ToBoolean)->GetFunction()
diff --git a/test/cpp/error.cpp b/test/cpp/error.cpp
index 921e3e10..652c2cf3 100644
--- a/test/cpp/error.cpp
+++ b/test/cpp/error.cpp
@@ -48,7 +48,7 @@ X(TypeError)
     , Nan::New<v8::FunctionTemplate>(NAME)->GetFunction());
 
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   EXPORT_ERROR_FUNCTIONS(Error)
   EXPORT_ERROR_FUNCTIONS(RangeError)
   EXPORT_ERROR_FUNCTIONS(ReferenceError)
diff --git a/test/cpp/gc.cpp b/test/cpp/gc.cpp
index 522c043d..67b6b8bd 100644
--- a/test/cpp/gc.cpp
+++ b/test/cpp/gc.cpp
@@ -33,7 +33,7 @@ NAN_METHOD(Check) {
       New(prologue_called && epilogue_called));
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("hook").ToLocalChecked()
     , New<v8::FunctionTemplate>(Hook)->GetFunction()
diff --git a/test/cpp/indexedinterceptors.cpp b/test/cpp/indexedinterceptors.cpp
index 237df464..ee01909b 100644
--- a/test/cpp/indexedinterceptors.cpp
+++ b/test/cpp/indexedinterceptors.cpp
@@ -16,8 +16,8 @@ class IndexedInterceptor : public ObjectWrap {
 
  public:
   IndexedInterceptor() { std::strncpy(this->buf, "foo", sizeof (this->buf)); }
-  static void Init (v8::Handle<v8::Object> target);
-  static v8::Handle<v8::Value> NewInstance ();
+  static NAN_MODULE_INIT(Init);
+  static v8::Local<v8::Value> NewInstance ();
   static NAN_METHOD(New);
 
   static NAN_INDEX_GETTER(PropertyGetter);
@@ -33,7 +33,7 @@ NAN_METHOD(CreateNew) {
   info.GetReturnValue().Set(IndexedInterceptor::NewInstance());
 }
 
-void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(IndexedInterceptor::Init) {
   v8::Local<v8::FunctionTemplate> tpl =
     Nan::New<v8::FunctionTemplate>(IndexedInterceptor::New);
   indexedinterceptors_constructor.Reset(tpl);
@@ -54,7 +54,7 @@ void IndexedInterceptor::Init(v8::Handle<v8::Object> target) {
   Set(target, Nan::New("create").ToLocalChecked(), createnew);
 }
 
-v8::Handle<v8::Value> IndexedInterceptor::NewInstance () {
+v8::Local<v8::Value> IndexedInterceptor::NewInstance () {
   EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(indexedinterceptors_constructor);
diff --git a/test/cpp/isolatedata.cpp b/test/cpp/isolatedata.cpp
index f39b1495..7005ae1e 100644
--- a/test/cpp/isolatedata.cpp
+++ b/test/cpp/isolatedata.cpp
@@ -28,7 +28,7 @@ NAN_METHOD(SetAndGet) {
   info.GetReturnValue().Set(New<v8::Boolean>(d0 == d1));
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("setAndGet").ToLocalChecked()
     , New<v8::FunctionTemplate>(SetAndGet)->GetFunction()
diff --git a/test/cpp/makecallback.cpp b/test/cpp/makecallback.cpp
index c29e278f..7bcfe1ae 100644
--- a/test/cpp/makecallback.cpp
+++ b/test/cpp/makecallback.cpp
@@ -12,7 +12,7 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 class MyObject : public node::ObjectWrap {
  public:
-  static void Init(v8::Handle<v8::Object> exports);
+  static NAN_MODULE_INIT(Init);
 
  private:
   MyObject();
@@ -31,7 +31,7 @@ MyObject::MyObject() {
 MyObject::~MyObject() {
 }
 
-void MyObject::Init(v8::Handle<v8::Object> exports) {
+NAN_MODULE_INIT(MyObject::Init) {
   // Prepare constructor template
   v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
   tpl->SetClassName(Nan::New<v8::String>("MyObject").ToLocalChecked());
@@ -40,7 +40,7 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
   SetPrototypeMethod(tpl, "call_emit", CallEmit);
 
   constructor.Reset(tpl->GetFunction());
-  Set(exports, Nan::New("MyObject").ToLocalChecked(), tpl->GetFunction());
+  Set(target, Nan::New("MyObject").ToLocalChecked(), tpl->GetFunction());
 }
 
 NAN_METHOD(MyObject::New) {
@@ -55,7 +55,7 @@ NAN_METHOD(MyObject::New) {
 }
 
 NAN_METHOD(MyObject::CallEmit) {
-  v8::Handle<v8::Value> argv[1] = {
+  v8::Local<v8::Value> argv[1] = {
     Nan::New("event").ToLocalChecked(),  // event name
   };
 
@@ -63,8 +63,4 @@ NAN_METHOD(MyObject::CallEmit) {
   info.GetReturnValue().SetUndefined();
 }
 
-void Init(v8::Handle<v8::Object> exports) {
-  MyObject::Init(exports);
-}
-
-NODE_MODULE(makecallback, Init)
+NODE_MODULE(makecallback, MyObject::Init)
diff --git a/test/cpp/morenews.cpp b/test/cpp/morenews.cpp
index 0a57d121..9cb8291f 100644
--- a/test/cpp/morenews.cpp
+++ b/test/cpp/morenews.cpp
@@ -65,7 +65,7 @@ NAN_METHOD(NewExternalAsciiStringResource) {
   info.GetReturnValue().Set(ext);
 }
 
-void Init(v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New("newNumber").ToLocalChecked()
     , New<v8::FunctionTemplate>(NewNumber)->GetFunction()
diff --git a/test/cpp/multifile1.cpp b/test/cpp/multifile1.cpp
index 7ee79678..59da9d5f 100644
--- a/test/cpp/multifile1.cpp
+++ b/test/cpp/multifile1.cpp
@@ -11,7 +11,7 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("r").ToLocalChecked()
     , New<v8::FunctionTemplate>(ReturnString)->GetFunction()
diff --git a/test/cpp/namedinterceptors.cpp b/test/cpp/namedinterceptors.cpp
index c97dcc6a..eea991ba 100644
--- a/test/cpp/namedinterceptors.cpp
+++ b/test/cpp/namedinterceptors.cpp
@@ -16,8 +16,8 @@ class NamedInterceptor : public ObjectWrap {
 
  public:
   NamedInterceptor() { std::strncpy(this->buf, "foo", sizeof (this->buf)); }
-  static void Init (v8::Handle<v8::Object> target);
-  static v8::Handle<v8::Value> NewInstance ();
+  static NAN_MODULE_INIT(Init);
+  static v8::Local<v8::Value> NewInstance ();
   static NAN_METHOD(New);
 
   static NAN_PROPERTY_GETTER(PropertyGetter);
@@ -33,7 +33,7 @@ NAN_METHOD(CreateNew) {
   info.GetReturnValue().Set(NamedInterceptor::NewInstance());
 }
 
-void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(NamedInterceptor::Init) {
   v8::Local<v8::FunctionTemplate> tpl =
     Nan::New<v8::FunctionTemplate>(NamedInterceptor::New);
   namedinterceptors_constructor.Reset(tpl);
@@ -54,7 +54,7 @@ void NamedInterceptor::Init(v8::Handle<v8::Object> target) {
   Set(target, Nan::New("create").ToLocalChecked(), createnew);
 }
 
-v8::Handle<v8::Value> NamedInterceptor::NewInstance () {
+v8::Local<v8::Value> NamedInterceptor::NewInstance () {
   EscapableHandleScope scope;
   v8::Local<v8::FunctionTemplate> constructorHandle =
       Nan::New(namedinterceptors_constructor);
diff --git a/test/cpp/nancallback.cpp b/test/cpp/nancallback.cpp
index 70545c81..85a40cca 100644
--- a/test/cpp/nancallback.cpp
+++ b/test/cpp/nancallback.cpp
@@ -41,7 +41,7 @@ NAN_METHOD(CallAsFunction) {
   Callback(info[0].As<v8::Function>())();
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("globalContext").ToLocalChecked()
     , New<v8::FunctionTemplate>(GlobalContext)->GetFunction()
diff --git a/test/cpp/nannew.cpp b/test/cpp/nannew.cpp
index b5b6c733..6d57f62f 100644
--- a/test/cpp/nannew.cpp
+++ b/test/cpp/nannew.cpp
@@ -108,12 +108,12 @@ NAN_METHOD(testContext) {
   t.ok(_( assertType<Context>( New<Context>(&extensions))));
   t.ok(_( assertType<Context>(
           New<Context>(static_cast<ExtensionConfiguration *>(NULL)
-          , Handle<ObjectTemplate>()))));
+          , Local<ObjectTemplate>()))));
   t.ok(_( assertType<Context>(
-          New<Context>(&extensions, Handle<ObjectTemplate>()))));
+          New<Context>(&extensions, Local<ObjectTemplate>()))));
   t.ok(_( assertType<Context>(
           New<Context>(&extensions
-          , Handle<ObjectTemplate>(), Handle<Value>()))));
+          , Local<ObjectTemplate>(), Local<Value>()))));
 
   info.GetReturnValue().SetUndefined();
 }
@@ -345,19 +345,6 @@ NAN_METHOD(testStringObject) {
 }
 #undef V
 
-template <typename T> Handle<T> asHandle(Local<T> l) { return l; }
-NAN_METHOD(testHandles) {
-  Tap t(info[0]);
-
-  t.plan(2);
-
-  t.ok(_( assertType<String>(
-      New( asHandle(New("foo").ToLocalChecked())))));
-  t.ok(_( assertType<Uint32>( New( asHandle(New(5u))))));
-
-  info.GetReturnValue().SetUndefined();
-}
-
 NAN_METHOD(testPersistents) {
   Tap t(info[0]);
 
@@ -456,38 +443,37 @@ NAN_METHOD(newExternal) {
   info.GetReturnValue().Set(New<External>(&ttt));
 }
 
-void Init(Handle<Object> exports) {
-  NAN_EXPORT(exports, testArray);
-  NAN_EXPORT(exports, testBoolean);
-  NAN_EXPORT(exports, testBooleanObject);
-  NAN_EXPORT(exports, testContext);
-  NAN_EXPORT(exports, testDate);
-  NAN_EXPORT(exports, testExternal);
-  NAN_EXPORT(exports, testFunction);
-  NAN_EXPORT(exports, testFunctionTemplate);
-  NAN_EXPORT(exports, testNumber);
-  NAN_EXPORT(exports, testNumberObject);
-  NAN_EXPORT(exports, testObject);
-  NAN_EXPORT(exports, testObjectTemplate);
-  NAN_EXPORT(exports, testScript);
-  NAN_EXPORT(exports, testSignature);
-  NAN_EXPORT(exports, testString);
-  NAN_EXPORT(exports, testStringObject);
-
-  NAN_EXPORT(exports, testHandles);
-  NAN_EXPORT(exports, testPersistents);
-
-  NAN_EXPORT(exports, testRegression212);
-  NAN_EXPORT(exports, testRegression242);
-
-  NAN_EXPORT(exports, newIntegerWithValue);
-  NAN_EXPORT(exports, newNumberWithValue);
-  NAN_EXPORT(exports, newUint32WithValue);
-  NAN_EXPORT(exports, newStringFromChars);
-  NAN_EXPORT(exports, newStringFromCharsWithLength);
-  NAN_EXPORT(exports, newStringFromStdString);
-
-  NAN_EXPORT(exports, newExternal);
+NAN_MODULE_INIT(Init) {
+  NAN_EXPORT(target, testArray);
+  NAN_EXPORT(target, testBoolean);
+  NAN_EXPORT(target, testBooleanObject);
+  NAN_EXPORT(target, testContext);
+  NAN_EXPORT(target, testDate);
+  NAN_EXPORT(target, testExternal);
+  NAN_EXPORT(target, testFunction);
+  NAN_EXPORT(target, testFunctionTemplate);
+  NAN_EXPORT(target, testNumber);
+  NAN_EXPORT(target, testNumberObject);
+  NAN_EXPORT(target, testObject);
+  NAN_EXPORT(target, testObjectTemplate);
+  NAN_EXPORT(target, testScript);
+  NAN_EXPORT(target, testSignature);
+  NAN_EXPORT(target, testString);
+  NAN_EXPORT(target, testStringObject);
+
+  NAN_EXPORT(target, testPersistents);
+
+  NAN_EXPORT(target, testRegression212);
+  NAN_EXPORT(target, testRegression242);
+
+  NAN_EXPORT(target, newIntegerWithValue);
+  NAN_EXPORT(target, newNumberWithValue);
+  NAN_EXPORT(target, newUint32WithValue);
+  NAN_EXPORT(target, newStringFromChars);
+  NAN_EXPORT(target, newStringFromCharsWithLength);
+  NAN_EXPORT(target, newStringFromStdString);
+
+  NAN_EXPORT(target, newExternal);
 }
 
 }  // end of anonymous namespace
diff --git a/test/cpp/news.cpp b/test/cpp/news.cpp
index 0bf4d698..11bdf91a 100644
--- a/test/cpp/news.cpp
+++ b/test/cpp/news.cpp
@@ -102,7 +102,7 @@ NAN_METHOD(NewSignature) {
       New<v8::FunctionTemplate>(NewSignature);
   v8::Local<v8::Signature> sig = New<v8::Signature>(tmpl);
   tmpl = New<v8::FunctionTemplate>(
-      NewSignature, v8::Handle<v8::Value>(), sig);
+      NewSignature, v8::Local<v8::Value>(), sig);
   info.GetReturnValue().Set(New("string").ToLocalChecked());
 }
 
@@ -162,7 +162,7 @@ NAN_METHOD(NewBoolean2) {
 #endif
 }
 
-void Init(v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("newNumber").ToLocalChecked()
     , New<v8::FunctionTemplate>(NewNumber)->GetFunction()
diff --git a/test/cpp/objectwraphandle.cpp b/test/cpp/objectwraphandle.cpp
index a52daf26..771f037c 100644
--- a/test/cpp/objectwraphandle.cpp
+++ b/test/cpp/objectwraphandle.cpp
@@ -12,7 +12,7 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 class MyObject : public ObjectWrap {
  public:
-  static void Init(v8::Handle<v8::Object> exports) {
+  static NAN_MODULE_INIT(Init) {
     v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
     tpl->SetClassName(Nan::New("MyObject").ToLocalChecked());
     tpl->InstanceTemplate()->SetInternalFieldCount(1);
@@ -20,7 +20,7 @@ class MyObject : public ObjectWrap {
     SetPrototypeMethod(tpl, "getHandle", GetHandle);
 
     constructor.Reset(tpl->GetFunction());
-    Set(exports, Nan::New("MyObject").ToLocalChecked(), tpl->GetFunction());
+    Set(target, Nan::New("MyObject").ToLocalChecked(), tpl->GetFunction());
   }
 
  private:
@@ -52,8 +52,4 @@ class MyObject : public ObjectWrap {
 
 Persistent<v8::Function> MyObject::constructor;
 
-void Init(v8::Handle<v8::Object> exports) {
-  MyObject::Init(exports);
-}
-
-NODE_MODULE(objectwraphandle, Init)
+NODE_MODULE(objectwraphandle, MyObject::Init)
diff --git a/test/cpp/persistent.cpp b/test/cpp/persistent.cpp
index 89b60488..7a333b30 100644
--- a/test/cpp/persistent.cpp
+++ b/test/cpp/persistent.cpp
@@ -49,7 +49,7 @@ NAN_METHOD(CopyablePersistent) {
   info.GetReturnValue().Set(New(p));
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("save1").ToLocalChecked()
     , New<v8::FunctionTemplate>(Save1)->GetFunction()
diff --git a/test/cpp/returnemptystring.cpp b/test/cpp/returnemptystring.cpp
index 7889bdf0..734c3c8b 100644
--- a/test/cpp/returnemptystring.cpp
+++ b/test/cpp/returnemptystring.cpp
@@ -14,7 +14,7 @@ NAN_METHOD(ReturnEmptyString) {
   info.GetReturnValue().SetEmptyString();
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("r").ToLocalChecked()
     , New<v8::FunctionTemplate>(ReturnEmptyString)->GetFunction()
diff --git a/test/cpp/returnnull.cpp b/test/cpp/returnnull.cpp
index 770dc810..f5869b16 100644
--- a/test/cpp/returnnull.cpp
+++ b/test/cpp/returnnull.cpp
@@ -12,7 +12,7 @@ NAN_METHOD(ReturnNull) {
   info.GetReturnValue().SetNull();
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Nan::Set(target
     , Nan::New<v8::String>("r").ToLocalChecked()
     , Nan::New<v8::FunctionTemplate>(ReturnNull)->GetFunction()
diff --git a/test/cpp/returnundefined.cpp b/test/cpp/returnundefined.cpp
index 661901f7..4c921d3c 100644
--- a/test/cpp/returnundefined.cpp
+++ b/test/cpp/returnundefined.cpp
@@ -14,7 +14,7 @@ NAN_METHOD(ReturnUndefined) {
   info.GetReturnValue().SetUndefined();
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("r").ToLocalChecked()
     , New<v8::FunctionTemplate>(ReturnUndefined)->GetFunction()
diff --git a/test/cpp/returnvalue.cpp b/test/cpp/returnvalue.cpp
index f0d3c5a2..7856baa4 100644
--- a/test/cpp/returnvalue.cpp
+++ b/test/cpp/returnvalue.cpp
@@ -30,7 +30,7 @@ NAN_METHOD(ReturnGlobal) {
   info.GetReturnValue().Set(global);
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   global.Reset(New(true));
 
   Set(target
diff --git a/test/cpp/settemplate.cpp b/test/cpp/settemplate.cpp
index 58f70e27..40c5933b 100644
--- a/test/cpp/settemplate.cpp
+++ b/test/cpp/settemplate.cpp
@@ -12,7 +12,7 @@ using namespace Nan;  // NOLINT(build/namespaces)
 
 class MyObject : public node::ObjectWrap {
  public:
-  static void Init(v8::Handle<v8::Object> exports);
+  static NAN_MODULE_INIT(Init);
 
  private:
   MyObject();
@@ -30,7 +30,7 @@ MyObject::MyObject() {
 MyObject::~MyObject() {
 }
 
-void MyObject::Init(v8::Handle<v8::Object> exports) {
+NAN_MODULE_INIT(MyObject::Init) {
   // Prepare constructor template
   v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
   tpl->SetClassName(Nan::New<v8::String>("MyObject").ToLocalChecked());
@@ -71,7 +71,7 @@ void MyObject::Init(v8::Handle<v8::Object> exports) {
   , v8::DontDelete);
 
   constructor.Reset(tpl->GetFunction());
-  Set(exports
+  Set(target
   , Nan::New<v8::String>("MyObject").ToLocalChecked()
   , tpl->GetFunction());
 }
@@ -87,8 +87,4 @@ NAN_METHOD(MyObject::New) {
   }
 }
 
-void Init(v8::Handle<v8::Object> exports) {
-  MyObject::Init(exports);
-}
-
-NODE_MODULE(settemplate, Init)
+NODE_MODULE(settemplate, MyObject::Init)
diff --git a/test/cpp/strings.cpp b/test/cpp/strings.cpp
index 97872e96..5c6517f1 100644
--- a/test/cpp/strings.cpp
+++ b/test/cpp/strings.cpp
@@ -34,7 +34,7 @@ Persistent<v8::FunctionTemplate> heapString_persistent;
 Persistent<v8::FunctionTemplate> encodeHex_persistent;
 Persistent<v8::FunctionTemplate> encodeUCS2_persistent;
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   v8::Local<v8::FunctionTemplate> returnUtf8String =
     New<v8::FunctionTemplate>(ReturnUtf8String);
 
diff --git a/test/cpp/symbols.cpp b/test/cpp/symbols.cpp
index c1a42e3c..a2ddd413 100644
--- a/test/cpp/symbols.cpp
+++ b/test/cpp/symbols.cpp
@@ -10,7 +10,7 @@
 
 using namespace Nan;  // NOLINT(build/namespaces)
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("key").ToLocalChecked()
     , New<v8::String>("a property").ToLocalChecked()
diff --git a/test/cpp/threadlocal.cpp b/test/cpp/threadlocal.cpp
index a8f4676a..b6ece4ee 100644
--- a/test/cpp/threadlocal.cpp
+++ b/test/cpp/threadlocal.cpp
@@ -59,8 +59,8 @@ NAN_METHOD(thread_local_storage) {
   info.GetReturnValue().SetUndefined();
 }
 
-void Init(v8::Handle<v8::Object> exports) {
-  Set(exports
+NAN_MODULE_INIT(Init) {
+  Set(target
     , New<v8::String>("thread_local_storage").ToLocalChecked()
     , New<v8::FunctionTemplate>(thread_local_storage)->GetFunction()
   );
diff --git a/test/cpp/trycatch.cpp b/test/cpp/trycatch.cpp
index c447e701..3318e075 100644
--- a/test/cpp/trycatch.cpp
+++ b/test/cpp/trycatch.cpp
@@ -21,7 +21,7 @@ NAN_METHOD(TryCatchTest) {
   }
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("r").ToLocalChecked()
     , New<v8::FunctionTemplate>(TryCatchTest)->GetFunction()
diff --git a/test/cpp/weak.cpp b/test/cpp/weak.cpp
index 062bff55..cfdf236b 100644
--- a/test/cpp/weak.cpp
+++ b/test/cpp/weak.cpp
@@ -20,7 +20,7 @@ void weakCallback(
   delete parameter;
 }
 
-v8::Handle<v8::String> wrap(v8::Local<v8::Function> func) {
+v8::Local<v8::String> wrap(v8::Local<v8::Function> func) {
   EscapableHandleScope scope;
   v8::Local<v8::String> lstring = New<v8::String>("result").ToLocalChecked();
   int *parameter = new int(42);
@@ -35,7 +35,7 @@ NAN_METHOD(Hustle) {
   info.GetReturnValue().Set(wrap(info[0].As<v8::Function>()));
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("hustle").ToLocalChecked()
     , New<v8::FunctionTemplate>(Hustle)->GetFunction()
diff --git a/test/cpp/weak2.cpp b/test/cpp/weak2.cpp
index 0eacbe57..9e4d2770 100644
--- a/test/cpp/weak2.cpp
+++ b/test/cpp/weak2.cpp
@@ -19,7 +19,7 @@ void weakCallback(
   delete parameter;
 }
 
-v8::Handle<v8::String> wrap() {
+v8::Local<v8::String> wrap() {
   EscapableHandleScope scope;
   v8::Local<v8::String> lstring = New("result").ToLocalChecked();
   v8::Local<v8::ObjectTemplate> otpl = New<v8::ObjectTemplate>();
@@ -40,7 +40,7 @@ NAN_METHOD(Hustle) {
   info.GetReturnValue().Set(wrap());
 }
 
-void Init (v8::Handle<v8::Object> target) {
+NAN_MODULE_INIT(Init) {
   Set(target
     , New<v8::String>("hustle").ToLocalChecked()
     , New<v8::FunctionTemplate>(Hustle)->GetFunction()

From 9be6c59e239fb464a81167b868d87e42509d200e Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Fri, 24 Jul 2015 12:17:56 +1000
Subject: [PATCH 45/84] minor reformat

---
 nan.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nan.h b/nan.h
index 0e982cf3..8b34ecff 100644
--- a/nan.h
+++ b/nan.h
@@ -47,9 +47,9 @@
 # ifndef UV_VERSION_PATCH
 #  define UV_VERSION_PATCH 0
 # endif
-# define NAUV_UVVERSION  ((UV_VERSION_MAJOR << 16) | \
-                     (UV_VERSION_MINOR <<  8) | \
-                     (UV_VERSION_PATCH))
+# define NAUV_UVVERSION ((UV_VERSION_MAJOR << 16) | \
+                         (UV_VERSION_MINOR <<  8) | \
+                         (UV_VERSION_PATCH))
 #else
 # define NAUV_UVVERSION 0x000b00
 #endif

From 0bb529d094dd91b1f74ffbf47e4f040feaa8e567 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 31 May 2015 00:49:29 +0300
Subject: [PATCH 46/84] First draft of docs for Persistent

---
 doc/persistent.md | 192 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 192 insertions(+)
 create mode 100644 doc/persistent.md

diff --git a/doc/persistent.md b/doc/persistent.md
new file mode 100644
index 00000000..898ee221
--- /dev/null
+++ b/doc/persistent.md
@@ -0,0 +1,192 @@
+# Persistent
+An object reference that is independent of any handle scope. Where a Local
+handle only lives as long as the `HandleScope` in which it was allocated,
+a `Persistent` handle remains valid until it is explicitly disposed.
+
+## PersistentBase
+A persistent handle contains a reference to a storage cell within
+the v8 engine which holds an object value and which is updated by
+the garbage collector whenever the object is moved.  A new storage
+cell can be created using the constructor or `PersistentBase::Reset`.
+Existing handles can be disposed using `PersistentBase::Reset`.
+```c++
+template<typename T>
+class PersistentBase {
+ public:
+  /**
+   * If non-empty, destroy the underlying storage cell
+   * IsEmpty() will return true after this call.
+   */
+  void Reset();
+
+  /**
+   * If non-empty, destroy the underlying storage cell
+   * and create a new one with the contents of other if other is non empty
+   */
+  template<typename S>
+  void Reset(const v8::Handle<S> &other);
+
+  /**
+   * If non-empty, destroy the underlying storage cell
+   * and create a new one with the contents of other if other is non empty
+   */
+  template<typename S>
+  void Reset(const PersistentBase<S> &other);
+
+  bool IsEmpty();
+
+  void Empty();
+
+  template<typename S>
+  bool operator==(const PersistentBase<S> &that);
+
+  template<typename S>
+  bool operator==(const v8::Handle<S> &that);
+
+  template<typename S>
+  bool operator!=(const PersistentBase<S> &that);
+
+  template<typename S>
+  bool operator!=(const v8::Handle<S> &that);
+
+   /**
+   *  Install a finalization callback on this object.
+   *  NOTE: There is no guarantee as to *when* or even *if* the callback is
+   *  invoked. The invocation is performed solely on a best effort basis.
+   *  As always, GC-based finalization should *not* be relied upon for any
+   *  critical form of resource management! At the moment you can either
+   *  specify a parameter for the callback or the location of two internal
+   *  fields in the dying object.
+   */
+  template<typename P>
+  void SetWeak(
+      P *parameter,
+      typename WeakCallbackInfo<P>::Callback callback,
+      WeakCallbackType type);
+
+  void ClearWeak();
+
+  /**
+   * Marks the reference to this object independent. Garbage collector is free
+   * to ignore any object groups containing this object. Weak callback for an
+   * independent handle should not assume that it will be preceded by a global
+   * GC prologue callback or followed by a global GC epilogue callback.
+   */
+  void MarkIndependent() const;
+
+  bool IsIndependent() const;
+
+  /** Checks if the handle holds the only reference to an object. */
+  bool IsNearDeath() const;
+
+  /** Returns true if the handle's reference is weak.  */
+  bool IsWeak() const
+};
+```
+
+## NonCopyablePersistentTraits
+Default traits for `Persistent`. This class does not allow use of the copy
+constructor or assignment operator. At present `kResetInDestructor` is not
+set, but that will change in a future version.
+```c++
+template<typename T>
+class NonCopyablePersistentTraits {
+ public:
+  typedef Persistent<T, NonCopyablePersistentTraits<T> > NonCopyablePersistent;
+  static const bool kResetInDestructor = false;
+  template<typename S, typename M>
+};
+```
+
+## CopyablePersistentTraits
+Helper class traits to allow copying and assignment of `Persistent`.
+This will clone the contents of storage cell, but not any of the flags, etc.
+```c++
+template<typename T>
+class CopyablePersistentTraits {
+ public:
+  typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
+  static const bool kResetInDestructor = true;
+};
+```
+
+## Persistent
+A `PersistentBase` which allows copy and assignment.
+Copy, assignment and destructor bevavior is controlled by the traits class `M`.
+```c++
+template<typename T, typename M = NonCopyablePersistentTraits<T> > class Persistent;
+
+template<typename T, typename M> class Persistent : public PersistentBase<T> {
+ public:
+ /**
+  * A Persistent with no storage cell.
+  */
+  Persistent();
+
+  /**
+   * Construct a Persistent from a v8::Handle.
+   * When the v8::Handle is non-empty, a new storage cell is created
+   * pointing to the same object, and no flags are set.
+   */
+  template<typename S>
+  Persistent(v8::Handle<S> that);
+
+  /**
+   * Construct a Persistent from a Persistent.
+   * When the Persistent is non-empty, a new storage cell is created
+   * pointing to the same object, and no flags are set.
+   */
+  Persistent(const Persistent &that);
+
+  /**
+   * The copy constructors and assignment operator create a Persistent
+   * exactly as the Persistent constructor, but the Copy function from the
+   * traits class is called, allowing the setting of flags based on the
+   * copied Persistent.
+   */
+  Persistent &operator=(const Persistent &that);
+
+  template <typename S, typename M2>
+  Persistent &operator=(const Persistent<S, M2> &that);
+
+  /**
+   * The destructor will dispose the Persistent based on the
+   * kResetInDestructor flags in the traits class.  Since not calling dispose
+   * can result in a memory leak, it is recommended to always set this flag.
+   */
+  ~Persistent();
+};
+```
+
+## Global
+A `PersistentBase` which has move semantics.
+```c++
+template<typename T>
+class Global : public PersistentBase<T> {
+ public:
+  /**
+   * A Global with no storage cell.
+   */
+  Global();
+
+  /**
+   * Construct a Global from a v8::Handle.
+   * When the v8::Handle is non-empty, a new storage cell is created
+   * pointing to the same object, and no flags are set.
+   */
+  template<typename S>
+  Global(v8::Handle<S> that);
+  /**
+   * Construct a Global from a PersistentBase.
+   * When the Persistent is non-empty, a new storage cell is created
+   * pointing to the same object, and no flags are set.
+   */
+  template<typename S>
+  Global(const PersistentBase<S> &that);
+
+  /**
+   * Pass allows returning globals from functions, etc.
+   */
+  Global Pass();
+};
+```

From 503df27685b1d1356946936d28fc282782b0e186 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 31 May 2015 01:39:19 +0300
Subject: [PATCH 47/84] First draft of docs for callbacks

---
 doc/callbacks.md | 108 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 doc/callbacks.md

diff --git a/doc/callbacks.md b/doc/callbacks.md
new file mode 100644
index 00000000..42923985
--- /dev/null
+++ b/doc/callbacks.md
@@ -0,0 +1,108 @@
+#Callbacks
+V8 can call back to your code through these functions.
+
+##Types
+```c++
+typedef void(*FunctionCallback)(const FunctionCallbackInfo<v8::Value>&);
+typedef void(*GetterCallback)
+    (v8::Local<v8::String>, const PropertyCallbackInfo<v8::Value>&);
+typedef void(*SetterCallback)(
+    v8::Local<v8::String>,
+    v8::Local<v8::Value>,
+    const PropertyCallbackInfo<void>&);
+typedef void(*PropertyGetterCallback)(
+    v8::Local<v8::String>,
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*PropertySetterCallback)(
+    v8::Local<v8::String>,
+    v8::Local<v8::Value>,
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*PropertyEnumeratorCallback)
+    (const PropertyCallbackInfo<v8::Array>&);
+typedef void(*PropertyDeleterCallback)(
+    v8::Local<v8::String>,
+    const PropertyCallbackInfo<v8::Boolean>&);
+typedef void(*PropertyQueryCallback)(
+    v8::Local<v8::String>,
+    const PropertyCallbackInfo<v8::Integer>&);
+typedef void(*IndexGetterCallback)(
+    uint32_t,
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*IndexSetterCallback)(
+    uint32_t,
+    v8::Local<v8::Value>,
+    const PropertyCallbackInfo<v8::Value>&);
+typedef void(*IndexEnumeratorCallback)
+    (const PropertyCallbackInfo<v8::Array>&);
+typedef void(*IndexDeleterCallback)(
+    uint32_t,
+    const PropertyCallbackInfo<v8::Boolean>&);
+typedef void(*IndexQueryCallback)(
+    uint32_t,
+    const PropertyCallbackInfo<v8::Integer>&);
+```
+
+##ReturnValue
+Used for setting the return value in callbacks.
+```c++
+template<typename T>
+class ReturnValue {
+ public:
+  // Handle setters
+  template <typename S> inline void Set(const v8::Handle<S> &handle);
+  template <typename S> inline void Set(const Global<S> &handle);
+
+  // Fast primitive setters
+  inline void Set(bool value);
+  inline void Set(double i);
+  inline void Set(int32_t i);
+  inline void Set(uint32_t i);
+
+  // Fast JS primitive setters
+  inline void SetNull();
+  inline void SetUndefined();
+  inline void SetEmptyString();
+
+  // Convenience getter for isolate
+  inline v8::Isolate *GetIsolate() const;
+};
+```
+
+##FunctionCallbackInfo
+The argument information given to function call callbacks.  This
+class provides access to information about the context of the call,
+including the receiver, the number and values of arguments, and
+the holder of the function.
+```c++
+template<typename T>
+class FunctionCallbackInfo {
+ public:
+  ReturnValue<T> GetReturnValue() const;
+
+  v8::Local<v8::Function> Callee();
+  v8::Local<v8::Value> Data();
+  v8::Local<v8::Object> Holder();
+  bool IsConstructCall();
+  int Length() const;
+  v8::Local<v8::Value> operator[](int i) const;
+  v8::Local<v8::Object> This() const;
+  v8::Isolate *GetIsolate() const;
+};
+```
+
+##PropertyCallbackInfo
+The information passed to a property callback about the context of the property access.
+This class provides access to information about the context of the access, including the
+receiver and the holder of the property.
+```c++
+template<typename T>
+class PropertyCallbackInfo : public PropertyCallbackInfoBase<T> {
+ public:
+  ReturnValue<T> GetReturnValue() const;
+
+  v8::Isolate* GetIsolate() const;
+  v8::Local<v8::Value> Data() const;
+  v8::Local<v8::Object> This() const;
+  v8::Local<v8::Object> Holder() const;
+};
+```

From f95d60d587f48d6cc03a42c73898760f3e8aec13 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 31 May 2015 01:39:31 +0300
Subject: [PATCH 48/84] First draft of docs for weak callbacks

---
 doc/weak.md | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 doc/weak.md

diff --git a/doc/weak.md b/doc/weak.md
new file mode 100644
index 00000000..21c038ef
--- /dev/null
+++ b/doc/weak.md
@@ -0,0 +1,36 @@
+#Weak Callbacks
+
+## WeakCallbackInfo
+Argument to weak callbacks.
+You may need to free any external resources attached to the object.
+```c++
+template<typename T>
+class WeakCallbackInfo {
+ public:
+  typedef void (*Callback)(const WeakCallbackInfo<T>& data);
+
+  v8::Isolate *GetIsolate() const;
+
+   /**
+    *   Get the parameter that was associated with the weak handle.
+    */
+  T *GetParameter() const;
+
+   /**
+    *   Get pointer from internal field, index can be 0 or 1.
+    */
+  void *GetInternalField(int index) const;
+};
+```
+
+### Example
+```c++
+void weakCallback(const WeakCallbackInfo<int> &data) {
+  int *parameter = data.GetParameter();
+  delete parameter;
+}
+
+Persistent<v8::Object> obj;
+int *data = new int(0);
+obj.SetWeak(data, callback, WeakCallbackType::kParameter);
+```

From c85ebc12cea3798d39b279496b4b5ee4e6dc3c21 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 31 May 2015 02:49:43 +0300
Subject: [PATCH 49/84] First draft of docs for maybe types

---
 doc/maybe_types.md | 75 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 doc/maybe_types.md

diff --git a/doc/maybe_types.md b/doc/maybe_types.md
new file mode 100644
index 00000000..46ce68d7
--- /dev/null
+++ b/doc/maybe_types.md
@@ -0,0 +1,75 @@
+#Maybe Types
+The `MaybeLocal` and `Maybe` types are monads that encapsulate possibly
+empty `v8::Local` handles.
+
+##MaybeLocal
+A `MaybeLocal<>` is a wrapper around `v8::Local<>` that enforces a check whether
+the `v8::Local<>` is empty before it can be used.
+
+If an API method returns a `MaybeLocal<>`, the API method can potentially fail
+either because an exception is thrown, or because an exception is pending,
+e.g. because a previous API call threw an exception that hasn't been caught
+yet, or because a `v8::TerminateExecution` exception was thrown. In that case, an
+empty `MaybeLocal` is returned.
+```c++
+template<typename T>
+class MaybeLocal {
+ public:
+  MaybeLocal();
+
+  template<typename S>
+  MaybeLocal(v8::Local<S> that);
+
+  bool IsEmpty() const;
+
+  template<typename S>
+  bool ToLocal(v8::Local<S> *out);
+
+  // Will crash if the MaybeLocal<> is empty.
+  v8::Local<T> ToLocalChecked();
+
+  template<typename S>
+  v8::Local<S> FromMaybe(v8::Local<S> default_value) const;
+};
+```
+
+##Maybe
+A simple `Maybe` type, representing an object which may or may not have a
+value, see https://hackage.haskell.org/package/base/docs/Data-Maybe.html.
+
+If an API method returns a `Maybe<>`, the API method can potentially fail
+either because an exception is thrown, or because an exception is pending,
+e.g. because a previous API call threw an exception that hasn't been caught
+yet, or because a `v8::TerminateExecution` exception was thrown. In that case,
+a "Nothing" value is returned.
+```c++
+template<typename T>
+class Maybe {
+ public:
+  bool IsNothing() const;
+  bool IsJust() const;
+
+  // Will crash if the Maybe<> is nothing.
+  T FromJust();
+
+  T FromMaybe(const T& default_value);
+
+  bool operator==(const Maybe &other);
+
+  bool operator!=(const Maybe &other);
+};
+```
+
+## Nothing
+Construct an empty `Maybe` type representing "Nothing".
+```c++
+template<typename T>
+Maybe<T> Nothing();
+```
+
+## Just
+Construct a `Maybe` type representing "Just" a value.
+```c++
+template<typename T>
+Maybe<T> Just(const T &t);
+```

From 2c58265573d1a85b2be828a8a68a5fcd1a845d48 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 31 May 2015 16:36:28 +0300
Subject: [PATCH 50/84] First draft of docs for converters

---
 doc/converters.md | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 doc/converters.md

diff --git a/doc/converters.md b/doc/converters.md
new file mode 100644
index 00000000..bb4ca0b0
--- /dev/null
+++ b/doc/converters.md
@@ -0,0 +1,30 @@
+#Converters
+These functions convert `v8::Value`s to other `v8::Value` types and native types.
+Since type conversion is not guaranteed to succeed, they return `Maybe` types.
+
+## To
+Converts a `v8::Handle<v8::Value>` to a different subtype of `v8::Value` or to a native
+data type. Returns a `MaybeLocal<>` or a `Maybe<>` accordingly.
+
+```c++
+MaybeLocal<v8::Boolean> To<>(v8::Handle<v8::Value> val);
+MaybeLocal<v8::Int32>   To<>(v8::Handle<v8::Value> val);
+MaybeLocal<v8::Integer> To<>(v8::Handle<v8::Value> val);
+MaybeLocal<v8::Object>  To<>(v8::Handle<v8::Value> val);
+MaybeLocal<v8::Number>  To<>(v8::Handle<v8::Value> val);
+MaybeLocal<v8::String>  To<>(v8::Handle<v8::Value> val);
+MaybeLocal<v8::Uint32>  To<>(v8::Handle<v8::Value> val);
+
+Maybe<bool>             To<>(v8::Handle<v8::Value> val);
+Maybe<double>           To<>(v8::Handle<v8::Value> val);
+Maybe<int32_t>          To<>(v8::Handle<v8::Value> val);
+Maybe<int64_t>          To<>(v8::Handle<v8::Value> val);
+Maybe<uint32_t>         To<>(v8::Handle<v8::Value> val);
+```
+
+###Example
+```c++
+v8::Local<v8::Value> val;
+MaybeLocal<v8::String> = To<v8::String>(val);
+Maybe<double> = To<double>(val);
+```

From e2b0c9a5ef3bf33a02af88667952de2b6a4515e2 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 31 May 2015 16:36:38 +0300
Subject: [PATCH 51/84] First draft of docs for asyncworker

---
 doc/asyncworker.md | 99 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 doc/asyncworker.md

diff --git a/doc/asyncworker.md b/doc/asyncworker.md
new file mode 100644
index 00000000..7b31f348
--- /dev/null
+++ b/doc/asyncworker.md
@@ -0,0 +1,99 @@
+#Asyncworker
+These classes make working with asynchronous code easier.
+
+##AsyncWorker
+`AsyncWorker` is an abstract class that you can subclass to have much of the annoying async queuing and handling taken care of for you.
+It can even store arbitrary V8 objects for you and have them persist while the async work is in progress.
+```c++
+/* abstract */ class AsyncWorker {
+ public:
+  explicit AsyncWorker(Callback *callback_);
+
+  virtual ~AsyncWorker();
+
+  virtual void WorkComplete();
+
+  void SaveToPersistent(
+      const char *key, const v8::Local<v8::Value> &value);
+
+  void SaveToPersistent(
+      const v8::Handle<v8::String> &key, const v8::Local<v8::Value> &value);
+
+  void SaveToPersistent(
+      uint32_t index, const v8::Local<v8::Value> &value);
+
+  v8::Local<v8::Value> GetFromPersistent(const char *key) const;
+
+  v8::Local<v8::Value>
+  GetFromPersistent(const v8::Local<v8::String> &key) const;
+
+  v8::Local<v8::Value> GetFromPersistent(uint32_t index) const;
+
+  virtual void Execute() = 0;
+
+  uv_work_t request;
+
+  virtual void Destroy();
+
+ protected:
+  Persistent<v8::Object> persistentHandle;
+  Callback *callback;
+
+  virtual void HandleOKCallback();
+
+  virtual void HandleErrorCallback();
+
+  void SetErrorMessage(const char *msg);
+
+  const char* ErrorMessage();
+};
+```
+
+###Example
+```c++
+Callback callback;
+AsyncWorker *worker = new AsyncWorker(callback);
+```
+
+##AsyncProgressWorker
+`AsyncProgressWorker` is an abstract class that you can subclass to have much of the annoying async queuing and handling taken care of for you.
+It is derived from `AsyncWorker` with additional progress reporting callbacks.
+```c++
+/* abstract */ class AsyncProgressWorker : public AsyncWorker {
+ public:
+  explicit AsyncProgressWorker(Callback *callback_);
+
+  virtual ~AsyncProgressWorker();
+
+  void WorkProgress();
+
+  class ExecutionProgress {
+   public:
+    void Send(const char* data, size_t size) const;
+  };
+
+  virtual void Execute(const ExecutionProgress& progress) = 0;
+  virtual void HandleProgressCallback(const char *data, size_t size) = 0;
+
+  virtual void Destroy();
+```
+
+###Example
+```c++
+Callback callback;
+AsyncProgressWorker *worker = new AsyncProgressWorker(callback);
+```
+
+##AsyncQueueWorker
+`AsyncQueueWorker` will run a `AsyncWorker` asynchronously via libuv.
+Both the `execute` and `after_work` steps are taken care of for you.
+Most of the logic for this is embedded in `AsyncWorker`.
+```c++
+void AsyncQueueWorker(AsyncWorker *);
+```
+
+###Example
+```c++
+AsyncWorker *worker = new AsyncWorker(/* ... */);
+AsyncQueueWorker(worker);
+```

From ef954b959056857727209aa1a902935bbf15a7e0 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Sun, 31 May 2015 16:36:47 +0300
Subject: [PATCH 52/84] First draft of docs for nancallback

---
 doc/nancallback.md | 52 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 doc/nancallback.md

diff --git a/doc/nancallback.md b/doc/nancallback.md
new file mode 100644
index 00000000..cd6b0b61
--- /dev/null
+++ b/doc/nancallback.md
@@ -0,0 +1,52 @@
+#Callback
+`Callback` makes it easier to use `v8::Function` handles as callbacks.
+
+##Callback
+A class that wraps a `v8::Function` handle, protecting it from garbage collection.
+```c++
+class Callback {
+ public:
+  Callback();
+
+  explicit Callback(const v8::Handle<v8::Function> &fn);
+
+  ~Callback();
+
+  bool operator==(const Callback &other) const;
+
+  bool operator!=(const Callback &other) const;
+
+  NAN_INLINE
+  v8::Local<v8::Function> operator*() const;
+
+  v8::Local<v8::Value> operator()(
+      v8::Handle<v8::Object> target
+    , int argc = 0
+    , v8::Handle<v8::Value> argv[] = 0) const;
+
+  v8::Local<v8::Value> operator()(
+      int argc = 0
+    , v8::Handle<v8::Value> argv[] = 0) const;
+
+  void SetFunction(const v8::Handle<v8::Function> &fn);
+
+  v8::Local<v8::Function> GetFunction() const;
+
+  bool IsEmpty() const;
+
+  v8::Local<v8::Value>
+  Call(v8::Handle<v8::Object> target
+     , int argc
+     , v8::Handle<v8::Value> argv[]) const;
+
+  v8::Local<v8::Value>
+  Call(int argc, v8::Handle<v8::Value> argv[]) const;
+};
+```
+
+###Example
+```c++
+v8::Local<v8::Function> function;
+Callback callback(function);
+callback->Call(0, 0);
+```

From ec953e5cf815e4167233b520563fb799f0f8ad25 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 14:56:10 +1000
Subject: [PATCH 53/84] docs: added initial methods & gc in methods.md

---
 README.md       | 208 +-----------------------------------
 doc/gc_stats.md | 157 +++++++++++++++++++++++++++
 doc/methods.md  | 279 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 438 insertions(+), 206 deletions(-)
 create mode 100644 doc/gc_stats.md
 create mode 100644 doc/methods.md

diff --git a/README.md b/README.md
index 5d24595b..eda9acfd 100644
--- a/README.md
+++ b/README.md
@@ -254,21 +254,7 @@ NAN_METHOD(CalculateAsync) {
 <a name="api"></a>
 ## API
 
- * <a href="#api_nan_method"><b><code>NAN_METHOD</code></b></a>
- * <a href="#api_nan_getter"><b><code>NAN_GETTER</code></b></a>
- * <a href="#api_nan_setter"><b><code>NAN_SETTER</code></b></a>
- * <a href="#api_nan_property_getter"><b><code>NAN_PROPERTY_GETTER</code></b></a>
- * <a href="#api_nan_property_setter"><b><code>NAN_PROPERTY_SETTER</code></b></a>
- * <a href="#api_nan_property_enumerator"><b><code>NAN_PROPERTY_ENUMERATOR</code></b></a>
- * <a href="#api_nan_property_deleter"><b><code>NAN_PROPERTY_DELETER</code></b></a>
- * <a href="#api_nan_property_query"><b><code>NAN_PROPERTY_QUERY</code></b></a>
- * <a href="#api_nan_index_getter"><b><code>NAN_INDEX_GETTER</code></b></a>
- * <a href="#api_nan_index_setter"><b><code>NAN_INDEX_SETTER</code></b></a>
- * <a href="#api_nan_index_enumerator"><b><code>NAN_INDEX_ENUMERATOR</code></b></a>
- * <a href="#api_nan_index_deleter"><b><code>NAN_INDEX_DELETER</code></b></a>
- * <a href="#api_nan_index_query"><b><code>NAN_INDEX_QUERY</code></b></a>
- * <a href="#api_nan_gc_callback"><b><code>NAN_GC_CALLBACK</code></b></a>
- * <a href="#api_nan_weak_callback"><b><code>NAN_WEAK_CALLBACK</code></b></a>
+ * <a href="#api_nan_weak_callback"><b><code>NAN_WEAK_CALLBACK(callbackname)</code></b></a>
  * <a href="#api_nan_deprecated"><b><code>NAN_DEPRECATED</code></b></a>
  * <a href="#api_nan_inline"><b><code>NAN_INLINE</code></b></a>
  * <a href="#api_nan_new"><b><code>NanNew</code></b></a>
@@ -322,147 +308,12 @@ NAN_METHOD(CalculateAsync) {
  * <a href="#api_nan_compile_script"><b><code>NanCompileScript</code></b></a>
  * <a href="#api_nan_run_script"><b><code>NanRunScript</code></b></a>
  * <a href="#api_nan_adjust_external_memory"><b><code>NanAdjustExternalMemory</code></b></a>
- * <a href="#api_nan_add_gc_epilogue_callback"><b><code>NanAddGCEpilogueCallback</code></b></a>
- * <a href="#api_nan_add_gc_prologue_callback"><b><code>NanAddGCPrologueCallback</code></b></a>
- * <a href="#api_nan_remove_gc_epilogue_callback"><b><code>NanRemoveGCEpilogueCallback</code></b></a>
- * <a href="#api_nan_remove_gc_prologue_callback"><b><code>NanRemoveGCPrologueCallback</code></b></a>
- * <a href="#api_nan_get_heap_statistics"><b><code>NanGetHeapStatistics</code></b></a>
- * <a href="#api_nan_set_counter_function"><b><code>NanSetCounterFunction</code></b></a>
- * <a href="#api_nan_set_create_histogram_function"><b><code>NanSetCreateHistogramFunction</code></b></a>
- * <a href="#api_nan_set_add_histogram_sample_function"><b><code>NanSetAddHistogramSampleFunction</code></b></a>
- * <a href="#api_nan_idle_notification"><b><code>NanIdleNotification</code></b></a>
- * <a href="#api_nan_low_memory_notification"><b><code>NanLowMemoryNotification</code></b></a>
- * <a href="#api_nan_context_disposed_notification"><b><code>NanContextDisposedNotification</code></b></a>
  * <a href="#api_nan_callback"><b><code>NanCallback</code></b></a>
  * <a href="#api_nan_async_worker"><b><code>NanAsyncWorker</code></b></a>
  * <a href="#api_nan_async_queue_worker"><b><code>NanAsyncQueueWorker</code></b></a>
 
-<a name="api_nan_method"></a>
-### NAN_METHOD(methodname)
-
-Use `NAN_METHOD` to define your V8 accessible methods:
-
-```c++
-// .h:
-class Foo : public node::ObjectWrap {
-  ...
-
-  static NAN_METHOD(Bar);
-  static NAN_METHOD(Baz);
-}
-
-
-// .cc:
-NAN_METHOD(Foo::Bar) {
-  ...
-}
-
-NAN_METHOD(Foo::Baz) {
-  ...
-}
-```
-
-The reason for this macro is because of the method signature change in 0.11:
-
-```c++
-// 0.10 and below:
-Handle<Value> name(const Arguments& args)
-
-// 0.11 and above
-void name(const FunctionCallbackInfo<Value>& args)
-```
-
-The introduction of `FunctionCallbackInfo` brings additional complications:
-
-<a name="api_nan_getter"></a>
-### NAN_GETTER(methodname)
-
-Use `NAN_GETTER` to declare your V8 accessible getters. You get a `Local<String>` `property` and an appropriately typed `args` object that can act like the `args` argument to a `NAN_METHOD` call.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_GETTER`.
-
-<a name="api_nan_setter"></a>
-### NAN_SETTER(methodname)
-
-Use `NAN_SETTER` to declare your V8 accessible setters. Same as `NAN_GETTER` but you also get a `Local<Value>` `value` object to work with.
-
-<a name="api_nan_property_getter"></a>
-### NAN_PROPERTY_GETTER(cbname)
-Use `NAN_PROPERTY_GETTER` to declare your V8 accessible property getters. You get a `Local<String>` `property` and an appropriately typed `args` object that can act similar to the `args` argument to a `NAN_METHOD` call.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_GETTER`.
-
-<a name="api_nan_property_setter"></a>
-### NAN_PROPERTY_SETTER(cbname)
-Use `NAN_PROPERTY_SETTER` to declare your V8 accessible property setters. Same as `NAN_PROPERTY_GETTER` but you also get a `Local<Value>` `value` object to work with.
-
-<a name="api_nan_property_enumerator"></a>
-### NAN_PROPERTY_ENUMERATOR(cbname)
-Use `NAN_PROPERTY_ENUMERATOR` to declare your V8 accessible property enumerators. You get an appropriately typed `args` object like the `args` argument to a `NAN_PROPERTY_GETTER` call.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_ENUMERATOR`.
-
-<a name="api_nan_property_deleter"></a>
-### NAN_PROPERTY_DELETER(cbname)
-Use `NAN_PROPERTY_DELETER` to declare your V8 accessible property deleters. Same as `NAN_PROPERTY_GETTER`.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_DELETER`.
-
-<a name="api_nan_property_query"></a>
-### NAN_PROPERTY_QUERY(cbname)
-Use `NAN_PROPERTY_QUERY` to declare your V8 accessible property queries. Same as `NAN_PROPERTY_GETTER`.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_PROPERTY_QUERY`.
-
-<a name="api_nan_index_getter"></a>
-### NAN_INDEX_GETTER(cbname)
-Use `NAN_INDEX_GETTER` to declare your V8 accessible index getters. You get a `uint32_t` `index` and an appropriately typed `args` object that can act similar to the `args` argument to a `NAN_METHOD` call.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_GETTER`.
-
-<a name="api_nan_index_setter"></a>
-### NAN_INDEX_SETTER(cbname)
-Use `NAN_INDEX_SETTER` to declare your V8 accessible index setters. Same as `NAN_INDEX_GETTER` but you also get a `Local<Value>` `value` object to work with.
-
-<a name="api_nan_index_enumerator"></a>
-### NAN_INDEX_ENUMERATOR(cbname)
-Use `NAN_INDEX_ENUMERATOR` to declare your V8 accessible index enumerators. You get an appropriately typed `args` object like the `args` argument to a `NAN_INDEX_GETTER` call.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_ENUMERATOR`.
-
-<a name="api_nan_index_deleter"></a>
-### NAN_INDEX_DELETER(cbname)
-Use `NAN_INDEX_DELETER` to declare your V8 accessible index deleters. Same as `NAN_INDEX_GETTER`.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_DELETER`.
-
-<a name="api_nan_index_query"></a>
-### NAN_INDEX_QUERY(cbname)
-Use `NAN_INDEX_QUERY` to declare your V8 accessible index queries. Same as `NAN_INDEX_GETTER`.
-
-You can use `NanReturnNull()`, `NanReturnEmptyString()`, `NanReturnUndefined()` and `NanReturnValue()` in a `NAN_INDEX_QUERY`.
-
-<a name="api_nan_gc_callback"></a>
-### NAN_GC_CALLBACK(cbname)
-Use `NAN_GC_CALLBACK` to declare your callbacks for `NanAddGCEpilogueCallback` and `NanAddGCPrologueCallback`. You get arguments `GCType type` and `GCCallbackFlags flags`.
-
-```c++
-static Persistent<Function> callback;
-
-NAN_GC_CALLBACK(gcPrologueCallback) {
-  Local<Value> argv[] = {NanNew("prologue")};
-  NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(callback), 1, argv);
-}
-
-NAN_METHOD(Hook) {
-  NanAssignPersistent(callback, args[0].As<Function>());
-  NanAddGCPrologueCallback(gcPrologueCallback);
-  NanReturnValue(args.Holder());
-}
-```
-
 <a name="api_nan_weak_callback"></a>
-### NAN_WEAK_CALLBACK(cbname)
+### NAN_WEAK_CALLBACK(callbackname)
 
 Use `NAN_WEAK_CALLBACK` to define your V8 WeakReference callbacks. There is an argument object `const _NanWeakCallbackData<T, P> &data` allowing access to the weak object and the supplied parameter through its `GetValue` and `GetParameter` methods. You can even access the weak callback info object through the `GetCallbackInfo()`method, but you probably should not. `Revive()` keeps the weak object alive until the next GC round.
 
@@ -1117,61 +968,6 @@ Use to run both bound and unbound scripts.
 
 Simply does `AdjustAmountOfExternalAllocatedMemory`, note that the argument and returned value have type `int`.
 
-<a name="api_nan_add_gc_epilogue_callback"></a>
-### NanAddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type_filter=kGCTypeAll)
-
-Simply does `AddGCEpilogueCallback`
-
-<a name="api_nan_add_gc_prologue_callback"></a>
-### NanAddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type_filter=kGCTypeAll)
-
-Simply does `AddGCPrologueCallback`
-
-<a name="api_nan_remove_gc_epilogue_callback"></a>
-### NanRemoveGCEpilogueCallback(GCEpilogueCallback callback)
-
-Simply does `RemoveGCEpilogueCallback`
-
-<a name="api_nan_remove_gc_prologue_callback"></a>
-### NanRemoveGCPrologueCallback(GCPrologueCallback callback)
-
-Simply does `RemoveGCPrologueCallback`
-
-<a name="api_nan_get_heap_statistics"></a>
-### NanGetHeapStatistics(HeapStatistics *heap_statistics)
-
-Simply does `GetHeapStatistics`
-
-<a name="api_nan_set_counter_function"></a>
-### NanSetCounterFunction(CounterLookupCallback cb)
-
-Simply does `SetCounterFunction`
-
-<a name="api_nan_set_create_histogram_function"></a>
-### NanSetCreateHistogramFunction(CreateHistogramCallback cb)
-
-Simply does `SetCreateHistogramFunction`
-
-<a name="api_nan_set_add_histogram_sample_function"></a>
-### NanSetAddHistogramSampleFunction(AddHistogramSampleCallback cb)
-
-Simply does `SetAddHistogramSampleFunction`
-
-<a name="api_nan_idle_notification"></a>
-### NanIdleNotification(int idle_time_in_ms)
-
-Simply does `IdleNotification`
-
-<a name="api_nan_low_memory_notification"></a>
-### NanLowMemoryNotification()
-
-Simply does `LowMemoryNotification`
-
-<a name="api_nan_context_disposed_notification"></a>
-### NanContextDisposedNotification()
-
-Simply does `ContextDisposedNotification`
-
 <a name="api_nan_callback"></a>
 ### NanCallback
 
diff --git a/doc/gc_stats.md b/doc/gc_stats.md
new file mode 100644
index 00000000..ede08b08
--- /dev/null
+++ b/doc/gc_stats.md
@@ -0,0 +1,157 @@
+Access to internal V8 GC and statistics hooks is different across the supported versions of V8, therefore NAN provides its own hooks that call the appropriate V8 methods.
+
+ - <a href="#api_nan_gc_callback"><b><code>NAN_GC_CALLBACK(callbackname)</code></b></a>
+ - <a href="#api_nan_add_gc_epilogue_callback"><b><code>Nan::AddGCEpilogueCallback</code></b></a
+ - <a href="#api_nan_remove_gc_epilogue_callback"><b><code>Nan::RemoveGCEpilogueCallback</code></b></a
+ - <a href="#api_nan_add_gc_prologue_callback"><b><code>Nan::AddGCPrologueCallback</code></b></a
+ - <a href="#api_nan_remove_gc_prologue_callback"><b><code>Nan::RemoveGCPrologueCallback</code></b></a
+ - <a href="#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics</code></b></a
+ - <a href="#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics</code></b></a>
+ - <a href="#api_nan_set_counter_function"><b><code>Nan::SetCounterFunction</code></b></a>
+ - <a href="#api_nan_set_create_histogram_function"><b><code>Nan::SetCreateHistogramFunction</code></b></a>
+ - <a href="#api_nan_set_add_histogram_sample_function"><b><code>Nan::SetAddHistogramSampleFunction</code></b></a>
+ - <a href="#api_nan_idle_notification"><b><code>Nan::IdleNotification</code></b></a>
+ - <a href="#api_nan_low_memory_notification"><b><code>Nan::LowMemoryNotification</code></b></a>
+ - <a href="#api_nan_context_disposed_notification"><b><code>Nan::ContextDisposedNotification</code></b></a>
+
+<a name="api_nan_gc_callback"></a>
+### NAN_GC_CALLBACK(callbackname)
+
+Use `NAN_GC_CALLBACK` to declare your callbacks for `Nan::AddGCPrologueCallback()` and `Nan::AddGCEpilogueCallback()`. Your new method receives the arguments `v8::GCType type` and `v8::GCCallbackFlags flags`.
+
+```c++
+static Nan::Persistent<Function> callback;
+
+NAN_GC_CALLBACK(gcPrologueCallback) {
+  v8::Local<Value> argv[] = { Nan::New("prologue").ToLocalChecked() };
+  Nan::MakeCallback(Nan::GetCurrentContext()->Global(), Nan::New(callback), 1, argv);
+}
+
+NAN_METHOD(Hook) {
+  callback.Reset(args[0].As<Function>());
+  Nan::AddGCPrologueCallback(gcPrologueCallback);
+  info.GetReturnValue().Set(info.Holder());
+}
+```
+
+<a name="api_nan_add_gc_epilogue_callback"></a>
+### Nan::AddGCEpilogueCallback()
+
+Signature:
+
+```c++
+void Nan::AddGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback, v8::GCType gc_type_filter = v8::kGCTypeAll)
+```
+
+Calls V8's [`AddGCEpilogueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a90d1860babc76059c62514b422f56960).
+
+<a name="api_nan_remove_gc_epilogue_callback"></a>
+### Nan::RemoveGCEpilogueCallback()
+
+Signature:
+
+```c++
+void Nan::RemoveGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback)
+```
+
+Calls V8's [`RemoveGCEpilogueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a05c60859fd4b8e96bfcd451281ed6c7c).
+
+<a name="api_nan_add_gc_prologue_callback"></a>
+### Nan::AddGCPrologueCallback()
+
+Signature:
+
+```c++
+void Nan::AddGCPrologueCallback(v8::Isolate::GCPrologueCallback, v8::GCType gc_type_filter callback)
+```
+
+Calls V8's [`AddGCPrologueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ab4b87b8f9f8e5bf95eba4009357e001f).
+
+<a name="api_nan_remove_gc_prologue_callback"></a>
+### Nan::RemoveGCPrologueCallback()
+
+Signature:
+
+```c++
+void Nan::RemoveGCPrologueCallback(v8::Isolate::GCPrologueCallback callback)
+```
+
+Calls V8's [`RemoveGCEpilogueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a9f6c51932811593f81ff30b949124186).
+
+<a name="api_nan_get_heap_statistics"></a>
+### Nan::GetHeapStatistics()
+
+Signature:
+
+```c++
+void Nan::GetHeapStatistics(v8::HeapStatistics *heap_statistics)
+```
+
+Calls V8's [`GetHeapStatistics`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a5593ac74687b713095c38987e5950b34).
+
+<a name="api_nan_set_counter_function"></a>
+### Nan::SetCounterFunction()
+
+Signature:
+
+```c++
+void Nan::SetCounterFunction(v8::CounterLookupCallback cb)
+```
+
+Calls V8's [`SetCounterFunction`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a045d7754e62fa0ec72ae6c259b29af94).
+
+<a name="api_nan_set_create_histogram_function"></a>
+### Nan::SetCreateHistogramFunction()
+
+Signature:
+
+```c++
+void Nan::SetCreateHistogramFunction(v8::CreateHistogramCallback cb) 
+```
+
+Calls V8's [`SetCreateHistogramFunction`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a542d67e85089cb3f92aadf032f99e732).
+
+<a name="api_nan_set_add_histogram_sample_function"></a>
+### Nan::SetAddHistogramSampleFunction()
+
+Signature:
+
+```c++
+void Nan::SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) 
+```
+
+Calls V8's [`SetAddHistogramSampleFunction`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#aeb420b690bc2c216882d6fdd00ddd3ea).
+
+<a name="api_nan_idle_notification"></a>
+### Nan::IdleNotification()
+
+Signature:
+
+```c++
+void Nan::IdleNotification(v8::HeapStatistics *heap_statistics)
+```
+
+Calls V8's [`IdleNotification` or `IdleNotificationDeadline`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad6a2a02657f5425ad460060652a5a118) depending on V8 version.
+
+<a name="api_nan_low_memory_notification"></a>
+### Nan::LowMemoryNotification()
+
+Signature:
+
+```c++
+void Nan::LowMemoryNotification() 
+```
+
+Calls V8's [`IdleNotification`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a24647f61d6b41f69668094bdcd6ea91f).
+
+<a name="api_nan_context_disposed_notification"></a>
+### Nan::ContextDisposedNotification()
+
+Signature:
+
+```c++
+void Nan::ContextDisposedNotification()
+```
+
+Calls V8's [`ContextDisposedNotification`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad7f5dc559866343fe6cd8db1f134d48b).
+
diff --git a/doc/methods.md b/doc/methods.md
new file mode 100644
index 00000000..b2f95b51
--- /dev/null
+++ b/doc/methods.md
@@ -0,0 +1,279 @@
+Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
+
+* **Method argument types**
+ - <a href="#api_nan_function_callback_info"><b><code>Nan::FunctionCallbackInfo</code></b></a>
+ - <a href="#api_nan_property_callback_info"><b><code>Nan::PropertyCallbackInfo</code></b></a>
+* **Method declarations**
+ - <a href="#api_nan_method"><b>Method declaration</b></a>
+ - <a href="#api_nan_getter"><b>Getter declaration</b></a>
+ - <a href="#api_nan_setter"><b>Setter declaration</b></a>
+ - <a href="#api_nan_property_getter"><b>Property getter declaration</b></a>
+ - <a href="#api_nan_property_setter"><b>Property setter declaration</b></a>
+ - <a href="#api_nan_property_enumerator"><b>Property enumerator declaration</b></a>
+ - <a href="#api_nan_property_deleter"><b>Property deleter declaration</b></a>
+ - <a href="#api_nan_property_query"><b>Property query declaration</b></a>
+ - <a href="#api_nan_index_getter"><b>Index getter declaration</b></a>
+ - <a href="#api_nan_index_setter"><b>Index setter declaration</b></a>
+ - <a href="#api_nan_index_enumerator"><b>Index enumerator declaration</b></a>
+ - <a href="#api_nan_index_deleter"><b>Index deleter declaration</b></a>
+ - <a href="#api_nan_index_query"><b>Index query declaration</b></a>
+
+<a name="api_nan_function_callback_info"></a>
+### Nan::FunctionCallbackInfo
+
+`Nan::FunctionCallbackInfo` should be used in place of [`v8::FunctionCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/dd/d0d/classv8_1_1_function_callback_info.html), even with older versions of Node where `v8::FunctionCallbackInfo` does not exist.
+
+The following methods are available:
+
+* `Nan::ReturnValue<T> GetReturnValue()`
+* `v8::Local<v8::Function> Callee()`
+* `v8::Local<v8::Value> Data()`
+* `v8::Local<v8::Object> Holder()`
+* `bool IsConstructCall()`
+* `int Length()`
+* `v8::Local<v8::Value> operator[](int i)`
+* `v8::Local<v8::Object> This()`
+* `v8::Isolate *GetIsolate()`
+
+See the [`v8::FunctionCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/dd/d0d/classv8_1_1_function_callback_info.html) documentation for usage details on these. Note that `Nan::ReturnValue` is also a mirror of the equivalent `v8::ReturnValue` type for similar reasons.
+
+<a name="api_nan_property_callback_info"></a>
+### Nan::PropertyCallbackInfo
+
+`Nan::PropertyCallbackInfo` should be used in place of [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/dc5/classv8_1_1_property_callback_info.html), even with older versions of Node where `v8::PropertyCallbackInfo` does not exist.
+
+The following methods are available:
+
+* `v8::Isolate* GetIsolate()`
+* `v8::Local<v8::Value> Data()`
+* `v8::Local<v8::Object> This()`
+* `v8::Local<v8::Object> Holder()`
+* `Nan::ReturnValue<T> GetReturnValue()`
+
+See the [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/dc5/classv8_1_1_property_callback_info.html) documentation for usage details on these. Note that `Nan::ReturnValue` is also a mirror of the equivalent `v8::ReturnValue` type for similar reasons.
+
+<a name="api_nan_method"></a>
+### Method declaration
+
+JavaScript-accessible methods should be declared with the following signature:
+
+```c++
+void MethodName(const Nan::FunctionCallbackInfo<v8::Value>& info);
+```
+
+You do not need to declare a new `HandleScope` within a method as one is implicitly created for you.
+
+**Example usage**
+
+```c++
+// .h:
+class Foo : public Nan::ObjectWrap {
+  ...
+
+  static void Bar(const Nan::FunctionCallbackInfo<v8::Value>& info);
+  static void Baz(const Nan::FunctionCallbackInfo<v8::Value>& info);
+}
+
+
+// .cc:
+void Foo::Bar(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+  ...
+}
+
+void Foo::Baz(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+  ...
+}
+```
+
+A helper macro `NAN_METHOD(methodname)` exists, compatible with NAN v1 method declarations.
+
+**Example usage with `NAN_METHOD(methodname)`**
+
+```c++
+// .h:
+class Foo : public Nan::ObjectWrap {
+  ...
+
+  static NAN_METHOD(Bar);
+  static NAN_METHOD(Baz);
+}
+
+
+// .cc:
+NAN_METHOD(Foo::Bar) {
+  ...
+}
+
+NAN_METHOD(Foo::Baz) {
+  ...
+}
+```
+
+
+<a name="api_nan_getter"></a>
+### Getter declaration
+
+JavaScript-accessible getters should be declared with the following signature:
+
+```c++
+void GetterName(v8::Local<v8::String> property,
+                const Nan::PropertyCallbackInfo<v8::Value>& info);
+```
+
+You do not need to declare a new `HandleScope` within a getter as one is implicitly created for you.
+
+A helper macro `NAN_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_setter"></a>
+### Setter declaration
+
+JavaScript-accessible setters should be declared with the following signature:
+
+```c++
+void SetterName(v8::Local<v8::String> property,
+                v8::Local<v8::Value> value,
+                const Nan::PropertyCallbackInfo<v8::Value>& info);
+```
+
+You do not need to declare a new `HandleScope` within a setter as one is implicitly created for you.
+
+A helper macro `NAN_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_property_getter"></a>
+### Property getter declaration
+
+JavaScript-accessible property getters should be declared with the following signature:
+
+```c++
+void PropertyGetterName(v8::Local<v8::String> property,
+                        const Nan::PropertyCallbackInfo<v8::Value>& info);
+```
+
+You do not need to declare a new `HandleScope` within a property getter as one is implicitly created for you.
+
+A helper macro `NAN_PROPERTY_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
+
+
+<a name="api_nan_property_setter"></a>
+### Property setter declaration
+
+JavaScript-accessible property setters should be declared with the following signature:
+
+```c++
+void PropertySetterName(v8::Local<v8::String> property,
+                        v8::Local<v8::Value> value,
+                        const Nan::PropertyCallbackInfo<v8::Value>& info);
+```
+
+You do not need to declare a new `HandleScope` within a property setter as one is implicitly created for you.
+
+A helper macro `NAN_PROPERTY_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_property_enumerator"></a>
+### Property enumerator declaration
+
+JavaScript-accessible property enumerators should be declared with the following signature:
+
+```c++
+void PropertyEnumeratorName(const Nan::PropertyCallbackInfo<v8::Array>& info);
+```
+
+You do not need to declare a new `HandleScope` within a property enumerator as one is implicitly created for you.
+
+A helper macro `NAN_PROPERTY_ENUMERATOR(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_property_deleter"></a>
+### Property deleter declaration
+
+JavaScript-accessible property deleters should be declared with the following signature:
+
+```c++
+void PropertyDeleterName(v8::Local<v8::String> property,
+                         const Nan::PropertyCallbackInfo<v8::Boolean>& info);
+```
+
+You do not need to declare a new `HandleScope` within a property deleter as one is implicitly created for you.
+
+A helper macro `NAN_PROPERTY_DELETER(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_property_query"></a>
+### Property query declaration
+
+JavaScript-accessible property query methods should be declared with the following signature:
+
+```c++
+void PropertyQueryName(v8::Local<v8::String> property,
+                       const Nan::PropertyCallbackInfo<v8::Integer>& info);
+```
+
+You do not need to declare a new `HandleScope` within a property query method as one is implicitly created for you.
+
+A helper macro `NAN_PROPERTY_QUERY(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_index_getter"></a>
+### Index getter declaration
+
+JavaScript-accessible index getter methods should be declared with the following signature:
+
+```c++
+void IndexGetterName(uint32_t index, const PropertyCallbackInfo<v8::Value>& info);
+```
+
+You do not need to declare a new `HandleScope` within a index getter as one is implicitly created for you.
+
+A helper macro `NAN_INDEX_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_index_setter"></a>
+### Index setter declaration
+
+JavaScript-accessible index setter methods should be declared with the following signature:
+
+```c++
+void IndexSetterName(uint32_t index,
+                     v8::Local<v8::Value> value,
+                     const PropertyCallbackInfo<v8::Value>& info);
+```
+
+You do not need to declare a new `HandleScope` within a index setter as one is implicitly created for you.
+
+A helper macro `NAN_INDEX_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_index_enumerator"></a>
+### Index enumerator declaration
+
+JavaScript-accessible index enumerator methods should be declared with the following signature:
+
+```c++
+void IndexEnumeratorName(const PropertyCallbackInfo<v8::Array>& info);
+```
+
+You do not need to declare a new `HandleScope` within a index enumerator as one is implicitly created for you.
+
+A helper macro `NAN_INDEX_ENUMERATOR(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_index_deleter"></a>
+### Index deleter declaration
+
+JavaScript-accessible index deleter methods should be declared with the following signature:
+
+```c++
+void IndexDeleterName(uint32_t index, const PropertyCallbackInfo<v8::Boolean>& info);
+```
+
+You do not need to declare a new `HandleScope` within a index deleter as one is implicitly created for you.
+
+A helper macro `NAN_INDEX_DELETER(methodname)` exists, compatible with NAN v1 method declarations.
+
+<a name="api_nan_index_query"></a>
+### Index query declaration
+
+JavaScript-accessible index query methods should be declared with the following signature:
+
+```c++
+void IndexQueryName(uint32_t index, const PropertyCallbackInfo<v8::Integer>& info);
+```
+
+You do not need to declare a new `HandleScope` within a index query method as one is implicitly created for you.
+
+A helper macro `NAN_INDEX_QUERY(methodname)` exists, compatible with NAN v1 method declarations.
+

From 48f2c62bb06e6df084414c334f50eb9272046bb2 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 20:28:43 +1000
Subject: [PATCH 54/84] doc: added more JS-accessibe methods info

---
 README.md       |  29 -------
 doc/gc_stats.md | 157 --------------------------------------
 doc/methods.md  | 197 ++++++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 184 insertions(+), 199 deletions(-)
 delete mode 100644 doc/gc_stats.md

diff --git a/README.md b/README.md
index eda9acfd..ad07e008 100644
--- a/README.md
+++ b/README.md
@@ -271,8 +271,6 @@ NAN_METHOD(CalculateAsync) {
  * <a href="#api_nan_scope"><b><code>NanScope</code></b></a>
  * <a href="#api_nan_escapable_scope"><b><code>NanEscapableScope</code></b></a>
  * <a href="#api_nan_escape_scope"><b><code>NanEscapeScope</code></b></a>
- * <a href="#api_nan_get_internal_field_pointer"><b><code>NanGetInternalFieldPointer</code></b></a>
- * <a href="#api_nan_set_internal_field_pointer"><b><code>NanSetInternalFieldPointer</code></b></a>
  * <a href="#api_nan_object_wrap_handle"><b><code>NanObjectWrapHandle</code></b></a>
  * <del><a href="#api_nan_symbol"><b><code>NanSymbol</code></b></a></del>
  * <del><a href="#api_nan_get_pointer_safe"><b><code>NanGetPointerSafe</code></b></a></del>
@@ -307,7 +305,6 @@ NAN_METHOD(CalculateAsync) {
  * <a href="#api_nan_decode_write"><b><code>NanDecodeWrite</code></b></a>
  * <a href="#api_nan_compile_script"><b><code>NanCompileScript</code></b></a>
  * <a href="#api_nan_run_script"><b><code>NanRunScript</code></b></a>
- * <a href="#api_nan_adjust_external_memory"><b><code>NanAdjustExternalMemory</code></b></a>
  * <a href="#api_nan_callback"><b><code>NanCallback</code></b></a>
  * <a href="#api_nan_async_worker"><b><code>NanAsyncWorker</code></b></a>
  * <a href="#api_nan_async_queue_worker"><b><code>NanAsyncQueueWorker</code></b></a>
@@ -516,27 +513,6 @@ Handle<String> Foo::Bar() {
 ### Local&lt;T&gt; NanEscapeScope(Handle&lt;T&gt; value);
 Use together with `NanEscapableScope` to escape the scope. Corresponds to `HandleScope::Close` or `EscapableHandleScope::Escape`.
 
-<a name="api_nan_get_internal_field_pointer"></a>
-### void * NanGetInternalFieldPointer(Handle&lt;Object&gt;, int)
-
-Gets a pointer to the internal field with at `index` from a V8 `Object` handle.
-
-```c++
-Local<Object> obj;
-...
-NanGetInternalFieldPointer(obj, 0);
-```
-<a name="api_nan_set_internal_field_pointer"></a>
-### void NanSetInternalFieldPointer(Handle&lt;Object&gt;, int, void *)
-
-Sets the value of the internal field at `index` on a V8 `Object` handle.
-
-```c++
-static Persistent<Function> dataWrapperCtor;
-...
-Local<Object> wrapper = NanNew(dataWrapperCtor)->NewInstance();
-NanSetInternalFieldPointer(wrapper, 0, this);
-```
 
 <a name="api_nan_object_wrap_handle"></a>
 ### Local&lt;Object&gt; NanObjectWrapHandle(const node::ObjectWrap &amp;obj)
@@ -963,11 +939,6 @@ Use to create new scripts bound to the current context.
 
 Use to run both bound and unbound scripts.
 
-<a name="api_nan_adjust_external_memory"></a>
-### NanAdjustExternalMemory(int change_in_bytes)
-
-Simply does `AdjustAmountOfExternalAllocatedMemory`, note that the argument and returned value have type `int`.
-
 <a name="api_nan_callback"></a>
 ### NanCallback
 
diff --git a/doc/gc_stats.md b/doc/gc_stats.md
deleted file mode 100644
index ede08b08..00000000
--- a/doc/gc_stats.md
+++ /dev/null
@@ -1,157 +0,0 @@
-Access to internal V8 GC and statistics hooks is different across the supported versions of V8, therefore NAN provides its own hooks that call the appropriate V8 methods.
-
- - <a href="#api_nan_gc_callback"><b><code>NAN_GC_CALLBACK(callbackname)</code></b></a>
- - <a href="#api_nan_add_gc_epilogue_callback"><b><code>Nan::AddGCEpilogueCallback</code></b></a
- - <a href="#api_nan_remove_gc_epilogue_callback"><b><code>Nan::RemoveGCEpilogueCallback</code></b></a
- - <a href="#api_nan_add_gc_prologue_callback"><b><code>Nan::AddGCPrologueCallback</code></b></a
- - <a href="#api_nan_remove_gc_prologue_callback"><b><code>Nan::RemoveGCPrologueCallback</code></b></a
- - <a href="#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics</code></b></a
- - <a href="#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics</code></b></a>
- - <a href="#api_nan_set_counter_function"><b><code>Nan::SetCounterFunction</code></b></a>
- - <a href="#api_nan_set_create_histogram_function"><b><code>Nan::SetCreateHistogramFunction</code></b></a>
- - <a href="#api_nan_set_add_histogram_sample_function"><b><code>Nan::SetAddHistogramSampleFunction</code></b></a>
- - <a href="#api_nan_idle_notification"><b><code>Nan::IdleNotification</code></b></a>
- - <a href="#api_nan_low_memory_notification"><b><code>Nan::LowMemoryNotification</code></b></a>
- - <a href="#api_nan_context_disposed_notification"><b><code>Nan::ContextDisposedNotification</code></b></a>
-
-<a name="api_nan_gc_callback"></a>
-### NAN_GC_CALLBACK(callbackname)
-
-Use `NAN_GC_CALLBACK` to declare your callbacks for `Nan::AddGCPrologueCallback()` and `Nan::AddGCEpilogueCallback()`. Your new method receives the arguments `v8::GCType type` and `v8::GCCallbackFlags flags`.
-
-```c++
-static Nan::Persistent<Function> callback;
-
-NAN_GC_CALLBACK(gcPrologueCallback) {
-  v8::Local<Value> argv[] = { Nan::New("prologue").ToLocalChecked() };
-  Nan::MakeCallback(Nan::GetCurrentContext()->Global(), Nan::New(callback), 1, argv);
-}
-
-NAN_METHOD(Hook) {
-  callback.Reset(args[0].As<Function>());
-  Nan::AddGCPrologueCallback(gcPrologueCallback);
-  info.GetReturnValue().Set(info.Holder());
-}
-```
-
-<a name="api_nan_add_gc_epilogue_callback"></a>
-### Nan::AddGCEpilogueCallback()
-
-Signature:
-
-```c++
-void Nan::AddGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback, v8::GCType gc_type_filter = v8::kGCTypeAll)
-```
-
-Calls V8's [`AddGCEpilogueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a90d1860babc76059c62514b422f56960).
-
-<a name="api_nan_remove_gc_epilogue_callback"></a>
-### Nan::RemoveGCEpilogueCallback()
-
-Signature:
-
-```c++
-void Nan::RemoveGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback)
-```
-
-Calls V8's [`RemoveGCEpilogueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a05c60859fd4b8e96bfcd451281ed6c7c).
-
-<a name="api_nan_add_gc_prologue_callback"></a>
-### Nan::AddGCPrologueCallback()
-
-Signature:
-
-```c++
-void Nan::AddGCPrologueCallback(v8::Isolate::GCPrologueCallback, v8::GCType gc_type_filter callback)
-```
-
-Calls V8's [`AddGCPrologueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ab4b87b8f9f8e5bf95eba4009357e001f).
-
-<a name="api_nan_remove_gc_prologue_callback"></a>
-### Nan::RemoveGCPrologueCallback()
-
-Signature:
-
-```c++
-void Nan::RemoveGCPrologueCallback(v8::Isolate::GCPrologueCallback callback)
-```
-
-Calls V8's [`RemoveGCEpilogueCallback`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a9f6c51932811593f81ff30b949124186).
-
-<a name="api_nan_get_heap_statistics"></a>
-### Nan::GetHeapStatistics()
-
-Signature:
-
-```c++
-void Nan::GetHeapStatistics(v8::HeapStatistics *heap_statistics)
-```
-
-Calls V8's [`GetHeapStatistics`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a5593ac74687b713095c38987e5950b34).
-
-<a name="api_nan_set_counter_function"></a>
-### Nan::SetCounterFunction()
-
-Signature:
-
-```c++
-void Nan::SetCounterFunction(v8::CounterLookupCallback cb)
-```
-
-Calls V8's [`SetCounterFunction`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a045d7754e62fa0ec72ae6c259b29af94).
-
-<a name="api_nan_set_create_histogram_function"></a>
-### Nan::SetCreateHistogramFunction()
-
-Signature:
-
-```c++
-void Nan::SetCreateHistogramFunction(v8::CreateHistogramCallback cb) 
-```
-
-Calls V8's [`SetCreateHistogramFunction`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a542d67e85089cb3f92aadf032f99e732).
-
-<a name="api_nan_set_add_histogram_sample_function"></a>
-### Nan::SetAddHistogramSampleFunction()
-
-Signature:
-
-```c++
-void Nan::SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) 
-```
-
-Calls V8's [`SetAddHistogramSampleFunction`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#aeb420b690bc2c216882d6fdd00ddd3ea).
-
-<a name="api_nan_idle_notification"></a>
-### Nan::IdleNotification()
-
-Signature:
-
-```c++
-void Nan::IdleNotification(v8::HeapStatistics *heap_statistics)
-```
-
-Calls V8's [`IdleNotification` or `IdleNotificationDeadline`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad6a2a02657f5425ad460060652a5a118) depending on V8 version.
-
-<a name="api_nan_low_memory_notification"></a>
-### Nan::LowMemoryNotification()
-
-Signature:
-
-```c++
-void Nan::LowMemoryNotification() 
-```
-
-Calls V8's [`IdleNotification`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a24647f61d6b41f69668094bdcd6ea91f).
-
-<a name="api_nan_context_disposed_notification"></a>
-### Nan::ContextDisposedNotification()
-
-Signature:
-
-```c++
-void Nan::ContextDisposedNotification()
-```
-
-Calls V8's [`ContextDisposedNotification`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad7f5dc559866343fe6cd8db1f134d48b).
-
diff --git a/doc/methods.md b/doc/methods.md
index b2f95b51..ffdaa124 100644
--- a/doc/methods.md
+++ b/doc/methods.md
@@ -1,3 +1,5 @@
+## JavaScript-accessible methods
+
 Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
 
 * **Method argument types**
@@ -17,6 +19,14 @@ Across the versions of V8 supported by NAN, JavaScript-accessible method signatu
  - <a href="#api_nan_index_enumerator"><b>Index enumerator declaration</b></a>
  - <a href="#api_nan_index_deleter"><b>Index deleter declaration</b></a>
  - <a href="#api_nan_index_query"><b>Index query declaration</b></a>
+* Method and template helpers
+ - <a href="#api_nan_set_method"><b><code>Nan::SetMethod()</code></b></a>
+ - <a href="#api_nan_set_named_property_handler"><b><code>Nan::SetNamedPropertyHandler()</code></b></a>
+ - <a href="#api_nan_set_indexed_property_handler"><b><code>Nan::SetIndexedPropertyHandler()</code></b></a>
+ - <a href="#api_nan_set_prototype_method"><b><code>Nan::SetPrototypeMethod()</code></b></a>
+ - <a href="#api_nan_set_template"><b><code>Nan::SetTemplate()</code></b></a>
+ - <a href="#api_nan_set_prototype_template"><b><code>Nan::SetPrototypeTemplate()</code></b></a>
+ - <a href="#api_nan_set_instance_template"><b><code>Nan::SetInstanceTemplate()</code></b></a>
 
 <a name="api_nan_function_callback_info"></a>
 ### Nan::FunctionCallbackInfo
@@ -55,7 +65,7 @@ See the [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/d
 <a name="api_nan_method"></a>
 ### Method declaration
 
-JavaScript-accessible methods should be declared with the following signature:
+JavaScript-accessible methods should be declared with the following signature to form a `Nan::FunctionCallback`:
 
 ```c++
 void MethodName(const Nan::FunctionCallbackInfo<v8::Value>& info);
@@ -109,11 +119,12 @@ NAN_METHOD(Foo::Baz) {
 }
 ```
 
+Use [`Nan::SetPrototypeMethod`](#api_nan_set_prototype_method) to attach a method to a JavaScript function prototype or [`Nan::SetMethod`](#api_nan_set_method) to attach a method directly on a JavaScript object.
 
 <a name="api_nan_getter"></a>
 ### Getter declaration
 
-JavaScript-accessible getters should be declared with the following signature:
+JavaScript-accessible getters should be declared with the following signature to form a `Nan::GetterCallback`:
 
 ```c++
 void GetterName(v8::Local<v8::String> property,
@@ -127,7 +138,7 @@ A helper macro `NAN_GETTER(methodname)` exists, compatible with NAN v1 method de
 <a name="api_nan_setter"></a>
 ### Setter declaration
 
-JavaScript-accessible setters should be declared with the following signature:
+JavaScript-accessible setters should be declared with the following signature to form a <b><code>Nan::SetterCallback</code></b>:
 
 ```c++
 void SetterName(v8::Local<v8::String> property,
@@ -142,7 +153,7 @@ A helper macro `NAN_SETTER(methodname)` exists, compatible with NAN v1 method de
 <a name="api_nan_property_getter"></a>
 ### Property getter declaration
 
-JavaScript-accessible property getters should be declared with the following signature:
+JavaScript-accessible property getters should be declared with the following signature to form a <b><code>Nan::PropertyGetterCallback</code></b>:
 
 ```c++
 void PropertyGetterName(v8::Local<v8::String> property,
@@ -157,7 +168,7 @@ A helper macro `NAN_PROPERTY_GETTER(methodname)` exists, compatible with NAN v1
 <a name="api_nan_property_setter"></a>
 ### Property setter declaration
 
-JavaScript-accessible property setters should be declared with the following signature:
+JavaScript-accessible property setters should be declared with the following signature to form a <b><code>Nan::PropertySetterCallback</code></b>:
 
 ```c++
 void PropertySetterName(v8::Local<v8::String> property,
@@ -172,7 +183,7 @@ A helper macro `NAN_PROPERTY_SETTER(methodname)` exists, compatible with NAN v1
 <a name="api_nan_property_enumerator"></a>
 ### Property enumerator declaration
 
-JavaScript-accessible property enumerators should be declared with the following signature:
+JavaScript-accessible property enumerators should be declared with the following signature to form a <b><code>Nan::PropertyEnumeratorCallback</code></b>:
 
 ```c++
 void PropertyEnumeratorName(const Nan::PropertyCallbackInfo<v8::Array>& info);
@@ -185,7 +196,7 @@ A helper macro `NAN_PROPERTY_ENUMERATOR(methodname)` exists, compatible with NAN
 <a name="api_nan_property_deleter"></a>
 ### Property deleter declaration
 
-JavaScript-accessible property deleters should be declared with the following signature:
+JavaScript-accessible property deleters should be declared with the following signature to form a <b><code>Nan::PropertyDeleterCallback</code></b>:
 
 ```c++
 void PropertyDeleterName(v8::Local<v8::String> property,
@@ -199,7 +210,7 @@ A helper macro `NAN_PROPERTY_DELETER(methodname)` exists, compatible with NAN v1
 <a name="api_nan_property_query"></a>
 ### Property query declaration
 
-JavaScript-accessible property query methods should be declared with the following signature:
+JavaScript-accessible property query methods should be declared with the following signature to form a <b><code>Nan::PropertyQueryCallback</code></b>:
 
 ```c++
 void PropertyQueryName(v8::Local<v8::String> property,
@@ -213,7 +224,7 @@ A helper macro `NAN_PROPERTY_QUERY(methodname)` exists, compatible with NAN v1 m
 <a name="api_nan_index_getter"></a>
 ### Index getter declaration
 
-JavaScript-accessible index getter methods should be declared with the following signature:
+JavaScript-accessible index getter methods should be declared with the following signature to form a <b><code>Nan::IndexGetterCallback</code></b>:
 
 ```c++
 void IndexGetterName(uint32_t index, const PropertyCallbackInfo<v8::Value>& info);
@@ -226,7 +237,7 @@ A helper macro `NAN_INDEX_GETTER(methodname)` exists, compatible with NAN v1 met
 <a name="api_nan_index_setter"></a>
 ### Index setter declaration
 
-JavaScript-accessible index setter methods should be declared with the following signature:
+JavaScript-accessible index setter methods should be declared with the following signature to form a <b><code>Nan::IndexSetterCallback</code></b>:
 
 ```c++
 void IndexSetterName(uint32_t index,
@@ -241,7 +252,7 @@ A helper macro `NAN_INDEX_SETTER(methodname)` exists, compatible with NAN v1 met
 <a name="api_nan_index_enumerator"></a>
 ### Index enumerator declaration
 
-JavaScript-accessible index enumerator methods should be declared with the following signature:
+JavaScript-accessible index enumerator methods should be declared with the following signature to form a <b><code>Nan::IndexEnumeratorCallback</code></b>:
 
 ```c++
 void IndexEnumeratorName(const PropertyCallbackInfo<v8::Array>& info);
@@ -254,7 +265,7 @@ A helper macro `NAN_INDEX_ENUMERATOR(methodname)` exists, compatible with NAN v1
 <a name="api_nan_index_deleter"></a>
 ### Index deleter declaration
 
-JavaScript-accessible index deleter methods should be declared with the following signature:
+JavaScript-accessible index deleter methods should be declared with the following signature to form a <b><code>Nan::IndexDeleterCallback</code></b>:
 
 ```c++
 void IndexDeleterName(uint32_t index, const PropertyCallbackInfo<v8::Boolean>& info);
@@ -267,7 +278,7 @@ A helper macro `NAN_INDEX_DELETER(methodname)` exists, compatible with NAN v1 me
 <a name="api_nan_index_query"></a>
 ### Index query declaration
 
-JavaScript-accessible index query methods should be declared with the following signature:
+JavaScript-accessible index query methods should be declared with the following signature to form a <b><code>Nan::IndexQueryCallback</code></b>:
 
 ```c++
 void IndexQueryName(uint32_t index, const PropertyCallbackInfo<v8::Integer>& info);
@@ -277,3 +288,163 @@ You do not need to declare a new `HandleScope` within a index query method as on
 
 A helper macro `NAN_INDEX_QUERY(methodname)` exists, compatible with NAN v1 method declarations.
 
+<a name="api_nan_set_method"></a>
+### Nan::SetMethod()
+
+Sets a method with a given name directly on a JavaScript object where the method has the `Nan::FunctionCallback` signature (see <a href="#api_nan_method">Method declaration</a>).
+
+Signature:
+
+```c++
+template<typename T> void Nan::SetMethod(const T &recv,
+                                    const char *name,
+                                    Nan::FunctionCallback callback)
+```
+
+<a name="api_nan_set_prototype_method"></a>
+### Nan::SetPrototypeMethod()
+
+Sets a method with a given name on a `FunctionTemplate`'s prototype where the method has the `Nan::FunctionCallback` signature (see <a href="#api_nan_method">Method declaration</a>).
+
+Signature:
+
+```c++
+void Nan::SetPrototypeMethod(v8::Handle<v8::FunctionTemplate> recv,
+                             const char* name,
+                             Nan::FunctionCallback callback)
+```
+
+<a name="api_nan_set_accessor"></a>
+### Nan::SetAccessor()
+
+Sets getters and setters for a property with a given name on an `ObjectTemplate` or a plain `Object`. Accepts getters with the `Nan::GetterCallback` signature (see <a href="#api_nan_getter">Getter declaration</a>) and setters with the `Nan::SetterCallback` signature (see <a href="#api_nan_setter">Setter declaration</a>).
+
+Signature:
+
+```c++
+void SetAccessor(v8::Handle<v8::ObjectTemplate> tpl,
+                 v8::Handle<v8::String> name,
+                 Nan::GetterCallback getter,
+                 Nan::SetterCallback setter = 0,
+                 v8::Handle<v8::Value> data = v8::Handle<v8::Value>(),
+                 v8::AccessControl settings = v8::DEFAULT,
+                 v8::PropertyAttribute attribute = v8::None,
+                 imp::Sig signature = imp::Sig())
+bool SetAccessor(v8::Handle<v8::Object> obj,
+                 v8::Handle<v8::String> name,
+                 Nan::GetterCallback getter,
+                 Nan::SetterCallback setter = 0,
+                 v8::Handle<v8::Value> data = v8::Handle<v8::Value>(),
+                 v8::AccessControl settings = v8::DEFAULT,
+                 v8::PropertyAttribute attribute = v8::None)
+```
+
+See the V8 [`ObjectTemplate#SetAccessor()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#aa90691622f01269c6a11391d372ca0c5) and [`Object#SetAccessor()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a3f9dee085f5ec346465f1dc924325043) for further information about how to use `Nan::SetAccessor()`.
+
+<a name="api_nan_set_named_property_handler"></a>
+### Nan::SetNamedPropertyHandler()
+
+Sets named property getters, setters, query, deleter and enumerator methods on an `ObjectTemplate`. Accepts:
+
+* Property getters with the `Nan::PropertyGetterCallback` signature (see <a href="#api_nan_property_getter">Property getter declaration</a>)
+* Property setters with the `Nan::PropertySetterCallback` signature (see <a href="#api_nan_property_setter">Property setter declaration</a>)
+* Property query methods with the `Nan::PropertyQueryCallback` signature (see <a href="#api_nan_property_query">Property query declaration</a>)
+* Property deleters with the `Nan::PropertyDeleterCallback` signature (see <a href="#api_nan_property_deleter">Property deleter declaration</a>)
+* Property enumerators with the `Nan::PropertyEnumeratorCallback` signature (see <a href="#api_nan_property_enumerator">Property enumerator declaration</a>)
+
+Signature:
+
+```c++
+void SetNamedPropertyHandler(v8::Handle<v8::ObjectTemplate> tpl,
+                             Nan::PropertyGetterCallback getter,
+                             Nan::PropertySetterCallback setter = 0,
+                             Nan::PropertyQueryCallback query = 0,
+                             Nan::PropertyDeleterCallback deleter = 0,
+                             Nan::PropertyEnumeratorCallback enumerator = 0,
+                             v8::Handle<v8::Value> data = v8::Handle<v8::Value>())
+```
+
+See the V8 [`ObjectTemplate#SetNamedPropertyHandler()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#a34d1cc45b642cd131706663801aadd76) for further information about how to use `Nan::SetNamedPropertyHandler()`.
+
+<a name="api_nan_set_indexed_property_handler"></a>
+### Nan::SetIndexedPropertyHandler()
+
+Sets indexed property getters, setters, query, deleter and enumerator methods on an `ObjectTemplate`. Accepts:
+
+* Indexed property getters with the `Nan::IndexGetterCallback` signature (see <a href="#api_nan_index_getter">Index getter declaration</a>)
+* Indexed property setters with the `Nan::IndexSetterCallback` signature (see <a href="#api_nan_index_setter">Index setter declaration</a>)
+* Indexed property query methods with the `Nan::IndexQueryCallback` signature (see <a href="#api_nan_index_query">Index query declaration</a>)
+* Indexed property deleters with the `Nan::IndexDeleterCallback` signature (see <a href="#api_nan_index_deleter">Index deleter declaration</a>)
+* Indexed property enumerators with the `Nan::IndexEnumeratorCallback` signature (see <a href="#api_nan_index_enumerator">Index enumerator declaration</a>)
+
+Signature:
+
+```c++
+void SetIndexedPropertyHandler(v8::Handle<v8::ObjectTemplate> tpl,
+                             Nan::IndexGetterCallback getter,
+                             Nan::IndexSetterCallback setter = 0,
+                             Nan::IndexQueryCallback query = 0,
+                             Nan::IndexDeleterCallback deleter = 0,
+                             Nan::IndexEnumeratorCallback enumerator = 0,
+                             v8::Handle<v8::Value> data = v8::Handle<v8::Value>())
+```
+
+See the V8 [`ObjectTemplate#SetIndexedPropertyHandler()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#ac0234cbede45d51778bb5f6a32a9e125) for further information about how to use `Nan::SetIndexedPropertyHandler()`.
+
+<a name="api_nan_set_template"></a>
+### Nan::SetTemplate()
+
+Adds properties on an `Object`'s or `Function`'s template.
+
+Signature:
+
+```c++
+void Nan::SetTemplate(v8::Local<v8::Template> templ,
+                      const char *name,
+                      v8::Local<v8::Data> value)
+void Nan::SetTemplate(v8::Local<v8::Template> templ,
+                      v8::Local<v8::String> name,
+                      v8::Local<v8::Data> value,
+                      v8::PropertyAttribute attributes)
+```
+
+Calls the `Template`'s [`Set()`](https://v8docs.nodesource.com/io.js-3.0/db/df7/classv8_1_1_template.html#a2db6a56597bf23c59659c0659e564ddf).
+
+<a name="api_nan_set_prototype_template"></a>
+### Nan::SetPrototypeTemplate()
+
+Adds properties on an `Object`'s or `Function`'s prototype template.
+
+Signature:
+
+```c++
+void Nan::SetPrototypeTemplate(v8::Local<v8::FunctionTemplate> templ,
+                               const char *name,
+                               v8::Handle<v8::Data> value)
+void Nan::SetPrototypeTemplate(v8::Local<v8::FunctionTemplate> templ,
+                               v8::Handle<v8::String> name,
+                               v8::Handle<v8::Data> value,
+                               v8::PropertyAttribute attributes)
+```
+
+Calls the `FunctionTemplate`'s _PrototypeTemplate's_ [`Set()`](https://v8docs.nodesource.com/io.js-3.0/db/df7/classv8_1_1_template.html#a2db6a56597bf23c59659c0659e564ddf).
+
+<a name="api_nan_set_instance_template"></a>
+### Nan::SetInstanceTemplate()
+
+Use to add instance properties on `FunctionTemplate`'s.
+
+Signature:
+
+```c++
+void Nan::SetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ,
+                              const char *name,
+                              v8::Handle<v8::Data> value)
+void Nan::SetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ,
+                              v8::Handle<v8::String> name,
+                              v8::Handle<v8::Data> value,
+                              v8::PropertyAttribute attributes)
+```
+
+Calls the `FunctionTemplate`'s _InstanceTemplate's_ [`Set()`](https://v8docs.nodesource.com/io.js-3.0/db/df7/classv8_1_1_template.html#a2db6a56597bf23c59659c0659e564ddf).
+

From d6fdd4f96f1b5d5d3ae647175f1b8df56ccecc49 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 20:57:46 +1000
Subject: [PATCH 55/84] doc: merged callbacks.md docs into methods.md

---
 doc/callbacks.md | 108 --------------------------
 doc/methods.md   | 193 +++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 171 insertions(+), 130 deletions(-)
 delete mode 100644 doc/callbacks.md

diff --git a/doc/callbacks.md b/doc/callbacks.md
deleted file mode 100644
index 42923985..00000000
--- a/doc/callbacks.md
+++ /dev/null
@@ -1,108 +0,0 @@
-#Callbacks
-V8 can call back to your code through these functions.
-
-##Types
-```c++
-typedef void(*FunctionCallback)(const FunctionCallbackInfo<v8::Value>&);
-typedef void(*GetterCallback)
-    (v8::Local<v8::String>, const PropertyCallbackInfo<v8::Value>&);
-typedef void(*SetterCallback)(
-    v8::Local<v8::String>,
-    v8::Local<v8::Value>,
-    const PropertyCallbackInfo<void>&);
-typedef void(*PropertyGetterCallback)(
-    v8::Local<v8::String>,
-    const PropertyCallbackInfo<v8::Value>&);
-typedef void(*PropertySetterCallback)(
-    v8::Local<v8::String>,
-    v8::Local<v8::Value>,
-    const PropertyCallbackInfo<v8::Value>&);
-typedef void(*PropertyEnumeratorCallback)
-    (const PropertyCallbackInfo<v8::Array>&);
-typedef void(*PropertyDeleterCallback)(
-    v8::Local<v8::String>,
-    const PropertyCallbackInfo<v8::Boolean>&);
-typedef void(*PropertyQueryCallback)(
-    v8::Local<v8::String>,
-    const PropertyCallbackInfo<v8::Integer>&);
-typedef void(*IndexGetterCallback)(
-    uint32_t,
-    const PropertyCallbackInfo<v8::Value>&);
-typedef void(*IndexSetterCallback)(
-    uint32_t,
-    v8::Local<v8::Value>,
-    const PropertyCallbackInfo<v8::Value>&);
-typedef void(*IndexEnumeratorCallback)
-    (const PropertyCallbackInfo<v8::Array>&);
-typedef void(*IndexDeleterCallback)(
-    uint32_t,
-    const PropertyCallbackInfo<v8::Boolean>&);
-typedef void(*IndexQueryCallback)(
-    uint32_t,
-    const PropertyCallbackInfo<v8::Integer>&);
-```
-
-##ReturnValue
-Used for setting the return value in callbacks.
-```c++
-template<typename T>
-class ReturnValue {
- public:
-  // Handle setters
-  template <typename S> inline void Set(const v8::Handle<S> &handle);
-  template <typename S> inline void Set(const Global<S> &handle);
-
-  // Fast primitive setters
-  inline void Set(bool value);
-  inline void Set(double i);
-  inline void Set(int32_t i);
-  inline void Set(uint32_t i);
-
-  // Fast JS primitive setters
-  inline void SetNull();
-  inline void SetUndefined();
-  inline void SetEmptyString();
-
-  // Convenience getter for isolate
-  inline v8::Isolate *GetIsolate() const;
-};
-```
-
-##FunctionCallbackInfo
-The argument information given to function call callbacks.  This
-class provides access to information about the context of the call,
-including the receiver, the number and values of arguments, and
-the holder of the function.
-```c++
-template<typename T>
-class FunctionCallbackInfo {
- public:
-  ReturnValue<T> GetReturnValue() const;
-
-  v8::Local<v8::Function> Callee();
-  v8::Local<v8::Value> Data();
-  v8::Local<v8::Object> Holder();
-  bool IsConstructCall();
-  int Length() const;
-  v8::Local<v8::Value> operator[](int i) const;
-  v8::Local<v8::Object> This() const;
-  v8::Isolate *GetIsolate() const;
-};
-```
-
-##PropertyCallbackInfo
-The information passed to a property callback about the context of the property access.
-This class provides access to information about the context of the access, including the
-receiver and the holder of the property.
-```c++
-template<typename T>
-class PropertyCallbackInfo : public PropertyCallbackInfoBase<T> {
- public:
-  ReturnValue<T> GetReturnValue() const;
-
-  v8::Isolate* GetIsolate() const;
-  v8::Local<v8::Value> Data() const;
-  v8::Local<v8::Object> This() const;
-  v8::Local<v8::Object> Holder() const;
-};
-```
diff --git a/doc/methods.md b/doc/methods.md
index ffdaa124..e56aaa04 100644
--- a/doc/methods.md
+++ b/doc/methods.md
@@ -5,6 +5,7 @@ Across the versions of V8 supported by NAN, JavaScript-accessible method signatu
 * **Method argument types**
  - <a href="#api_nan_function_callback_info"><b><code>Nan::FunctionCallbackInfo</code></b></a>
  - <a href="#api_nan_property_callback_info"><b><code>Nan::PropertyCallbackInfo</code></b></a>
+ - <a href="#api_nan_property_callback_info"><b><code>Nan::ReturnValue</code></b></a>
 * **Method declarations**
  - <a href="#api_nan_method"><b>Method declaration</b></a>
  - <a href="#api_nan_getter"><b>Getter declaration</b></a>
@@ -33,34 +34,84 @@ Across the versions of V8 supported by NAN, JavaScript-accessible method signatu
 
 `Nan::FunctionCallbackInfo` should be used in place of [`v8::FunctionCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/dd/d0d/classv8_1_1_function_callback_info.html), even with older versions of Node where `v8::FunctionCallbackInfo` does not exist.
 
-The following methods are available:
+Definition:
 
-* `Nan::ReturnValue<T> GetReturnValue()`
-* `v8::Local<v8::Function> Callee()`
-* `v8::Local<v8::Value> Data()`
-* `v8::Local<v8::Object> Holder()`
-* `bool IsConstructCall()`
-* `int Length()`
-* `v8::Local<v8::Value> operator[](int i)`
-* `v8::Local<v8::Object> This()`
-* `v8::Isolate *GetIsolate()`
+```c++
+template<typename T> class FunctionCallbackInfo {
+ public:
+  ReturnValue<T> GetReturnValue() const;
+  v8::Local<v8::Function> Callee();
+  v8::Local<v8::Value> Data();
+  v8::Local<v8::Object> Holder();
+  bool IsConstructCall();
+  int Length() const;
+  v8::Local<v8::Value> operator[](int i) const;
+  v8::Local<v8::Object> This() const;
+  v8::Isolate *GetIsolate() const;
+};
+```
 
-See the [`v8::FunctionCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/dd/d0d/classv8_1_1_function_callback_info.html) documentation for usage details on these. Note that `Nan::ReturnValue` is also a mirror of the equivalent `v8::ReturnValue` type for similar reasons.
+See the [`v8::FunctionCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/dd/d0d/classv8_1_1_function_callback_info.html) documentation for usage details on these. See [`Nan::ReturnValue`](#api_nan_return_value) for further information on how to set a return value from methods.
 
 <a name="api_nan_property_callback_info"></a>
 ### Nan::PropertyCallbackInfo
 
 `Nan::PropertyCallbackInfo` should be used in place of [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/dc5/classv8_1_1_property_callback_info.html), even with older versions of Node where `v8::PropertyCallbackInfo` does not exist.
 
-The following methods are available:
+Definition:
+
+```c++
+template<typename T> class PropertyCallbackInfo : public PropertyCallbackInfoBase<T> {
+ public:
+  ReturnValue<T> GetReturnValue() const;
+  v8::Isolate* GetIsolate() const;
+  v8::Local<v8::Value> Data() const;
+  v8::Local<v8::Object> This() const;
+  v8::Local<v8::Object> Holder() const;
+};
+```
+
+See the [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/dc5/classv8_1_1_property_callback_info.html) documentation for usage details on these. See [`Nan::ReturnValue`](#api_nan_return_value) for further information on how to set a return value from property accessor methods.
+
+<a name="api_nan_return_value"></a>
+### Nan::ReturnValue
 
-* `v8::Isolate* GetIsolate()`
-* `v8::Local<v8::Value> Data()`
-* `v8::Local<v8::Object> This()`
-* `v8::Local<v8::Object> Holder()`
-* `Nan::ReturnValue<T> GetReturnValue()`
+`Nan::ReturnValue` is used in place of [`v8::ReturnValue](https://v8docs.nodesource.com/io.js-3.0/da/da7/classv8_1_1_return_value.html) on both [`Nan::FunctionCallbackInfo`](#api_nan_function_callback_info) and [`Nan::PropertyCallbackInfo`](#api_nan_property_callback_info) as the return type of `GetReturnValue()`.
 
-See the [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/dc5/classv8_1_1_property_callback_info.html) documentation for usage details on these. Note that `Nan::ReturnValue` is also a mirror of the equivalent `v8::ReturnValue` type for similar reasons.
+Example usage:
+
+```c++
+void EmptyArray(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(Nan::New<v8::Array>());
+}
+```
+
+Definition:
+
+```c++
+template<typename T> class ReturnValue {
+ public:
+  // Handle setters
+  template <typename S> void Set(const v8::Local<S> &handle);
+  template <typename S> void Set(const Nan::Global<S> &handle);
+
+  // Fast primitive setters
+  void Set(bool value);
+  void Set(double i);
+  void Set(int32_t i);
+  void Set(uint32_t i);
+
+  // Fast JS primitive setters
+  void SetNull();
+  void SetUndefined();
+  void SetEmptyString();
+
+  // Convenience getter for isolate
+  v8::Isolate *GetIsolate() const;
+};
+```
+
+See the documentation on [`v8::ReturnValue](https://v8docs.nodesource.com/io.js-3.0/da/da7/classv8_1_1_return_value.html) for further information on this.
 
 <a name="api_nan_method"></a>
 ### Method declaration
@@ -68,9 +119,16 @@ See the [`v8::PropertyCallbackInfo](https://v8docs.nodesource.com/io.js-3.0/d7/d
 JavaScript-accessible methods should be declared with the following signature to form a `Nan::FunctionCallback`:
 
 ```c++
-void MethodName(const Nan::FunctionCallbackInfo<v8::Value>& info);
+typedef void(*FunctionCallback)(const FunctionCallbackInfo<v8::Value>&);
 ```
 
+Example:
+
+```c++
+void MethodName(const Nan::FunctionCallbackInfo<v8::Value>& info) {
+  ...
+}
+
 You do not need to declare a new `HandleScope` within a method as one is implicitly created for you.
 
 **Example usage**
@@ -126,9 +184,18 @@ Use [`Nan::SetPrototypeMethod`](#api_nan_set_prototype_method) to attach a metho
 
 JavaScript-accessible getters should be declared with the following signature to form a `Nan::GetterCallback`:
 
+```c++
+typedef void(*GetterCallback)(v8::Local<v8::String>,
+                              const PropertyCallbackInfo<v8::Value>&);
+```
+
+Example:
+
 ```c++
 void GetterName(v8::Local<v8::String> property,
-                const Nan::PropertyCallbackInfo<v8::Value>& info);
+                const Nan::PropertyCallbackInfo<v8::Value>& info) {
+  ...
+}
 ```
 
 You do not need to declare a new `HandleScope` within a getter as one is implicitly created for you.
@@ -140,10 +207,20 @@ A helper macro `NAN_GETTER(methodname)` exists, compatible with NAN v1 method de
 
 JavaScript-accessible setters should be declared with the following signature to form a <b><code>Nan::SetterCallback</code></b>:
 
+```c++
+typedef void(*SetterCallback)(v8::Local<v8::String>,
+                              v8::Local<v8::Value>,
+                              const PropertyCallbackInfo<void>&);
+```
+
+Example:
+
 ```c++
 void SetterName(v8::Local<v8::String> property,
                 v8::Local<v8::Value> value,
-                const Nan::PropertyCallbackInfo<v8::Value>& info);
+                const Nan::PropertyCallbackInfo<v8::Value>& info) {
+  ...
+}
 ```
 
 You do not need to declare a new `HandleScope` within a setter as one is implicitly created for you.
@@ -155,9 +232,18 @@ A helper macro `NAN_SETTER(methodname)` exists, compatible with NAN v1 method de
 
 JavaScript-accessible property getters should be declared with the following signature to form a <b><code>Nan::PropertyGetterCallback</code></b>:
 
+```c++
+typedef void(*PropertyGetterCallback)(v8::Local<v8::String>,
+                                      const PropertyCallbackInfo<v8::Value>&);
+```
+
+Example:
+
 ```c++
 void PropertyGetterName(v8::Local<v8::String> property,
-                        const Nan::PropertyCallbackInfo<v8::Value>& info);
+                        const Nan::PropertyCallbackInfo<v8::Value>& info) {
+  ...
+}
 ```
 
 You do not need to declare a new `HandleScope` within a property getter as one is implicitly created for you.
@@ -170,6 +256,14 @@ A helper macro `NAN_PROPERTY_GETTER(methodname)` exists, compatible with NAN v1
 
 JavaScript-accessible property setters should be declared with the following signature to form a <b><code>Nan::PropertySetterCallback</code></b>:
 
+```c++
+typedef void(*PropertySetterCallback)(v8::Local<v8::String>,
+                                      v8::Local<v8::Value>,
+                                      const PropertyCallbackInfo<v8::Value>&);
+```
+
+Example:
+
 ```c++
 void PropertySetterName(v8::Local<v8::String> property,
                         v8::Local<v8::Value> value,
@@ -185,6 +279,12 @@ A helper macro `NAN_PROPERTY_SETTER(methodname)` exists, compatible with NAN v1
 
 JavaScript-accessible property enumerators should be declared with the following signature to form a <b><code>Nan::PropertyEnumeratorCallback</code></b>:
 
+```c++
+typedef void(*PropertyEnumeratorCallback)(const PropertyCallbackInfo<v8::Array>&);
+```
+
+Example:
+
 ```c++
 void PropertyEnumeratorName(const Nan::PropertyCallbackInfo<v8::Array>& info);
 ```
@@ -198,6 +298,13 @@ A helper macro `NAN_PROPERTY_ENUMERATOR(methodname)` exists, compatible with NAN
 
 JavaScript-accessible property deleters should be declared with the following signature to form a <b><code>Nan::PropertyDeleterCallback</code></b>:
 
+```c++
+typedef void(*PropertyDeleterCallback)(v8::Local<v8::String>,
+                                       const PropertyCallbackInfo<v8::Boolean>&);
+```
+
+Example:
+
 ```c++
 void PropertyDeleterName(v8::Local<v8::String> property,
                          const Nan::PropertyCallbackInfo<v8::Boolean>& info);
@@ -212,6 +319,13 @@ A helper macro `NAN_PROPERTY_DELETER(methodname)` exists, compatible with NAN v1
 
 JavaScript-accessible property query methods should be declared with the following signature to form a <b><code>Nan::PropertyQueryCallback</code></b>:
 
+```c++
+typedef void(*PropertyQueryCallback)(v8::Local<v8::String>,
+                                     const PropertyCallbackInfo<v8::Integer>&);
+```
+
+Example:
+
 ```c++
 void PropertyQueryName(v8::Local<v8::String> property,
                        const Nan::PropertyCallbackInfo<v8::Integer>& info);
@@ -226,6 +340,13 @@ A helper macro `NAN_PROPERTY_QUERY(methodname)` exists, compatible with NAN v1 m
 
 JavaScript-accessible index getter methods should be declared with the following signature to form a <b><code>Nan::IndexGetterCallback</code></b>:
 
+```c++
+typedef void(*IndexGetterCallback)(uint32_t,
+                                   const PropertyCallbackInfo<v8::Value>&);
+```
+
+Example:
+
 ```c++
 void IndexGetterName(uint32_t index, const PropertyCallbackInfo<v8::Value>& info);
 ```
@@ -239,6 +360,14 @@ A helper macro `NAN_INDEX_GETTER(methodname)` exists, compatible with NAN v1 met
 
 JavaScript-accessible index setter methods should be declared with the following signature to form a <b><code>Nan::IndexSetterCallback</code></b>:
 
+```c++
+typedef void(*IndexSetterCallback)(uint32_t,
+                                   v8::Local<v8::Value>,
+                                   const PropertyCallbackInfo<v8::Value>&);
+```
+
+Example:
+
 ```c++
 void IndexSetterName(uint32_t index,
                      v8::Local<v8::Value> value,
@@ -254,6 +383,12 @@ A helper macro `NAN_INDEX_SETTER(methodname)` exists, compatible with NAN v1 met
 
 JavaScript-accessible index enumerator methods should be declared with the following signature to form a <b><code>Nan::IndexEnumeratorCallback</code></b>:
 
+```c++
+typedef void(*IndexEnumeratorCallback)(const PropertyCallbackInfo<v8::Array>&);
+```
+
+Example:
+
 ```c++
 void IndexEnumeratorName(const PropertyCallbackInfo<v8::Array>& info);
 ```
@@ -267,6 +402,13 @@ A helper macro `NAN_INDEX_ENUMERATOR(methodname)` exists, compatible with NAN v1
 
 JavaScript-accessible index deleter methods should be declared with the following signature to form a <b><code>Nan::IndexDeleterCallback</code></b>:
 
+```c++
+typedef void(*IndexDeleterCallback)(uint32_t,
+                                    const PropertyCallbackInfo<v8::Boolean>&);
+```
+
+Example:
+
 ```c++
 void IndexDeleterName(uint32_t index, const PropertyCallbackInfo<v8::Boolean>& info);
 ```
@@ -280,6 +422,13 @@ A helper macro `NAN_INDEX_DELETER(methodname)` exists, compatible with NAN v1 me
 
 JavaScript-accessible index query methods should be declared with the following signature to form a <b><code>Nan::IndexQueryCallback</code></b>:
 
+```c++
+typedef void(*IndexQueryCallback)(uint32_t,
+                                  const PropertyCallbackInfo<v8::Integer>&);
+```
+
+Example:
+
 ```c++
 void IndexQueryName(uint32_t index, const PropertyCallbackInfo<v8::Integer>& info);
 ```

From e81b34b73e2f43317fa2256d6e23ae650eb33e16 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 21:05:18 +1000
Subject: [PATCH 56/84] doc: added v8_internals.md

---
 README.md           |  18 ----
 doc/v8_internals.md | 200 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 200 insertions(+), 18 deletions(-)
 create mode 100644 doc/v8_internals.md

diff --git a/README.md b/README.md
index ad07e008..a2418cac 100644
--- a/README.md
+++ b/README.md
@@ -292,9 +292,6 @@ NAN_METHOD(CalculateAsync) {
  * <a href="#api_nan_dispose_persistent"><b><code>NanDisposePersistent</code></b></a>
  * <a href="#api_nan_assign_persistent"><b><code>NanAssignPersistent</code></b></a>
  * <a href="#api_nan_make_weak_persistent"><b><code>NanMakeWeakPersistent</code></b></a>
- * <a href="#api_nan_set_template"><b><code>NanSetTemplate</code></b></a>
- * <a href="#api_nan_set_prototype_template"><b><code>NanSetPrototypeTemplate</code></b></a>
- * <a href="#api_nan_set_instance_template"><b><code>NanSetInstanceTemplate</code></b></a>
  * <a href="#api_nan_make_callback"><b><code>NanMakeCallback</code></b></a>
  * <a href="#api_nan_fatal_exception"><b><code>NanFatalException</code></b></a>
  * <a href="#api_nan_errno_exception"><b><code>NanErrnoException</code></b></a>
@@ -874,21 +871,6 @@ int *parameter = new int(0);
 NanMakeWeakPersistent(func, parameter, &weakCallback);
 ```
 
-<a name="api_nan_set_template"></a>
-### NanSetTemplate(templ, name, value [, attributes])
-
-Use to add properties on object and function templates.
-
-<a name="api_nan_set_prototype_template"></a>
-### NanSetPrototypeTemplate(templ, name, value [, attributes])
-
-Use to add prototype properties on function templates.
-
-<a name="api_nan_set_instance_template"></a>
-### NanSetInstanceTemplate(templ, name, value [, attributes])
-
-Use to add instance properties on function templates.
-
 <a name="api_nan_make_callback"></a>
 ### NanMakeCallback(target, func, argc, argv)
 
diff --git a/doc/v8_internals.md b/doc/v8_internals.md
new file mode 100644
index 00000000..bfbce869
--- /dev/null
+++ b/doc/v8_internals.md
@@ -0,0 +1,200 @@
+## V8 internals
+
+The hooks to access V8 internals—including GC and statistics—are different across the supported versions of V8, therefore NAN provides its own hooks that call the appropriate V8 methods.
+
+ - <a href="#api_nan_gc_callback"><b><code>NAN_GC_CALLBACK()</code></b></a>
+ - <a href="#api_nan_add_gc_epilogue_callback"><b><code>Nan::AddGCEpilogueCallback()</code></b></a
+ - <a href="#api_nan_remove_gc_epilogue_callback"><b><code>Nan::RemoveGCEpilogueCallback()</code></b></a
+ - <a href="#api_nan_add_gc_prologue_callback"><b><code>Nan::AddGCPrologueCallback()</code></b></a
+ - <a href="#api_nan_remove_gc_prologue_callback"><b><code>Nan::RemoveGCPrologueCallback()</code></b></a
+ - <a href="#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics()</code></b></a
+ - <a href="#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics()</code></b></a>
+ - <a href="#api_nan_set_counter_function"><b><code>Nan::SetCounterFunction()</code></b></a>
+ - <a href="#api_nan_set_create_histogram_function"><b><code>Nan::SetCreateHistogramFunction()</code></b></a>
+ - <a href="#api_nan_set_add_histogram_sample_function"><b><code>Nan::SetAddHistogramSampleFunction()</code></b></a>
+ - <a href="#api_nan_idle_notification"><b><code>Nan::IdleNotification()</code></b></a>
+ - <a href="#api_nan_low_memory_notification"><b><code>Nan::LowMemoryNotification()</code></b></a>
+ - <a href="#api_nan_context_disposed_notification"><b><code>Nan::ContextDisposedNotification()</code></b></a>
+ - <a href="#api_nan_get_internal_field_pointer"><b><code>Nan::GetInternalFieldPointer()</code></b></a>
+ - <a href="#api_nan_set_internal_field_pointer"><b><code>Nan::SetInternalFieldPointer()</code></b></a>
+ - <a href="#api_nan_adjust_external_memory"><b><code>Nan::AdjustExternalMemory()</code></b></a>
+
+
+<a name="api_nan_gc_callback"></a>
+### NAN_GC_CALLBACK(callbackname)
+
+Use `NAN_GC_CALLBACK` to declare your callbacks for `Nan::AddGCPrologueCallback()` and `Nan::AddGCEpilogueCallback()`. Your new method receives the arguments `v8::GCType type` and `v8::GCCallbackFlags flags`.
+
+```c++
+static Nan::Persistent<Function> callback;
+
+NAN_GC_CALLBACK(gcPrologueCallback) {
+  v8::Local<Value> argv[] = { Nan::New("prologue").ToLocalChecked() };
+  Nan::MakeCallback(Nan::GetCurrentContext()->Global(), Nan::New(callback), 1, argv);
+}
+
+NAN_METHOD(Hook) {
+  callback.Reset(args[0].As<Function>());
+  Nan::AddGCPrologueCallback(gcPrologueCallback);
+  info.GetReturnValue().Set(info.Holder());
+}
+```
+
+<a name="api_nan_add_gc_epilogue_callback"></a>
+### Nan::AddGCEpilogueCallback()
+
+Signature:
+
+```c++
+void Nan::AddGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback, v8::GCType gc_type_filter = v8::kGCTypeAll)
+```
+
+Calls V8's [`AddGCEpilogueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a90d1860babc76059c62514b422f56960).
+
+<a name="api_nan_remove_gc_epilogue_callback"></a>
+### Nan::RemoveGCEpilogueCallback()
+
+Signature:
+
+```c++
+void Nan::RemoveGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback)
+```
+
+Calls V8's [`RemoveGCEpilogueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a05c60859fd4b8e96bfcd451281ed6c7c).
+
+<a name="api_nan_add_gc_prologue_callback"></a>
+### Nan::AddGCPrologueCallback()
+
+Signature:
+
+```c++
+void Nan::AddGCPrologueCallback(v8::Isolate::GCPrologueCallback, v8::GCType gc_type_filter callback)
+```
+
+Calls V8's [`AddGCPrologueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ab4b87b8f9f8e5bf95eba4009357e001f).
+
+<a name="api_nan_remove_gc_prologue_callback"></a>
+### Nan::RemoveGCPrologueCallback()
+
+Signature:
+
+```c++
+void Nan::RemoveGCPrologueCallback(v8::Isolate::GCPrologueCallback callback)
+```
+
+Calls V8's [`RemoveGCEpilogueCallback()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a9f6c51932811593f81ff30b949124186).
+
+<a name="api_nan_get_heap_statistics"></a>
+### Nan::GetHeapStatistics()
+
+Signature:
+
+```c++
+void Nan::GetHeapStatistics(v8::HeapStatistics *heap_statistics)
+```
+
+Calls V8's [`GetHeapStatistics()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a5593ac74687b713095c38987e5950b34).
+
+<a name="api_nan_set_counter_function"></a>
+### Nan::SetCounterFunction()
+
+Signature:
+
+```c++
+void Nan::SetCounterFunction(v8::CounterLookupCallback cb)
+```
+
+Calls V8's [`SetCounterFunction()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a045d7754e62fa0ec72ae6c259b29af94).
+
+<a name="api_nan_set_create_histogram_function"></a>
+### Nan::SetCreateHistogramFunction()
+
+Signature:
+
+```c++
+void Nan::SetCreateHistogramFunction(v8::CreateHistogramCallback cb) 
+```
+
+Calls V8's [`SetCreateHistogramFunction()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a542d67e85089cb3f92aadf032f99e732).
+
+<a name="api_nan_set_add_histogram_sample_function"></a>
+### Nan::SetAddHistogramSampleFunction()
+
+Signature:
+
+```c++
+void Nan::SetAddHistogramSampleFunction(v8::AddHistogramSampleCallback cb) 
+```
+
+Calls V8's [`SetAddHistogramSampleFunction()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#aeb420b690bc2c216882d6fdd00ddd3ea).
+
+<a name="api_nan_idle_notification"></a>
+### Nan::IdleNotification()
+
+Signature:
+
+```c++
+void Nan::IdleNotification(v8::HeapStatistics *heap_statistics)
+```
+
+Calls V8's [`IdleNotification()` or `IdleNotificationDeadline()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad6a2a02657f5425ad460060652a5a118) depending on V8 version.
+
+<a name="api_nan_low_memory_notification"></a>
+### Nan::LowMemoryNotification()
+
+Signature:
+
+```c++
+void Nan::LowMemoryNotification() 
+```
+
+Calls V8's [`IdleNotification()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a24647f61d6b41f69668094bdcd6ea91f).
+
+<a name="api_nan_context_disposed_notification"></a>
+### Nan::ContextDisposedNotification()
+
+Signature:
+
+```c++
+void Nan::ContextDisposedNotification()
+```
+
+Calls V8's [`ContextDisposedNotification()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad7f5dc559866343fe6cd8db1f134d48b).
+
+<a name="api_nan_get_internal_field_pointer"></a>
+### Nan::GetInternalFieldPointer()
+
+Gets a pointer to the internal field with at `index` from a V8 `Object` handle.
+
+Signature:
+
+```c++
+void* Nan::GetInternalFieldPointer(v8::Local<v8::Object> object, int index) 
+```
+
+Calls the Object's [`GetAlignedPointerFromInternalField()` or `GetPointerFromInternalField()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab3c57184263cf29963ef0017bec82281) depending on the version of V8.
+
+<a name="api_nan_set_internal_field_pointer"></a>
+### Nan::SetInternalFieldPointer()
+
+Sets the value of the internal field at `index` on a V8 `Object` handle.
+
+Signature:
+
+```c++
+void Nan::SetInternalFieldPointer(v8::Local<v8::Object> object, int index, void* value)
+```
+
+Calls the Object's [`SetAlignedPointerInInternalField()` or `SetPointerInInternalField()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ad7f5dc559866343fe6cd8db1f134d48b) depending on the version of V8.
+
+<a name="api_nan_adjust_external_memory"></a>
+### Nan::AdjustExternalMemory()
+
+Signature:
+
+```c++
+int Nan::AdjustExternalMemory(int bytesChange)
+```
+
+Calls V8's [`AdjustAmountOfExternalAllocatedMemory()` or `AdjustAmountOfExternalAllocatedMemory()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#ae1a59cac60409d3922582c4af675473e) depending on the version of V8.
+

From b0528ad489ba5c1bda00770b94a3623db88c9a44 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 21:45:03 +1000
Subject: [PATCH 57/84] doc: clean up and extend persistent.md

---
 doc/persistent.md | 192 +++++++++++++++++++++++++++-------------------
 1 file changed, 115 insertions(+), 77 deletions(-)

diff --git a/doc/persistent.md b/doc/persistent.md
index 898ee221..d22410cd 100644
--- a/doc/persistent.md
+++ b/doc/persistent.md
@@ -1,53 +1,59 @@
-# Persistent
-An object reference that is independent of any handle scope. Where a Local
-handle only lives as long as the `HandleScope` in which it was allocated,
-a `Persistent` handle remains valid until it is explicitly disposed.
-
-## PersistentBase
-A persistent handle contains a reference to a storage cell within
-the v8 engine which holds an object value and which is updated by
-the garbage collector whenever the object is moved.  A new storage
-cell can be created using the constructor or `PersistentBase::Reset`.
-Existing handles can be disposed using `PersistentBase::Reset`.
+## Persistent references
+
+An object reference that is independent of any `HandleScope` is a _persistent_ reference. Where a `Local` handle only lives as long as the `HandleScope` in which it was allocated, a `Persistent` handle remains valid until it is explicitly disposed.
+
+Due to the evolution of the V8 API, it is necessary for NAN to provide a wrapper implementation of the `Persistent` classes to supply compatibility across the V8 versions supported.
+
+ - <a href="#api_nan_persistent_base"><b><code>Nan::PersistentBase & v8::PersistentBase</code></b></a>
+ - <a href="#api_nan_non_copyable_persistent_traits"><b><code>Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits</code></b></a>
+ - <a href="#api_nan_copyable_persistent_traits"><b><code>Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits</code></b></a>
+ - <a href="#api_nan_persistent"><b><code>Nan::Persistent</code></b></a>
+ - <a href="#api_nan_global"><b><code>Nan::Global</code></b></a>
+
+<a name="api_nan_persistent_base"></a>
+### Nan::PersistentBase & v8::PersistentBase
+
+A persistent handle contains a reference to a storage cell in V8 which holds an object value and which is updated by the garbage collector whenever the object is moved. A new storage cell can be created using the constructor or `Nan::PersistentBase::Reset()`. Existing handles can be disposed using an argument-less `Nan::PersistentBase::Reset()`.
+
+Definition:
+
+_(note: this is implemented as `Nan::PersistentBase` for older versions of V8 and the native `v8::PersistentBase` is used for newer versions of V8)_
+
 ```c++
-template<typename T>
-class PersistentBase {
+template<typename T> class PersistentBase {
  public:
   /**
    * If non-empty, destroy the underlying storage cell
-   * IsEmpty() will return true after this call.
    */
   void Reset();
 
   /**
-   * If non-empty, destroy the underlying storage cell
-   * and create a new one with the contents of other if other is non empty
+   * If non-empty, destroy the underlying storage cell and create a new one with
+   * the contents of another if it is also non-empty
    */
-  template<typename S>
-  void Reset(const v8::Handle<S> &other);
+  template<typename S> void Reset(const v8::Local<S> &other);
 
   /**
-   * If non-empty, destroy the underlying storage cell
-   * and create a new one with the contents of other if other is non empty
+   * If non-empty, destroy the underlying storage cell and create a new one with
+   * the contents of another if it is also non-empty
    */
-  template<typename S>
-  void Reset(const PersistentBase<S> &other);
+  template<typename S> void Reset(const PersistentBase<S> &other);
 
+  /**
+   * If non-empty, destroy the underlying storage cell
+   * IsEmpty() will return true after this call.
+   */
   bool IsEmpty();
 
   void Empty();
 
-  template<typename S>
-  bool operator==(const PersistentBase<S> &that);
+  template<typename S> bool operator==(const PersistentBase<S> &that);
 
-  template<typename S>
-  bool operator==(const v8::Handle<S> &that);
+  template<typename S> bool operator==(const v8::Local<S> &that);
 
-  template<typename S>
-  bool operator!=(const PersistentBase<S> &that);
+  template<typename S> bool operator!=(const PersistentBase<S> &that);
 
-  template<typename S>
-  bool operator!=(const v8::Handle<S> &that);
+  template<typename S> bool operator!=(const v8::Local<S> &that);
 
    /**
    *  Install a finalization callback on this object.
@@ -59,10 +65,9 @@ class PersistentBase {
    *  fields in the dying object.
    */
   template<typename P>
-  void SetWeak(
-      P *parameter,
-      typename WeakCallbackInfo<P>::Callback callback,
-      WeakCallbackType type);
+  void SetWeak(P *parameter,
+               typename WeakCallbackInfo<P>::Callback callback,
+               WeakCallbackType type);
 
   void ClearWeak();
 
@@ -84,37 +89,69 @@ class PersistentBase {
 };
 ```
 
-## NonCopyablePersistentTraits
-Default traits for `Persistent`. This class does not allow use of the copy
-constructor or assignment operator. At present `kResetInDestructor` is not
-set, but that will change in a future version.
+See the V8 documentation for [`PersistentBase`](https://v8docs.nodesource.com/io.js-3.0/d4/dca/classv8_1_1_persistent_base.html) for further information.
+
+<a name="api_nan_non_copyable_persistent_traits"></a>
+## Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits
+
+Default traits for `Nan::Persistent`. This class does not allow use of the a copy constructor or assignment operator. At present `kResetInDestructor` is not set, but that will change in a future version.
+
+Definition:
+
+_(note: this is implemented as `Nan::NonCopyablePersistentTraits` for older versions of V8 and the native `v8::NonCopyablePersistentTraits` is used for newer versions of V8)_
+
 ```c++
-template<typename T>
-class NonCopyablePersistentTraits {
+template<typename T> class NonCopyablePersistentTraits {
  public:
   typedef Persistent<T, NonCopyablePersistentTraits<T> > NonCopyablePersistent;
+  
   static const bool kResetInDestructor = false;
-  template<typename S, typename M>
+  
+  template<typename S, typename M> 
+  static void Copy(const Persistent<S, M> &source,
+                   NonCopyablePersistent *dest);
+
+  template<typename O> static void Uncompilable();
 };
 ```
 
-## CopyablePersistentTraits
-Helper class traits to allow copying and assignment of `Persistent`.
-This will clone the contents of storage cell, but not any of the flags, etc.
+See the V8 documentation for [`NonCopyablePersistentTraits`](https://v8docs.nodesource.com/io.js-3.0/de/d73/classv8_1_1_non_copyable_persistent_traits.html) for further information.
+
+<a name="api_nan_copyable_persistent_traits"></a>
+## Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits
+
+A helper class of traits to allow copying and assignment of `Persistent`. This will clone the contents of storage cell, but not any of the flags, etc..
+
+Definition:
+
+_(note: this is implemented as `Nan::CopyablePersistentTraits` for older versions of V8 and the native `v8::NonCopyablePersistentTraits` is used for newer versions of V8)_
+
 ```c++
 template<typename T>
 class CopyablePersistentTraits {
  public:
   typedef Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
+
   static const bool kResetInDestructor = true;
+
+  template<typename S, typename M>
+  static void Copy(const Persistent<S, M> &source,
+                   CopyablePersistent *dest);
 };
 ```
 
-## Persistent
-A `PersistentBase` which allows copy and assignment.
-Copy, assignment and destructor bevavior is controlled by the traits class `M`.
+See the V8 documentation for [`CopyablePersistentTraits`](https://v8docs.nodesource.com/io.js-3.0/da/d5c/structv8_1_1_copyable_persistent_traits.html) for further information.
+
+<a name="api_nan_persistent"></a>
+## Nan::Persistent
+
+A type of `PersistentBase` which allows copy and assignment. Copy, assignment and destructor behavior is controlled by the traits class `M`.
+
+Definition:
+
 ```c++
-template<typename T, typename M = NonCopyablePersistentTraits<T> > class Persistent;
+template<typename T, typename M = NonCopyablePersistentTraits<T> >
+class Persistent;
 
 template<typename T, typename M> class Persistent : public PersistentBase<T> {
  public:
@@ -124,25 +161,23 @@ template<typename T, typename M> class Persistent : public PersistentBase<T> {
   Persistent();
 
   /**
-   * Construct a Persistent from a v8::Handle.
-   * When the v8::Handle is non-empty, a new storage cell is created
-   * pointing to the same object, and no flags are set.
+   * Construct a Persistent from a v8::Local. When the v8::Local is non-empty, a
+   * new storage cell is created pointing to the same object, and no flags are
+   * set.
    */
-  template<typename S>
-  Persistent(v8::Handle<S> that);
+  template<typename S> Persistent(v8::Local<S> that);
 
   /**
-   * Construct a Persistent from a Persistent.
-   * When the Persistent is non-empty, a new storage cell is created
-   * pointing to the same object, and no flags are set.
+   * Construct a Persistent from a Persistent. When the Persistent is non-empty,
+   * a new storage cell is created pointing to the same object, and no flags are
+   * set.
    */
   Persistent(const Persistent &that);
 
   /**
-   * The copy constructors and assignment operator create a Persistent
-   * exactly as the Persistent constructor, but the Copy function from the
-   * traits class is called, allowing the setting of flags based on the
-   * copied Persistent.
+   * The copy constructors and assignment operator create a Persistent exactly
+   * as the Persistent constructor, but the Copy function from the traits class
+   * is called, allowing the setting of flags based on the copied Persistent.
    */
   Persistent &operator=(const Persistent &that);
 
@@ -150,19 +185,23 @@ template<typename T, typename M> class Persistent : public PersistentBase<T> {
   Persistent &operator=(const Persistent<S, M2> &that);
 
   /**
-   * The destructor will dispose the Persistent based on the
-   * kResetInDestructor flags in the traits class.  Since not calling dispose
-   * can result in a memory leak, it is recommended to always set this flag.
+   * The destructor will dispose the Persistent based on the kResetInDestructor
+   * flags in the traits class.  Since not calling dispose can result in a
+   * memory leak, it is recommended to always set this flag.
    */
   ~Persistent();
 };
 ```
 
-## Global
-A `PersistentBase` which has move semantics.
+See the V8 documentation for [`Persistent`](https://v8docs.nodesource.com/io.js-3.0/d2/d78/classv8_1_1_persistent.html) for further information.
+
+<a name="api_nan_global"></a>
+## Nan::Global
+
+A type of `PersistentBase` which has move semantics.
+
 ```c++
-template<typename T>
-class Global : public PersistentBase<T> {
+template<typename T> class Global : public PersistentBase<T> {
  public:
   /**
    * A Global with no storage cell.
@@ -170,19 +209,16 @@ class Global : public PersistentBase<T> {
   Global();
 
   /**
-   * Construct a Global from a v8::Handle.
-   * When the v8::Handle is non-empty, a new storage cell is created
-   * pointing to the same object, and no flags are set.
+   * Construct a Global from a v8::Local. When the v8::Local is non-empty, a new
+   * storage cell is created pointing to the same object, and no flags are set.
    */
-  template<typename S>
-  Global(v8::Handle<S> that);
+  template<typename S> Global(v8::Local<S> that);
   /**
-   * Construct a Global from a PersistentBase.
-   * When the Persistent is non-empty, a new storage cell is created
-   * pointing to the same object, and no flags are set.
+   * Construct a Global from a PersistentBase. When the Persistent is non-empty,
+   * a new storage cell is created pointing to the same object, and no flags are
+   * set.
    */
-  template<typename S>
-  Global(const PersistentBase<S> &that);
+  template<typename S> Global(const PersistentBase<S> &that);
 
   /**
    * Pass allows returning globals from functions, etc.
@@ -190,3 +226,5 @@ class Global : public PersistentBase<T> {
   Global Pass();
 };
 ```
+
+See the V8 documentation for [`Global`](https://v8docs.nodesource.com/io.js-3.0/d5/d40/classv8_1_1_global.html) for further information.

From f380ded549ae8037b13729dea85e7599244f6ad0 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 21:54:18 +1000
Subject: [PATCH 58/84] doc: clean up callback.md

---
 doc/callback.md    | 47 +++++++++++++++++++++++++++++++++++++++++
 doc/nancallback.md | 52 ----------------------------------------------
 2 files changed, 47 insertions(+), 52 deletions(-)
 create mode 100644 doc/callback.md
 delete mode 100644 doc/nancallback.md

diff --git a/doc/callback.md b/doc/callback.md
new file mode 100644
index 00000000..9b64ba40
--- /dev/null
+++ b/doc/callback.md
@@ -0,0 +1,47 @@
+## Nan::Callback
+
+`Nan::Callback` makes it easier to use `v8::Function` handles as callbacks. A class that wraps a `v8::Function` handle, protecting it from garbage collection and making it particularly useful for storage and use across asynchronous execution.
+
+```c++
+class Callback {
+ public:
+  Callback();
+
+  explicit Callback(const v8::Handle<v8::Function> &fn);
+
+  ~Callback();
+
+  bool operator==(const Callback &other) const;
+
+  bool operator!=(const Callback &other) const;
+
+  v8::Local<v8::Function> operator*() const;
+
+  v8::Local<v8::Value> operator()(v8::Handle<v8::Object> target,
+                                  int argc = 0,
+                                  v8::Handle<v8::Value> argv[] = 0) const;
+
+  v8::Local<v8::Value> operator()(int argc = 0,
+                                  v8::Handle<v8::Value> argv[] = 0) const;
+
+  void SetFunction(const v8::Handle<v8::Function> &fn);
+
+  v8::Local<v8::Function> GetFunction() const;
+
+  bool IsEmpty() const;
+
+  v8::Local<v8::Value> Call(v8::Handle<v8::Object> target,
+                            int argc,
+                            v8::Handle<v8::Value> argv[]) const;
+
+  v8::Local<v8::Value> Call(int argc, v8::Handle<v8::Value> argv[]) const;
+};
+```
+
+Example usage:
+
+```c++
+v8::Local<v8::Function> function;
+Nan::Callback callback(function);
+callback->Call(0, 0);
+```
diff --git a/doc/nancallback.md b/doc/nancallback.md
deleted file mode 100644
index cd6b0b61..00000000
--- a/doc/nancallback.md
+++ /dev/null
@@ -1,52 +0,0 @@
-#Callback
-`Callback` makes it easier to use `v8::Function` handles as callbacks.
-
-##Callback
-A class that wraps a `v8::Function` handle, protecting it from garbage collection.
-```c++
-class Callback {
- public:
-  Callback();
-
-  explicit Callback(const v8::Handle<v8::Function> &fn);
-
-  ~Callback();
-
-  bool operator==(const Callback &other) const;
-
-  bool operator!=(const Callback &other) const;
-
-  NAN_INLINE
-  v8::Local<v8::Function> operator*() const;
-
-  v8::Local<v8::Value> operator()(
-      v8::Handle<v8::Object> target
-    , int argc = 0
-    , v8::Handle<v8::Value> argv[] = 0) const;
-
-  v8::Local<v8::Value> operator()(
-      int argc = 0
-    , v8::Handle<v8::Value> argv[] = 0) const;
-
-  void SetFunction(const v8::Handle<v8::Function> &fn);
-
-  v8::Local<v8::Function> GetFunction() const;
-
-  bool IsEmpty() const;
-
-  v8::Local<v8::Value>
-  Call(v8::Handle<v8::Object> target
-     , int argc
-     , v8::Handle<v8::Value> argv[]) const;
-
-  v8::Local<v8::Value>
-  Call(int argc, v8::Handle<v8::Value> argv[]) const;
-};
-```
-
-###Example
-```c++
-v8::Local<v8::Function> function;
-Callback callback(function);
-callback->Call(0, 0);
-```

From fdcfbfd88faeaa0d7b50dc493105a728f5bcdbbc Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 22:08:55 +1000
Subject: [PATCH 59/84] doc: clean up asyncworker.md

---
 doc/asyncworker.md | 74 ++++++++++++++++++++++------------------------
 1 file changed, 36 insertions(+), 38 deletions(-)

diff --git a/doc/asyncworker.md b/doc/asyncworker.md
index 7b31f348..1a583cc5 100644
--- a/doc/asyncworker.md
+++ b/doc/asyncworker.md
@@ -1,11 +1,20 @@
-#Asyncworker
-These classes make working with asynchronous code easier.
+## Asynchronous work helpers
+
+`Nan::AsyncWorker` and `Nan::AsyncProgressWorker` are helper classes that make working with asynchronous code easier.
+
+ - <a href="#api_nan_async_worker"><b><code>Nan::AsyncWorker</code></b></a>
+ - <a href="#api_nan_async_progress_worker"><b><code>Nan::AsyncProgressWorker</code></b></a>
+ - <a href="#api_nan_async_queue_worker"><b><code>Nan::AsyncQueueWorker</code></b></a>
+
+<a name="api_nan_async_worker"></a>
+### Nan::AsyncWorker
+
+`Nan::AsyncWorker` is an _abstract_ class that you can subclass to have much of the annoying asynchronous queuing and handling taken care of for you. It can even store arbitrary V8 objects for you and have them persist while the asynchronous work is in progress.
+
+Definition:
 
-##AsyncWorker
-`AsyncWorker` is an abstract class that you can subclass to have much of the annoying async queuing and handling taken care of for you.
-It can even store arbitrary V8 objects for you and have them persist while the async work is in progress.
 ```c++
-/* abstract */ class AsyncWorker {
+class AsyncWorker {
  public:
   explicit AsyncWorker(Callback *callback_);
 
@@ -13,19 +22,17 @@ It can even store arbitrary V8 objects for you and have them persist while the a
 
   virtual void WorkComplete();
 
-  void SaveToPersistent(
-      const char *key, const v8::Local<v8::Value> &value);
+  void SaveToPersistent(const char *key, const v8::Local<v8::Value> &value);
 
-  void SaveToPersistent(
-      const v8::Handle<v8::String> &key, const v8::Local<v8::Value> &value);
+  void SaveToPersistent(const v8::Handle<v8::String> &key,
+                        const v8::Local<v8::Value> &value);
 
-  void SaveToPersistent(
-      uint32_t index, const v8::Local<v8::Value> &value);
+  void SaveToPersistent(uint32_t index,
+                        const v8::Local<v8::Value> &value);
 
   v8::Local<v8::Value> GetFromPersistent(const char *key) const;
 
-  v8::Local<v8::Value>
-  GetFromPersistent(const v8::Local<v8::String> &key) const;
+  v8::Local<v8::Value> GetFromPersistent(const v8::Local<v8::String> &key) const;
 
   v8::Local<v8::Value> GetFromPersistent(uint32_t index) const;
 
@@ -37,6 +44,7 @@ It can even store arbitrary V8 objects for you and have them persist while the a
 
  protected:
   Persistent<v8::Object> persistentHandle;
+
   Callback *callback;
 
   virtual void HandleOKCallback();
@@ -49,17 +57,15 @@ It can even store arbitrary V8 objects for you and have them persist while the a
 };
 ```
 
-###Example
-```c++
-Callback callback;
-AsyncWorker *worker = new AsyncWorker(callback);
-```
+<a name="api_nan_async_progress_worker"></a>
+### Nan::AsyncProgressWorker
+
+`Nan::AsyncProgressWorker` is an _abstract_ class that extends `Nan::AsyncWorker` and adds additional progress reporting callbacks that can be used during the asynchronous work execution to provide progress data back to JavaScript.
+
+Definition:
 
-##AsyncProgressWorker
-`AsyncProgressWorker` is an abstract class that you can subclass to have much of the annoying async queuing and handling taken care of for you.
-It is derived from `AsyncWorker` with additional progress reporting callbacks.
 ```c++
-/* abstract */ class AsyncProgressWorker : public AsyncWorker {
+class AsyncProgressWorker : public AsyncWorker {
  public:
   explicit AsyncProgressWorker(Callback *callback_);
 
@@ -73,27 +79,19 @@ It is derived from `AsyncWorker` with additional progress reporting callbacks.
   };
 
   virtual void Execute(const ExecutionProgress& progress) = 0;
+
   virtual void HandleProgressCallback(const char *data, size_t size) = 0;
 
   virtual void Destroy();
 ```
 
-###Example
-```c++
-Callback callback;
-AsyncProgressWorker *worker = new AsyncProgressWorker(callback);
-```
+<a name="api_nan_async_queue_worker"></a>
+### Nan::AsyncQueueWorker
 
-##AsyncQueueWorker
-`AsyncQueueWorker` will run a `AsyncWorker` asynchronously via libuv.
-Both the `execute` and `after_work` steps are taken care of for you.
-Most of the logic for this is embedded in `AsyncWorker`.
-```c++
-void AsyncQueueWorker(AsyncWorker *);
-```
+`Nan::AsyncQueueWorker` will run a `Nan::AsyncWorker` asynchronously via libuv. Both the `execute` and `after_work` steps are taken care of for you. Most of the logic for this is embedded in `Nan::AsyncWorker`.
+
+Definition:
 
-###Example
 ```c++
-AsyncWorker *worker = new AsyncWorker(/* ... */);
-AsyncQueueWorker(worker);
+void AsyncQueueWorker(AsyncWorker *);
 ```

From da9f6d8e1c1b6f2d63cc8b9a77888789ba1bedf5 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 22:23:09 +1000
Subject: [PATCH 60/84] doc: merge weak.md into persistent.md

---
 doc/persistent.md | 40 ++++++++++++++++++++++++++++++++++++++++
 doc/weak.md       | 36 ------------------------------------
 2 files changed, 40 insertions(+), 36 deletions(-)
 delete mode 100644 doc/weak.md

diff --git a/doc/persistent.md b/doc/persistent.md
index d22410cd..8e183a84 100644
--- a/doc/persistent.md
+++ b/doc/persistent.md
@@ -9,6 +9,7 @@ Due to the evolution of the V8 API, it is necessary for NAN to provide a wrapper
  - <a href="#api_nan_copyable_persistent_traits"><b><code>Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits</code></b></a>
  - <a href="#api_nan_persistent"><b><code>Nan::Persistent</code></b></a>
  - <a href="#api_nan_global"><b><code>Nan::Global</code></b></a>
+ - <a href="#api_nan_weak_callback_info"><b><code>Nan::WeakCallbackInfo</code></b></a>
 
 <a name="api_nan_persistent_base"></a>
 ### Nan::PersistentBase & v8::PersistentBase
@@ -228,3 +229,42 @@ template<typename T> class Global : public PersistentBase<T> {
 ```
 
 See the V8 documentation for [`Global`](https://v8docs.nodesource.com/io.js-3.0/d5/d40/classv8_1_1_global.html) for further information.
+
+<a name="api_nan_weak_callback_info"></a>
+## Nan::WeakCallbackInfo
+
+`Nan::WeakCallbackInfo` is used as an argument when setting a persistent reference as weak. You may need to free any external resources attached to the object.
+
+Definition:
+
+```c++
+template<typename T> class WeakCallbackInfo {
+ public:
+  typedef void (*Callback)(const WeakCallbackInfo<T>& data);
+
+  v8::Isolate *GetIsolate() const;
+
+  /**
+   * Get the parameter that was associated with the weak handle.
+   */
+  T *GetParameter() const;
+
+  /**
+   * Get pointer from internal field, index can be 0 or 1.
+   */
+  void *GetInternalField(int index) const;
+};
+```
+
+Example usage:
+
+```c++
+void weakCallback(const WeakCallbackInfo<int> &data) {
+  int *parameter = data.GetParameter();
+  delete parameter;
+}
+
+Persistent<v8::Object> obj;
+int *data = new int(0);
+obj.SetWeak(data, callback, WeakCallbackType::kParameter);
+```
diff --git a/doc/weak.md b/doc/weak.md
deleted file mode 100644
index 21c038ef..00000000
--- a/doc/weak.md
+++ /dev/null
@@ -1,36 +0,0 @@
-#Weak Callbacks
-
-## WeakCallbackInfo
-Argument to weak callbacks.
-You may need to free any external resources attached to the object.
-```c++
-template<typename T>
-class WeakCallbackInfo {
- public:
-  typedef void (*Callback)(const WeakCallbackInfo<T>& data);
-
-  v8::Isolate *GetIsolate() const;
-
-   /**
-    *   Get the parameter that was associated with the weak handle.
-    */
-  T *GetParameter() const;
-
-   /**
-    *   Get pointer from internal field, index can be 0 or 1.
-    */
-  void *GetInternalField(int index) const;
-};
-```
-
-### Example
-```c++
-void weakCallback(const WeakCallbackInfo<int> &data) {
-  int *parameter = data.GetParameter();
-  delete parameter;
-}
-
-Persistent<v8::Object> obj;
-int *data = new int(0);
-obj.SetWeak(data, callback, WeakCallbackType::kParameter);
-```

From 3b4232a25cfdf21376bd2661c4d76d1abedef264 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 22:31:54 +1000
Subject: [PATCH 61/84] doc: added WeakCallbackType (stub)

---
 doc/persistent.md | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/doc/persistent.md b/doc/persistent.md
index 8e183a84..c29292c6 100644
--- a/doc/persistent.md
+++ b/doc/persistent.md
@@ -10,6 +10,7 @@ Due to the evolution of the V8 API, it is necessary for NAN to provide a wrapper
  - <a href="#api_nan_persistent"><b><code>Nan::Persistent</code></b></a>
  - <a href="#api_nan_global"><b><code>Nan::Global</code></b></a>
  - <a href="#api_nan_weak_callback_info"><b><code>Nan::WeakCallbackInfo</code></b></a>
+ - <a href="#api_nan_weak_callback_type"><b><code>Nan::WeakCallbackType</code></b></a>
 
 <a name="api_nan_persistent_base"></a>
 ### Nan::PersistentBase & v8::PersistentBase
@@ -230,10 +231,13 @@ template<typename T> class Global : public PersistentBase<T> {
 
 See the V8 documentation for [`Global`](https://v8docs.nodesource.com/io.js-3.0/d5/d40/classv8_1_1_global.html) for further information.
 
+<a name="api_nan_weak_callback_type"></a>
+## Nan::WeakCallbackType
+
 <a name="api_nan_weak_callback_info"></a>
 ## Nan::WeakCallbackInfo
 
-`Nan::WeakCallbackInfo` is used as an argument when setting a persistent reference as weak. You may need to free any external resources attached to the object.
+`Nan::WeakCallbackInfo` is used as an argument when setting a persistent reference as weak. You may need to free any external resources attached to the object. It is a mirror of `v8:WeakCallbackInfo` as found in newer versions of V8.
 
 Definition:
 
@@ -268,3 +272,16 @@ Persistent<v8::Object> obj;
 int *data = new int(0);
 obj.SetWeak(data, callback, WeakCallbackType::kParameter);
 ```
+
+See the V8 documentation for [`WeakCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/d8/d06/classv8_1_1_weak_callback_info.html) for further information.
+
+<a name="api_nan_weak_callback_type"></a>
+## Nan::WeakCallbackType
+
+_TODO: explain this_
+
+Definition:
+
+```c++
+enum class WeakCallbackType { kParameter, kInternalFields };
+```

From 63fdd46a5df2f6317fc8c199f454e0bf2a9c57b2 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Sat, 25 Jul 2015 22:33:14 +1000
Subject: [PATCH 62/84] doc: further trim readme

---
 README.md | 219 ------------------------------------------------------
 1 file changed, 219 deletions(-)

diff --git a/README.md b/README.md
index a2418cac..7ea7cc1c 100644
--- a/README.md
+++ b/README.md
@@ -262,31 +262,17 @@ NAN_METHOD(CalculateAsync) {
  * <a href="#api_nan_null"><b><code>NanNull</code></b></a>
  * <a href="#api_nan_true"><b><code>NanTrue</code></b></a>
  * <a href="#api_nan_false"><b><code>NanFalse</code></b></a>
- * <a href="#api_nan_return_value"><b><code>NanReturnValue</code></b></a>
- * <a href="#api_nan_return_undefined"><b><code>NanReturnUndefined</code></b></a>
- * <a href="#api_nan_return_null"><b><code>NanReturnNull</code></b></a>
- * <a href="#api_nan_return_empty_string"><b><code>NanReturnEmptyString</code></b></a>
- * <a href="#api_nan_return_this"><b><code>NanReturnThis</code></b></a>
- * <a href="#api_nan_return_holder"><b><code>NanReturnHolder</code></b></a>
  * <a href="#api_nan_scope"><b><code>NanScope</code></b></a>
  * <a href="#api_nan_escapable_scope"><b><code>NanEscapableScope</code></b></a>
  * <a href="#api_nan_escape_scope"><b><code>NanEscapeScope</code></b></a>
  * <a href="#api_nan_object_wrap_handle"><b><code>NanObjectWrapHandle</code></b></a>
- * <del><a href="#api_nan_symbol"><b><code>NanSymbol</code></b></a></del>
- * <del><a href="#api_nan_get_pointer_safe"><b><code>NanGetPointerSafe</code></b></a></del>
- * <del><a href="#api_nan_set_pointer_safe"><b><code>NanSetPointerSafe</code></b></a></del>
- * <del><a href="#api_nan_raw_string"><b><code>NanRawString</code></b></a></del>
- * <del><a href="#api_nan_c_string"><b><code>NanCString</code></b></a></del>
  * <a href="#api_nan_ascii_string"><b><code>NanAsciiString</code></b></a>
  * <a href="#api_nan_utf8_string"><b><code>NanUtf8String</code></b></a>
  * <a href="#api_nan_ucs2_string"><b><code>NanUcs2String</code></b></a>
- * <del><a href="#api_nan_boolean_option_value"><b><code>NanBooleanOptionValue</code></b></a></del>
- * <del><a href="#api_nan_uint32_option_value"><b><code>NanUInt32OptionValue</code></b></a></del>
  * <a href="#api_nan_error"><b><code>NanError</code></b>, <b><code>NanRangeError</code></b>, <b><code>NanReferenceError</code></b>, <b><code>NanSyntaxError</code></b>, <b><code>NanTypeError</code></b></a>
  * <a href="#api_nan_throw_error"><b><code>NanThrowError</code></b>, <b><code>NanThrowRangeError</code></b>, <b><code>NanThrowReferenceError</code></b>, <b><code>NanThrowSyntaxError</code></b>, <b><code>NanThrowTypeError</code></b>, <b><code>NanThrowError(Handle<Value>)</code></b>, <b><code>NanThrowError(Handle<Value>, int)</code></b></a>
  * <a href="#api_nan_new_buffer_handle"><b><code>NanNewBufferHandle(char *, size_t, FreeCallback, void *)</code></b>, <b><code>NanNewBufferHandle(char *, uint32_t)</code></b>, <b><code>NanNewBufferHandle(uint32_t)</code></b></a>
  * <a href="#api_nan_buffer_use"><b><code>NanBufferUse(char *, uint32_t)</code></b></a>
- * <del><a href="#api_nan_new_context_handle"><b><code>NanNewContextHandle</code></b></a></del>
  * <a href="#api_nan_get_current_context"><b><code>NanGetCurrentContext</code></b></a>
  * <a href="#api_nan_has_instance"><b><code>NanHasInstance</code></b></a>
  * <a href="#api_nan_dispose_persistent"><b><code>NanDisposePersistent</code></b></a>
@@ -381,95 +367,6 @@ Use instead of `True()`
 
 Use instead of `False()`
 
-<a name="api_nan_return_value"></a>
-### NanReturnValue(Handle&lt;Value&gt;)
-
-Use `NanReturnValue` when you want to return a value from your V8 accessible method:
-
-```c++
-NAN_METHOD(Foo::Bar) {
-  ...
-
-  NanReturnValue(NanNew<String>("FooBar!"));
-}
-```
-
-No `return` statement required.
-
-For convenience, `NanReturnValue` also accepts common primitives directly by implicitly performing an overloaded `NanNew(T)`.
-
-```c++
-NanReturnValue("FooBar!");
-NanReturnValue(true);
-NanReturnValue(12);
-NanReturnValue(3.14);
-```
-
-<a name="api_nan_return_undefined"></a>
-### NanReturnUndefined()
-
-Use `NanReturnUndefined` when you don't want to return anything from your V8 accessible method:
-
-```c++
-NAN_METHOD(Foo::Baz) {
-  ...
-
-  NanReturnUndefined();
-}
-```
-
-<a name="api_nan_return_null"></a>
-### NanReturnNull()
-
-Use `NanReturnNull` when you want to return `Null` from your V8 accessible method:
-
-```c++
-NAN_METHOD(Foo::Baz) {
-  ...
-
-  NanReturnNull();
-}
-```
-
-<a name="api_nan_return_empty_string"></a>
-### NanReturnEmptyString()
-
-Use `NanReturnEmptyString` when you want to return an empty `String` from your V8 accessible method:
-
-```c++
-NAN_METHOD(Foo::Baz) {
-  ...
-
-  NanReturnEmptyString();
-}
-```
-
-<a name="api_nan_return_this"></a>
-### NanReturnThis()
-
-Use `NanReturnThis` when you want to return `This` from your V8 accessible method:
-
-```c++
-NAN_METHOD(Foo::Baz) {
-  ...
-
-  NanReturnThis();
-}
-```
-
-<a name="api_nan_return_holder"></a>
-### NanReturnHolder()
-
-Use `NanReturnHolder` when you want to return `Holder` from your V8 accessible method:
-
-```c++
-NAN_METHOD(Foo::Baz) {
-  ...
-
-  NanReturnHolder();
-}
-```
-
 <a name="api_nan_scope"></a>
 ### NanScope()
 
@@ -520,82 +417,6 @@ When you want to fetch the V8 object handle from a native object you've wrapped
 NanObjectWrapHandle(iterator)->Get(NanNew<String>("end"))
 ```
 
-<a name="api_nan_symbol"></a>
-### ~~Local&lt;String&gt; NanSymbol(const char *)~~
-
-Deprecated. Use `NanNew<String>` instead.
-~~Use to create string symbol objects (i.e. `v8::String::NewSymbol(x)`), for getting and setting object properties, or names of objects.~~
-
-```c++
-bool foo = false;
-if (obj->Has(NanNew<String>("foo")))
-  foo = optionsObj->Get(NanNew<String>("foo"))->BooleanValue()
-```
-
-<a name="api_nan_get_pointer_safe"></a>
-### ~~Type NanGetPointerSafe(Type *[, Type])~~
-
-Deprecated.
-~~A helper for getting values from optional pointers. If the pointer is `NULL`, the function returns the optional default value, which defaults to `0`.  Otherwise, the function returns the value the pointer points to.~~
-
-```c++
-char *plugh(uint32_t *optional) {
-  char res[] = "xyzzy";
-  uint32_t param = NanGetPointerSafe<uint32_t>(optional, 0x1337);
-  switch (param) {
-    ...
-  }
-  NanSetPointerSafe<uint32_t>(optional, 0xDEADBEEF);
-}  
-```
-
-<a name="api_nan_set_pointer_safe"></a>
-### ~~bool NanSetPointerSafe(Type *, Type)~~
-
-Deprecated.
-~~A helper for setting optional argument pointers. If the pointer is `NULL`, the function simply returns `false`.  Otherwise, the value is assigned to the variable the pointer points to.~~
-
-```c++
-const char *plugh(size_t *outputsize) {
-  char res[] = "xyzzy";
-  if !(NanSetPointerSafe<size_t>(outputsize, strlen(res) + 1)) {
-    ...
-  }
-
-  ...
-}
-```
-
-<a name="api_nan_raw_string"></a>
-### ~~void* NanRawString(Handle&lt;Value&gt;, enum Nan::Encoding, size_t *, void *, size_t, int)~~
-
-Deprecated. Use something else.
-
-~~When you want to convert a V8 `String` to a `char*` buffer, use `NanRawString`. You have to supply an encoding as well as a pointer to a variable that will be assigned the number of bytes in the returned string. It is also possible to supply a buffer and its length to the function in order not to have a new buffer allocated. The final argument allows setting `String::WriteOptions`.
-Just remember that you'll end up with an object that you'll need to `delete[]` at some point unless you supply your own buffer:~~
-
-```c++
-size_t count;
-void* decoded = NanRawString(args[1], Nan::BASE64, &count, NULL, 0, String::HINT_MANY_WRITES_EXPECTED);
-...
-delete[] reinterpret_cast<char*>(decoded);
-```
-
-<a name="api_nan_c_string"></a>
-### ~~char* NanCString(Handle&lt;Value&gt;, size_t *[, char *, size_t, int])~~
-
-Deprecated. Use `String::Utf8Value` or `NanUtf8String` instead.
-
-~~When you want to convert a V8 `String` to a null-terminated C `char*` use `NanCString`. The resulting `char*` will be UTF-8-encoded, and you need to supply a pointer to a variable that will be assigned the number of bytes in the returned string. It is also possible to supply a buffer and its length to the function in order not to have a new buffer allocated. The final argument allows optionally setting `String::WriteOptions`, which default to `v8::String::NO_OPTIONS`.
-Just remember that you'll end up with an object that you'll need to `delete[]` at some point unless you supply your own buffer:~~
-
-```c++
-size_t count;
-char* name = NanCString(args[0], &count);
-...
-delete[] name;
-```
-
 <a name="api_nan_ascii_string"></a>
 ### NanAsciiString
 
@@ -726,33 +547,6 @@ NAN_METHOD(bar) {
 printf(**str);
 ```
 
-<a name="api_nan_boolean_option_value"></a>
-### ~~bool NanBooleanOptionValue(Handle&lt;Value&gt;, Handle&lt;String&gt;[, bool])~~
-
-Deprecated.
-~~When you have an "options" object that you need to fetch properties from, boolean options can be fetched with this pair. They check first if the object exists (`IsEmpty`), then if the object has the given property (`Has`) then they get and convert/coerce the property to a `bool`.~~
-
-~~The optional last parameter is the *default* value, which is `false` if left off:~~
-
-```c++
-// `foo` is false unless the user supplies a truthy value for it
-bool foo = NanBooleanOptionValue(optionsObj, NanNew<String>("foo"));
-// `bar` is true unless the user supplies a falsy value for it
-bool bar = NanBooleanOptionValueDefTrue(optionsObj, NanNew<String>("bar"), true);
-```
-
-<a name="api_nan_uint32_option_value"></a>
-### ~~uint32_t NanUInt32OptionValue(Handle&lt;Value&gt;, Handle&lt;String&gt;, uint32_t)~~
-
-Deprecated.
-~~Similar to `NanBooleanOptionValue`, use `NanUInt32OptionValue` to fetch an integer option from your options object. Can be any kind of JavaScript `Number` and it will be coerced to an unsigned 32-bit integer.~~
-
-~~Requires all 3 arguments as a default is not optional:~~
-
-```c++
-uint32_t count = NanUInt32OptionValue(optionsObj, NanNew<String>("count"), 1024);
-```
-
 <a name="api_nan_error"></a>
 ### NanError(message), NanRangeError(message), NanReferenceError(message), NanSyntaxError(message), NanTypeError(message)
 
@@ -803,19 +597,6 @@ careless use can lead to "double free or corruption" and other cryptic failures.
 
 Can be used to check the type of an object to determine it is of a particular class you have already defined and have a `Persistent<FunctionTemplate>` handle for.
 
-<a name="api_nan_new_context_handle"></a>
-### ~~Local&lt;Context&gt; NanNewContextHandle([ExtensionConfiguration*, Handle&lt;ObjectTemplate&gt;, Handle&lt;Value&gt;])~~
-
-Deprecated. Use `NanNew<Context>` instead.
-
-~~Creates a new `Local<Context>` handle.~~
-
-```c++
-Local<FunctionTemplate> ftmpl = NanNew<FunctionTemplate>();
-Local<ObjectTemplate> otmpl = ftmpl->InstanceTemplate();
-Local<Context> ctx =  NanNewContextHandle(NULL, otmpl);
-```
-
 <a name="api_nan_get_current_context"></a>
 ### Local&lt;Context&gt; NanGetCurrentContext()
 

From fd486f4cdb2594ee280dc58200cb9ae6d06c3fda Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 14:06:31 +1000
Subject: [PATCH 63/84] doc: clean up converters.md

---
 doc/converters.md | 55 ++++++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 22 deletions(-)

diff --git a/doc/converters.md b/doc/converters.md
index bb4ca0b0..f0d065b0 100644
--- a/doc/converters.md
+++ b/doc/converters.md
@@ -1,30 +1,41 @@
-#Converters
-These functions convert `v8::Value`s to other `v8::Value` types and native types.
-Since type conversion is not guaranteed to succeed, they return `Maybe` types.
+## Converters
 
-## To
-Converts a `v8::Handle<v8::Value>` to a different subtype of `v8::Value` or to a native
-data type. Returns a `MaybeLocal<>` or a `Maybe<>` accordingly.
+NAN contains functions that convert `v8::Value`s to other `v8::Value` types and native types. Since type conversion is not guaranteed to succeed, they return `Nan::Maybe` types. These converters can be used in place of `value->ToX()` and `value->XValue()` (where `X` is one of the types, e.g. `Boolean`) in a way that provides a consistent interface across V8 versions. Newer versions of V8 use the new `v8::Maybe` and `v8::MaybeLocal` types for these conversions, older versions don't have this functionality so it is provided by NAN.
+
+ - <a href="#api_nan_to"><b><code>Nan::To</code></b></a>
+
+<a name="api_nan_to"></a>
+### Nan::To
+
+Converts a `v8::Handle<v8::Value>` to a different subtype of `v8::Value` or to a native data type. Returns a `Nan::MaybeLocal<>` or a `Nan::Maybe<>` accordingly.
+
+See [maybe_types.md](./maybe_types.md) for more information on `Nan::Maybe` types.
+
+Signatures:
 
 ```c++
-MaybeLocal<v8::Boolean> To<>(v8::Handle<v8::Value> val);
-MaybeLocal<v8::Int32>   To<>(v8::Handle<v8::Value> val);
-MaybeLocal<v8::Integer> To<>(v8::Handle<v8::Value> val);
-MaybeLocal<v8::Object>  To<>(v8::Handle<v8::Value> val);
-MaybeLocal<v8::Number>  To<>(v8::Handle<v8::Value> val);
-MaybeLocal<v8::String>  To<>(v8::Handle<v8::Value> val);
-MaybeLocal<v8::Uint32>  To<>(v8::Handle<v8::Value> val);
-
-Maybe<bool>             To<>(v8::Handle<v8::Value> val);
-Maybe<double>           To<>(v8::Handle<v8::Value> val);
-Maybe<int32_t>          To<>(v8::Handle<v8::Value> val);
-Maybe<int64_t>          To<>(v8::Handle<v8::Value> val);
-Maybe<uint32_t>         To<>(v8::Handle<v8::Value> val);
+// V8 types
+Nan::MaybeLocal<v8::Boolean> Nan::To<v8::Boolean>(v8::Handle<v8::Value> val);
+Nan::MaybeLocal<v8::Int32> Nan::To<v8::Int32>(v8::Handle<v8::Value> val);
+Nan::MaybeLocal<v8::Integer> Nan::To<v8::Integer>(v8::Handle<v8::Value> val);
+Nan::MaybeLocal<v8::Object> Nan::To<v8::Object>(v8::Handle<v8::Value> val);
+Nan::MaybeLocal<v8::Number> Nan::To<v8::Number>(v8::Handle<v8::Value> val);
+Nan::MaybeLocal<v8::String> Nan::To<v8::String>(v8::Handle<v8::Value> val);
+Nan::MaybeLocal<v8::Uint32> Nan::To<v8::Uint32>(v8::Handle<v8::Value> val);
+
+// Native types
+Nan::Maybe<bool> Nan::To<bool>(v8::Handle<v8::Value> val);
+Nan::Maybe<double> Nan::To<double>(v8::Handle<v8::Value> val);
+Nan::Maybe<int32_t> Nan::To<int32_t>(v8::Handle<v8::Value> val);
+Nan::Maybe<int64_t> Nan::To<int64_t>(v8::Handle<v8::Value> val);
+Nan::Maybe<uint32_t> Nan::To<uint32_t>(v8::Handle<v8::Value> val);
 ```
 
-###Example
+### Example
+
 ```c++
 v8::Local<v8::Value> val;
-MaybeLocal<v8::String> = To<v8::String>(val);
-Maybe<double> = To<double>(val);
+Nan::MaybeLocal<v8::String> str = Nan::To<v8::String>(val);
+Nan::Maybe<double> d = Nan::To<double>(val);
 ```
+

From 77d9978bdebafa27f7ae39394d68fd11cea05111 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 14:21:47 +1000
Subject: [PATCH 64/84] doc: clean up maybe_types.md

---
 doc/maybe_types.md | 87 +++++++++++++++++++++++++---------------------
 1 file changed, 48 insertions(+), 39 deletions(-)

diff --git a/doc/maybe_types.md b/doc/maybe_types.md
index 46ce68d7..ab7df4de 100644
--- a/doc/maybe_types.md
+++ b/doc/maybe_types.md
@@ -1,50 +1,53 @@
-#Maybe Types
-The `MaybeLocal` and `Maybe` types are monads that encapsulate possibly
-empty `v8::Local` handles.
-
-##MaybeLocal
-A `MaybeLocal<>` is a wrapper around `v8::Local<>` that enforces a check whether
-the `v8::Local<>` is empty before it can be used.
-
-If an API method returns a `MaybeLocal<>`, the API method can potentially fail
-either because an exception is thrown, or because an exception is pending,
-e.g. because a previous API call threw an exception that hasn't been caught
-yet, or because a `v8::TerminateExecution` exception was thrown. In that case, an
-empty `MaybeLocal` is returned.
+## Maybe Types
+
+The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Local` handles that _may be empty_.
+
+ - <a href="#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
+ - <a href="#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
+ - <a href="#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
+ - <a href="#api_nan_just"><b><code>Nan::Just</code></b></a>
+
+<a name="api_nan_maybe"></a>
+<a name="api_nan_maybe_local"></a>
+### Nan::MaybeLocal
+
+A `Nan::MaybeLocal<T>` is a wrapper around [`v8::Local<T>`](https://v8docs.nodesource.com/io.js-3.0/de/deb/classv8_1_1_local.html) that enforces a check that determines whether the `v8::Local<T>` is empty before it can be used.
+
+If an API method returns a `Nan::MaybeLocal`, the API method can potentially fail either because an exception is thrown, or because an exception is pending, e.g. because a previous API call threw an exception that hasn't been caught yet, or because a `v8::TerminateExecution` exception was thrown. In that case, an empty `Nan::MaybeLocal` is returned.
+
+Definition:
+
 ```c++
-template<typename T>
-class MaybeLocal {
+template<typename T> class Nan::MaybeLocal {
  public:
   MaybeLocal();
 
-  template<typename S>
-  MaybeLocal(v8::Local<S> that);
+  template<typename S> MaybeLocal(v8::Local<S> that);
 
   bool IsEmpty() const;
 
-  template<typename S>
-  bool ToLocal(v8::Local<S> *out);
+  template<typename S> bool ToLocal(v8::Local<S> *out);
 
   // Will crash if the MaybeLocal<> is empty.
   v8::Local<T> ToLocalChecked();
 
-  template<typename S>
-  v8::Local<S> FromMaybe(v8::Local<S> default_value) const;
+  template<typename S> v8::Local<S> FromMaybe(v8::Local<S> default_value) const;
 };
 ```
 
-##Maybe
-A simple `Maybe` type, representing an object which may or may not have a
-value, see https://hackage.haskell.org/package/base/docs/Data-Maybe.html.
+See the documentation for [`v8::MaybeLocal`](https://v8docs.nodesource.com/io.js-3.0/d8/d7d/classv8_1_1_maybe_local.html) for further details.
+
+<a name="api_nan_maybe"></a>
+## Nan::Maybe
+
+A simple `Nan::Maybe` type, representing an object which may or may not have a value, see https://hackage.haskell.org/package/base/docs/Data-Maybe.html.
+
+If an API method returns a `Nan::Maybe<>`, the API method can potentially fail either because an exception is thrown, or because an exception is pending, e.g. because a previous API call threw an exception that hasn't been caught yet, or because a `v8::TerminateExecution` exception was thrown. In that case, a "Nothing" value is returned.
+
+Definition:
 
-If an API method returns a `Maybe<>`, the API method can potentially fail
-either because an exception is thrown, or because an exception is pending,
-e.g. because a previous API call threw an exception that hasn't been caught
-yet, or because a `v8::TerminateExecution` exception was thrown. In that case,
-a "Nothing" value is returned.
 ```c++
-template<typename T>
-class Maybe {
+template<typename T> class Nan::Maybe {
  public:
   bool IsNothing() const;
   bool IsJust() const;
@@ -60,16 +63,22 @@ class Maybe {
 };
 ```
 
-## Nothing
-Construct an empty `Maybe` type representing "Nothing".
+See the documentation for [`v8::Maybe`](https://v8docs.nodesource.com/io.js-3.0/d9/d4b/classv8_1_1_maybe.html) for further details.
+
+<a name="api_nan_nothing"></a>
+## Nan::Nothing
+
+Construct an empty `Nan::Maybe` type representing _nothing_.
+
 ```c++
-template<typename T>
-Maybe<T> Nothing();
+template<typename T> Nan::Maybe<T> Nan::Nothing();
 ```
 
-## Just
-Construct a `Maybe` type representing "Just" a value.
+<a name="api_nan_just"></a>
+## Nan::Just
+
+Construct a `Nan::Maybe` type representing _just_ a value.
+
 ```c++
-template<typename T>
-Maybe<T> Just(const T &t);
+template<typename T> Nan::Maybe<T> Nan::Just(const T &t);
 ```

From fdd18efc16296f65fbc79ff85afcc06fbab9e096 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 14:43:33 +1000
Subject: [PATCH 65/84] doc: remove news, insert TOC holder

---
 README.md       | 85 ++++++-------------------------------------------
 doc/callback.md |  5 +++
 2 files changed, 14 insertions(+), 76 deletions(-)

diff --git a/README.md b/README.md
index 7ea7cc1c..d3e13ef4 100644
--- a/README.md
+++ b/README.md
@@ -27,81 +27,6 @@ This project also contains some helper utilities that make addon development a b
 <a name="news"></a>
 ## News & Updates
 
-### Apr-2015: 1.8.0 release
-
-* Support V8 4.2
-* Removed support for creating `Signature`s with arguments
-* Backported thread local storage routines for libuv
-
-### Feb-2015: 1.7.0 release
-
-* Made `NanCallback::Call` accept optional target
-* Support atom-shell 0.21
-
-Node 0.12.0 is out and supported by NAN. So is atom-shell 0.21. `NanCallback::Call` now accepts an optional `target` argument like `NanMakeCallback`.
-
-### Jan-2015: 1.6.0 release
-
-* Deprecated `NanNewContextHandle` in favor of `NanNew<Context>`
-* Added `NanSetCounterFunction`, `NanSetCreateHistogramFunction`, `NanSetAddHistogramSampleFunction`
-* Added `NanIdleNotification`, `NanLowMemoryNotification`, `NanContextDisposedNotification`
-* Added `NanEncode`, `NanDecodeBytes` and `NanDecodeWrite`
-
-### Jan-2015: 1.5.0 release
-
-* Support [io.js](https://github.com/iojs/io.js) thanks to [Ben Noordhuis](bnoordhuis)
-* Rewritten NanNew internals thanks to [David Siegel](agnat)
-* NanAsyncWorker now supports progress reporting thanks to [Brett Lawson](brett19)
-
-### Aug-2014: 1.3.0 release
-
-* `NanCString()` and `NanRawString()` have been deprecated in favour of new <a href="#api_nan_ascii_string"><b><code>NanAsciiString</code></b></a>, <a href="#api_nan_utf8_string"><b><code>NanUtf8String</code></b></a> and <a href="#api_nan_ucs2_string"><b><code>NanUcs2String</code></b></a>. These classes manage the underlying memory for you in a safer way than just handing off an allocated array. You should now `*NanAsciiString(handle)` to access the raw `char` data, you can also allocate on the heap if you need to keep a reference.
-* Two more <a href="#api_nan_make_callback"><b><code>NanMakeCallback</code></b></a> overloads have been added to for parity with Node core.
-* You can now `NanNew(std::string)` (use `NanNew<std::string&>(std::string&)` to pass by reference)
-* <a href="#api_nan_set_template"><b><code>NanSetTemplate</code></b></a>, <a href="#api_nan_set_prototype_template"><b><code>NanSetPrototypeTemplate</code></b></a> and <a href="#api_nan_set_instance_template"><b><code>NanSetInstanceTemplate</code></b></a> have been added.
-
-### May-2014: 1.1.0 release
-
-* We've deprecated `NanSymbol()`, you should just use `NanNew<String>()` now.
-* `NanNull()`, `NanUndefined()`, `NanTrue()`, `NanFalse()` all return `Local`s now.
-* `nan_isolate` is gone, it was intended to be internal-only but if you were using it then you should switch to `v8::Isolate::GetCurrent()`.
-* `NanNew()` has received some additional overload-love so you should be able to give it many kinds of values without specifying the `<Type>`.
-* Lots of small fixes and additions to expand the V8 API coverage, *use the source, Luke*.
-
-
-### May-2014: Major changes for V8 3.25 / Node 0.11.13
-
-Node 0.11.11 and 0.11.12 were both broken releases for native add-ons, you simply can't properly compile against either of them for different reasons. But we now have a 0.11.13 release that jumps a couple of versions of V8 ahead and includes some more, major (traumatic) API changes.
-
-Because we are now nearing Node 0.12 and estimate that the version of V8 we are using in Node 0.11.13 will be close to the API we get for 0.12, we have taken the opportunity to not only *fix* NAN for 0.11.13 but make some major changes to improve the NAN API.
-
-We have **removed support for Node 0.11 versions prior to 0.11.13**. As usual, our tests are run against (and pass) the last 5 versions of Node 0.8 and Node 0.10. We also include Node 0.11.13 obviously.
-
-The major change is something that [Benjamin Byholm](kkoopa) has put many hours in to. We now have a fantastic new `NanNew<T>(args)` interface for creating new `Local`s, this replaces `NanNewLocal()` and much more. If you look in [./nan.h](nan.h) you'll see a large number of overloaded versions of this method. In general you should be able to `NanNew<Type>(arguments)` for any type you want to make a `Local` from. This includes `Persistent` types, so we now have a `Local<T> NanNew(const Persistent<T> arg)` to replace `NanPersistentToLocal()`.
-
-We also now have `NanUndefined()`, `NanNull()`, `NanTrue()` and `NanFalse()`. Mainly because of the new requirement for an `Isolate` argument for each of the native V8 versions of this.
-
-V8 has now introduced an `EscapableHandleScope` from which you `scope.Escape(Local<T> value)` to *return* a value from a one scope to another. This replaces the standard `HandleScope` and `scope.Close(Local<T> value)`, although `HandleScope` still exists for when you don't need to return a handle to the caller. For NAN we are exposing it as `NanEscapableScope()` and `NanEscapeScope()`, while `NanScope()` is still how you create a new scope that doesn't need to return handles. For older versions of Node/V8, it'll still map to the older `HandleScope` functionality.
-
-`NanFromV8String()` was deprecated and has now been removed. You should use `NanCString()` or `NanRawString()` instead.
-
-Because `node::MakeCallback()` now takes an `Isolate`, and because it doesn't exist in older versions of Node, we've introduced `NanMakeCallback()`. You should *always* use this when calling a JavaScript function from C++.
-
-There's lots more, check out the Changelog in nan.h or look through [#86](https://github.com/nodejs/nan/pull/86) for all the gory details.
-
-### Dec-2013: NanCString and NanRawString
-
-Two new functions have been introduced to replace the functionality that's been provided by `NanFromV8String` until now. NanCString has sensible defaults so it's super easy to fetch a null-terminated c-style string out of a `v8::String`. `NanFromV8String` is still around and has defaults that allow you to pass a single handle to fetch a `char*` while `NanRawString` requires a little more attention to arguments.
-
-### Nov-2013: Node 0.11.9+ breaking V8 change
-
-The version of V8 that's shipping with Node 0.11.9+ has changed the signature for new `Local`s to: `v8::Local<T>::New(isolate, value)`, i.e. introducing the `isolate` argument and therefore breaking all new `Local` declarations for previous versions. NAN 0.6+ now includes a `NanNewLocal<T>(value)` that can be used in place to work around this incompatibility and maintain compatibility with 0.8->0.11.9+ (minus a few early 0.11 releases).
-
-For example, if you wanted to return a `null` on a callback you will have to change the argument from `v8::Local<v8::Value>::New(v8::Null())` to `NanNewLocal<v8::Value>(v8::Null())`.
-
-### Nov-2013: Change to binding.gyp `"include_dirs"` for NAN
-
-Inclusion of NAN in a project's binding.gyp is now greatly simplified. You can now just use `"<!(node -e \"require('nan')\")"` in your `"include_dirs"`, see example below (note Windows needs the quoting around `require` to be just right: `"require('nan')"` with appropriate `\` escaping).
 
 <a name="usage"></a>
 ## Usage
@@ -254,6 +179,15 @@ NAN_METHOD(CalculateAsync) {
 <a name="api"></a>
 ## API
 
+<!-- START API -->
+
+API docs in here
+
+<!-- END API -->
+
+
+
+```
  * <a href="#api_nan_weak_callback"><b><code>NAN_WEAK_CALLBACK(callbackname)</code></b></a>
  * <a href="#api_nan_deprecated"><b><code>NAN_DEPRECATED</code></b></a>
  * <a href="#api_nan_inline"><b><code>NAN_INLINE</code></b></a>
@@ -307,7 +241,6 @@ NAN_WEAK_CALLBACK(weakCallback) {
     delete parameter;
   }
 }
-```
 
 <a name="api_nan_deprecated"></a>
 ### NAN_DEPRECATED
diff --git a/doc/callback.md b/doc/callback.md
index 9b64ba40..28514cc4 100644
--- a/doc/callback.md
+++ b/doc/callback.md
@@ -2,6 +2,11 @@
 
 `Nan::Callback` makes it easier to use `v8::Function` handles as callbacks. A class that wraps a `v8::Function` handle, protecting it from garbage collection and making it particularly useful for storage and use across asynchronous execution.
 
+ - <a href="#api_nan_callback"><b><code>Nan::Callback</code></b></a>
+
+<a name="api_nan_callback"></a>
+## Nan::Callback
+
 ```c++
 class Callback {
  public:

From 854d63a12bdb5e57daf86f4f6d1fd38203d66368 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 14:56:35 +1000
Subject: [PATCH 66/84] doc: add script to replace API TOC in README

---
 README.md     | 97 +++++++++++++++++++++++++++++++++++++++++++++++++--
 doc/.build.sh | 30 ++++++++++++++++
 package.json  |  3 +-
 3 files changed, 126 insertions(+), 4 deletions(-)
 create mode 100755 doc/.build.sh

diff --git a/README.md b/README.md
index d3e13ef4..cc0a6327 100644
--- a/README.md
+++ b/README.md
@@ -181,13 +181,104 @@ NAN_METHOD(CalculateAsync) {
 
 <!-- START API -->
 
-API docs in here
+### JavaScript-accessible methods
+
+Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
+
+* **Method argument types**
+ - <a href="doc/methods.md#api_nan_function_callback_info"><b><code>Nan::FunctionCallbackInfo</code></b></a>
+ - <a href="doc/methods.md#api_nan_property_callback_info"><b><code>Nan::PropertyCallbackInfo</code></b></a>
+ - <a href="doc/methods.md#api_nan_property_callback_info"><b><code>Nan::ReturnValue</code></b></a>
+* **Method declarations**
+ - <a href="doc/methods.md#api_nan_method"><b>Method declaration</b></a>
+ - <a href="doc/methods.md#api_nan_getter"><b>Getter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_setter"><b>Setter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_property_getter"><b>Property getter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_property_setter"><b>Property setter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_property_enumerator"><b>Property enumerator declaration</b></a>
+ - <a href="doc/methods.md#api_nan_property_deleter"><b>Property deleter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_property_query"><b>Property query declaration</b></a>
+ - <a href="doc/methods.md#api_nan_index_getter"><b>Index getter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_index_setter"><b>Index setter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_index_enumerator"><b>Index enumerator declaration</b></a>
+ - <a href="doc/methods.md#api_nan_index_deleter"><b>Index deleter declaration</b></a>
+ - <a href="doc/methods.md#api_nan_index_query"><b>Index query declaration</b></a>
+* Method and template helpers
+ - <a href="doc/methods.md#api_nan_set_method"><b><code>Nan::SetMethod()</code></b></a>
+ - <a href="doc/methods.md#api_nan_set_named_property_handler"><b><code>Nan::SetNamedPropertyHandler()</code></b></a>
+ - <a href="doc/methods.md#api_nan_set_indexed_property_handler"><b><code>Nan::SetIndexedPropertyHandler()</code></b></a>
+ - <a href="doc/methods.md#api_nan_set_prototype_method"><b><code>Nan::SetPrototypeMethod()</code></b></a>
+ - <a href="doc/methods.md#api_nan_set_template"><b><code>Nan::SetTemplate()</code></b></a>
+ - <a href="doc/methods.md#api_nan_set_prototype_template"><b><code>Nan::SetPrototypeTemplate()</code></b></a>
+ - <a href="doc/methods.md#api_nan_set_instance_template"><b><code>Nan::SetInstanceTemplate()</code></b></a>
+
+### Persistent references
+
+An object reference that is independent of any `HandleScope` is a _persistent_ reference. Where a `Local` handle only lives as long as the `HandleScope` in which it was allocated, a `Persistent` handle remains valid until it is explicitly disposed.
+
+Due to the evolution of the V8 API, it is necessary for NAN to provide a wrapper implementation of the `Persistent` classes to supply compatibility across the V8 versions supported.
+
+ - <a href="doc/persistent.md#api_nan_persistent_base"><b><code>Nan::PersistentBase & v8::PersistentBase</code></b></a>
+ - <a href="doc/persistent.md#api_nan_non_copyable_persistent_traits"><b><code>Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits</code></b></a>
+ - <a href="doc/persistent.md#api_nan_copyable_persistent_traits"><b><code>Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits</code></b></a>
+ - <a href="doc/persistent.md#api_nan_persistent"><b><code>Nan::Persistent</code></b></a>
+ - <a href="doc/persistent.md#api_nan_global"><b><code>Nan::Global</code></b></a>
+ - <a href="doc/persistent.md#api_nan_weak_callback_info"><b><code>Nan::WeakCallbackInfo</code></b></a>
+ - <a href="doc/persistent.md#api_nan_weak_callback_type"><b><code>Nan::WeakCallbackType</code></b></a>
+
+### Converters
+
+NAN contains functions that convert `v8::Value`s to other `v8::Value` types and native types. Since type conversion is not guaranteed to succeed, they return `Nan::Maybe` types. These converters can be used in place of `value->ToX()` and `value->XValue()` (where `X` is one of the types, e.g. `Boolean`) in a way that provides a consistent interface across V8 versions. Newer versions of V8 use the new `v8::Maybe` and `v8::MaybeLocal` types for these conversions, older versions don't have this functionality so it is provided by NAN.
+
+ - <a href="doc/converters.md#api_nan_to"><b><code>Nan::To</code></b></a>
+
+### Maybe Types
+
+The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Local` handles that _may be empty_.
+
+ - <a href="doc/maybe_types.md#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
+ - <a href="doc/maybe_types.md#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
+ - <a href="doc/maybe_types.md#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
+ - <a href="doc/maybe_types.md#api_nan_just"><b><code>Nan::Just</code></b></a>
+
+### Nan::Callback
+
+`Nan::Callback` makes it easier to use `v8::Function` handles as callbacks. A class that wraps a `v8::Function` handle, protecting it from garbage collection and making it particularly useful for storage and use across asynchronous execution.
+
+ - <a href="doc/callback.md#api_nan_callback"><b><code>Nan::Callback</code></b></a>
+
+### Asynchronous work helpers
+
+`Nan::AsyncWorker` and `Nan::AsyncProgressWorker` are helper classes that make working with asynchronous code easier.
+
+ - <a href="doc/asyncworker.md#api_nan_async_worker"><b><code>Nan::AsyncWorker</code></b></a>
+ - <a href="doc/asyncworker.md#api_nan_async_progress_worker"><b><code>Nan::AsyncProgressWorker</code></b></a>
+ - <a href="doc/asyncworker.md#api_nan_async_queue_worker"><b><code>Nan::AsyncQueueWorker</code></b></a>
+
+### V8 internals
+
+The hooks to access V8 internals—including GC and statistics—are different across the supported versions of V8, therefore NAN provides its own hooks that call the appropriate V8 methods.
+
+ - <a href="doc/v8_internals.md#api_nan_gc_callback"><b><code>NAN_GC_CALLBACK()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_add_gc_epilogue_callback"><b><code>Nan::AddGCEpilogueCallback()</code></b></a
+ - <a href="doc/v8_internals.md#api_nan_remove_gc_epilogue_callback"><b><code>Nan::RemoveGCEpilogueCallback()</code></b></a
+ - <a href="doc/v8_internals.md#api_nan_add_gc_prologue_callback"><b><code>Nan::AddGCPrologueCallback()</code></b></a
+ - <a href="doc/v8_internals.md#api_nan_remove_gc_prologue_callback"><b><code>Nan::RemoveGCPrologueCallback()</code></b></a
+ - <a href="doc/v8_internals.md#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics()</code></b></a
+ - <a href="doc/v8_internals.md#api_nan_get_heap_statistics"><b><code>Nan::GetHeapStatistics()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_set_counter_function"><b><code>Nan::SetCounterFunction()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_set_create_histogram_function"><b><code>Nan::SetCreateHistogramFunction()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_set_add_histogram_sample_function"><b><code>Nan::SetAddHistogramSampleFunction()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_idle_notification"><b><code>Nan::IdleNotification()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_low_memory_notification"><b><code>Nan::LowMemoryNotification()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_context_disposed_notification"><b><code>Nan::ContextDisposedNotification()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_get_internal_field_pointer"><b><code>Nan::GetInternalFieldPointer()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_set_internal_field_pointer"><b><code>Nan::SetInternalFieldPointer()</code></b></a>
+ - <a href="doc/v8_internals.md#api_nan_adjust_external_memory"><b><code>Nan::AdjustExternalMemory()</code></b></a>
 
 <!-- END API -->
 
 
-
-```
  * <a href="#api_nan_weak_callback"><b><code>NAN_WEAK_CALLBACK(callbackname)</code></b></a>
  * <a href="#api_nan_deprecated"><b><code>NAN_DEPRECATED</code></b></a>
  * <a href="#api_nan_inline"><b><code>NAN_INLINE</code></b></a>
diff --git a/doc/.build.sh b/doc/.build.sh
new file mode 100755
index 00000000..de5cdedc
--- /dev/null
+++ b/doc/.build.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+files="         \
+  methods.md      \
+  persistent.md   \
+  converters.md   \
+  maybe_types.md  \
+  callback.md     \
+  asyncworker.md  \
+  v8_internals.md \
+"
+
+__dirname=$(dirname "${BASH_SOURCE[0]}")
+head=$(perl -e 'while (<>) { if (!$en){print;} if ($_=~/<!-- START/){$en=1} };' $__dirname/../README.md)
+tail=$(perl -e 'while (<>) { if ($_=~/<!-- END/){$st=1} if ($st){print;} };' $__dirname/../README.md)
+apidocs=$(for f in $files; do
+  perl -pe '
+    last if /^<a name/;
+    $_ =~ s/^## /### /;
+    $_ =~ s/<a href="#/<a href="doc\/'$f'#/;
+  ' $__dirname/$f;
+done)
+
+cat > $__dirname/../README.md << EOF
+$head
+
+$apidocs
+
+$tail
+EOF
\ No newline at end of file
diff --git a/package.json b/package.json
index d4bd35ed..6ea730f5 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,8 @@
   },
   "scripts": {
     "test": "tap --gc test/js/*-test.js",
-    "rebuild-tests": "pangyp rebuild --msvs_version=2013 --directory test"
+    "rebuild-tests": "pangyp rebuild --msvs_version=2013 --directory test",
+    "docs": "doc/.build.sh"
   },
   "contributors": [
     "Rod Vagg <r@va.gg> (https://github.com/rvagg)",

From 3e890e4b08987395623c2b9725636cd2ac03a58c Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 22:22:03 +1000
Subject: [PATCH 67/84] doc: added errors.md

---
 README.md          |  33 -------
 doc/errors.md      | 224 +++++++++++++++++++++++++++++++++++++++++++++
 doc/maybe_types.md |   1 -
 3 files changed, 224 insertions(+), 34 deletions(-)
 create mode 100644 doc/errors.md

diff --git a/README.md b/README.md
index cc0a6327..7306e71b 100644
--- a/README.md
+++ b/README.md
@@ -294,8 +294,6 @@ The hooks to access V8 internals—including GC and statistics—are different a
  * <a href="#api_nan_ascii_string"><b><code>NanAsciiString</code></b></a>
  * <a href="#api_nan_utf8_string"><b><code>NanUtf8String</code></b></a>
  * <a href="#api_nan_ucs2_string"><b><code>NanUcs2String</code></b></a>
- * <a href="#api_nan_error"><b><code>NanError</code></b>, <b><code>NanRangeError</code></b>, <b><code>NanReferenceError</code></b>, <b><code>NanSyntaxError</code></b>, <b><code>NanTypeError</code></b></a>
- * <a href="#api_nan_throw_error"><b><code>NanThrowError</code></b>, <b><code>NanThrowRangeError</code></b>, <b><code>NanThrowReferenceError</code></b>, <b><code>NanThrowSyntaxError</code></b>, <b><code>NanThrowTypeError</code></b>, <b><code>NanThrowError(Handle<Value>)</code></b>, <b><code>NanThrowError(Handle<Value>, int)</code></b></a>
  * <a href="#api_nan_new_buffer_handle"><b><code>NanNewBufferHandle(char *, size_t, FreeCallback, void *)</code></b>, <b><code>NanNewBufferHandle(char *, uint32_t)</code></b>, <b><code>NanNewBufferHandle(uint32_t)</code></b></a>
  * <a href="#api_nan_buffer_use"><b><code>NanBufferUse(char *, uint32_t)</code></b></a>
  * <a href="#api_nan_get_current_context"><b><code>NanGetCurrentContext</code></b></a>
@@ -304,8 +302,6 @@ The hooks to access V8 internals—including GC and statistics—are different a
  * <a href="#api_nan_assign_persistent"><b><code>NanAssignPersistent</code></b></a>
  * <a href="#api_nan_make_weak_persistent"><b><code>NanMakeWeakPersistent</code></b></a>
  * <a href="#api_nan_make_callback"><b><code>NanMakeCallback</code></b></a>
- * <a href="#api_nan_fatal_exception"><b><code>NanFatalException</code></b></a>
- * <a href="#api_nan_errno_exception"><b><code>NanErrnoException</code></b></a>
  * <a href="#api_nan_get_isolate_data"><b><code>NanGetIsolateData</code></b></a>
  * <a href="#api_nan_set_isolate_data"><b><code>NanSetIsolateData</code></b></a>
  * <a href="#api_nan_encode"><b><code>NanEncode</code></b></a>
@@ -571,25 +567,6 @@ NAN_METHOD(bar) {
 printf(**str);
 ```
 
-<a name="api_nan_error"></a>
-### NanError(message), NanRangeError(message), NanReferenceError(message), NanSyntaxError(message), NanTypeError(message)
-
-For making `Error`, `RangeError`, `ReferenceError`, `SyntaxError` and `TypeError` objects.
-
-```c++
-Local<Value> res = NanError("you must supply a callback argument");
-```
-
-<a name="api_nan_throw_error"></a>
-### NanThrowError(message), NanThrowRangeError(message), NanThrowReferenceError(message), NanThrowSyntaxError(message), NanThrowTypeError(message), NanThrowError(Local&lt;Value&gt;), NanThrowError(Local&lt;Value&gt;, int)
-
-For throwing `Error`, `RangeError`, `ReferenceError`, `SyntaxError` and `TypeError` objects.
-
-```c++
-NanThrowError("you must supply a callback argument");
-```
-
-Can also handle any custom object you may want to throw. If used with the error code argument, it will add the supplied error code to the error object as a property called `code`.
 
 <a name="api_nan_new_buffer_handle"></a>
 ### Local&lt;Object&gt; NanNewBufferHandle(char *, uint32_t), Local&lt;Object&gt; NanNewBufferHandle(uint32_t)
@@ -681,16 +658,6 @@ NanMakeWeakPersistent(func, parameter, &weakCallback);
 
 Use instead of `node::MakeCallback` to call javascript functions. This (or `NanCallback`) is the only proper way of calling functions. You must _*never, ever*_ directly use `Function::Call`, it will lead to run-time failures.
 
-<a name="api_nan_fatal_exception"></a>
-### NanFatalException(const v8::TryCatch &amp;)
-
-Replaces `node::FatalException`.
-
-<a name="api_nan_errno_exception"></a>
-### NanErrnoException(int errorno, const char *syscall = NULL, const char *message = NULL, const char *path = NULL)
-
-Replaces `node::ErrnoException`.
-
 <a name="api_nan_get_isolate_data"></a>
 ### NanGetIsolateData(v8::Isolate *)
 
diff --git a/doc/errors.md b/doc/errors.md
new file mode 100644
index 00000000..7222c6be
--- /dev/null
+++ b/doc/errors.md
@@ -0,0 +1,224 @@
+## Errors
+
+NAN includes helpers for creating, throwing and catching Errors as much of this functionality varies across the supported versions of V8 and must be abstracted.
+
+Note that an Error object is simply a specialized form of `v8::Value`.
+
+ - <a href="#api_nan_error"><b><code>Nan::Error()</code></b></a>
+ - <a href="#api_nan_range_error"><b><code>Nan::RangeError()</code></b></a>
+ - <a href="#api_nan_reference_error"><b><code>Nan::ReferenceError()</code></b></a>
+ - <a href="#api_nan_syntax_error"><b><code>Nan::SyntaxError()</code></b></a>
+ - <a href="#api_nan_type_error"><b><code>Nan::TypeError()</code></b></a>
+ - <a href="#api_nan_throw_error"><b><code>Nan::ThrowError()</code></b></a>
+ - <a href="#api_nan_throw_range_error"><b><code>Nan::ThrowRangeError()</code></b></a>
+ - <a href="#api_nan_throw_reference_error"><b><code>Nan::ThrowReferenceError()</code></b></a>
+ - <a href="#api_nan_throw_syntax_error"><b><code>Nan::ThrowSyntaxError()</code></b></a>
+ - <a href="#api_nan_throw_type_error"><b><code>Nan::ThrowTypeError()</code></b></a>
+ - <a href="#api_nan_fatal_exception"><b><code>Nan::FatalException()</code></b></a>
+ - <a href="#api_nan_errno_exception"><b><code>Nan::ErrnoException()</code></b></a>
+ - <a href="#api_nan_try_catch"><b><code>Nan::TryCatch</code></b></a>
+
+
+<a name="api_nan_error"></a>
+### Nan::Error()
+
+Create a new Error object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
+
+Note that an Error object is simply a specialized form of `v8::Value`.
+
+Signature:
+
+```c++
+v8::Local<v8::Value> Nan::Error(const char *msg);
+v8::Local<v8::Value> Nan::Error(v8::Local<v8::String> msg);
+```
+
+
+<a name="api_nan_range_error"></a>
+### Nan::RangeError()
+
+Create a new RangeError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
+
+Note that an RangeError object is simply a specialized form of `v8::Value`.
+
+Signature:
+
+```c++
+v8::Local<v8::Value> Nan::RangeError(const char *msg);
+v8::Local<v8::Value> Nan::RangeError(v8::Local<v8::String> msg);
+```
+
+
+<a name="api_nan_reference_error"></a>
+### Nan::ReferenceError()
+
+Create a new ReferenceError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
+
+Note that an ReferenceError object is simply a specialized form of `v8::Value`.
+
+Signature:
+
+```c++
+v8::Local<v8::Value> Nan::ReferenceError(const char *msg);
+v8::Local<v8::Value> Nan::ReferenceError(v8::Local<v8::String> msg);
+```
+
+
+<a name="api_nan_syntax_error"></a>
+### Nan::SyntaxError()
+
+Create a new SyntaxError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
+
+Note that an SyntaxError object is simply a specialized form of `v8::Value`.
+
+Signature:
+
+```c++
+v8::Local<v8::Value> Nan::SyntaxError(const char *msg);
+v8::Local<v8::Value> Nan::SyntaxError(v8::Local<v8::String> msg);
+```
+
+
+<a name="api_nan_type_error"></a>
+### Nan::TypeError()
+
+Create a new TypeError object using the [v8::Exception](https://v8docs.nodesource.com/io.js-3.0/da/d6a/classv8_1_1_exception.html) class in a way that is compatible across the supported versions of V8.
+
+Note that an TypeError object is simply a specialized form of `v8::Value`.
+
+Signature:
+
+```c++
+v8::Local<v8::Value> Nan::TypeError(const char *msg);
+v8::Local<v8::Value> Nan::TypeError(v8::Local<v8::String> msg);
+```
+
+
+<a name="api_nan_throw_error"></a>
+### Nan::ThrowError()
+
+Throw an Error object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new Error object will be created.
+
+Signature:
+
+```c++
+void Nan::ThrowError(const char *msg);
+void Nan::ThrowError(v8::Local<v8::String> msg);
+void Nan::ThrowError(v8::Local<v8::Value> error);
+```
+
+
+<a name="api_nan_throw_range_error"></a>
+### Nan::ThrowRangeError()
+
+Throw an RangeError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new RangeError object will be created.
+
+Signature:
+
+```c++
+void Nan::ThrowRangeError(const char *msg);
+void Nan::ThrowRangeError(v8::Local<v8::String> msg);
+void Nan::ThrowRangeError(v8::Local<v8::Value> error);
+```
+
+
+<a name="api_nan_throw_reference_error"></a>
+### Nan::ThrowReferenceError()
+
+Throw an ReferenceError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new ReferenceError object will be created.
+
+Signature:
+
+```c++
+void Nan::ThrowReferenceError(const char *msg);
+void Nan::ThrowReferenceError(v8::Local<v8::String> msg);
+void Nan::ThrowReferenceError(v8::Local<v8::Value> error);
+```
+
+
+<a name="api_nan_throw_syntax_error"></a>
+### Nan::ThrowSyntaxError()
+
+Throw an SyntaxError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new SyntaxError object will be created.
+
+Signature:
+
+```c++
+void Nan::ThrowSyntaxError(const char *msg);
+void Nan::ThrowSyntaxError(v8::Local<v8::String> msg);
+void Nan::ThrowSyntaxError(v8::Local<v8::Value> error);
+```
+
+
+<a name="api_nan_throw_type_error"></a>
+### Nan::ThrowTypeError()
+
+Throw an TypeError object (a specialized `v8::Value` as above) in the current context. If a `msg` is provided, a new TypeError object will be created.
+
+Signature:
+
+```c++
+void Nan::ThrowTypeError(const char *msg);
+void Nan::ThrowTypeError(v8::Local<v8::String> msg);
+void Nan::ThrowTypeError(v8::Local<v8::Value> error);
+```
+
+<a name="api_nan_fatal_exception"></a>
+### Nan::FatalException()
+
+Replaces `node::FatalException()` which has a different API across supported versions of Node. For use with [`Nan::TryCatch`](#api_nan_try_catch).
+
+Signature:
+
+```c++
+void Nan::FatalException(const Nan::TryCatch& try_catch);
+```
+
+<a name="api_nan_errno_exception"></a>
+### Nan::ErrnoException()
+
+Replaces `node::ErrnoException()` which has a different API across supported versions of Node. 
+
+Signature:
+
+```c++
+v8::Local<v8::Value> Nan::ErrnoException(int errorno,
+                                         const char* syscall = NULL,
+                                         const char* message = NULL,
+                                         const char* path = NULL);
+```
+
+
+<a name="api_nan_try_catch"></a>
+### Nan::TryCatch
+
+A simple wrapper around [`v8::TryCatch`](https://v8docs.nodesource.com/io.js-3.0/d4/dc6/classv8_1_1_try_catch.html) compatible with all supported versions of V8. Can be used as a direct replacement in most cases. See also [`Nan::FatalException()`](#api_nan_fatal_exception) for an internal use compatible with `node::FatalException`.
+
+Signature:
+
+```c++
+class Nan::TryCatch {
+ public:
+  Nan::TryCatch();
+
+  bool HasCaught() const;
+
+  bool CanContinue() const;
+
+  v8::Local<v8::Value> ReThrow();
+
+  v8::Local<v8::Value> Exception() const;
+
+  // Nan::MaybeLocal for older versions of V8
+  v8::MaybeLocal<v8::Value> StackTrace() const;
+
+  v8::Local<v8::Message> Message() const;
+
+  void Reset();
+
+  void SetVerbose(bool value);
+
+  void SetCaptureMessage(bool value);
+};
+```
+
diff --git a/doc/maybe_types.md b/doc/maybe_types.md
index ab7df4de..018d1fa1 100644
--- a/doc/maybe_types.md
+++ b/doc/maybe_types.md
@@ -7,7 +7,6 @@ The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Lo
  - <a href="#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
  - <a href="#api_nan_just"><b><code>Nan::Just</code></b></a>
 
-<a name="api_nan_maybe"></a>
 <a name="api_nan_maybe_local"></a>
 ### Nan::MaybeLocal
 

From e85fd3c0932a8f106f4e0e8e66db4c0313178830 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 22:58:21 +1000
Subject: [PATCH 68/84] doc: added new.md

---
 doc/.build.sh |  4 ++-
 doc/new.md    | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 doc/new.md

diff --git a/doc/.build.sh b/doc/.build.sh
index de5cdedc..fde47e3a 100755
--- a/doc/.build.sh
+++ b/doc/.build.sh
@@ -1,10 +1,12 @@
 #!/usr/bin/env bash
 
-files="         \
+files="           \
   methods.md      \
   persistent.md   \
+  new.md          \
   converters.md   \
   maybe_types.md  \
+  errors.md       \
   callback.md     \
   asyncworker.md  \
   v8_internals.md \
diff --git a/doc/new.md b/doc/new.md
new file mode 100644
index 00000000..b2ebac13
--- /dev/null
+++ b/doc/new.md
@@ -0,0 +1,67 @@
+## New
+
+NAN provides a `Nan::New()` helper for the creation of new JavaScript objects in a way that's compatible across the supported versions of V8.
+
+ - <a href="#api_nan_new"><b><code>Nan::New()</code></b></a>
+
+
+<a name="api_nan_new"></a>
+### Nan::New()
+
+`Nan::New()` should be used to instantiate new JavaScript objects.
+
+Refer to the specific V8 type in the [V8 documentation](https://v8docs.nodesource.com/io.js-3.0/d1/d83/classv8_1_1_data.html) for information on the types of arguments required for instantiation.
+
+Signatures:
+
+Return types are mostly omitted from the signatures for simplicity. In most cases the type will be contained within a `v8::Local<T>`. The following types will be contained within a `Nan::MaybeLocal<T>`: `v8::String`, `v8::Date`, `v8::RegExp`, `v8::Script`, `v8::UnboundScript`.
+
+Empty objects:
+
+```c++
+Nan::New<T>();
+```
+
+Generic single and multiple-argument:
+
+```c++
+Nan::New<T>(A0 arg0);
+Nan::New<T>(A0 arg0, A1 arg1);
+Nan::New<T>(A0 arg0, A1 arg1, A2 arg2);
+Nan::New<T>(A0 arg0, A1 arg1, A2 arg2, A3 arg3);
+```
+
+For creating `v8::FunctionTemplate` and `v8::Function` objects:
+
+_The definition of `Nan::FunctionCallback` can be found in the [Method declaration](./methods.md#api_nan_method) documentation._
+
+```c++
+Nan::New<T>(Nan::FunctionCallback callback,
+            v8::Local<v8::Value> data = v8::Local<v8::Value>());
+Nan::New<T>(Nan::FunctionCallback callback,
+            v8::Local<v8::Value> data = v8::Local<v8::Value>(),
+            A2 a2 = A2());
+```
+
+Native types:
+
+```c++
+v8::Local<v8::Boolean> Nan::New<T>(bool value);
+v8::Local<v8::Int32> Nan::New<T>(int32_t value);
+v8::Local<v8::Uint32> Nan::New<T>(uint32_t value);
+v8::Local<v8::Number> Nan::New<T>(double value);
+v8::Local<v8::String> Nan::New<T>(std::string const& value);
+v8::Local<v8::String> Nan::New<T>(const char * value, int length);
+v8::Local<v8::String> Nan::New<T>(const char * value);
+v8::Local<v8::String> Nan::New<T>(const uint16_t * value);
+```
+
+Specialized types:
+
+```c++
+v8::Local<v8::String> Nan::New<T>(v8::String::ExternalStringResource * value);
+v8::Local<v8::String> Nan::New<T>(Nan::ExternalOneByteStringResource * value);
+v8::Local<v8::RegExp> Nan::New<T>(v8::Local<v8::String> pattern, v8::RegExp::Flags flags);
+```
+
+Note that `Nan::ExternalOneByteStringResource` maps to [`v8::String::ExternalOneByteStringResource`](https://v8docs.nodesource.com/io.js-3.0/d9/db3/classv8_1_1_string_1_1_external_one_byte_string_resource.html), and `v8::String::ExternalAsciiStringResource` in older versions of V8.

From 91586e83a50834dfb9375259e31333bda904f9f5 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 23:13:33 +1000
Subject: [PATCH 69/84] doc: added scopes.md

---
 doc/.build.sh |  1 +
 doc/scopes.md | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)
 create mode 100644 doc/scopes.md

diff --git a/doc/.build.sh b/doc/.build.sh
index fde47e3a..9c3e3506 100755
--- a/doc/.build.sh
+++ b/doc/.build.sh
@@ -2,6 +2,7 @@
 
 files="           \
   methods.md      \
+  scopes.md       \
   persistent.md   \
   new.md          \
   converters.md   \
diff --git a/doc/scopes.md b/doc/scopes.md
new file mode 100644
index 00000000..5c24ef22
--- /dev/null
+++ b/doc/scopes.md
@@ -0,0 +1,68 @@
+## Scopes
+
+The creation of `HandleScope` objects is different across the supported versions of V8. Therefore, NAN provides its own implementations that can be used safely across these.
+
+ - <a href="#api_nan_handle_scope"><b><code>Nan::HandleScope</code></b></a>
+ - <a href="#api_nan_escapable_handle_scope"><b><code>Nan::EscapableHandleScope</code></b></a>
+
+
+<a name="api_nan_handle_scope"></a>
+### Nan::HandleScope
+
+A simple wrapper around [`v8::HandleScope`](https://v8docs.nodesource.com/io.js-3.0/d3/d95/classv8_1_1_handle_scope.html).
+
+Definition:
+
+```c++
+class Nan::HandleScope {
+ public:
+  Nan::HandleScope();
+  static int NumberOfHandles();
+};
+```
+
+Allocate a new `Nan::HandleScope` whenever you are creating new V8 JavaScript objects. Note that an implicit `HandleScope` is created for you on JavaScript-accessible methods so you do not need to insert one yourself.
+
+Example:
+
+```c++
+// new object is created, it needs a new scope:
+void Pointless() {
+  Nan::HandleScope scope;
+  v8::Local<v8::Object> obj = Nan::New<v8::Object>();
+}
+
+// JavaScript-accessible method already has a HandleScope
+NAN_METHOD(Pointless2) {
+  v8::Local<v8::Object> obj = Nan::New<v8::Object>();
+}
+```
+
+<a name="api_nan_escapable_handle_scope"></a>
+### Nan::EscapableHandleScope
+
+Similar to [`Nan::HandleScope`](#api_nan_handle_scope) but should be used in cases where a function needs to return a V8 JavaScript type that has been created within it.
+
+Definition:
+
+```c++
+class Nan::EscapableHandleScope {
+ public:
+  Nan::EscapableHandleScope();
+  static int NumberOfHandles();
+  template<typename T> v8::Local<T> Escape(v8::Local<T> value);
+}
+```
+
+Use `Escape(value)` to return the object.
+
+Example:
+
+```c++
+v8::Local<v8::Object> EmptyObj() {
+  Nan::EscapableHandleScope scope;
+  v8::Local<v8::Object> obj = Nan::New<v8::Object>();
+  return scope.Escape(obj);
+}
+```
+

From 67eca52ce5fec4d4bbe7703317ae0d80feb2085a Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Wed, 29 Jul 2015 23:58:42 +1000
Subject: [PATCH 70/84] doc: added Maybe helpers

---
 doc/callback.md    |   2 +-
 doc/maybe_types.md | 410 ++++++++++++++++++++++++++++++++++++++++++++-
 doc/new.md         |  56 +++++++
 doc/persistent.md  |  14 +-
 4 files changed, 467 insertions(+), 15 deletions(-)

diff --git a/doc/callback.md b/doc/callback.md
index 28514cc4..93f89dc7 100644
--- a/doc/callback.md
+++ b/doc/callback.md
@@ -5,7 +5,7 @@
  - <a href="#api_nan_callback"><b><code>Nan::Callback</code></b></a>
 
 <a name="api_nan_callback"></a>
-## Nan::Callback
+### Nan::Callback
 
 ```c++
 class Callback {
diff --git a/doc/maybe_types.md b/doc/maybe_types.md
index 018d1fa1..6e2f92f2 100644
--- a/doc/maybe_types.md
+++ b/doc/maybe_types.md
@@ -2,10 +2,40 @@
 
 The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Local` handles that _may be empty_.
 
- - <a href="#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
- - <a href="#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
- - <a href="#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
- - <a href="#api_nan_just"><b><code>Nan::Just</code></b></a>
+* **Maybe Types**
+  - <a href="#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
+  - <a href="#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
+  - <a href="#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
+  - <a href="#api_nan_just"><b><code>Nan::Just</code></b></a>
+* **Maybe Helpers**
+  - <a href="#api_nan_to_detail_string"><b><code>Nan::ToDetailString()</code></b></a>
+  - <a href="#api_nan_to_array_index"><b><code>Nan::ToArrayIndex()</code></b></a>
+  - <a href="#api_nan_equals"><b><code>Nan::Equals()</code></b></a>
+  - <a href="#api_nan_new_instance"><b><code>Nan::NewInstance()</code></b></a>
+  - <a href="#api_nan_get_function"><b><code>Nan::GetFunction()</code></b></a>
+  - <a href="#api_nan_set"><b><code>Nan::Set()</code></b></a>
+  - <a href="#api_nan_force_set"><b><code>Nan::ForceSet()</code></b></a>
+  - <a href="#api_nan_get"><b><code>Nan::Get()</code></b></a>
+  - <a href="#api_nan_get_property_attribute"><b><code>Nan::GetPropertyAttributes()</code></b></a>
+  - <a href="#api_nan_has"><b><code>Nan::Has()</code></b></a>
+  - <a href="#api_nan_delete"><b><code>Nan::Delete()</code></b></a>
+  - <a href="#api_nan_get_property_names"><b><code>Nan::GetPropertyNames()</code></b></a>
+  - <a href="#api_nan_get_own_property_names"><b><code>Nan::GetOwnPropertyNames()</code></b></a>
+  - <a href="#api_nan_set_prototype"><b><code>Nan::SetPrototype()</code></b></a>
+  - <a href="#api_nan_object_proto_to_string"><b><code>Nan::ObjectProtoToString()</code></b></a>
+  - <a href="#api_nan_has_own_property"><b><code>Nan::HasOwnProperty()</code></b></a>
+  - <a href="#api_nan_has_real_named_property"><b><code>Nan::HasRealNamedProperty()</code></b></a>
+  - <a href="#api_nan_has_real_indexed_property"><b><code>Nan::HasRealIndexedProperty()</code></b></a>
+  - <a href="#api_nan_has_real_named_callback_property"><b><code>Nan::HasRealNamedCallbackProperty()</code></b></a>
+  - <a href="#api_nan_get_real_named_property_in_prototype_chain"><b><code>Nan::GetRealNamedPropertyInPrototypeChain()</code></b></a>
+  - <a href="#api_nan_get_real_named_property"><b><code>Nan::GetRealNamedProperty()</code></b></a>
+  - <a href="#api_nan_call_as_function"><b><code>Nan::CallAsFunction()</code></b></a>
+  - <a href="#api_nan_call_as_constructor"><b><code>Nan::CallAsConstructor()</code></b></a>
+  - <a href="#api_nan_get_source_line"><b><code>Nan::GetSourceLine()</code></b></a>
+  - <a href="#api_nan_get_line_number"><b><code>Nan::GetLineNumber()</code></b></a>
+  - <a href="#api_nan_get_start_column"><b><code>Nan::GetStartColumn()</code></b></a>
+  - <a href="#api_nan_get_end_column"><b><code>Nan::GetEndColumn()</code></b></a>
+  - <a href="#api_nan_clone_element_at"><b><code>Nan::CloneElementAt()</code></b></a>
 
 <a name="api_nan_maybe_local"></a>
 ### Nan::MaybeLocal
@@ -37,7 +67,7 @@ template<typename T> class Nan::MaybeLocal {
 See the documentation for [`v8::MaybeLocal`](https://v8docs.nodesource.com/io.js-3.0/d8/d7d/classv8_1_1_maybe_local.html) for further details.
 
 <a name="api_nan_maybe"></a>
-## Nan::Maybe
+### Nan::Maybe
 
 A simple `Nan::Maybe` type, representing an object which may or may not have a value, see https://hackage.haskell.org/package/base/docs/Data-Maybe.html.
 
@@ -65,7 +95,7 @@ template<typename T> class Nan::Maybe {
 See the documentation for [`v8::Maybe`](https://v8docs.nodesource.com/io.js-3.0/d9/d4b/classv8_1_1_maybe.html) for further details.
 
 <a name="api_nan_nothing"></a>
-## Nan::Nothing
+### Nan::Nothing
 
 Construct an empty `Nan::Maybe` type representing _nothing_.
 
@@ -74,10 +104,376 @@ template<typename T> Nan::Maybe<T> Nan::Nothing();
 ```
 
 <a name="api_nan_just"></a>
-## Nan::Just
+### Nan::Just
 
 Construct a `Nan::Maybe` type representing _just_ a value.
 
 ```c++
 template<typename T> Nan::Maybe<T> Nan::Just(const T &t);
 ```
+
+
+<a name="api_nan_to_detail_string"></a>
+### Nan::ToDetailString()
+
+A helper method for calling [`v8::Value#ToDetailString()`](https://v8docs.nodesource.com/io.js-3.0/dc/d0a/classv8_1_1_value.html#a2f9770296dc2c8d274bc8cc0dca243e5) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::String> Nan::ToDetailString(v8::Local<v8::Value> val);
+```
+
+
+<a name="api_nan_to_array_index"></a>
+### Nan::ToArrayIndex()
+
+A helper method for calling [`v8::Value#ToArrayIndex()`](https://v8docs.nodesource.com/io.js-3.0/dc/d0a/classv8_1_1_value.html#acc5bbef3c805ec458470c0fcd6f13493) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Uint32> Nan::ToArrayIndex(v8::Local<v8::Value> val);
+```
+
+
+<a name="api_nan_equals"></a>
+### Nan::Equals()
+
+A helper method for calling [`v8::Value#Equals()`](https://v8docs.nodesource.com/io.js-3.0/dc/d0a/classv8_1_1_value.html#a0d9616ab2de899d4e3047c30a10c9285) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::Equals(v8::Local<v8::Value> a, v8::Local<v8::Value>(b));
+```
+
+
+<a name="api_nan_new_instance"></a>
+### Nan::NewInstance()
+
+A helper method for calling [`v8::Function#NewInstance()`](https://v8docs.nodesource.com/io.js-3.0/d5/d54/classv8_1_1_function.html#a691b13f7a553069732cbacf5ac8c62ec) and [`v8::ObjectTemplate#NewInstance()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#ad605a7543cfbc5dab54cdb0883d14ae4) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Object> Nan::NewInstance(v8::Local<v8::Function> h);
+Nan::MaybeLocal<v8::Object> Nan::NewInstance(v8::Local<v8::ObjectTemplate> h);
+```
+
+
+<a name="api_nan_get_function"></a>
+### Nan::GetFunction()
+
+A helper method for calling [`v8::FunctionTemplate#GetFunction()`](https://v8docs.nodesource.com/io.js-3.0/d8/d83/classv8_1_1_function_template.html#a56d904662a86eca78da37d9bb0ed3705) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Function> Nan::GetFunction(v8::Local<v8::FunctionTemplate> t);
+```
+
+
+<a name="api_nan_set"></a>
+### Nan::Set()
+
+A helper method for calling [`v8::Object#Set()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a67604ea3734f170c66026064ea808f20) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::Set(v8::Local<v8::Object> obj,
+                          v8::Local<v8::Value> key,
+                          v8::Local<v8::Value> value)
+Nan::Maybe<bool> Nan::Set(v8::Local<v8::Object> obj,
+                          uint32_t index,
+                          v8::Local<v8::Value> value);
+```
+
+
+<a name="api_nan_force_set"></a>
+### Nan::ForceSet()
+
+A helper method for calling [`v8::Object#ForceSet()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a796b7b682896fb64bf1872747734e836) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::ForceSet(v8::Local<v8::Object> obj,
+                               v8::Local<v8::Value> key,
+                               v8::Local<v8::Value> value,
+                               v8::PropertyAttribute attribs = v8::None);
+```
+
+
+<a name="api_nan_get"></a>
+### Nan::Get()
+
+A helper method for calling [`v8::Object#Get()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a2565f03e736694f6b1e1cf22a0b4eac2) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Value> Nan::Get(v8::Local<v8::Object> obj,
+                                    v8::Local<v8::Value> key);
+Nan::MaybeLocal<v8::Value> Nan::Get(v8::Local<v8::Object> obj, uint32_t index);
+```
+
+
+<a name="api_nan_get_property_attribute"></a>
+### Nan::GetPropertyAttributes()
+
+A helper method for calling [`v8::Object#GetPropertyAttributes()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a9b898894da3d1db2714fd9325a54fe57) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<v8::PropertyAttribute> Nan::GetPropertyAttributes(
+    v8::Local<v8::Object> obj,
+    v8::Local<v8::Value> key);
+```
+
+
+<a name="api_nan_has"></a>
+### Nan::Has()
+
+A helper method for calling [`v8::Object#Has()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab3c3d89ea7c2f9afd08965bd7299a41d) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::Has(v8::Local<v8::Object> obj, v8::Local<v8::String> key);
+Nan::Maybe<bool> Nan::Has(v8::Local<v8::Object> obj, uint32_t index);
+```
+
+
+<a name="api_nan_delete"></a>
+### Nan::Delete()
+
+A helper method for calling [`v8::Object#Delete()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a2fa0f5a592582434ed1ceceff7d891ef) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::Delete(v8::Local<v8::Object> obj,
+                             v8::Local<v8::String> key);
+Nan::Maybe<bool> Nan::Delete(v8::Local<v8::Object> obj, uint32_t index);
+```
+
+
+<a name="api_nan_get_property_names"></a>
+### Nan::GetPropertyNames()
+
+A helper method for calling [`v8::Object#GetPropertyNames()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#aced885270cfd2c956367b5eedc7fbfe8) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Array> Nan::GetPropertyNames(v8::Local<v8::Object> obj);
+```
+
+
+<a name="api_nan_get_own_property_names"></a>
+### Nan::GetOwnPropertyNames()
+
+A helper method for calling [`v8::Object#GetOwnPropertyNames()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a79a6e4d66049b9aa648ed4dfdb23e6eb) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Array> Nan::GetOwnPropertyNames(v8::Local<v8::Object> obj);
+```
+
+
+<a name="api_nan_set_prototype"></a>
+### Nan::SetPrototype()
+
+A helper method for calling [`v8::Object#SetPrototype()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a442706b22fceda6e6d1f632122a9a9f4) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::SetPrototype(v8::Local<v8::Object> obj,
+                                   v8::Local<v8::Value> prototype);
+```
+
+
+<a name="api_nan_object_proto_to_string"></a>
+### Nan::ObjectProtoToString()
+
+A helper method for calling [`v8::Object#ObjectProtoToString()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab7a92b4dcf822bef72f6c0ac6fea1f0b) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::String> Nan::ObjectProtoToString(v8::Local<v8::Object> obj);
+```
+
+
+<a name="api_nan_has_own_property"></a>
+### Nan::HasOwnProperty()
+
+A helper method for calling [`v8::Object#HasOwnProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ab7b7245442ca6de1e1c145ea3fd653ff) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::HasOwnProperty(v8::Local<v8::Object> obj,
+                                     v8::Local<v8::String> key);
+```
+
+
+<a name="api_nan_has_real_named_property"></a>
+### Nan::HasRealNamedProperty()
+
+A helper method for calling [`v8::Object#HasRealNamedProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#ad8b80a59c9eb3c1e6c3cd6c84571f767) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::HasRealNamedProperty(v8::Local<v8::Object> obj,
+                                           v8::Local<v8::String> key);
+```
+
+
+<a name="api_nan_has_real_indexed_property"></a>
+### Nan::HasRealIndexedProperty()
+
+A helper method for calling [`v8::Object#HasRealIndexedProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#af94fc1135a5e74a2193fb72c3a1b9855) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::HasRealIndexedProperty(v8::Local<v8::Object> obj,
+                                             uint32_t index);
+```
+
+
+<a name="api_nan_has_real_named_callback_property"></a>
+### Nan::HasRealNamedCallbackProperty()
+
+A helper method for calling [`v8::Object#HasRealNamedCallbackProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#af743b7ea132b89f84d34d164d0668811) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<bool> Nan::HasRealNamedCallbackProperty(
+    v8::Local<v8::Object> obj,
+    v8::Local<v8::String> key);
+```
+
+
+<a name="api_nan_get_real_named_property_in_prototype_chain"></a>
+### Nan::GetRealNamedPropertyInPrototypeChain()
+
+A helper method for calling [`v8::Object#GetRealNamedPropertyInPrototypeChain()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a8700b1862e6b4783716964ba4d5e6172) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Value> Nan::GetRealNamedPropertyInPrototypeChain(
+    v8::Local<v8::Object> obj,
+    v8::Local<v8::String> key);
+```
+
+
+<a name="api_nan_get_real_named_property"></a>
+### Nan::GetRealNamedProperty()
+
+A helper method for calling [`v8::Object#GetRealNamedProperty()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a84471a824576a5994fdd0ffcbf99ccc0) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Value> Nan::GetRealNamedProperty(v8::Local<v8::Object> obj,
+                                                     v8::Local<v8::String> key);
+```
+
+
+<a name="api_nan_call_as_function"></a>
+### Nan::CallAsFunction()
+
+A helper method for calling [`v8::Object#CallAsFunction()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a9ef18be634e79b4f0cdffa1667a29f58) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Value> Nan::CallAsFunction(v8::Local<v8::Object> obj,
+                                               v8::Local<v8::Object> recv,
+                                               int argc,
+                                               v8::Local<v8::Value> argv[]);
+```
+
+
+<a name="api_nan_call_as_constructor"></a>
+### Nan::CallAsConstructor()
+
+A helper method for calling [`v8::Object#CallAsConstructor()`](https://v8docs.nodesource.com/io.js-3.0/db/d85/classv8_1_1_object.html#a9ef18be634e79b4f0cdffa1667a29f58) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Value> Nan::CallAsConstructor(v8::Local<v8::Object> obj,
+                                                  int argc,
+                                                  v8::Local<v8::Value> argv[]);
+```
+
+
+<a name="api_nan_get_source_line"></a>
+### Nan::GetSourceLine()
+
+A helper method for calling [`v8::Message#GetSourceLine()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#a849f7a6c41549d83d8159825efccd23a) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::String> Nan::GetSourceLine(v8::Local<v8::Message> msg);
+```
+
+
+<a name="api_nan_get_line_number"></a>
+### Nan::GetLineNumber()
+
+A helper method for calling [`v8::Message#GetLineNumber()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#adbe46c10a88a6565f2732a2d2adf99b9) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<int> Nan::GetLineNumber(v8::Local<v8::Message> msg);
+```
+
+
+<a name="api_nan_get_start_column"></a>
+### Nan::GetStartColumn()
+
+A helper method for calling [`v8::Message#GetStartColumn()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#a60ede616ba3822d712e44c7a74487ba6) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<int> Nan::GetStartColumn(v8::Local<v8::Message> msg);
+```
+
+
+<a name="api_nan_get_end_column"></a>
+### Nan::GetEndColumn()
+
+A helper method for calling [`v8::Message#GetEndColumn()`](https://v8docs.nodesource.com/io.js-3.0/d9/d28/classv8_1_1_message.html#aaa004cf19e529da980bc19fcb76d93be) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::Maybe<int> Nan::GetEndColumn(v8::Local<v8::Message> msg);
+```
+
+
+<a name="api_nan_clone_element_at"></a>
+### Nan::CloneElementAt()
+
+A helper method for calling [`v8::Array#CloneElementAt()`](https://v8docs.nodesource.com/io.js-3.0/d3/d32/classv8_1_1_array.html#a1d3a878d4c1c7cae974dd50a1639245e) in a way compatible across supported versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Object> Nan::CloneElementAt(v8::Local<v8::Array> array, uint32_t index);
+```
diff --git a/doc/new.md b/doc/new.md
index b2ebac13..23710541 100644
--- a/doc/new.md
+++ b/doc/new.md
@@ -65,3 +65,59 @@ v8::Local<v8::RegExp> Nan::New<T>(v8::Local<v8::String> pattern, v8::RegExp::Fla
 ```
 
 Note that `Nan::ExternalOneByteStringResource` maps to [`v8::String::ExternalOneByteStringResource`](https://v8docs.nodesource.com/io.js-3.0/d9/db3/classv8_1_1_string_1_1_external_one_byte_string_resource.html), and `v8::String::ExternalAsciiStringResource` in older versions of V8.
+
+
+<a name="api_nan_undefined"></a>
+### Nan::Undefined()
+
+A helper method to create a new `v8::Undefined` object in a way that is compatible across all supported versions of V8.
+
+Signature:
+
+```c++
+v8::Local<v8::Primitive> Nan::Undefined()
+```
+
+<a name="api_nan_null"></a>
+### Nan::Null()
+
+A helper method to create a new `v8::Null` object in a way that is compatible across all supported versions of V8.
+
+Signature:
+
+```c++
+v8::Local<v8::Primitive> Nan::Null()
+```
+
+<a name="api_nan_true"></a>
+### Nan::True()
+
+A helper method to create a new `v8::Boolean` object representing a `true` value in a way that is compatible across all supported versions of V8.
+
+Signature:
+
+```c++
+v8::Local<v8::Boolean> Nan::True()
+```
+
+<a name="api_nan_false"></a>
+### Nan::False()
+
+A helper method to create a new `v8::Boolean` object representing a `false` value in a way that is compatible across all supported versions of V8.
+
+Signature:
+
+```c++
+v8::Local<v8::Boolean> Nan::False()
+```
+
+<a name="api_nan_empty_string"></a>
+### Nan::EmptyString()
+
+Call [`v8::String::Empty`](https://v8docs.nodesource.com/io.js-3.0/d2/db3/classv8_1_1_string.html#a7c1bc8886115d7ee46f1d571dd6ebc6d) to create a zero-length string in a way that is compatible across all supported versions of V8.
+
+Signature:
+
+```c++
+v8::Local<v8::String> Nan::EmptyString() 
+```
diff --git a/doc/persistent.md b/doc/persistent.md
index c29292c6..a7d8e8a0 100644
--- a/doc/persistent.md
+++ b/doc/persistent.md
@@ -94,7 +94,7 @@ template<typename T> class PersistentBase {
 See the V8 documentation for [`PersistentBase`](https://v8docs.nodesource.com/io.js-3.0/d4/dca/classv8_1_1_persistent_base.html) for further information.
 
 <a name="api_nan_non_copyable_persistent_traits"></a>
-## Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits
+### Nan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraits
 
 Default traits for `Nan::Persistent`. This class does not allow use of the a copy constructor or assignment operator. At present `kResetInDestructor` is not set, but that will change in a future version.
 
@@ -120,7 +120,7 @@ template<typename T> class NonCopyablePersistentTraits {
 See the V8 documentation for [`NonCopyablePersistentTraits`](https://v8docs.nodesource.com/io.js-3.0/de/d73/classv8_1_1_non_copyable_persistent_traits.html) for further information.
 
 <a name="api_nan_copyable_persistent_traits"></a>
-## Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits
+### Nan::CopyablePersistentTraits & v8::CopyablePersistentTraits
 
 A helper class of traits to allow copying and assignment of `Persistent`. This will clone the contents of storage cell, but not any of the flags, etc..
 
@@ -145,7 +145,7 @@ class CopyablePersistentTraits {
 See the V8 documentation for [`CopyablePersistentTraits`](https://v8docs.nodesource.com/io.js-3.0/da/d5c/structv8_1_1_copyable_persistent_traits.html) for further information.
 
 <a name="api_nan_persistent"></a>
-## Nan::Persistent
+### Nan::Persistent
 
 A type of `PersistentBase` which allows copy and assignment. Copy, assignment and destructor behavior is controlled by the traits class `M`.
 
@@ -198,7 +198,7 @@ template<typename T, typename M> class Persistent : public PersistentBase<T> {
 See the V8 documentation for [`Persistent`](https://v8docs.nodesource.com/io.js-3.0/d2/d78/classv8_1_1_persistent.html) for further information.
 
 <a name="api_nan_global"></a>
-## Nan::Global
+### Nan::Global
 
 A type of `PersistentBase` which has move semantics.
 
@@ -232,10 +232,10 @@ template<typename T> class Global : public PersistentBase<T> {
 See the V8 documentation for [`Global`](https://v8docs.nodesource.com/io.js-3.0/d5/d40/classv8_1_1_global.html) for further information.
 
 <a name="api_nan_weak_callback_type"></a>
-## Nan::WeakCallbackType
+### Nan::WeakCallbackType
 
 <a name="api_nan_weak_callback_info"></a>
-## Nan::WeakCallbackInfo
+### Nan::WeakCallbackInfo
 
 `Nan::WeakCallbackInfo` is used as an argument when setting a persistent reference as weak. You may need to free any external resources attached to the object. It is a mirror of `v8:WeakCallbackInfo` as found in newer versions of V8.
 
@@ -276,7 +276,7 @@ obj.SetWeak(data, callback, WeakCallbackType::kParameter);
 See the V8 documentation for [`WeakCallbackInfo`](https://v8docs.nodesource.com/io.js-3.0/d8/d06/classv8_1_1_weak_callback_info.html) for further information.
 
 <a name="api_nan_weak_callback_type"></a>
-## Nan::WeakCallbackType
+### Nan::WeakCallbackType
 
 _TODO: explain this_
 

From 80fbc0a64500cbe20b90d61bc2bd78f9693d5656 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 00:10:53 +1000
Subject: [PATCH 71/84] doc: added buffers.md

---
 doc/.build.sh  |  1 +
 doc/buffers.md | 40 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+)
 create mode 100644 doc/buffers.md

diff --git a/doc/.build.sh b/doc/.build.sh
index 9c3e3506..cf3bc5c5 100755
--- a/doc/.build.sh
+++ b/doc/.build.sh
@@ -8,6 +8,7 @@ files="           \
   converters.md   \
   maybe_types.md  \
   errors.md       \
+  buffers.md      \
   callback.md     \
   asyncworker.md  \
   v8_internals.md \
diff --git a/doc/buffers.md b/doc/buffers.md
new file mode 100644
index 00000000..4e1d18e0
--- /dev/null
+++ b/doc/buffers.md
@@ -0,0 +1,40 @@
+## Buffers
+
+NAN's `node::Buffer` helpers exist as the API has changed across supported Node versions. Use these methods to ensure compatibility.
+
+ - <a href="#api_nan_new_buffer"><b><code>Nan::NewBuffer()</code></b></a>
+ - <a href="#api_nan_copy_buffer"><b><code>Nan::CopyBuffer()</code></b></a>
+
+
+<a name="api_nan_new_buffer"></a>
+### Nan::NewBuffer()
+
+Allocate a new `node::Buffer` object with the specified size and optional data. Calls `node::Buffer::New()`.
+
+Note that when creating a `Buffer` using `Nan::NewBuffer()` and an existing `char*`, it is assumed that the ownership of the pointer is being transferred to the new `Buffer` for management. You _must not_ free the memory space manually once you have created a `Buffer` in this way.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Object> Nan::NewBuffer(uint32_t size)
+Nan::MaybeLocal<v8::Object> Nan::NewBuffer(char* data, uint32_t size)
+// uses `node::smalloc::FreeCallback` on older versions of Node
+Nan::MaybeLocal<v8::Object> Nan::NewBuffer(char *data,
+                                           size_t length,
+                                           node::Buffer::FreeCallback callback,
+                                           void *hint)
+```
+
+
+<a name="api_nan_copy_buffer"></a>
+### Nan::CopyBuffer()
+
+Similar to [`Nan::NewBuffer()`](#api_nan_new_buffer) except that an implicit memcpy will occur within Node. Calls `node::Buffer::Copy()`.
+
+Management of the `char*` is left to the user, you should manually free the memory space if necessary as the new `Buffer` will have its own copy.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Object> Nan::CopyBuffer(const char *data, uint32_t size)
+```

From be73f35095749775fc4b536b7a4c9190fd5bc79a Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 00:20:00 +1000
Subject: [PATCH 72/84] added string_bytes.md

---
 doc/.build.sh       |  1 +
 doc/string_bytes.md | 62 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 doc/string_bytes.md

diff --git a/doc/.build.sh b/doc/.build.sh
index cf3bc5c5..c82ec8d5 100755
--- a/doc/.build.sh
+++ b/doc/.build.sh
@@ -11,6 +11,7 @@ files="           \
   buffers.md      \
   callback.md     \
   asyncworker.md  \
+  string_bytes.md \
   v8_internals.md \
 "
 
diff --git a/doc/string_bytes.md b/doc/string_bytes.md
new file mode 100644
index 00000000..c7339435
--- /dev/null
+++ b/doc/string_bytes.md
@@ -0,0 +1,62 @@
+## Strings & Bytes
+
+Miscellaneous string & byte encoding and decoding functionality provided for compatibility across supported versions of V8 and Node. Implemented by NAN to ensure that all encoding types are supported, even for older versions of Node where they are missing.
+
+ - <a href="#api_nan_encoding"><b><code>Nan::Encoding</code></b></a>
+ - <a href="#api_nan_encode"><b><code>Nan::Encode()</code></b></a>
+ - <a href="#api_nan_decode_bytes"><b><code>Nan::DecodeBytes()</code></b></a>
+ - <a href="#api_nan_decode_write"><b><code>Nan::DecodeWrite()</code></b></a>
+
+
+<a name="api_nan_encoding"></a>
+### Nan::Encoding
+
+An enum representing the supported encoding types. A copy of `node::encoding` that is consistent across versions of Node.
+
+Definition:
+
+```c++
+enum Nan::Encoding { ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER }
+```
+
+
+<a name="api_nan_encode"></a>
+### Nan::Encode()
+
+A wrapper around `node::Encode()` that provides a consistent implementation across supported versions of Node.
+
+Signature:
+
+```c++
+v8::Local<v8::Value> Nan::Encode(const void *buf,
+                                 size_t len,
+                                 enum Nan::Encoding encoding = BINARY);
+```
+
+
+<a name="api_nan_decode_bytes"></a>
+### Nan::DecodeBytes()
+
+A wrapper around `node::DecodeBytes()` that provides a consistent implementation across supported versions of Node.
+
+Signature:
+
+```c++
+ssize_t Nan::DecodeBytes(v8::Handle<v8::Value> val,
+                         enum Nan::Encoding encoding = BINARY);
+```
+
+
+<a name="api_nan_decode_write"></a>
+### Nan::DecodeWrite()
+
+A wrapper around `node::DecodeWrite()` that provides a consistent implementation across supported versions of Node.
+
+Signature:
+
+```c++
+ssize_t Nan::DecodeWrite(char *buf,
+                         size_t len,
+                         v8::Handle<v8::Value> val,
+                         enum Nan::Encoding encoding = BINARY);
+```

From 9f4841fba51e3ceb82a5dcb592433e1bc6234e57 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 00:25:25 +1000
Subject: [PATCH 73/84] doc: added NewFromOneByte

---
 doc/maybe_types.md |  1 +
 doc/new.md         | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/doc/maybe_types.md b/doc/maybe_types.md
index 6e2f92f2..9804c2b6 100644
--- a/doc/maybe_types.md
+++ b/doc/maybe_types.md
@@ -8,6 +8,7 @@ The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Lo
   - <a href="#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
   - <a href="#api_nan_just"><b><code>Nan::Just</code></b></a>
 * **Maybe Helpers**
+  - <a href="#api_nan_to_detail_string"><b><code>Nan::ToDetailString()</code></b></a>
   - <a href="#api_nan_to_detail_string"><b><code>Nan::ToDetailString()</code></b></a>
   - <a href="#api_nan_to_array_index"><b><code>Nan::ToArrayIndex()</code></b></a>
   - <a href="#api_nan_equals"><b><code>Nan::Equals()</code></b></a>
diff --git a/doc/new.md b/doc/new.md
index 23710541..26e591b7 100644
--- a/doc/new.md
+++ b/doc/new.md
@@ -3,6 +3,11 @@
 NAN provides a `Nan::New()` helper for the creation of new JavaScript objects in a way that's compatible across the supported versions of V8.
 
  - <a href="#api_nan_new"><b><code>Nan::New()</code></b></a>
+ - <a href="#api_nan_undefined"><b><code>Nan::Undefined()</code></b></a>
+ - <a href="#api_nan_null"><b><code>Nan::Null()</code></b></a>
+ - <a href="#api_nan_true"><b><code>Nan::True()</code></b></a>
+ - <a href="#api_nan_false"><b><code>Nan::False()</code></b></a>
+ - <a href="#api_nan_empty_string"><b><code>Nan::EmptyString()</code></b></a>
 
 
 <a name="api_nan_new"></a>
@@ -121,3 +126,16 @@ Signature:
 ```c++
 v8::Local<v8::String> Nan::EmptyString() 
 ```
+
+
+<a name="api_nan_new_one_byte_string"></a>
+### Nan::NewOneByteString()
+
+An implementation of [`v8::String::NewFromOneByte()`](https://v8docs.nodesource.com/io.js-3.0/d2/db3/classv8_1_1_string.html#a5264d50b96d2c896ce525a734dc10f09) provided for consistent availability and API across supported versions of V8. Allocates a new string from Latin-1 data.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::String> Nan::NewOneByteString(const uint8_t * value,
+                                                  int length = -1) 
+```

From b9bf5cd2632f04c1dc03e19fd19142eba566c514 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 00:33:45 +1000
Subject: [PATCH 74/84] doc: added script.md

---
 doc/.build.sh |  1 +
 doc/script.md | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+)
 create mode 100644 doc/script.md

diff --git a/doc/.build.sh b/doc/.build.sh
index c82ec8d5..2f1c11ae 100755
--- a/doc/.build.sh
+++ b/doc/.build.sh
@@ -7,6 +7,7 @@ files="           \
   new.md          \
   converters.md   \
   maybe_types.md  \
+  script.md       \
   errors.md       \
   buffers.md      \
   callback.md     \
diff --git a/doc/script.md b/doc/script.md
new file mode 100644
index 00000000..80ed4b64
--- /dev/null
+++ b/doc/script.md
@@ -0,0 +1,38 @@
+## Script
+
+NAN provides a `v8::Script` helpers as the API has changed over the supported versions of V8.
+
+ - <a href="#api_nan_compile_script"><b><code>Nan::CompileScript()</code></b></a>
+ - <a href="#api_nan_run_script"><b><code>Nan::RunScript()</code></b></a>
+
+
+<a name="api_nan_compile_script"></a>
+### Nan::CompileScript()
+
+A wrapper around [`v8::Script::Compile()`](https://v8docs.nodesource.com/io.js-3.0/da/da5/classv8_1_1_script_compiler.html#a93f5072a0db55d881b969e9fc98e564b).
+
+Note that `Nan::BoundScript` is an alias for `v8::Script`.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<Nan::BoundScript> Nan::CompileScript(
+    v8::Local<v8::String> s,
+    const v8::ScriptOrigin& origin);
+Nan::MaybeLocal<Nan::BoundScript> Nan::CompileScript(v8::Local<v8::String> s);
+```
+
+
+<a name="api_nan_run_script"></a>
+### Nan::RunScript()
+
+Calls `script->Run()` or `script->BindToCurrentContext()->Run(Nan::GetCurrentContext())`.
+
+Note that `Nan::BoundScript` is an alias for `v8::Script` and `Nan::UnboundScript` is an alias for `v8::UnboundScript` where available and `v8::Script` on older versions of V8.
+
+Signature:
+
+```c++
+Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Handle<Nan::UnboundScript> script)
+Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Handle<Nan::BoundScript> script) 
+```

From 23e8151052c09016be06536366b0b0a8281f23b2 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 01:02:41 +1000
Subject: [PATCH 75/84] doc: added node_misc.md and v8_misc.md

---
 doc/.build.sh    |  2 ++
 doc/node_misc.md | 80 ++++++++++++++++++++++++++++++++++++++++++++++++
 doc/v8_misc.md   | 63 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 145 insertions(+)
 create mode 100644 doc/node_misc.md
 create mode 100644 doc/v8_misc.md

diff --git a/doc/.build.sh b/doc/.build.sh
index 2f1c11ae..75a975af 100755
--- a/doc/.build.sh
+++ b/doc/.build.sh
@@ -14,6 +14,8 @@ files="           \
   asyncworker.md  \
   string_bytes.md \
   v8_internals.md \
+  v8_misc.md      \
+  node_misc.md    \
 "
 
 __dirname=$(dirname "${BASH_SOURCE[0]}")
diff --git a/doc/node_misc.md b/doc/node_misc.md
new file mode 100644
index 00000000..01a03120
--- /dev/null
+++ b/doc/node_misc.md
@@ -0,0 +1,80 @@
+## Miscellaneous Node Helpers
+
+ - <a href="#api_nan_make_callback"><b><code>Nan::MakeCallback()</code></b></a>
+ - <a href="#api_nan_object_wrap"><b><code>Nan::ObjectWrap</code></b></a>
+ - <a href="#api_nan_module_init"><b><code>NAN_MODULE_INIT()</code></b></a>
+ - <a href="#api_nan_export"><b><code>Nan::Export()</code></b></a>
+
+
+<a name="api_nan_make_callback"></a>
+### Nan::MakeCallback()
+
+Wrappers around `node::MakeCallback()` providing a consistent API across all supported versions of Node.
+
+Use `MakeCallback()` rather than using `v8::Function#Call()` directly in order to properly process internal Node functionality including domains, async hooks, the microtask queue, and other debugging functionality.
+
+Signatures:
+
+```c++
+v8::Local<v8::Value> Nan::MakeCallback(v8::Handle<v8::Object> target,
+                                       v8::Handle<v8::Function> func,
+                                       int argc,
+                                       v8::Handle<v8::Value>* argv);
+v8::Local<v8::Value> Nan::MakeCallback(v8::Handle<v8::Object> target,
+                                       v8::Handle<v8::String> symbol,
+                                       int argc,
+                                       v8::Handle<v8::Value>* argv);
+v8::Local<v8::Value> Nan::MakeCallback(v8::Handle<v8::Object> target,
+                                       const char* method,
+                                       int argc,
+                                       v8::Handle<v8::Value>* argv);
+```
+
+
+<a name="api_nan_object_wrap"></a>
+### Nan::ObjectWrap()
+
+A simple extension of `node::ObjectWrap` that adds some API not present in older versions of Node. Should be preferred over `node::ObjectWrap` in all cases for consistency.
+
+Definition:
+
+```c++
+class ObjectWrap : public node::ObjectWrap {
+ public:
+  v8::Local<v8::Object> handle(); // for older Node where only handle_ is provided
+  Persistent<v8::Object> &persistent(); // for older Node
+};
+```
+
+
+<a name="api_nan_module_init"></a>
+### NAN_MODULE_INIT()
+
+Used to define the entry point function to a Node add-on. Creates a function with a given `name` that receives a `target` object representing the equivalent of the JavaScript `exports` object.
+
+See example below.
+
+<a name="api_nan_export"></a>
+### Nan::Export()
+
+A simple helper to register a `v8::FunctionTemplate` from a JavaScript-accessible method (see [Methods](./methods.md)) as a property on an object. Can be used in a way similar to assigning properties to `module.exports` in JavaScript.
+
+Signature:
+
+```c++
+void Export(v8::Handle<v8::Object> target, const char *name, Nan::FunctionCallback f)
+```
+
+Also available as the shortcut `NAN_EXPORT` macro.
+
+Example:
+
+```c++
+NAN_METHOD(Foo) {
+  ...
+}
+
+NAN_MODULE_INIT(Init) {
+  NAN_EXPORT(target, Foo);
+}
+```
\ No newline at end of file
diff --git a/doc/v8_misc.md b/doc/v8_misc.md
new file mode 100644
index 00000000..74431744
--- /dev/null
+++ b/doc/v8_misc.md
@@ -0,0 +1,63 @@
+## Miscellaneous V8 Helpers
+
+ - <a href="#api_nan_utf8_string"><b><code>Nan::Utf8String</code></b></a>
+ - <a href="#api_nan_get_current_context"><b><code>Nan::GetCurrentContext()</code></b></a>
+ - <a href="#api_nan_set_isolate_data"><b><code>Nan::SetIsolateData()</code></b></a>
+ - <a href="#api_nan_get_isolate_data"><b><code>Nan::GetIsolateData()</code></b></a>
+
+
+<a name="api_nan_utf8_string"></a>
+### Nan::Utf8String
+
+Converts an object to a UTF-8-encoded character array. If conversion to a string fails (e.g. due to an exception in the toString() method of the object) then the length() method returns 0 and the * operator returns NULL. The underlying memory used for this object is managed by the object.
+
+An implementation of [`v8::String::Utf8Value`](https://v8docs.nodesource.com/io.js-3.0/d4/d1b/classv8_1_1_string_1_1_utf8_value.html) that is consistent across all supported versions of V8.
+
+Definition:
+
+```c++
+class Nan::Utf8String {
+ public:
+  Nan::Utf8String(v8::Local<v8::Value> from);
+
+  int length() const;
+
+  char* operator*();
+  const char* operator*() const;
+};
+```
+
+<a name="api_nan_get_current_context"></a>
+### Nan::GetCurrentContext()
+
+A call to [`v8::Isolate::GetCurrent()->GetCurrentContext()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a81c7a1ed7001ae2a65e89107f75fd053) that works across all supported versiosn of V8.
+
+Signature:
+
+```c++
+v8::Local<v8::Context> Nan::GetCurrentContext()
+```
+
+<a name="api_nan_set_isolate_data"></a>
+### Nan::SetIsolateData()
+
+A helper to provide a consistent API to [`v8::Isolate#SetData()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#a7acadfe7965997e9c386a05f098fbe36).
+
+Signature:
+
+```c++
+void Nan::SetIsolateData(v8::Isolate *isolate, T *data)
+```
+
+
+<a name="api_nan_get_isolate_data"></a>
+### Nan::GetIsolateData()
+
+A helper to provide a consistent API to [`v8::Isolate#GetData()`](https://v8docs.nodesource.com/io.js-3.0/d5/dda/classv8_1_1_isolate.html#aabd223436bc1100a787dadaa024c6257).
+
+Signature:
+
+```c++
+T *Nan::GetIsolateData(v8::Isolate *isolate)
+```
+

From b257716c048e5ee64a2f06de9ea054703593bee4 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 01:08:45 +1000
Subject: [PATCH 76/84] doc: update readme with new apidocs, remove cruft and
 clean up

---
 README.md | 742 +++++++++---------------------------------------------
 1 file changed, 115 insertions(+), 627 deletions(-)

diff --git a/README.md b/README.md
index 7306e71b..6bcca449 100644
--- a/README.md
+++ b/README.md
@@ -52,130 +52,10 @@ This works like a `-I<path-to-NAN>` when compiling your addon.
 
 Just getting started with Nan? Refer to a [quick-start **Nan** Boilerplate](https://github.com/fcanas/node-native-boilerplate) for a ready-to-go project that utilizes basic Nan functionality.
 
-See **[LevelDOWN](https://github.com/rvagg/node-leveldown/pull/48)** for a full example of **NAN** in use.
-
 For a simpler example, see the **[async pi estimation example](https://github.com/nodejs/nan/tree/master/examples/async_pi_estimate)** in the examples directory for full code and an explanation of what this Monte Carlo Pi estimation example does. Below are just some parts of the full example that illustrate the use of **NAN**.
 
 For another example, see **[nan-example-eol](https://github.com/CodeCharmLtd/nan-example-eol)**. It shows newline detection implemented as a native addon.
 
-Compare to the current 0.10 version of this example, found in the [node-addon-examples](https://github.com/iojs/node-addon-examples/tree/master/9_async_work) repository and also a 0.11 version of the same found [here](https://github.com/kkoopa/node-addon-examples/tree/5c01f58fc993377a567812597e54a83af69686d7/9_async_work).
-
-Note that there is no embedded version sniffing going on here and also the async work is made much simpler, see below for details on the `NanAsyncWorker` class.
-
-```c++
-// addon.cc
-#include <node.h>
-#include <nan.h>
-// ...
-
-using v8::FunctionTemplate;
-using v8::Handle;
-using v8::Object;
-using v8::String;
-
-void InitAll(Handle<Object> exports) {
-  exports->Set(NanNew<String>("calculateSync"),
-    NanNew<FunctionTemplate>(CalculateSync)->GetFunction());
-
-  exports->Set(NanNew<String>("calculateAsync"),
-    NanNew<FunctionTemplate>(CalculateAsync)->GetFunction());
-}
-
-NODE_MODULE(addon, InitAll)
-```
-
-```c++
-// sync.h
-#include <node.h>
-#include <nan.h>
-
-NAN_METHOD(CalculateSync);
-```
-
-```c++
-// sync.cc
-#include <node.h>
-#include <nan.h>
-#include "./sync.h"
-// ...
-
-using v8::Number;
-
-// Simple synchronous access to the `Estimate()` function
-NAN_METHOD(CalculateSync) {
-  // expect a number as the first argument
-  int points = args[0]->Uint32Value();
-  double est = Estimate(points);
-
-  NanReturnValue(NanNew<Number>(est));
-}
-```
-
-```c++
-// async.h
-#include <node.h>
-#include <nan.h>
-
-NAN_METHOD(CalculateAsync);
-```
-
-```c++
-// async.cc
-#include <node.h>
-#include <nan.h>
-#include "./async.h"
-
-// ...
-
-using v8::Function;
-using v8::Local;
-using v8::Null;
-using v8::Number;
-using v8::Value;
-
-class PiWorker : public NanAsyncWorker {
- public:
-  PiWorker(NanCallback *callback, int points)
-    : NanAsyncWorker(callback), points(points) {}
-  ~PiWorker() {}
-
-  // Executed inside the worker-thread.
-  // It is not safe to access V8, or V8 data structures
-  // here, so everything we need for input and output
-  // should go on `this`.
-  void Execute () {
-    estimate = Estimate(points);
-  }
-
-  // Executed when the async work is complete
-  // this function will be run inside the main event loop
-  // so it is safe to use V8 again
-  void HandleOKCallback () {
-    NanScope();
-
-    Local<Value> argv[] = {
-        NanNull()
-      , NanNew<Number>(estimate)
-    };
-
-    callback->Call(2, argv);
-  };
-
- private:
-  int points;
-  double estimate;
-};
-
-// Asynchronous access to the `Estimate()` function
-NAN_METHOD(CalculateAsync) {
-  int points = args[0]->Uint32Value();
-  NanCallback *callback = new NanCallback(args[1].As<Function>());
-
-  NanAsyncQueueWorker(new PiWorker(callback, points));
-  NanReturnUndefined();
-}
-```
-
 <a name="api"></a>
 ## API
 
@@ -212,6 +92,14 @@ Across the versions of V8 supported by NAN, JavaScript-accessible method signatu
  - <a href="doc/methods.md#api_nan_set_prototype_template"><b><code>Nan::SetPrototypeTemplate()</code></b></a>
  - <a href="doc/methods.md#api_nan_set_instance_template"><b><code>Nan::SetInstanceTemplate()</code></b></a>
 
+### Scopes
+
+The creation of `HandleScope` objects is different across the supported versions of V8. Therefore, NAN provides its own implementations that can be used safely across these.
+
+ - <a href="doc/scopes.md#api_nan_handle_scope"><b><code>Nan::HandleScope</code></b></a>
+ - <a href="doc/scopes.md#api_nan_escapable_handle_scope"><b><code>Nan::EscapableHandleScope</code></b></a>
+
+
 ### Persistent references
 
 An object reference that is independent of any `HandleScope` is a _persistent_ reference. Where a `Local` handle only lives as long as the `HandleScope` in which it was allocated, a `Persistent` handle remains valid until it is explicitly disposed.
@@ -226,6 +114,18 @@ Due to the evolution of the V8 API, it is necessary for NAN to provide a wrapper
  - <a href="doc/persistent.md#api_nan_weak_callback_info"><b><code>Nan::WeakCallbackInfo</code></b></a>
  - <a href="doc/persistent.md#api_nan_weak_callback_type"><b><code>Nan::WeakCallbackType</code></b></a>
 
+### New
+
+NAN provides a `Nan::New()` helper for the creation of new JavaScript objects in a way that's compatible across the supported versions of V8.
+
+ - <a href="doc/new.md#api_nan_new"><b><code>Nan::New()</code></b></a>
+ - <a href="doc/new.md#api_nan_undefined"><b><code>Nan::Undefined()</code></b></a>
+ - <a href="doc/new.md#api_nan_null"><b><code>Nan::Null()</code></b></a>
+ - <a href="doc/new.md#api_nan_true"><b><code>Nan::True()</code></b></a>
+ - <a href="doc/new.md#api_nan_false"><b><code>Nan::False()</code></b></a>
+ - <a href="doc/new.md#api_nan_empty_string"><b><code>Nan::EmptyString()</code></b></a>
+
+
 ### Converters
 
 NAN contains functions that convert `v8::Value`s to other `v8::Value` types and native types. Since type conversion is not guaranteed to succeed, they return `Nan::Maybe` types. These converters can be used in place of `value->ToX()` and `value->XValue()` (where `X` is one of the types, e.g. `Boolean`) in a way that provides a consistent interface across V8 versions. Newer versions of V8 use the new `v8::Maybe` and `v8::MaybeLocal` types for these conversions, older versions don't have this functionality so it is provided by NAN.
@@ -236,10 +136,78 @@ NAN contains functions that convert `v8::Value`s to other `v8::Value` types and
 
 The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Local` handles that _may be empty_.
 
- - <a href="doc/maybe_types.md#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
- - <a href="doc/maybe_types.md#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
- - <a href="doc/maybe_types.md#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
- - <a href="doc/maybe_types.md#api_nan_just"><b><code>Nan::Just</code></b></a>
+* **Maybe Types**
+  - <a href="doc/maybe_types.md#api_nan_maybe_local"><b><code>Nan::MaybeLocal</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_maybe"><b><code>Nan::Maybe</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_nothing"><b><code>Nan::Nothing</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_just"><b><code>Nan::Just</code></b></a>
+* **Maybe Helpers**
+  - <a href="doc/maybe_types.md#api_nan_to_detail_string"><b><code>Nan::ToDetailString()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_to_detail_string"><b><code>Nan::ToDetailString()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_to_array_index"><b><code>Nan::ToArrayIndex()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_equals"><b><code>Nan::Equals()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_new_instance"><b><code>Nan::NewInstance()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_function"><b><code>Nan::GetFunction()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_set"><b><code>Nan::Set()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_force_set"><b><code>Nan::ForceSet()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get"><b><code>Nan::Get()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_property_attribute"><b><code>Nan::GetPropertyAttributes()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_has"><b><code>Nan::Has()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_delete"><b><code>Nan::Delete()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_property_names"><b><code>Nan::GetPropertyNames()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_own_property_names"><b><code>Nan::GetOwnPropertyNames()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_set_prototype"><b><code>Nan::SetPrototype()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_object_proto_to_string"><b><code>Nan::ObjectProtoToString()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_has_own_property"><b><code>Nan::HasOwnProperty()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_has_real_named_property"><b><code>Nan::HasRealNamedProperty()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_has_real_indexed_property"><b><code>Nan::HasRealIndexedProperty()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_has_real_named_callback_property"><b><code>Nan::HasRealNamedCallbackProperty()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_real_named_property_in_prototype_chain"><b><code>Nan::GetRealNamedPropertyInPrototypeChain()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_real_named_property"><b><code>Nan::GetRealNamedProperty()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_call_as_function"><b><code>Nan::CallAsFunction()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_call_as_constructor"><b><code>Nan::CallAsConstructor()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_source_line"><b><code>Nan::GetSourceLine()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_line_number"><b><code>Nan::GetLineNumber()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_start_column"><b><code>Nan::GetStartColumn()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_get_end_column"><b><code>Nan::GetEndColumn()</code></b></a>
+  - <a href="doc/maybe_types.md#api_nan_clone_element_at"><b><code>Nan::CloneElementAt()</code></b></a>
+
+### Script
+
+NAN provides a `v8::Script` helpers as the API has changed over the supported versions of V8.
+
+ - <a href="doc/script.md#api_nan_compile_script"><b><code>Nan::CompileScript()</code></b></a>
+ - <a href="doc/script.md#api_nan_run_script"><b><code>Nan::RunScript()</code></b></a>
+
+
+### Errors
+
+NAN includes helpers for creating, throwing and catching Errors as much of this functionality varies across the supported versions of V8 and must be abstracted.
+
+Note that an Error object is simply a specialized form of `v8::Value`.
+
+ - <a href="doc/errors.md#api_nan_error"><b><code>Nan::Error()</code></b></a>
+ - <a href="doc/errors.md#api_nan_range_error"><b><code>Nan::RangeError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_reference_error"><b><code>Nan::ReferenceError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_syntax_error"><b><code>Nan::SyntaxError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_type_error"><b><code>Nan::TypeError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_throw_error"><b><code>Nan::ThrowError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_throw_range_error"><b><code>Nan::ThrowRangeError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_throw_reference_error"><b><code>Nan::ThrowReferenceError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_throw_syntax_error"><b><code>Nan::ThrowSyntaxError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_throw_type_error"><b><code>Nan::ThrowTypeError()</code></b></a>
+ - <a href="doc/errors.md#api_nan_fatal_exception"><b><code>Nan::FatalException()</code></b></a>
+ - <a href="doc/errors.md#api_nan_errno_exception"><b><code>Nan::ErrnoException()</code></b></a>
+ - <a href="doc/errors.md#api_nan_try_catch"><b><code>Nan::TryCatch</code></b></a>
+
+
+### Buffers
+
+NAN's `node::Buffer` helpers exist as the API has changed across supported Node versions. Use these methods to ensure compatibility.
+
+ - <a href="doc/buffers.md#api_nan_new_buffer"><b><code>Nan::NewBuffer()</code></b></a>
+ - <a href="doc/buffers.md#api_nan_copy_buffer"><b><code>Nan::CopyBuffer()</code></b></a>
+
 
 ### Nan::Callback
 
@@ -255,6 +223,16 @@ The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Lo
  - <a href="doc/asyncworker.md#api_nan_async_progress_worker"><b><code>Nan::AsyncProgressWorker</code></b></a>
  - <a href="doc/asyncworker.md#api_nan_async_queue_worker"><b><code>Nan::AsyncQueueWorker</code></b></a>
 
+### Strings & Bytes
+
+Miscellaneous string & byte encoding and decoding functionality provided for compatibility across supported versions of V8 and Node. Implemented by NAN to ensure that all encoding types are supported, even for older versions of Node where they are missing.
+
+ - <a href="doc/string_bytes.md#api_nan_encoding"><b><code>Nan::Encoding</code></b></a>
+ - <a href="doc/string_bytes.md#api_nan_encode"><b><code>Nan::Encode()</code></b></a>
+ - <a href="doc/string_bytes.md#api_nan_decode_bytes"><b><code>Nan::DecodeBytes()</code></b></a>
+ - <a href="doc/string_bytes.md#api_nan_decode_write"><b><code>Nan::DecodeWrite()</code></b></a>
+
+
 ### V8 internals
 
 The hooks to access V8 internals—including GC and statistics—are different across the supported versions of V8, therefore NAN provides its own hooks that call the appropriate V8 methods.
@@ -276,514 +254,26 @@ The hooks to access V8 internals—including GC and statistics—are different a
  - <a href="doc/v8_internals.md#api_nan_set_internal_field_pointer"><b><code>Nan::SetInternalFieldPointer()</code></b></a>
  - <a href="doc/v8_internals.md#api_nan_adjust_external_memory"><b><code>Nan::AdjustExternalMemory()</code></b></a>
 
-<!-- END API -->
-
-
- * <a href="#api_nan_weak_callback"><b><code>NAN_WEAK_CALLBACK(callbackname)</code></b></a>
- * <a href="#api_nan_deprecated"><b><code>NAN_DEPRECATED</code></b></a>
- * <a href="#api_nan_inline"><b><code>NAN_INLINE</code></b></a>
- * <a href="#api_nan_new"><b><code>NanNew</code></b></a>
- * <a href="#api_nan_undefined"><b><code>NanUndefined</code></b></a>
- * <a href="#api_nan_null"><b><code>NanNull</code></b></a>
- * <a href="#api_nan_true"><b><code>NanTrue</code></b></a>
- * <a href="#api_nan_false"><b><code>NanFalse</code></b></a>
- * <a href="#api_nan_scope"><b><code>NanScope</code></b></a>
- * <a href="#api_nan_escapable_scope"><b><code>NanEscapableScope</code></b></a>
- * <a href="#api_nan_escape_scope"><b><code>NanEscapeScope</code></b></a>
- * <a href="#api_nan_object_wrap_handle"><b><code>NanObjectWrapHandle</code></b></a>
- * <a href="#api_nan_ascii_string"><b><code>NanAsciiString</code></b></a>
- * <a href="#api_nan_utf8_string"><b><code>NanUtf8String</code></b></a>
- * <a href="#api_nan_ucs2_string"><b><code>NanUcs2String</code></b></a>
- * <a href="#api_nan_new_buffer_handle"><b><code>NanNewBufferHandle(char *, size_t, FreeCallback, void *)</code></b>, <b><code>NanNewBufferHandle(char *, uint32_t)</code></b>, <b><code>NanNewBufferHandle(uint32_t)</code></b></a>
- * <a href="#api_nan_buffer_use"><b><code>NanBufferUse(char *, uint32_t)</code></b></a>
- * <a href="#api_nan_get_current_context"><b><code>NanGetCurrentContext</code></b></a>
- * <a href="#api_nan_has_instance"><b><code>NanHasInstance</code></b></a>
- * <a href="#api_nan_dispose_persistent"><b><code>NanDisposePersistent</code></b></a>
- * <a href="#api_nan_assign_persistent"><b><code>NanAssignPersistent</code></b></a>
- * <a href="#api_nan_make_weak_persistent"><b><code>NanMakeWeakPersistent</code></b></a>
- * <a href="#api_nan_make_callback"><b><code>NanMakeCallback</code></b></a>
- * <a href="#api_nan_get_isolate_data"><b><code>NanGetIsolateData</code></b></a>
- * <a href="#api_nan_set_isolate_data"><b><code>NanSetIsolateData</code></b></a>
- * <a href="#api_nan_encode"><b><code>NanEncode</code></b></a>
- * <a href="#api_nan_decode_bytes"><b><code>NanDecodeBytes</code></b></a>
- * <a href="#api_nan_decode_write"><b><code>NanDecodeWrite</code></b></a>
- * <a href="#api_nan_compile_script"><b><code>NanCompileScript</code></b></a>
- * <a href="#api_nan_run_script"><b><code>NanRunScript</code></b></a>
- * <a href="#api_nan_callback"><b><code>NanCallback</code></b></a>
- * <a href="#api_nan_async_worker"><b><code>NanAsyncWorker</code></b></a>
- * <a href="#api_nan_async_queue_worker"><b><code>NanAsyncQueueWorker</code></b></a>
-
-<a name="api_nan_weak_callback"></a>
-### NAN_WEAK_CALLBACK(callbackname)
-
-Use `NAN_WEAK_CALLBACK` to define your V8 WeakReference callbacks. There is an argument object `const _NanWeakCallbackData<T, P> &data` allowing access to the weak object and the supplied parameter through its `GetValue` and `GetParameter` methods. You can even access the weak callback info object through the `GetCallbackInfo()`method, but you probably should not. `Revive()` keeps the weak object alive until the next GC round.
-
-```c++
-NAN_WEAK_CALLBACK(weakCallback) {
-  int *parameter = data.GetParameter();
-  NanMakeCallback(NanGetCurrentContext()->Global(), data.GetValue(), 0, NULL);
-  if ((*parameter)++ == 0) {
-    data.Revive();
-  } else {
-    delete parameter;
-  }
-}
-
-<a name="api_nan_deprecated"></a>
-### NAN_DEPRECATED
-Declares a function as deprecated.
-
-```c++
-static NAN_DEPRECATED NAN_METHOD(foo) {
-  ...
-}
-```
-
-<a name="api_nan_inline"></a>
-### NAN_INLINE
-Inlines a function.
-
-```c++
-NAN_INLINE int foo(int bar) {
-  ...
-}
-```
-
-<a name="api_nan_new"></a>
-### Local&lt;T&gt; NanNew&lt;T&gt;( ... )
-
-Use `NanNew` to construct almost all v8 objects (bound `Script`s are constructed with <a href="#api_nan_compile_script">`NanCompileScript(Handle)`</a>) and make new local handles.
-
-```c++
-Local<String> s = NanNew<String>("value");
-
-...
-
-Persistent<Object> o;
-
-...
-
-Local<Object> lo = NanNew(o);
-
-```
-
-<a name="api_nan_undefined"></a>
-### Local&lt;Primitive&gt; NanUndefined()
-
-Use instead of `Undefined()`
-
-<a name="api_nan_null"></a>
-### Local&lt;Primitive&gt; NanNull()
-
-Use instead of `Null()`
-
-<a name="api_nan_true"></a>
-### Local&lt;Boolean&gt; NanTrue()
-
-Use instead of `True()`
-
-<a name="api_nan_false"></a>
-### Local&lt;Boolean&gt; NanFalse()
-
-Use instead of `False()`
-
-<a name="api_nan_scope"></a>
-### NanScope()
-
-The introduction of `isolate` references for many V8 calls in Node 0.11 makes `NanScope()` necessary, use it in place of `HandleScope scope` when you do not wish to return handles (`Handle` or `Local`) to the surrounding scope (or in functions directly exposed to V8, as they do not return values in the normal sense). V8-exposed methods (NAN_METHOD, etc.) have implicit handle scopes and do not need extra scopes:
-
-```c++
-NAN_METHOD(Foo::Bar) {
-  NanReturnValue(NanNew<String>("FooBar!"));
-}
-```
-
-This method is not directly exposed to V8, nor does it return a handle, so it uses an unescapable scope:
-
-```c++
-bool Foo::Bar() {
-  NanScope();
-
-  Local<Boolean> val = NanFalse();
-  ...
-  return val->Value();
-}
-```
-
-<a name="api_nan_escapable_scope"></a>
-### NanEscapableScope()
-
-The separation of handle scopes into escapable and inescapable scopes makes `NanEscapableScope()` necessary, use it in place of `HandleScope scope` when you later wish to return a handle (`Handle` or `Local`) from the scope, this is for internal functions not directly exposed to V8:
-
-```c++
-Handle<String> Foo::Bar() {
-  NanEscapableScope();
-
-  return NanEscapeScope(NanNew<String>("FooBar!"));
-}
-```
-
-<a name="api_nan_escape_scope"></a>
-### Local&lt;T&gt; NanEscapeScope(Handle&lt;T&gt; value);
-Use together with `NanEscapableScope` to escape the scope. Corresponds to `HandleScope::Close` or `EscapableHandleScope::Escape`.
-
-
-<a name="api_nan_object_wrap_handle"></a>
-### Local&lt;Object&gt; NanObjectWrapHandle(const node::ObjectWrap &amp;obj)
-
-When you want to fetch the V8 object handle from a native object you've wrapped with Node's `ObjectWrap`, you should use `NanObjectWrapHandle`:
-
-```c++
-NanObjectWrapHandle(iterator)->Get(NanNew<String>("end"))
-```
-
-<a name="api_nan_ascii_string"></a>
-### NanAsciiString
-
-Contrary to the name, this is not actually an ASCII string, it is a one-byte string with no particular encoding. Do not use unless you actually need this incorrect legacy behavior. Consider fixing your broken code instead. If you actually have a proper ASCII-string, use UTF-8, which is a proper superset of ASCII.
-Convert a `String` to zero-terminated, sort-of Ascii-encoded `char *`. The underlying buffer is freed when the owner object goes out of scope, so make a copy or heap allocation if you need it to stick around.
-
-```c++
-NAN_METHOD(foo) {
-  NanReturnValue(NanNew(*NanAsciiString(arg[0])));
-}
-```
-
-####*WRONG*:
-the buffer `str` points to has been freed when `baz` was destroyed:
-```c++
-static char *str;
-
-NAN_METHOD(bar) {
-  NanAsciiString baz(arg[0]);
-
-  str = *baz;
-  NanReturnUndefined(); // baz goes out of scope, freeing str
-}
-
-...
-
-printf(str); // use-after-free error
-```
-
-####*RIGHT*:
-```c++
-static NanAsciiString *str;
-
-NAN_METHOD(bar) {
-  str = new NanAsciiString(arg[0]);
-  NanReturnUndefined();
-}
-
-...
-
-printf(**str);
-```
-
-<a name="api_nan_utf8_string"></a>
-### NanUtf8String
-
-Equivalent to `String::Utf8Value`, it only exists for the sake of completeness.
-Convert a `String` to zero-terminated, Utf8-encoded `char *`. The underlying buffer is freed when the owner object goes out of scope, so make a copy or heap allocation if you need it to stick around.
-
-```c++
-NAN_METHOD(foo) {
-  NanReturnValue(NanNew(*NanUtf8String(arg[0])));
-}
-```
-
-####*WRONG*:
-the buffer `str` points to has been freed when `baz` was destroyed:
-```c++
-static char *str;
-
-NAN_METHOD(bar) {
-  NanUtf8String baz(arg[0]);
 
-  str = *baz;
-  NanReturnUndefined(); // baz goes out of scope, freeing str
-}
+### Miscellaneous V8 Helpers
 
-...
+ - <a href="doc/v8_misc.md#api_nan_utf8_string"><b><code>Nan::Utf8String</code></b></a>
+ - <a href="doc/v8_misc.md#api_nan_get_current_context"><b><code>Nan::GetCurrentContext()</code></b></a>
+ - <a href="doc/v8_misc.md#api_nan_set_isolate_data"><b><code>Nan::SetIsolateData()</code></b></a>
+ - <a href="doc/v8_misc.md#api_nan_get_isolate_data"><b><code>Nan::GetIsolateData()</code></b></a>
 
-printf(str); // use-after-free error
-```
-
-####*RIGHT*:
-```c++
-static NanUtf8String *str;
-
-NAN_METHOD(bar) {
-  str = new NanUtf8String(arg[0]);
-  NanReturnUndefined();
-}
-
-...
-
-printf(**str);
-```
-
-
-<a name="api_nan_ucs2_string"></a>
-### NanUcs2String
-
-Equivalent to `String::Value`, it only exists for the sake of completeness.
-Convert a `String` to zero-terminated, Ucs2-encoded `uint16_t *`. The underlying buffer is freed when the owner object goes out of scope, so make a copy or heap allocation if you need it to stick around.
-
-```c++
-NAN_METHOD(foo) {
-  NanReturnValue(NanNew(*NanUcs2String(arg[0])));
-}
-```
-
-####*WRONG*:
-the buffer `str` points to has been freed when `baz` was destroyed:
-```c++
-static char *str;
-
-NAN_METHOD(bar) {
-  NanUcs2String baz(arg[0]);
-
-  str = *baz;
-  NanReturnUndefined(); // baz goes out of scope, freeing str
-}
-
-...
-
-printf(str); // use-after-free error
-```
-
-####*RIGHT*:
-```c++
-static NanUcs2String *str;
-
-NAN_METHOD(bar) {
-  str = new NanUcs2String(arg[0]);
-  NanReturnUndefined();
-}
-
-...
-
-printf(**str);
-```
-
-
-<a name="api_nan_new_buffer_handle"></a>
-### Local&lt;Object&gt; NanNewBufferHandle(char *, uint32_t), Local&lt;Object&gt; NanNewBufferHandle(uint32_t)
-
-The `Buffer` API has changed a little in Node 0.11, this helper provides consistent access to `Buffer` creation:
-
-```c++
-NanNewBufferHandle((char*)value.data(), value.size());
-```
-
-Can also be used to initialize a `Buffer` with just a `size` argument.
-
-Can also be supplied with a `NanFreeCallback` and a hint for the garbage collector.
-
-<a name="api_nan_buffer_use"></a>
-### Local&lt;Object&gt; NanBufferUse(char*, uint32_t)
-
-`Buffer::New(char*, uint32_t)` prior to 0.11 would make a copy of the data.
-While it was possible to get around this, it required a shim by passing a
-callback. So the new API `Buffer::Use(char*, uint32_t)` was introduced to remove
-needing to use this shim.
-
-`NanBufferUse` uses the `char*` passed as the backing data, and will free the
-memory automatically when the weak callback is called. Keep this in mind, as
-careless use can lead to "double free or corruption" and other cryptic failures.
-
-<a name="api_nan_has_instance"></a>
-### bool NanHasInstance(Persistent&lt;FunctionTemplate&gt;&, Handle&lt;Value&gt;)
-
-Can be used to check the type of an object to determine it is of a particular class you have already defined and have a `Persistent<FunctionTemplate>` handle for.
-
-<a name="api_nan_get_current_context"></a>
-### Local&lt;Context&gt; NanGetCurrentContext()
-
-Gets the current context.
-
-```c++
-Local<Context> ctx = NanGetCurrentContext();
-```
-
-<a name="api_nan_dispose_persistent"></a>
-### void NanDisposePersistent(Persistent&lt;T&gt; &)
-
-Use `NanDisposePersistent` to dispose a `Persistent` handle.
-
-```c++
-NanDisposePersistent(persistentHandle);
-```
-
-<a name="api_nan_assign_persistent"></a>
-### NanAssignPersistent(handle, object)
-
-Use `NanAssignPersistent` to assign a non-`Persistent` handle to a `Persistent` one. You can no longer just declare a `Persistent` handle and assign directly to it later, you have to `Reset` it in Node 0.11, so this makes it easier.
-
-In general it is now better to place anything you want to protect from V8's garbage collector as properties of a generic `Object` and then assign that to a `Persistent`. This works in older versions of Node also if you use `NanAssignPersistent`:
-
-```c++
-Persistent<Object> persistentHandle;
-
-...
-
-Local<Object> obj = NanNew<Object>();
-obj->Set(NanNew<String>("key"), keyHandle); // where keyHandle might be a Local<String>
-NanAssignPersistent(persistentHandle, obj)
-```
-
-<a name="api_nan_make_weak_persistent"></a>
-### _NanWeakCallbackInfo&lt;T, P&gt;* NanMakeWeakPersistent(Handle&lt;T&gt;, P*, _NanWeakCallbackInfo&lt;T, P&gt;::Callback)
 
-Creates a weak persistent handle with the supplied parameter and `NAN_WEAK_CALLBACK`.
+### Miscellaneous Node Helpers
 
-```c++
-NAN_WEAK_CALLBACK(weakCallback) {
+ - <a href="doc/node_misc.md#api_nan_make_callback"><b><code>Nan::MakeCallback()</code></b></a>
+ - <a href="doc/node_misc.md#api_nan_object_wrap"><b><code>Nan::ObjectWrap</code></b></a>
+ - <a href="doc/node_misc.md#api_nan_module_init"><b><code>NAN_MODULE_INIT()</code></b></a>
+ - <a href="doc/node_misc.md#api_nan_export"><b><code>Nan::Export()</code></b></a>
 
-...
-
-}
-
-Local<Function> func;
-
-...
-
-int *parameter = new int(0);
-NanMakeWeakPersistent(func, parameter, &weakCallback);
-```
-
-<a name="api_nan_make_callback"></a>
-### NanMakeCallback(target, func, argc, argv)
-
-Use instead of `node::MakeCallback` to call javascript functions. This (or `NanCallback`) is the only proper way of calling functions. You must _*never, ever*_ directly use `Function::Call`, it will lead to run-time failures.
-
-<a name="api_nan_get_isolate_data"></a>
-### NanGetIsolateData(v8::Isolate *)
-
-Replaces `v8::Isolate::GetData`.
-
-<a name="api_nan_set_isolate_data"></a>
-### NanSetIsolateData(v8::Isolate *, T*)
-
-Replaces `v8::Isolate::SetData`.
-
-<a name="api_nan_encode"></a>
-### NanEncode(const void*, size_t[, enum Nan::Encoding])
-
-Replaces `node::Encode`.
-
-<a name="api_nan_decode_bytes"></a>
-### NanDecodeBytes(v8::Handle&lt;v8::Value&gt;[, enum Nan::Encoding])
-
-Replaces `node::DecodeBytes`.
-
-<a name="api_nan_decode_write"></a>
-### NanDecodeWrite(char *, size_t, v8::Handle&lt;v8::Value&gt;[, enum Nan::Encoding])
-
-Replaces `node::DecodeWrite`.
-
-<a name="api_nan_compile_script"></a>
-### NanCompileScript(Handle<String> s [, const ScriptOrigin&amp; origin])
-
-Use to create new scripts bound to the current context.
-
-<a name="api_nan_run_script"></a>
-### NanRunScript(script)
-
-Use to run both bound and unbound scripts.
-
-<a name="api_nan_callback"></a>
-### NanCallback
-
-Because of the difficulties imposed by the changes to `Persistent` handles in V8 in Node 0.11, creating `Persistent` versions of your `Handle<Function>` is annoyingly tricky. `NanCallback` makes it easier by taking your handle, making it persistent until the `NanCallback` is deleted and even providing a handy `Call()` method to fetch and execute the callback `Function`.
-
-```c++
-Local<Function> callbackHandle = args[0].As<Function>();
-NanCallback *callback = new NanCallback(callbackHandle);
-// pass `callback` around and it's safe from GC until you:
-delete callback;
-```
-
-You can execute the callback like so:
-
-```c++
-// no arguments:
-callback->Call(0, NULL);
-
-// an error argument:
-Handle<Value> argv[] = {
-  NanError(NanNew<String>("fail!"))
-};
-callback->Call(1, argv);
-
-// a success argument:
-Handle<Value> argv[] = {
-  NanNull(),
-  NanNew<String>("w00t!")
-};
-callback->Call(2, argv);
-```
-
-`NanCallback` also has a `Local<Function> GetFunction()` method that you can use
-to fetch a local handle to the underlying callback function, as well  as a
-`void SetFunction(Handle<Function>)` for setting the callback on the
-`NanCallback`. You can check if a `NanCallback` is empty with the `bool IsEmpty()` method. Additionally a generic constructor is available for using
-`NanCallback` without performing heap allocations.
-
-<a name="api_nan_async_worker"></a>
-### NanAsyncWorker
-
-`NanAsyncWorker` is an abstract class that you can subclass to have much of the annoying async queuing and handling taken care of for you. It can even store arbitrary V8 objects for you and have them persist while the async work is in progress.
-
-See a rough outline of the implementation:
-
-```c++
-class NanAsyncWorker {
-public:
-  NanAsyncWorker (NanCallback *callback);
-
-  // Clean up persistent handles and delete the *callback
-  virtual ~NanAsyncWorker ();
-
-  // Check the `ErrorMessage()` and call HandleOKCallback()
-  // or HandleErrorCallback depending on whether it has been set or not
-  virtual void WorkComplete ();
-
-  // You must implement this to do some async work. If there is an
-  // error then use `SetErrorMessage()` to set an error message and the callback will
-  // be passed that string in an Error object
-  virtual void Execute ();
-
-  // Save a V8 object in a Persistent handle to protect it from GC
-  void SaveToPersistent(const char *key, Local<Object> &obj);
-
-  // Fetch a stored V8 object (don't call from within `Execute()`)
-  Local<Object> GetFromPersistent(const char *key);
-
-  // Get the error message (or NULL)
-  const char *ErrorMessage();
-
-  // Set an error message
-  void SetErrorMessage(const char *msg);
-
-protected:
-  // Default implementation calls the callback function with no arguments.
-  // Override this to return meaningful data
-  virtual void HandleOKCallback ();
-
-  // Default implementation calls the callback function with an Error object
-  // wrapping the `errmsg` string
-  virtual void HandleErrorCallback ();
-};
-```
-
-<a name="api_nan_async_queue_worker"></a>
-### NanAsyncQueueWorker(NanAsyncWorker *)
+<!-- END API -->
 
-`NanAsyncQueueWorker` will run a `NanAsyncWorker` asynchronously via libuv. Both the *execute* and *after_work* steps are taken care of for you&mdash;most of the logic for this is embedded in `NanAsyncWorker`.
 
-<a name="api"></a>
+<a name="tests"></a>
 ### Tests
 
 To run the NAN tests do:
@@ -801,6 +291,7 @@ npm install
 make test
 ```
 
+<a name="tests"></a>
 ## Porting
 
 Follows is a guide to porting your C++ node to NAN.
@@ -843,10 +334,7 @@ NAN_METHOD(MyClass::ToString)
 
 </tbody></table>
 
-## Contributors
-
 <a name="governance"></a>
-
 ## Governance & Contributing
 
 NAN is governed by the [io.js](https://iojs.org/) Addon API Working Group

From 442fdc31bb1613e657383071a123c328a45593c3 Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 01:13:49 +1000
Subject: [PATCH 77/84] doc: added links to embedders guide

---
 doc/methods.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/doc/methods.md b/doc/methods.md
index e56aaa04..a4ecd67b 100644
--- a/doc/methods.md
+++ b/doc/methods.md
@@ -202,6 +202,8 @@ You do not need to declare a new `HandleScope` within a getter as one is implici
 
 A helper macro `NAN_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on [Accessors](https://developers.google.com/v8/embed#accesssors).
+
 <a name="api_nan_setter"></a>
 ### Setter declaration
 
@@ -227,6 +229,8 @@ You do not need to declare a new `HandleScope` within a setter as one is implici
 
 A helper macro `NAN_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on [Accessors](https://developers.google.com/v8/embed#accesssors).
+
 <a name="api_nan_property_getter"></a>
 ### Property getter declaration
 
@@ -250,6 +254,7 @@ You do not need to declare a new `HandleScope` within a property getter as one i
 
 A helper macro `NAN_PROPERTY_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
 
 <a name="api_nan_property_setter"></a>
 ### Property setter declaration
@@ -274,6 +279,8 @@ You do not need to declare a new `HandleScope` within a property setter as one i
 
 A helper macro `NAN_PROPERTY_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_property_enumerator"></a>
 ### Property enumerator declaration
 
@@ -293,6 +300,8 @@ You do not need to declare a new `HandleScope` within a property enumerator as o
 
 A helper macro `NAN_PROPERTY_ENUMERATOR(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_property_deleter"></a>
 ### Property deleter declaration
 
@@ -314,6 +323,8 @@ You do not need to declare a new `HandleScope` within a property deleter as one
 
 A helper macro `NAN_PROPERTY_DELETER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_property_query"></a>
 ### Property query declaration
 
@@ -335,6 +346,8 @@ You do not need to declare a new `HandleScope` within a property query method as
 
 A helper macro `NAN_PROPERTY_QUERY(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on named property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_index_getter"></a>
 ### Index getter declaration
 
@@ -355,6 +368,8 @@ You do not need to declare a new `HandleScope` within a index getter as one is i
 
 A helper macro `NAN_INDEX_GETTER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_index_setter"></a>
 ### Index setter declaration
 
@@ -378,6 +393,8 @@ You do not need to declare a new `HandleScope` within a index setter as one is i
 
 A helper macro `NAN_INDEX_SETTER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_index_enumerator"></a>
 ### Index enumerator declaration
 
@@ -397,6 +414,8 @@ You do not need to declare a new `HandleScope` within a index enumerator as one
 
 A helper macro `NAN_INDEX_ENUMERATOR(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_index_deleter"></a>
 ### Index deleter declaration
 
@@ -417,6 +436,8 @@ You do not need to declare a new `HandleScope` within a index deleter as one is
 
 A helper macro `NAN_INDEX_DELETER(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_index_query"></a>
 ### Index query declaration
 
@@ -437,6 +458,8 @@ You do not need to declare a new `HandleScope` within a index query method as on
 
 A helper macro `NAN_INDEX_QUERY(methodname)` exists, compatible with NAN v1 method declarations.
 
+Also see the V8 Embedders Guide documentation on indexed property [Interceptors](https://developers.google.com/v8/embed#interceptors).
+
 <a name="api_nan_set_method"></a>
 ### Nan::SetMethod()
 

From d7ad18d688776d77d45557010c5e909e8e3189ef Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Thu, 30 Jul 2015 01:16:31 +1000
Subject: [PATCH 78/84] doc: added Makefile 'docs' target

---
 Makefile | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Makefile b/Makefile
index 30f66e3c..f1821ade 100644
--- a/Makefile
+++ b/Makefile
@@ -83,6 +83,13 @@ forcetest:
 	cd test/ && node-gyp rebuild && cd ..
 	npm test
 
+docs: README.md doc/.build.sh doc/asyncworker.md doc/buffers.md doc/callback.md \
+		doc/converters.md doc/errors.md doc/maybe_types.md doc/methods.md doc/new.md \
+		doc/node_misc.md doc/persistent.md doc/scopes.md doc/script.md doc/string_bytes.md \
+		doc/v8_internals.md doc/v8_misc.md
+	doc/.build.sh
+
+
 $(ADDONS): nan.h nan_new.h nan_implementation_pre_12_inl.h nan_implementation_12_inl.h \
 		nan_callbacks.h nan_callbacks_12_inl.h nan_callbacks_pre_12_inl.h \
 		nan_converters.h nan_converters_43_inl.h nan_converters_pre_43_inl.h \

From 0867d3487c72f8c6f8719e59dfc080e4d7d5d07b Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Thu, 30 Jul 2015 03:00:00 +0300
Subject: [PATCH 79/84] Handle -> Local in converters.md

---
 doc/converters.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/doc/converters.md b/doc/converters.md
index f0d065b0..6409bc23 100644
--- a/doc/converters.md
+++ b/doc/converters.md
@@ -7,7 +7,7 @@ NAN contains functions that convert `v8::Value`s to other `v8::Value` types and
 <a name="api_nan_to"></a>
 ### Nan::To
 
-Converts a `v8::Handle<v8::Value>` to a different subtype of `v8::Value` or to a native data type. Returns a `Nan::MaybeLocal<>` or a `Nan::Maybe<>` accordingly.
+Converts a `v8::Local<v8::Value>` to a different subtype of `v8::Value` or to a native data type. Returns a `Nan::MaybeLocal<>` or a `Nan::Maybe<>` accordingly.
 
 See [maybe_types.md](./maybe_types.md) for more information on `Nan::Maybe` types.
 
@@ -15,20 +15,20 @@ Signatures:
 
 ```c++
 // V8 types
-Nan::MaybeLocal<v8::Boolean> Nan::To<v8::Boolean>(v8::Handle<v8::Value> val);
-Nan::MaybeLocal<v8::Int32> Nan::To<v8::Int32>(v8::Handle<v8::Value> val);
-Nan::MaybeLocal<v8::Integer> Nan::To<v8::Integer>(v8::Handle<v8::Value> val);
-Nan::MaybeLocal<v8::Object> Nan::To<v8::Object>(v8::Handle<v8::Value> val);
-Nan::MaybeLocal<v8::Number> Nan::To<v8::Number>(v8::Handle<v8::Value> val);
-Nan::MaybeLocal<v8::String> Nan::To<v8::String>(v8::Handle<v8::Value> val);
-Nan::MaybeLocal<v8::Uint32> Nan::To<v8::Uint32>(v8::Handle<v8::Value> val);
+Nan::MaybeLocal<v8::Boolean> Nan::To<v8::Boolean>(v8::Local<v8::Value> val);
+Nan::MaybeLocal<v8::Int32> Nan::To<v8::Int32>(v8::Local<v8::Value> val);
+Nan::MaybeLocal<v8::Integer> Nan::To<v8::Integer>(v8::Local<v8::Value> val);
+Nan::MaybeLocal<v8::Object> Nan::To<v8::Object>(v8::Local<v8::Value> val);
+Nan::MaybeLocal<v8::Number> Nan::To<v8::Number>(v8::Local<v8::Value> val);
+Nan::MaybeLocal<v8::String> Nan::To<v8::String>(v8::Local<v8::Value> val);
+Nan::MaybeLocal<v8::Uint32> Nan::To<v8::Uint32>(v8::Local<v8::Value> val);
 
 // Native types
-Nan::Maybe<bool> Nan::To<bool>(v8::Handle<v8::Value> val);
-Nan::Maybe<double> Nan::To<double>(v8::Handle<v8::Value> val);
-Nan::Maybe<int32_t> Nan::To<int32_t>(v8::Handle<v8::Value> val);
-Nan::Maybe<int64_t> Nan::To<int64_t>(v8::Handle<v8::Value> val);
-Nan::Maybe<uint32_t> Nan::To<uint32_t>(v8::Handle<v8::Value> val);
+Nan::Maybe<bool> Nan::To<bool>(v8::Local<v8::Value> val);
+Nan::Maybe<double> Nan::To<double>(v8::Local<v8::Value> val);
+Nan::Maybe<int32_t> Nan::To<int32_t>(v8::Local<v8::Value> val);
+Nan::Maybe<int64_t> Nan::To<int64_t>(v8::Local<v8::Value> val);
+Nan::Maybe<uint32_t> Nan::To<uint32_t>(v8::Local<v8::Value> val);
 ```
 
 ### Example

From 2a977531bae30ed42ef00321912201b881c899cc Mon Sep 17 00:00:00 2001
From: Rod Vagg <rod@vagg.org>
Date: Fri, 31 Jul 2015 13:02:18 +1000
Subject: [PATCH 80/84] doc: more links and info from the V8 Embedders Guide

---
 README.md      | 17 ++++++++++++++++-
 doc/errors.md  |  2 ++
 doc/methods.md |  4 +++-
 doc/scopes.md  |  5 +++++
 4 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 6bcca449..1051a047 100644
--- a/README.md
+++ b/README.md
@@ -59,11 +59,19 @@ For another example, see **[nan-example-eol](https://github.com/CodeCharmLtd/nan
 <a name="api"></a>
 ## API
 
+Additional to the NAN documentation below, please consult:
+
+* [The V8 Getting Started Guide](https://developers.google.com/v8/get_started)
+* [The V8 Embedders Guide](https://developers.google.com/v8/embed)
+* [V8 API Documentation](http://v8docs.nodesource.com/)
+
 <!-- START API -->
 
 ### JavaScript-accessible methods
 
-Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
+A _template_ is a blueprint for JavaScript functions and objects in a context. You can use a template to wrap C++ functions and data structures within JavaScript objects so that they can be manipulated from JavaScript. See the V8 Embedders Guide section on [Templates](https://developers.google.com/v8/embed#templates) for further information.
+
+In order to expose functionality to JavaScript via a template, you must provide it to V8 in a form that it understands. Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
 
 * **Method argument types**
  - <a href="doc/methods.md#api_nan_function_callback_info"><b><code>Nan::FunctionCallbackInfo</code></b></a>
@@ -94,11 +102,16 @@ Across the versions of V8 supported by NAN, JavaScript-accessible method signatu
 
 ### Scopes
 
+A _local handle_ is a pointer to an object. All V8 objects are accessed using handles, they are necessary because of the way the V8 garbage collector works.
+
+A handle scope can be thought of as a container for any number of handles. When you've finished with your handles, instead of deleting each one individually you can simply delete their scope.
+
 The creation of `HandleScope` objects is different across the supported versions of V8. Therefore, NAN provides its own implementations that can be used safely across these.
 
  - <a href="doc/scopes.md#api_nan_handle_scope"><b><code>Nan::HandleScope</code></b></a>
  - <a href="doc/scopes.md#api_nan_escapable_handle_scope"><b><code>Nan::EscapableHandleScope</code></b></a>
 
+Also see the V8 Embedders Guide section on [Handles and Garbage Collection](https://developers.google.com/v8/embed#handles).
 
 ### Persistent references
 
@@ -186,6 +199,8 @@ NAN includes helpers for creating, throwing and catching Errors as much of this
 
 Note that an Error object is simply a specialized form of `v8::Value`.
 
+Also consult the V8 Embedders Guide section on [Exceptions](https://developers.google.com/v8/embed#exceptions) for more information.
+
  - <a href="doc/errors.md#api_nan_error"><b><code>Nan::Error()</code></b></a>
  - <a href="doc/errors.md#api_nan_range_error"><b><code>Nan::RangeError()</code></b></a>
  - <a href="doc/errors.md#api_nan_reference_error"><b><code>Nan::ReferenceError()</code></b></a>
diff --git a/doc/errors.md b/doc/errors.md
index 7222c6be..aac6e087 100644
--- a/doc/errors.md
+++ b/doc/errors.md
@@ -4,6 +4,8 @@ NAN includes helpers for creating, throwing and catching Errors as much of this
 
 Note that an Error object is simply a specialized form of `v8::Value`.
 
+Also consult the V8 Embedders Guide section on [Exceptions](https://developers.google.com/v8/embed#exceptions) for more information.
+
  - <a href="#api_nan_error"><b><code>Nan::Error()</code></b></a>
  - <a href="#api_nan_range_error"><b><code>Nan::RangeError()</code></b></a>
  - <a href="#api_nan_reference_error"><b><code>Nan::ReferenceError()</code></b></a>
diff --git a/doc/methods.md b/doc/methods.md
index a4ecd67b..0a0316f1 100644
--- a/doc/methods.md
+++ b/doc/methods.md
@@ -1,6 +1,8 @@
 ## JavaScript-accessible methods
 
-Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
+A _template_ is a blueprint for JavaScript functions and objects in a context. You can use a template to wrap C++ functions and data structures within JavaScript objects so that they can be manipulated from JavaScript. See the V8 Embedders Guide section on [Templates](https://developers.google.com/v8/embed#templates) for further information.
+
+In order to expose functionality to JavaScript via a template, you must provide it to V8 in a form that it understands. Across the versions of V8 supported by NAN, JavaScript-accessible method signatures vary widely, NAN fully abstracts method declaration and provides you with an interface that is similar to the most recent V8 API but is backward-compatible with older versions that still use the now-deceased `v8::Argument` type.
 
 * **Method argument types**
  - <a href="#api_nan_function_callback_info"><b><code>Nan::FunctionCallbackInfo</code></b></a>
diff --git a/doc/scopes.md b/doc/scopes.md
index 5c24ef22..e9a35d0f 100644
--- a/doc/scopes.md
+++ b/doc/scopes.md
@@ -1,10 +1,15 @@
 ## Scopes
 
+A _local handle_ is a pointer to an object. All V8 objects are accessed using handles, they are necessary because of the way the V8 garbage collector works.
+
+A handle scope can be thought of as a container for any number of handles. When you've finished with your handles, instead of deleting each one individually you can simply delete their scope.
+
 The creation of `HandleScope` objects is different across the supported versions of V8. Therefore, NAN provides its own implementations that can be used safely across these.
 
  - <a href="#api_nan_handle_scope"><b><code>Nan::HandleScope</code></b></a>
  - <a href="#api_nan_escapable_handle_scope"><b><code>Nan::EscapableHandleScope</code></b></a>
 
+Also see the V8 Embedders Guide section on [Handles and Garbage Collection](https://developers.google.com/v8/embed#handles).
 
 <a name="api_nan_handle_scope"></a>
 ### Nan::HandleScope

From 53107d9647f4a7faca6413d2b415c66612129fed Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 31 Jul 2015 13:01:28 +0300
Subject: [PATCH 81/84] Handle -> Local

---
 doc/asyncworker.md  |  2 +-
 doc/callback.md     | 16 ++++++++--------
 doc/methods.md      | 34 +++++++++++++++++-----------------
 doc/node_misc.md    | 20 ++++++++++----------
 doc/script.md       |  4 ++--
 doc/string_bytes.md |  4 ++--
 6 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/doc/asyncworker.md b/doc/asyncworker.md
index 1a583cc5..1f445b47 100644
--- a/doc/asyncworker.md
+++ b/doc/asyncworker.md
@@ -24,7 +24,7 @@ class AsyncWorker {
 
   void SaveToPersistent(const char *key, const v8::Local<v8::Value> &value);
 
-  void SaveToPersistent(const v8::Handle<v8::String> &key,
+  void SaveToPersistent(const v8::Local<v8::String> &key,
                         const v8::Local<v8::Value> &value);
 
   void SaveToPersistent(uint32_t index,
diff --git a/doc/callback.md b/doc/callback.md
index 93f89dc7..9e0f0a2a 100644
--- a/doc/callback.md
+++ b/doc/callback.md
@@ -12,7 +12,7 @@ class Callback {
  public:
   Callback();
 
-  explicit Callback(const v8::Handle<v8::Function> &fn);
+  explicit Callback(const v8::Local<v8::Function> &fn);
 
   ~Callback();
 
@@ -22,24 +22,24 @@ class Callback {
 
   v8::Local<v8::Function> operator*() const;
 
-  v8::Local<v8::Value> operator()(v8::Handle<v8::Object> target,
+  v8::Local<v8::Value> operator()(v8::Local<v8::Object> target,
                                   int argc = 0,
-                                  v8::Handle<v8::Value> argv[] = 0) const;
+                                  v8::Local<v8::Value> argv[] = 0) const;
 
   v8::Local<v8::Value> operator()(int argc = 0,
-                                  v8::Handle<v8::Value> argv[] = 0) const;
+                                  v8::Local<v8::Value> argv[] = 0) const;
 
-  void SetFunction(const v8::Handle<v8::Function> &fn);
+  void SetFunction(const v8::Local<v8::Function> &fn);
 
   v8::Local<v8::Function> GetFunction() const;
 
   bool IsEmpty() const;
 
-  v8::Local<v8::Value> Call(v8::Handle<v8::Object> target,
+  v8::Local<v8::Value> Call(v8::Local<v8::Object> target,
                             int argc,
-                            v8::Handle<v8::Value> argv[]) const;
+                            v8::Local<v8::Value> argv[]) const;
 
-  v8::Local<v8::Value> Call(int argc, v8::Handle<v8::Value> argv[]) const;
+  v8::Local<v8::Value> Call(int argc, v8::Local<v8::Value> argv[]) const;
 };
 ```
 
diff --git a/doc/methods.md b/doc/methods.md
index 0a0316f1..638ae566 100644
--- a/doc/methods.md
+++ b/doc/methods.md
@@ -483,7 +483,7 @@ Sets a method with a given name on a `FunctionTemplate`'s prototype where the me
 Signature:
 
 ```c++
-void Nan::SetPrototypeMethod(v8::Handle<v8::FunctionTemplate> recv,
+void Nan::SetPrototypeMethod(v8::Local<v8::FunctionTemplate> recv,
                              const char* name,
                              Nan::FunctionCallback callback)
 ```
@@ -496,19 +496,19 @@ Sets getters and setters for a property with a given name on an `ObjectTemplate`
 Signature:
 
 ```c++
-void SetAccessor(v8::Handle<v8::ObjectTemplate> tpl,
-                 v8::Handle<v8::String> name,
+void SetAccessor(v8::Local<v8::ObjectTemplate> tpl,
+                 v8::Local<v8::String> name,
                  Nan::GetterCallback getter,
                  Nan::SetterCallback setter = 0,
-                 v8::Handle<v8::Value> data = v8::Handle<v8::Value>(),
+                 v8::Local<v8::Value> data = v8::Local<v8::Value>(),
                  v8::AccessControl settings = v8::DEFAULT,
                  v8::PropertyAttribute attribute = v8::None,
                  imp::Sig signature = imp::Sig())
-bool SetAccessor(v8::Handle<v8::Object> obj,
-                 v8::Handle<v8::String> name,
+bool SetAccessor(v8::Local<v8::Object> obj,
+                 v8::Local<v8::String> name,
                  Nan::GetterCallback getter,
                  Nan::SetterCallback setter = 0,
-                 v8::Handle<v8::Value> data = v8::Handle<v8::Value>(),
+                 v8::Local<v8::Value> data = v8::Local<v8::Value>(),
                  v8::AccessControl settings = v8::DEFAULT,
                  v8::PropertyAttribute attribute = v8::None)
 ```
@@ -529,13 +529,13 @@ Sets named property getters, setters, query, deleter and enumerator methods on a
 Signature:
 
 ```c++
-void SetNamedPropertyHandler(v8::Handle<v8::ObjectTemplate> tpl,
+void SetNamedPropertyHandler(v8::Local<v8::ObjectTemplate> tpl,
                              Nan::PropertyGetterCallback getter,
                              Nan::PropertySetterCallback setter = 0,
                              Nan::PropertyQueryCallback query = 0,
                              Nan::PropertyDeleterCallback deleter = 0,
                              Nan::PropertyEnumeratorCallback enumerator = 0,
-                             v8::Handle<v8::Value> data = v8::Handle<v8::Value>())
+                             v8::Local<v8::Value> data = v8::Local<v8::Value>())
 ```
 
 See the V8 [`ObjectTemplate#SetNamedPropertyHandler()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#a34d1cc45b642cd131706663801aadd76) for further information about how to use `Nan::SetNamedPropertyHandler()`.
@@ -554,13 +554,13 @@ Sets indexed property getters, setters, query, deleter and enumerator methods on
 Signature:
 
 ```c++
-void SetIndexedPropertyHandler(v8::Handle<v8::ObjectTemplate> tpl,
+void SetIndexedPropertyHandler(v8::Local<v8::ObjectTemplate> tpl,
                              Nan::IndexGetterCallback getter,
                              Nan::IndexSetterCallback setter = 0,
                              Nan::IndexQueryCallback query = 0,
                              Nan::IndexDeleterCallback deleter = 0,
                              Nan::IndexEnumeratorCallback enumerator = 0,
-                             v8::Handle<v8::Value> data = v8::Handle<v8::Value>())
+                             v8::Local<v8::Value> data = v8::Local<v8::Value>())
 ```
 
 See the V8 [`ObjectTemplate#SetIndexedPropertyHandler()`](https://v8docs.nodesource.com/io.js-3.0/db/d5f/classv8_1_1_object_template.html#ac0234cbede45d51778bb5f6a32a9e125) for further information about how to use `Nan::SetIndexedPropertyHandler()`.
@@ -594,10 +594,10 @@ Signature:
 ```c++
 void Nan::SetPrototypeTemplate(v8::Local<v8::FunctionTemplate> templ,
                                const char *name,
-                               v8::Handle<v8::Data> value)
+                               v8::Local<v8::Data> value)
 void Nan::SetPrototypeTemplate(v8::Local<v8::FunctionTemplate> templ,
-                               v8::Handle<v8::String> name,
-                               v8::Handle<v8::Data> value,
+                               v8::Local<v8::String> name,
+                               v8::Local<v8::Data> value,
                                v8::PropertyAttribute attributes)
 ```
 
@@ -613,10 +613,10 @@ Signature:
 ```c++
 void Nan::SetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ,
                               const char *name,
-                              v8::Handle<v8::Data> value)
+                              v8::Local<v8::Data> value)
 void Nan::SetInstanceTemplate(v8::Local<v8::FunctionTemplate> templ,
-                              v8::Handle<v8::String> name,
-                              v8::Handle<v8::Data> value,
+                              v8::Local<v8::String> name,
+                              v8::Local<v8::Data> value,
                               v8::PropertyAttribute attributes)
 ```
 
diff --git a/doc/node_misc.md b/doc/node_misc.md
index 01a03120..18f729cc 100644
--- a/doc/node_misc.md
+++ b/doc/node_misc.md
@@ -16,18 +16,18 @@ Use `MakeCallback()` rather than using `v8::Function#Call()` directly in order t
 Signatures:
 
 ```c++
-v8::Local<v8::Value> Nan::MakeCallback(v8::Handle<v8::Object> target,
-                                       v8::Handle<v8::Function> func,
+v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
+                                       v8::Local<v8::Function> func,
                                        int argc,
-                                       v8::Handle<v8::Value>* argv);
-v8::Local<v8::Value> Nan::MakeCallback(v8::Handle<v8::Object> target,
-                                       v8::Handle<v8::String> symbol,
+                                       v8::Local<v8::Value>* argv);
+v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
+                                       v8::Local<v8::String> symbol,
                                        int argc,
-                                       v8::Handle<v8::Value>* argv);
-v8::Local<v8::Value> Nan::MakeCallback(v8::Handle<v8::Object> target,
+                                       v8::Local<v8::Value>* argv);
+v8::Local<v8::Value> Nan::MakeCallback(v8::Local<v8::Object> target,
                                        const char* method,
                                        int argc,
-                                       v8::Handle<v8::Value>* argv);
+                                       v8::Local<v8::Value>* argv);
 ```
 
 
@@ -62,7 +62,7 @@ A simple helper to register a `v8::FunctionTemplate` from a JavaScript-accessibl
 Signature:
 
 ```c++
-void Export(v8::Handle<v8::Object> target, const char *name, Nan::FunctionCallback f)
+void Export(v8::Local<v8::Object> target, const char *name, Nan::FunctionCallback f)
 ```
 
 Also available as the shortcut `NAN_EXPORT` macro.
@@ -77,4 +77,4 @@ NAN_METHOD(Foo) {
 NAN_MODULE_INIT(Init) {
   NAN_EXPORT(target, Foo);
 }
-```
\ No newline at end of file
+```
diff --git a/doc/script.md b/doc/script.md
index 80ed4b64..1267b5e7 100644
--- a/doc/script.md
+++ b/doc/script.md
@@ -33,6 +33,6 @@ Note that `Nan::BoundScript` is an alias for `v8::Script` and `Nan::UnboundScrip
 Signature:
 
 ```c++
-Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Handle<Nan::UnboundScript> script)
-Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Handle<Nan::BoundScript> script) 
+Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Local<Nan::UnboundScript> script)
+Nan::MaybeLocal<v8::Value> Nan::RunScript(v8::Local<Nan::BoundScript> script) 
 ```
diff --git a/doc/string_bytes.md b/doc/string_bytes.md
index c7339435..7c1bd325 100644
--- a/doc/string_bytes.md
+++ b/doc/string_bytes.md
@@ -42,7 +42,7 @@ A wrapper around `node::DecodeBytes()` that provides a consistent implementation
 Signature:
 
 ```c++
-ssize_t Nan::DecodeBytes(v8::Handle<v8::Value> val,
+ssize_t Nan::DecodeBytes(v8::Local<v8::Value> val,
                          enum Nan::Encoding encoding = BINARY);
 ```
 
@@ -57,6 +57,6 @@ Signature:
 ```c++
 ssize_t Nan::DecodeWrite(char *buf,
                          size_t len,
-                         v8::Handle<v8::Value> val,
+                         v8::Local<v8::Value> val,
                          enum Nan::Encoding encoding = BINARY);
 ```

From 898a90adf106ce64f55472c9eeb9332dc2ef3069 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 31 Jul 2015 13:13:15 +0300
Subject: [PATCH 82/84] Document WeakCallbackType

---
 doc/persistent.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/persistent.md b/doc/persistent.md
index a7d8e8a0..c6c8323b 100644
--- a/doc/persistent.md
+++ b/doc/persistent.md
@@ -278,7 +278,10 @@ See the V8 documentation for [`WeakCallbackInfo`](https://v8docs.nodesource.com/
 <a name="api_nan_weak_callback_type"></a>
 ### Nan::WeakCallbackType
 
-_TODO: explain this_
+Represents the type of a weak callback.
+A weak callback of type `kParameter` makes the supplied parameter to `Nan::PersistentBase::SetWeak` available through `WeakCallbackInfo::GetParameter`.
+A weak callback of type `kInternalFields` uses up to two internal fields at indices 0 and 1 on the `Nan::PersistentBase<v8::Object>` being made weak.
+Note that only `v8::Object`s and derivatives can have internal fields.
 
 Definition:
 

From 9cfb390e8f1f1f09b7821f423e6273a9b602862c Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 31 Jul 2015 13:31:40 +0300
Subject: [PATCH 83/84] Update example

---
 examples/async_pi_estimate/addon.cc | 14 +++++++-------
 examples/async_pi_estimate/async.cc | 28 ++++++++++++++++------------
 examples/async_pi_estimate/async.h  |  2 --
 examples/async_pi_estimate/pi_est.h |  2 +-
 examples/async_pi_estimate/sync.cc  |  4 ----
 examples/async_pi_estimate/sync.h   |  2 --
 6 files changed, 24 insertions(+), 28 deletions(-)

diff --git a/examples/async_pi_estimate/addon.cc b/examples/async_pi_estimate/addon.cc
index 3b1ba0b1..3873380f 100644
--- a/examples/async_pi_estimate/addon.cc
+++ b/examples/async_pi_estimate/addon.cc
@@ -10,21 +10,21 @@
 #include "sync.h"   // NOLINT(build/include)
 #include "async.h"  // NOLINT(build/include)
 
-using namespace Nan;  // NOLINT(build/namespaces)
-
 using v8::FunctionTemplate;
 using v8::Handle;
 using v8::Object;
 using v8::String;
+using Nan::New;
+using Nan::Set;
 
 // Expose synchronous and asynchronous access to our
 // Estimate() function
-void InitAll(Handle<Object> exports) {
-  exports->Set(NanNew<String>("calculateSync").ToLocalChecked(),
-    NanNew<FunctionTemplate>(CalculateSync)->GetFunction());
+NAN_MODULE_INIT(InitAll) {
+  Set(target, New<String>("calculateSync").ToLocalChecked(),
+    New<FunctionTemplate>(CalculateSync)->GetFunction());
 
-  exports->Set(NanNew<String>("calculateAsync").ToLocalChecked(),
-    NanNew<FunctionTemplate>(CalculateAsync)->GetFunction());
+  Set(target, New<String>("calculateAsync").ToLocalChecked(),
+    New<FunctionTemplate>(CalculateAsync)->GetFunction());
 }
 
 NODE_MODULE(addon, InitAll)
diff --git a/examples/async_pi_estimate/async.cc b/examples/async_pi_estimate/async.cc
index 173f565e..d1e3384e 100644
--- a/examples/async_pi_estimate/async.cc
+++ b/examples/async_pi_estimate/async.cc
@@ -10,18 +10,22 @@
 #include "pi_est.h"  // NOLINT(build/include)
 #include "async.h"  // NOLINT(build/include)
 
-using namespace Nan;  // NOLINT(build/namespaces)
-
 using v8::Function;
 using v8::Local;
-using v8::Null;
 using v8::Number;
 using v8::Value;
+using Nan::AsyncQueueWorker;
+using Nan::AsyncWorker;
+using Nan::Callback;
+using Nan::HandleScope;
+using Nan::New;
+using Nan::Null;
+using Nan::To;
 
-class PiWorker : public NanAsyncWorker {
+class PiWorker : public AsyncWorker {
  public:
-  PiWorker(NanCallback *callback, int points)
-    : NanAsyncWorker(callback), points(points), estimate(0) {}
+  PiWorker(Callback *callback, int points)
+    : AsyncWorker(callback), points(points), estimate(0) {}
   ~PiWorker() {}
 
   // Executed inside the worker-thread.
@@ -36,11 +40,11 @@ class PiWorker : public NanAsyncWorker {
   // this function will be run inside the main event loop
   // so it is safe to use V8 again
   void HandleOKCallback () {
-    NanScope();
+    HandleScope();
 
     Local<Value> argv[] = {
-        NanNull()
-      , NanNew<Number>(estimate)
+        Null()
+      , New<Number>(estimate)
     };
 
     callback->Call(2, argv);
@@ -53,8 +57,8 @@ class PiWorker : public NanAsyncWorker {
 
 // Asynchronous access to the `Estimate()` function
 NAN_METHOD(CalculateAsync) {
-  int points = info[0]->Uint32Value();
-  NanCallback *callback = new NanCallback(info[1].As<Function>());
+  int points = To<int>(info[0]).FromJust();
+  Callback *callback = new Callback(info[1].As<Function>());
 
-  NanAsyncQueueWorker(new PiWorker(callback, points));
+  AsyncQueueWorker(new PiWorker(callback, points));
 }
diff --git a/examples/async_pi_estimate/async.h b/examples/async_pi_estimate/async.h
index adba6769..ad3e8897 100644
--- a/examples/async_pi_estimate/async.h
+++ b/examples/async_pi_estimate/async.h
@@ -11,8 +11,6 @@
 
 #include <nan.h>
 
-using namespace Nan;  // NOLINT(build/namespaces)
-
 NAN_METHOD(CalculateAsync);
 
 #endif  // EXAMPLES_ASYNC_PI_ESTIMATE_ASYNC_H_
diff --git a/examples/async_pi_estimate/pi_est.h b/examples/async_pi_estimate/pi_est.h
index 0e76c0df..778ddd8d 100644
--- a/examples/async_pi_estimate/pi_est.h
+++ b/examples/async_pi_estimate/pi_est.h
@@ -9,6 +9,6 @@
 #ifndef EXAMPLES_ASYNC_PI_ESTIMATE_PI_EST_H_
 #define EXAMPLES_ASYNC_PI_ESTIMATE_PI_EST_H_
 
-double Estimate (int points);
+double Estimate(int points);
 
 #endif  // EXAMPLES_ASYNC_PI_ESTIMATE_PI_EST_H_
diff --git a/examples/async_pi_estimate/sync.cc b/examples/async_pi_estimate/sync.cc
index 28ebb6c4..3dae9fdf 100644
--- a/examples/async_pi_estimate/sync.cc
+++ b/examples/async_pi_estimate/sync.cc
@@ -10,10 +10,6 @@
 #include "pi_est.h"  // NOLINT(build/include)
 #include "sync.h"  // NOLINT(build/include)
 
-using namespace Nan;  // NOLINT(build/namespaces)
-
-using v8::Number;
-
 // Simple synchronous access to the `Estimate()` function
 NAN_METHOD(CalculateSync) {
   // expect a number as the first argument
diff --git a/examples/async_pi_estimate/sync.h b/examples/async_pi_estimate/sync.h
index b76d6d6a..282d540d 100644
--- a/examples/async_pi_estimate/sync.h
+++ b/examples/async_pi_estimate/sync.h
@@ -11,8 +11,6 @@
 
 #include <nan.h>
 
-using namespace Nan;  // NOLINT(build/namespaces)
-
 NAN_METHOD(CalculateSync);
 
 #endif  // EXAMPLES_ASYNC_PI_ESTIMATE_SYNC_H_

From 05a582609b1f3b7c783ebfa901dab62a177fa472 Mon Sep 17 00:00:00 2001
From: Benjamin Byholm <bbyholm@abo.fi>
Date: Fri, 31 Jul 2015 13:34:21 +0300
Subject: [PATCH 84/84] Remove outdated porting guide

---
 README.md | 43 -------------------------------------------
 1 file changed, 43 deletions(-)

diff --git a/README.md b/README.md
index 1051a047..2deb9b7b 100644
--- a/README.md
+++ b/README.md
@@ -306,49 +306,6 @@ npm install
 make test
 ```
 
-<a name="tests"></a>
-## Porting
-
-Follows is a guide to porting your C++ node to NAN.
-
-<table><tbody>
-
-<tr><th>Aspect</th><th>Without NAN</th><th>With NAN</th></tr>
-
-<tr><td>Function declaration</td><td><pre>class MyClass : public ObjectWrap {
-    ....
-    static Handle<Value> ToString(const Arguments& args);
-    ....
-}</pre></td></th><td><pre>class MyClass : public ObjectWrap {
-    ....
-    static NAN_METHOD(ToString);
-    ....
-}</pre></td></tr>
-
-<tr><td>Function definition</td><td><pre>Handle<Value>
-MyClass::ToString(const Arguments& args)
-{
-	HandleScope scope;
-	....
-}</pre></td></th><td><pre>
-NAN_METHOD(MyClass::ToString)
-{
-  NanScope();
-  ....
-}</pre></td></tr>
-
-<tr><td>Return a value</td><td><pre>return scope.Close(result);</pre></td></th><td><pre>NanReturnValue(result);</pre></td></tr>
-
-<tr><td>Return undefined</td><td><pre>return Undefined();</pre></td></th><td><pre>NanReturnUndefined();</pre></td></tr>
-
-<tr><td>Throw an error</td><td><pre>return ThrowException(
-  Exception::Error(
-    String::New("Error text...")));</pre></td></th><td><pre>return NanThrowError("Error text...");</pre></td></tr>
-
-<tr><td>New v8 string literal</td><td><pre>String::NewSymbol("my text")</pre></td></th><td><pre>NanNew("my text")</pre></td></tr>
-
-</tbody></table>
-
 <a name="governance"></a>
 ## Governance & Contributing