diff --git a/README.md b/README.md
index 5d24595b..35c20a14 100644
--- a/README.md
+++ b/README.md
@@ -254,21 +254,7 @@ NAN_METHOD(CalculateAsync) {
## API
- * 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
- * NAN_GC_CALLBACK
- * NAN_WEAK_CALLBACK
+ * NAN_WEAK_CALLBACK(callbackname)
* NAN_DEPRECATED
* NAN_INLINE
* NanNew
@@ -337,132 +323,8 @@ NAN_METHOD(CalculateAsync) {
* NanAsyncWorker
* NanAsyncQueueWorker
-
-### 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 name(const Arguments& args)
-
-// 0.11 and above
-void name(const FunctionCallbackInfo& args)
-```
-
-The introduction of `FunctionCallbackInfo` brings additional complications:
-
-
-### NAN_GETTER(methodname)
-
-Use `NAN_GETTER` to declare your V8 accessible getters. You get a `Local` `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`.
-
-
-### NAN_SETTER(methodname)
-
-Use `NAN_SETTER` to declare your V8 accessible setters. Same as `NAN_GETTER` but you also get a `Local` `value` object to work with.
-
-
-### NAN_PROPERTY_GETTER(cbname)
-Use `NAN_PROPERTY_GETTER` to declare your V8 accessible property getters. You get a `Local` `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`.
-
-
-### 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` object to work with.
-
-
-### 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`.
-
-
-### 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`.
-
-
-### 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`.
-
-
-### 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`.
-
-
-### 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` object to work with.
-
-
-### 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`.
-
-
-### 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`.
-
-
-### 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`.
-
-
-### 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 callback;
-
-NAN_GC_CALLBACK(gcPrologueCallback) {
- Local argv[] = {NanNew("prologue")};
- NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(callback), 1, argv);
-}
-
-NAN_METHOD(Hook) {
- NanAssignPersistent(callback, args[0].As());
- NanAddGCPrologueCallback(gcPrologueCallback);
- NanReturnValue(args.Holder());
-}
-```
-
-### 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 &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.
diff --git a/doc/methods.md b/doc/methods.md
new file mode 100644
index 00000000..75aa77e0
--- /dev/null
+++ b/doc/methods.md
@@ -0,0 +1,360 @@
+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**
+ - Nan::FunctionCallbackInfo
+ - Nan::PropertyCallbackInfo
+* **Method declarations**
+ - Method declaration
+ - Getter declaration
+ - Setter declaration
+ - Property getter declaration
+ - Property setter declaration
+ - Property enumerator declaration
+ - Property deleter declaration
+ - Property query declaration
+ - Index getter declaration
+ - Index setter declaration
+ - Index enumerator declaration
+ - Index deleter declaration
+ - Index query declaration
+* **Garbage collector**
+ * NAN_GC_CALLBACK(callbackname)
+ - Nan::AddGCEpilogueCallbackNan::RemoveGCEpilogueCallbackNan::AddGCPrologueCallbackNan::RemoveGCPrologueCallbackNan::GetHeapStatistics
+### 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 GetReturnValue()`
+* `v8::Local Callee()`
+* `v8::Local Data()`
+* `v8::Local Holder()`
+* `bool IsConstructCall()`
+* `int Length()`
+* `v8::Local operator[](int i)`
+* `v8::Local 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.
+
+
+### 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 Data()`
+* `v8::Local This()`
+* `v8::Local Holder()`
+* `Nan::ReturnValue 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.
+
+
+### Method declaration
+
+JavaScript-accessible methods should be declared with the following signature:
+
+```c++
+void MethodName(const Nan::FunctionCallbackInfo& 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& info);
+ static void Baz(const Nan::FunctionCallbackInfo& info);
+}
+
+
+// .cc:
+void Foo::Bar(const Nan::FunctionCallbackInfo& info) {
+ ...
+}
+
+void Foo::Baz(const Nan::FunctionCallbackInfo& 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) {
+ ...
+}
+```
+
+
+
+### Getter declaration
+
+JavaScript-accessible getters should be declared with the following signature:
+
+```c++
+void GetterName(v8::Local property,
+ const Nan::PropertyCallbackInfo& 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.
+
+
+### Setter declaration
+
+JavaScript-accessible setters should be declared with the following signature:
+
+```c++
+void SetterName(v8::Local property,
+ v8::Local value,
+ const Nan::PropertyCallbackInfo& 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.
+
+
+### Property getter declaration
+
+JavaScript-accessible property getters should be declared with the following signature:
+
+```c++
+void PropertyGetterName(v8::Local property,
+ const Nan::PropertyCallbackInfo& 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.
+
+
+
+### Property setter declaration
+
+JavaScript-accessible property setters should be declared with the following signature:
+
+```c++
+void PropertySetterName(v8::Local property,
+ v8::Local value,
+ const Nan::PropertyCallbackInfo& 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.
+
+
+### Property enumerator declaration
+
+JavaScript-accessible property enumerators should be declared with the following signature:
+
+```c++
+void PropertyEnumeratorName(const Nan::PropertyCallbackInfo& 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.
+
+
+### Property deleter declaration
+
+JavaScript-accessible property deleters should be declared with the following signature:
+
+```c++
+void PropertyDeleterName(v8::Local property,
+ const Nan::PropertyCallbackInfo& 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.
+
+
+### Property query declaration
+
+JavaScript-accessible property query methods should be declared with the following signature:
+
+```c++
+void PropertyQueryName(v8::Local property,
+ const Nan::PropertyCallbackInfo& 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.
+
+
+### Index getter declaration
+
+JavaScript-accessible index getter methods should be declared with the following signature:
+
+```c++
+void IndexGetterName(uint32_t index, const PropertyCallbackInfo& 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.
+
+
+### Index setter declaration
+
+JavaScript-accessible index setter methods should be declared with the following signature:
+
+```c++
+void IndexSetterName(uint32_t index,
+ v8::Local value,
+ const PropertyCallbackInfo& 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.
+
+
+### Index enumerator declaration
+
+JavaScript-accessible index enumerator methods should be declared with the following signature:
+
+```c++
+void IndexEnumeratorName(const PropertyCallbackInfo& 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.
+
+
+### Index deleter declaration
+
+JavaScript-accessible index deleter methods should be declared with the following signature:
+
+```c++
+void IndexDeleterName(uint32_t index, const PropertyCallbackInfo& 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.
+
+
+### Index query declaration
+
+JavaScript-accessible index query methods should be declared with the following signature:
+
+```c++
+void IndexQueryName(uint32_t index, const PropertyCallbackInfo& 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.
+
+
+### 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 callback;
+
+NAN_GC_CALLBACK(gcPrologueCallback) {
+ v8::Local argv[] = { Nan::New("prologue").ToLocalChecked() };
+ Nan::MakeCallback(Nan::GetCurrentContext()->Global(), Nan::New(callback), 1, argv);
+}
+
+NAN_METHOD(Hook) {
+ callback.Reset(args[0].As());
+ Nan::AddGCPrologueCallback(gcPrologueCallback);
+ info.GetReturnValue().Set(info.Holder());
+}
+```
+
+
+### 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).
+
+
+### 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).
+
+
+### 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).
+
+
+### 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).
+
+
+### 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).