From 368467aceb6bfcc53f313e7886688e3830ccf1d7 Mon Sep 17 00:00:00 2001
From: Aaron Meriwether <me@ameriwether.com>
Date: Wed, 9 Oct 2019 15:32:42 -0500
Subject: [PATCH] Build for Node 12 / Electron 6

---
 src/NodeClipboard.cc |   6 +-
 src/NodeClipboard.h  |   2 +-
 src/NodeCommon.h     |  95 ++++++++++-----
 src/NodeImage.cc     |  57 +++++----
 src/NodeImage.h      |   2 +-
 src/NodeKeyboard.cc  |  43 ++++---
 src/NodeKeyboard.h   |   2 +-
 src/NodeMemory.cc    | 189 +++++++++++++++--------------
 src/NodeMemory.h     |   2 +-
 src/NodeMouse.cc     |  49 ++++----
 src/NodeMouse.h      |   2 +-
 src/NodeProcess.cc   |  65 +++++-----
 src/NodeProcess.h    |   2 +-
 src/NodeRobot.cc     | 280 +++++++++++++++++++++----------------------
 src/NodeRobot.rc     |   9 +-
 src/NodeScreen.cc    |  25 ++--
 src/NodeScreen.h     |   2 +-
 src/NodeWindow.cc    |  63 +++++-----
 src/NodeWindow.h     |   2 +-
 src/robot            |   2 +-
 20 files changed, 462 insertions(+), 437 deletions(-)

diff --git a/src/NodeClipboard.cc b/src/NodeClipboard.cc
index dcc63cf..5fe3d5f 100644
--- a/src/NodeClipboard.cc
+++ b/src/NodeClipboard.cc
@@ -53,7 +53,7 @@ void ClipboardWrap::SetText (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsString())
 		THROW (Type, "Invalid arguments");
 
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	auto text = *value ? *value : "";
 	RETURN_BOOL (Clipboard::SetText (text));
 }
@@ -100,7 +100,7 @@ void ClipboardWrap::GetSequence (const FunctionCallbackInfo<Value>& args)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void ClipboardWrap::Initialize (Handle<Object> exports)
+void ClipboardWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -121,5 +121,5 @@ void ClipboardWrap::Initialize (Handle<Object> exports)
 	NODE_SET_METHOD (result, "getSequence", GetSequence);
 
 	// Export clipboard functions inside object
-	exports->Set (NEW_STR ("Clipboard"), result);
+	OBJECT_SET (exports, NEW_STR ("Clipboard"), result);
 }
diff --git a/src/NodeClipboard.h b/src/NodeClipboard.h
index ae80f9c..a789350 100644
--- a/src/NodeClipboard.h
+++ b/src/NodeClipboard.h
@@ -38,5 +38,5 @@ class ClipboardWrap : public ObjectWrap
 	static void		GetSequence		(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 };
diff --git a/src/NodeCommon.h b/src/NodeCommon.h
index 7a196b4..4deab81 100644
--- a/src/NodeCommon.h
+++ b/src/NodeCommon.h
@@ -47,10 +47,26 @@ ROBOT_NS_USE_ALL;
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#if NODE_MODULE_VERSION >= 46
+
+	#define NEW_INSTANCE( f, argc, argv ) f->NewInstance(v8::Context::New(isolate), argc, argv).ToLocalChecked()
+
+#else
+
+	#define NEW_INSTANCE( f, argc, argv ) f->NewInstance(argc, argv)
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
 #define NEW_INT( value ) Integer::New         (isolate, value )
 #define NEW_NUM( value ) Number ::New         (isolate, value )
 #define NEW_BOOL(value ) Boolean::New         (isolate, value )
+#if NODE_MODULE_VERSION >= 67
+#define NEW_STR( value ) String ::NewFromUtf8 (isolate, value, v8::NewStringType::kNormal).ToLocalChecked()
+#else
 #define NEW_STR( value ) String ::NewFromUtf8 (isolate, value )
+#endif
 #define NEW_OBJ          Object ::New         (isolate        )
 #define NEW_ARR( length) Array  ::New         (isolate, length)
 #define NEW_NULL         Null                 (isolate        )
@@ -64,32 +80,28 @@ ROBOT_NS_USE_ALL;
 		_jsArgs[1] = NEW_INT (g),							\
 		_jsArgs[2] = NEW_INT (b),							\
 		_jsArgs[3] = NEW_INT (a),							\
-		Local<Function>::New								\
-			(isolate, JsColor)->NewInstance (4, _jsArgs)	\
+		NEW_INSTANCE(Local<Function>::New(isolate, JsColor), 4, _jsArgs) \
 	)
 
 #define NEW_RANGE( min, max )								\
 	(														\
 		_jsArgs[0] = NEW_INT (min),							\
 		_jsArgs[1] = NEW_INT (max),							\
-		Local<Function>::New								\
-			(isolate, JsRange)->NewInstance (2, _jsArgs)	\
+		NEW_INSTANCE(Local<Function>::New(isolate, JsRange), 2, _jsArgs) \
 	)
 
 #define NEW_POINT( x, y )									\
 	(														\
 		_jsArgs[0] = NEW_INT (x),							\
 		_jsArgs[1] = NEW_INT (y),							\
-		Local<Function>::New								\
-			(isolate, JsPoint)->NewInstance (2, _jsArgs)	\
+		NEW_INSTANCE(Local<Function>::New(isolate, JsPoint), 2, _jsArgs) \
 	)
 
 #define NEW_SIZE( w, h )									\
 	(														\
 		_jsArgs[0] = NEW_INT (w),							\
 		_jsArgs[1] = NEW_INT (h),							\
-		Local<Function>::New								\
-			(isolate, JsSize)->NewInstance (2, _jsArgs)		\
+		NEW_INSTANCE(Local<Function>::New(isolate, JsSize), 2, _jsArgs) \
 	)
 
 #define NEW_BOUNDS( x, y, w, h )							\
@@ -98,14 +110,47 @@ ROBOT_NS_USE_ALL;
 		_jsArgs[1] = NEW_INT (y),							\
 		_jsArgs[2] = NEW_INT (w),							\
 		_jsArgs[3] = NEW_INT (h),							\
-		Local<Function>::New								\
-			(isolate, JsBounds)->NewInstance (4, _jsArgs)	\
+		NEW_INSTANCE(Local<Function>::New(isolate, JsBounds), 4, _jsArgs) \
 	)
 
-#define NEW_MODULE  Local<Function>::New (isolate, JsModule )->NewInstance()
-#define NEW_SEGMENT Local<Function>::New (isolate, JsSegment)->NewInstance()
-#define NEW_STATS   Local<Function>::New (isolate, JsStats  )->NewInstance()
-#define NEW_REGION  Local<Function>::New (isolate, JsRegion )->NewInstance()
+#define NEW_MODULE  NEW_INSTANCE(Local<Function>::New(isolate, JsModule ), 0, NULL)
+#define NEW_SEGMENT NEW_INSTANCE(Local<Function>::New(isolate, JsSegment), 0, NULL)
+#define NEW_STATS   NEW_INSTANCE(Local<Function>::New(isolate, JsStats  ), 0, NULL)
+#define NEW_REGION  NEW_INSTANCE(Local<Function>::New(isolate, JsRegion ), 0, NULL)
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if NODE_MODULE_VERSION >= 70
+#define BOOLEAN_VALUE( value ) (value->BooleanValue (isolate))
+#define UTF8_VAR( var, value ) String::Utf8Value var (isolate, value)
+#else
+#define BOOLEAN_VALUE( value ) (value->BooleanValue())
+#define UTF8_VAR( var, value ) String::Utf8Value var (value)
+#endif
+
+#if NODE_MODULE_VERSION >= 67
+#define TO_OBJECT( value ) (value->ToObject (isolate->GetCurrentContext()).ToLocalChecked())
+#define NUMBER_VALUE( value ) (value->NumberValue (isolate->GetCurrentContext()).ToChecked())
+#define INT32_VALUE( value ) (value->Int32Value (isolate->GetCurrentContext()).ToChecked())
+#define UINT32_VALUE( value ) (value->Uint32Value (isolate->GetCurrentContext()).ToChecked())
+#define OBJECT_GET( map, key ) (map->Get (isolate->GetCurrentContext(), key).ToLocalChecked())
+#define OBJECT_SET( map, key, value ) (map->Set (isolate->GetCurrentContext(), key, value).ToChecked())
+#define GET_FUNCTION( tpl ) (tpl->GetFunction (isolate->GetCurrentContext()).ToLocalChecked())
+#else
+#define TO_OBJECT( value ) (value->ToObject())
+#define NUMBER_VALUE( value ) (value->NumberValue())
+#define INT32_VALUE( value ) (value->Int32Value())
+#define UINT32_VALUE( value ) (value->Uint32Value())
+#define OBJECT_GET( map, key ) (map->Get (key))
+#define OBJECT_SET( map, key, value ) (map->Set (key, value))
+#define GET_FUNCTION( tpl ) (tpl->GetFunction())
+#endif
+
+#if NODE_MODULE_VERSION >= 48
+#define GET_PRIVATE( obj, key ) ((obj->GetPrivate (isolate->GetCurrentContext(), Private::ForApi (isolate, NEW_STR (key)))).ToLocalChecked())
+#else
+#define GET_PRIVATE( obj, key ) (obj->GetHiddenValue (NEW_STR (key)))
+#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -212,7 +257,7 @@ enum RobotType
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T>
-inline T* UnwrapRobot (Handle<Value> value)
+inline T* UnwrapRobot (Local<Value> value)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -221,30 +266,16 @@ inline T* UnwrapRobot (Handle<Value> value)
 	if (!value->IsObject()) return nullptr;
 
 	// Retrieve the local object
-	auto obj = value->ToObject();
-
-#if NODE_MODULE_VERSION >= 48
-
-	auto context = isolate->GetCurrentContext();
-	auto privateKeyValue = Private::ForApi
-		(isolate, NEW_STR ("_ROBOT_TYPE"));
-
-	auto type = obj->GetPrivate (context,
-		privateKeyValue).ToLocalChecked();
-
-#else
+	auto obj = TO_OBJECT (value);
 
 	// Convert and get hidden type
-	auto type = obj->GetHiddenValue
-		  (NEW_STR ("_ROBOT_TYPE"));
-
-#endif
+	auto type = GET_PRIVATE (obj, "_ROBOT_TYPE");
 
 	// The value must contain a handle
 	if (type.IsEmpty()) return nullptr;
 
 	// Compare hidden type with class type
-	if (type->Int32Value() != T::ClassType)
+	if (INT32_VALUE (type) != T::ClassType)
 		return nullptr;
 
 	// Return the final unwrapped class
diff --git a/src/NodeImage.cc b/src/NodeImage.cc
index 9bad137..57e2e65 100644
--- a/src/NodeImage.cc
+++ b/src/NodeImage.cc
@@ -35,8 +35,8 @@ void ImageWrap::Create (const FunctionCallbackInfo<Value>& args)
 	ISOWRAP (Image, args.Holder());
 
 	RETURN_BOOL (mImage->Create
-		((uint16) args[0]->Int32Value(),
-		 (uint16) args[1]->Int32Value()));
+		((uint16) INT32_VALUE (args[0]),
+		 (uint16) INT32_VALUE (args[1])));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -106,8 +106,8 @@ void ImageWrap::GetPixel (const FunctionCallbackInfo<Value>& args)
 	ISOWRAP (Image, args.Holder());
 
 	Color color = mImage->GetPixel
-		((uint16) args[0]->Int32Value(),
-		 (uint16) args[1]->Int32Value());
+		((uint16) INT32_VALUE (args[0]),
+		 (uint16) INT32_VALUE (args[1]));
 
 	RETURN_COLOR (color.R, color.G,
 				  color.B, color.A);
@@ -120,12 +120,12 @@ void ImageWrap::SetPixel (const FunctionCallbackInfo<Value>& args)
 	ISOWRAP (Image, args.Holder());
 
 	mImage->SetPixel
-		  ((uint16) args[0]->Int32Value(),
-		   (uint16) args[1]->Int32Value(),
-	Color ((uint8 ) args[2]->Int32Value(),
-		   (uint8 ) args[3]->Int32Value(),
-		   (uint8 ) args[4]->Int32Value(),
-		   (uint8 ) args[5]->Int32Value()));
+		  ((uint16) INT32_VALUE (args[0]),
+		   (uint16) INT32_VALUE (args[1]),
+	Color ((uint8 ) INT32_VALUE (args[2]),
+		   (uint8 ) INT32_VALUE (args[3]),
+		   (uint8 ) INT32_VALUE (args[4]),
+		   (uint8 ) INT32_VALUE (args[5])));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -135,10 +135,10 @@ void ImageWrap::Fill (const FunctionCallbackInfo<Value>& args)
 	ISOWRAP (Image, args.Holder());
 
 	RETURN_BOOL (mImage->Fill (Color
-		((uint8) args[0]->Int32Value(),
-		 (uint8) args[1]->Int32Value(),
-		 (uint8) args[2]->Int32Value(),
-		 (uint8) args[3]->Int32Value())));
+		((uint8) INT32_VALUE (args[0]),
+		 (uint8) INT32_VALUE (args[1]),
+		 (uint8) INT32_VALUE (args[2]),
+		 (uint8) INT32_VALUE (args[3]))));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -151,7 +151,7 @@ void ImageWrap::Swap (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsString())
 		THROW (Type, "Invalid arguments");
 
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	auto swap = *value ? *value : "";
 	RETURN_BOOL (mImage->Swap (swap));
 }
@@ -167,8 +167,8 @@ void ImageWrap::Flip (const FunctionCallbackInfo<Value>& args)
 		!args[1]->IsBoolean())
 		THROW (Type, "Invalid arguments");
 
-	bool h = args[0]->BooleanValue();
-	bool v = args[1]->BooleanValue();
+	bool h = BOOLEAN_VALUE (args[0]);
+	bool v = BOOLEAN_VALUE (args[1]);
 	RETURN_BOOL (mImage->Flip (h, v));
 }
 
@@ -178,7 +178,7 @@ void ImageWrap::Equals (const FunctionCallbackInfo<Value>& args)
 {
 	ISOLATE;
 	auto* wrapper1 = ObjectWrap::Unwrap<ImageWrap> (args      .Holder());
-	auto* wrapper2 = ObjectWrap::Unwrap<ImageWrap> (args[0]->ToObject());
+	auto* wrapper2 = ObjectWrap::Unwrap<ImageWrap> (TO_OBJECT (args[0]));
 	RETURN_BOOL (wrapper1->mImage == wrapper2->mImage);
 }
 
@@ -200,14 +200,14 @@ void ImageWrap::New (const FunctionCallbackInfo<Value>& args)
 		else
 		{
 			// Normalize the size argument
-			auto s = Local<Function>::New
-				(isolate, JsSize)->NewInstance
-				(2, (_jsArgs[0] = args[0],
-					 _jsArgs[1] = args[1], _jsArgs));
+			auto s = NEW_INSTANCE(
+				Local<Function>::New(isolate, JsSize),
+				2, (_jsArgs[0] = args[0],
+					_jsArgs[1] = args[1], _jsArgs));
 
 			wrapper->mImage.Create
-				((uint16) s->Get (NEW_STR ("w"))->Int32Value(),
-				 (uint16) s->Get (NEW_STR ("h"))->Int32Value());
+				(INT32_VALUE ((uint16) OBJECT_GET (s, NEW_STR ("w"))),
+				 INT32_VALUE ((uint16) OBJECT_GET (s, NEW_STR ("h"))));
 		}
 
 		REGISTER_ROBOT_TYPE;
@@ -218,7 +218,7 @@ void ImageWrap::New (const FunctionCallbackInfo<Value>& args)
 	{
 		auto ctor = NEW_CTOR (Image);
 		// Return as a new instance
-		RETURN (ctor->NewInstance (2,
+		RETURN (NEW_INSTANCE(ctor, 2,
 			   (_jsArgs[0] = args[0],
 				_jsArgs[1] = args[1], _jsArgs)));
 	}
@@ -226,7 +226,7 @@ void ImageWrap::New (const FunctionCallbackInfo<Value>& args)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void ImageWrap::Initialize (Handle<Object> exports)
+void ImageWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -256,7 +256,6 @@ void ImageWrap::Initialize (Handle<Object> exports)
 	NODE_SET_PROTOTYPE_METHOD (tpl, "_equals",    Equals   );
 
 	// Assign function template to our class creator
-	constructor.Reset (isolate, tpl->GetFunction());
-	exports->Set
-			(NEW_STR ("Image"), tpl->GetFunction());
+	constructor.Reset (isolate, GET_FUNCTION (tpl));
+	OBJECT_SET (exports, NEW_STR ("Image"), GET_FUNCTION (tpl));
 }
diff --git a/src/NodeImage.h b/src/NodeImage.h
index 8d4dc71..420a13b 100644
--- a/src/NodeImage.h
+++ b/src/NodeImage.h
@@ -49,7 +49,7 @@ class ImageWrap : public ObjectWrap
 	static void		New				(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 
 public:
 	Image mImage;
diff --git a/src/NodeKeyboard.cc b/src/NodeKeyboard.cc
index 514696a..07817d5 100644
--- a/src/NodeKeyboard.cc
+++ b/src/NodeKeyboard.cc
@@ -26,10 +26,10 @@ void KeyboardWrap::Click (const FunctionCallbackInfo<Value>& args)
 {
 	ISOWRAP (Keyboard, args.Holder());
 
-	mKeyboard->AutoDelay.Min = args[1]->Int32Value();
-	mKeyboard->AutoDelay.Max = args[2]->Int32Value();
+	mKeyboard->AutoDelay.Min = INT32_VALUE (args[1]);
+	mKeyboard->AutoDelay.Max = INT32_VALUE (args[2]);
 	if (args[0]->IsInt32())
-		mKeyboard->Click ((Key) args[0]->Int32Value());
+		mKeyboard->Click ((Key) INT32_VALUE (args[0]));
 
 	else
 	{
@@ -37,7 +37,7 @@ void KeyboardWrap::Click (const FunctionCallbackInfo<Value>& args)
 		if (!args[0]->IsString())
 			THROW (Type, "Invalid arguments");
 
-		String::Utf8Value value (args[0]);
+		UTF8_VAR (value, args[0]);
 		auto keys = *value ? *value : "";
 		// Perform a series of keycode actions
 		RETURN_BOOL (mKeyboard->Click (keys));
@@ -54,9 +54,9 @@ void KeyboardWrap::Press (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsInt32())
 		THROW (Type, "Invalid arguments");
 
-	mKeyboard->AutoDelay.Min = args[1]->Int32Value();
-	mKeyboard->AutoDelay.Max = args[2]->Int32Value();
-	mKeyboard->Press ((Key) args[0]->Int32Value());
+	mKeyboard->AutoDelay.Min = INT32_VALUE (args[1]);
+	mKeyboard->AutoDelay.Max = INT32_VALUE (args[2]);
+	mKeyboard->Press ((Key) INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -69,9 +69,9 @@ void KeyboardWrap::Release (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsInt32())
 		THROW (Type, "Invalid arguments");
 
-	mKeyboard->AutoDelay.Min = args[1]->Int32Value();
-	mKeyboard->AutoDelay.Max = args[2]->Int32Value();
-	mKeyboard->Release ((Key) args[0]->Int32Value());
+	mKeyboard->AutoDelay.Min = INT32_VALUE (args[1]);
+	mKeyboard->AutoDelay.Max = INT32_VALUE (args[2]);
+	mKeyboard->Release ((Key) INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -84,7 +84,7 @@ void KeyboardWrap::Compile (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsString())
 		THROW (Type, "Invalid arguments");
 
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	auto keys = *value ? *value : "";
 
 	KeyList list;
@@ -97,9 +97,9 @@ void KeyboardWrap::Compile (const FunctionCallbackInfo<Value>& args)
 		for (int i = 0; i < length; ++i)
 		{
 			auto obj = NEW_OBJ;
-			obj->Set (NEW_STR ("down"), NEW_BOOL (list[i].first ));
-			obj->Set (NEW_STR ("key" ), NEW_INT  (list[i].second));
-			res->Set (i, obj);
+			OBJECT_SET (obj, NEW_STR ("down"), NEW_BOOL (list[i].first ));
+			OBJECT_SET (obj, NEW_STR ("key" ), NEW_INT  (list[i].second));
+			OBJECT_SET (res, i, obj);
 		}
 
 		RETURN (res);
@@ -123,7 +123,7 @@ void KeyboardWrap::GetState (const FunctionCallbackInfo<Value>& args)
 		{
 			// Loop every state and add it to resulting object
 			for (auto i = state.begin(); i != state.end(); ++i)
-				res->Set (NEW_INT (i->first), NEW_BOOL (i->second));
+				OBJECT_SET (res, NEW_INT (i->first), NEW_BOOL (i->second));
 		}
 
 		RETURN (res);
@@ -134,7 +134,7 @@ void KeyboardWrap::GetState (const FunctionCallbackInfo<Value>& args)
 	{
 		RETURN_BOOL (Keyboard::GetState
 			// Get info about a single key
-			((Key) args[0]->Int32Value()));
+			((Key) INT32_VALUE (args[0])));
 	}
 
 	THROW (Type, "Invalid arguments");
@@ -149,7 +149,7 @@ void KeyboardWrap::New (const FunctionCallbackInfo<Value>& args)
 	if (args.IsConstructCall())
 	{
 		(new KeyboardWrap())->Wrap (args.This());
-		args.This()->Set (NEW_STR ("autoDelay"),
+		OBJECT_SET (args.This(), NEW_STR ("autoDelay"),
 						  NEW_RANGE ( 40,  90));
 
 		REGISTER_ROBOT_TYPE;
@@ -160,13 +160,13 @@ void KeyboardWrap::New (const FunctionCallbackInfo<Value>& args)
 	{
 		auto ctor = NEW_CTOR (Keyboard);
 		// Return as a new instance
-		RETURN (ctor->NewInstance());
+		RETURN (NEW_INSTANCE(ctor, 0, NULL));
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void KeyboardWrap::Initialize (Handle<Object> exports)
+void KeyboardWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -184,7 +184,6 @@ void KeyboardWrap::Initialize (Handle<Object> exports)
 	NODE_SET_METHOD ((Local<Template>) tpl, "getState", GetState);
 
 	// Assign function template to our class creator
-	constructor.Reset (isolate, tpl->GetFunction());
-	exports->Set
-		 (NEW_STR ("Keyboard"), tpl->GetFunction());
+	constructor.Reset (isolate, GET_FUNCTION (tpl));
+	OBJECT_SET (exports, NEW_STR ("Keyboard"), GET_FUNCTION (tpl));
 }
diff --git a/src/NodeKeyboard.h b/src/NodeKeyboard.h
index b1ff30f..82c11d9 100644
--- a/src/NodeKeyboard.h
+++ b/src/NodeKeyboard.h
@@ -37,7 +37,7 @@ class KeyboardWrap : public ObjectWrap
 	static void		New				(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 
 public:
 	Keyboard mKeyboard;
diff --git a/src/NodeMemory.cc b/src/NodeMemory.cc
index d68cb09..8661855 100644
--- a/src/NodeMemory.cc
+++ b/src/NodeMemory.cc
@@ -57,7 +57,7 @@ void MemoryWrap::GetProcess (const FunctionCallbackInfo<Value>& args)
 	auto ctor = NEW_CTOR (Process);
 
 	// Create a new instance of wrapper
-	auto instance = ctor->NewInstance();
+	auto instance = NEW_INSTANCE(ctor, 0, NULL);
 	UNWRAP (Process, instance);
 
 	auto process = mMemory->GetProcess();
@@ -79,17 +79,17 @@ void MemoryWrap::GetStats (const FunctionCallbackInfo<Value>& args)
 
 	// Retrieve memory statistics value
 	bool reset = args[0]->IsBoolean() ?
-		 args[0]->BooleanValue() : false;
+		 BOOLEAN_VALUE (args[0]) : false;
 	auto stats = mMemory->GetStats (reset);
 
 	auto res = NEW_STATS;
-	res->Set (NEW_STR ("systemReads" ), NEW_INT (stats.SystemReads ));
-	res->Set (NEW_STR ("cachedReads" ), NEW_INT (stats.CachedReads ));
-	res->Set (NEW_STR ("systemWrites"), NEW_INT (stats.SystemWrites));
-	res->Set (NEW_STR ("accessWrites"), NEW_INT (stats.AccessWrites));
+	OBJECT_SET (res, NEW_STR ("systemReads" ), NEW_INT (stats.SystemReads ));
+	OBJECT_SET (res, NEW_STR ("cachedReads" ), NEW_INT (stats.CachedReads ));
+	OBJECT_SET (res, NEW_STR ("systemWrites"), NEW_INT (stats.SystemWrites));
+	OBJECT_SET (res, NEW_STR ("accessWrites"), NEW_INT (stats.AccessWrites));
 
-	res->Set (NEW_STR ( "readErrors" ), NEW_INT (stats. ReadErrors ));
-	res->Set (NEW_STR ("writeErrors" ), NEW_INT (stats.WriteErrors ));
+	OBJECT_SET (res, NEW_STR ( "readErrors" ), NEW_INT (stats. ReadErrors ));
+	OBJECT_SET (res, NEW_STR ("writeErrors" ), NEW_INT (stats.WriteErrors ));
 	RETURN (res);
 }
 
@@ -105,23 +105,23 @@ void MemoryWrap::GetRegion (const FunctionCallbackInfo<Value>& args)
 
 	// Get memory region information
 	auto region = mMemory->GetRegion
-		((uintptr) args[0]->NumberValue());
+		((uintptr) NUMBER_VALUE (args[0]));
 
 	auto res = NEW_REGION;
-	res->Set (NEW_STR ("valid"     ), NEW_BOOL (         region.Valid     ));
-	res->Set (NEW_STR ("bound"     ), NEW_BOOL (         region.Bound     ));
+	OBJECT_SET (res, NEW_STR ("valid"     ), NEW_BOOL (         region.Valid     ));
+	OBJECT_SET (res, NEW_STR ("bound"     ), NEW_BOOL (         region.Bound     ));
 
-	res->Set (NEW_STR ("start"     ), NEW_NUM  ((double) region.Start     ));
-	res->Set (NEW_STR ("stop"      ), NEW_NUM  ((double) region.Stop      ));
-	res->Set (NEW_STR ("size"      ), NEW_NUM  ((double) region.Size      ));
+	OBJECT_SET (res, NEW_STR ("start"     ), NEW_NUM  ((double) region.Start     ));
+	OBJECT_SET (res, NEW_STR ("stop"      ), NEW_NUM  ((double) region.Stop      ));
+	OBJECT_SET (res, NEW_STR ("size"      ), NEW_NUM  ((double) region.Size      ));
 
-	res->Set (NEW_STR ("readable"  ), NEW_BOOL (         region.Readable  ));
-	res->Set (NEW_STR ("writable"  ), NEW_BOOL (         region.Writable  ));
-	res->Set (NEW_STR ("executable"), NEW_BOOL (         region.Executable));
-	res->Set (NEW_STR ("access"    ), NEW_INT  (( int32) region.Access    ));
+	OBJECT_SET (res, NEW_STR ("readable"  ), NEW_BOOL (         region.Readable  ));
+	OBJECT_SET (res, NEW_STR ("writable"  ), NEW_BOOL (         region.Writable  ));
+	OBJECT_SET (res, NEW_STR ("executable"), NEW_BOOL (         region.Executable));
+	OBJECT_SET (res, NEW_STR ("access"    ), NEW_INT  (( int32) region.Access    ));
 
-	res->Set (NEW_STR ("private"   ), NEW_BOOL (         region.Private   ));
-	res->Set (NEW_STR ("guarded"   ), NEW_BOOL (         region.Guarded   ));
+	OBJECT_SET (res, NEW_STR ("private"   ), NEW_BOOL (         region.Private   ));
+	OBJECT_SET (res, NEW_STR ("guarded"   ), NEW_BOOL (         region.Guarded   ));
 	RETURN (res);
 }
 
@@ -144,9 +144,9 @@ void MemoryWrap::GetRegions (const FunctionCallbackInfo<Value>& args)
 	auto stop  = (uintptr) -1;
 
 	if (args[0]->IsNumber())
-		start = (uintptr) args[0]->NumberValue();
+		start = (uintptr) NUMBER_VALUE (args[0]);
 	if (args[1]->IsNumber())
-		stop  = (uintptr) args[1]->NumberValue();
+		stop  = (uintptr) NUMBER_VALUE (args[1]);
 
 	// Get a region list with the specified range
 	auto list = mMemory->GetRegions (start, stop);
@@ -160,23 +160,23 @@ void MemoryWrap::GetRegions (const FunctionCallbackInfo<Value>& args)
 		const auto& current = list[i];
 
 		// Create a new region instance
-		auto obj = ctor->NewInstance();
+		auto obj = NEW_INSTANCE(ctor, 0, NULL);
 
-		obj->Set (NEW_STR ("valid"     ), NEW_BOOL (         current.Valid     ));
-		obj->Set (NEW_STR ("bound"     ), NEW_BOOL (         current.Bound     ));
+		OBJECT_SET (obj, NEW_STR ("valid"     ), NEW_BOOL (         current.Valid     ));
+		OBJECT_SET (obj, NEW_STR ("bound"     ), NEW_BOOL (         current.Bound     ));
 
-		obj->Set (NEW_STR ("start"     ), NEW_NUM  ((double) current.Start     ));
-		obj->Set (NEW_STR ("stop"      ), NEW_NUM  ((double) current.Stop      ));
-		obj->Set (NEW_STR ("size"      ), NEW_NUM  ((double) current.Size      ));
+		OBJECT_SET (obj, NEW_STR ("start"     ), NEW_NUM  ((double) current.Start     ));
+		OBJECT_SET (obj, NEW_STR ("stop"      ), NEW_NUM  ((double) current.Stop      ));
+		OBJECT_SET (obj, NEW_STR ("size"      ), NEW_NUM  ((double) current.Size      ));
 
-		obj->Set (NEW_STR ("readable"  ), NEW_BOOL (         current.Readable  ));
-		obj->Set (NEW_STR ("writable"  ), NEW_BOOL (         current.Writable  ));
-		obj->Set (NEW_STR ("executable"), NEW_BOOL (         current.Executable));
-		obj->Set (NEW_STR ("access"    ), NEW_INT  (( int32) current.Access    ));
+		OBJECT_SET (obj, NEW_STR ("readable"  ), NEW_BOOL (         current.Readable  ));
+		OBJECT_SET (obj, NEW_STR ("writable"  ), NEW_BOOL (         current.Writable  ));
+		OBJECT_SET (obj, NEW_STR ("executable"), NEW_BOOL (         current.Executable));
+		OBJECT_SET (obj, NEW_STR ("access"    ), NEW_INT  (( int32) current.Access    ));
 
-		obj->Set (NEW_STR ("private"   ), NEW_BOOL (         current.Private   ));
-		obj->Set (NEW_STR ("guarded"   ), NEW_BOOL (         current.Guarded   ));
-		res->Set (i, obj);
+		OBJECT_SET (obj, NEW_STR ("private"   ), NEW_BOOL (         current.Private   ));
+		OBJECT_SET (obj, NEW_STR ("guarded"   ), NEW_BOOL (         current.Guarded   ));
+		OBJECT_SET (res, i, obj);
 	}
 
 	RETURN (res);
@@ -190,25 +190,25 @@ void MemoryWrap::SetAccess (const FunctionCallbackInfo<Value>& args)
 
 	// Synthesize a region
 	Memory::Region region;
-	region.Valid =           args[0]->BooleanValue();
-	region.Bound =           args[1]->BooleanValue();
-	region.Start = (uintptr) args[2]-> NumberValue();
-	region.Size  = (uintptr) args[3]-> NumberValue();
+	region.Valid =           BOOLEAN_VALUE (args[0]);
+	region.Bound =           BOOLEAN_VALUE (args[1]);
+	region.Start = (uintptr) NUMBER_VALUE  (args[2]);
+	region.Size  = (uintptr) NUMBER_VALUE  (args[3]);
 
 	if (args[4]->IsBoolean() &&
 		args[5]->IsBoolean() &&
 		args[6]->IsBoolean())
 	{
 		RETURN_BOOL (mMemory->SetAccess
-		(region, args[4]->BooleanValue(),
-				 args[5]->BooleanValue(),
-				 args[6]->BooleanValue()));
+		(region, BOOLEAN_VALUE (args[4]),
+				 BOOLEAN_VALUE (args[5]),
+				 BOOLEAN_VALUE (args[6])));
 	}
 
 	if (args[4]->IsUint32())
 	{
 		RETURN_BOOL (mMemory->SetAccess
-			(region, args[4]->Uint32Value()));
+			(region, UINT32_VALUE (args[4])));
 	}
 
 	THROW (Type, "Invalid arguments");
@@ -237,14 +237,14 @@ void MemoryWrap::Find (const FunctionCallbackInfo<Value>& args)
 	auto limit = (uintptr)  0;
 
 	if (args[1]->IsNumber())
-		start = (uintptr) args[1]->NumberValue();
+		start = (uintptr) NUMBER_VALUE (args[1]);
 	if (args[2]->IsNumber())
-		stop  = (uintptr) args[2]->NumberValue();
+		stop  = (uintptr) NUMBER_VALUE (args[2]);
 	if (args[3]->IsNumber())
-		limit = (uintptr) args[3]->NumberValue();
+		limit = (uintptr) NUMBER_VALUE (args[3]);
 
-	String::Utf8Value jsPattern (args[0]);
-	String::Utf8Value jsFlags   (args[4]);
+	UTF8_VAR (jsPattern, args[0]);
+	UTF8_VAR (jsFlags,   args[4]);
 
 	auto pattern = *jsPattern ? *jsPattern : "";
 	auto flags   = *jsFlags   ? *jsFlags   : "";
@@ -260,7 +260,7 @@ void MemoryWrap::Find (const FunctionCallbackInfo<Value>& args)
 	for (int i = 0; i < length; ++i)
 	{
 		// The result is simply a list of numbers
-		res->Set (i, NEW_NUM ((double) list[i]));
+		OBJECT_SET (res, i, NEW_NUM ((double) list[i]));
 	}
 
 	RETURN (res);
@@ -286,15 +286,15 @@ void MemoryWrap::CreateCache (const FunctionCallbackInfo<Value>& args)
 	auto maximumSize = (uintptr) 0;
 
 	if (args[3]->IsNumber())
-		enlargeSize = (uintptr) args[3]->NumberValue();
+		enlargeSize = (uintptr) NUMBER_VALUE (args[3]);
 	if (args[4]->IsNumber())
-		maximumSize = (uintptr) args[4]->NumberValue();
+		maximumSize = (uintptr) NUMBER_VALUE (args[4]);
 
 	// Attempt to create memory cache
 	RETURN_BOOL (mMemory->CreateCache
-		((uintptr) args[0]->NumberValue(),
-		 (uintptr) args[1]->NumberValue(),
-		 (uintptr) args[2]->NumberValue(),
+		((uintptr) NUMBER_VALUE (args[0]),
+		 (uintptr) NUMBER_VALUE (args[1]),
+		 (uintptr) NUMBER_VALUE (args[2]),
 		 enlargeSize, maximumSize));
 }
 
@@ -347,14 +347,14 @@ void MemoryWrap::ReadData (const FunctionCallbackInfo<Value>& args)
 	if (!Buffer::HasInstance (args[1]))
 		THROW (Type, "Invalid arguments");
 
-	auto address = (uintptr) args[0]->NumberValue();
-	auto length  = (uintptr) args[2]->NumberValue();
+	auto address = (uintptr) NUMBER_VALUE (args[0]);
+	auto length  = (uintptr) NUMBER_VALUE (args[2]);
 	auto flags   = Memory::Default;
 
 	if (args[3]->IsUint32())
-		flags = (Memory::Flags) args[3]->Uint32Value();
+		flags = (Memory::Flags) UINT32_VALUE (args[3]);
 
-	auto buffer = args[1]->ToObject();
+	auto buffer = TO_OBJECT (args[1]);
 	// Get data pointers from node buffer
 	auto data = Buffer::Data   (buffer);
 	auto size = Buffer::Length (buffer);
@@ -384,14 +384,14 @@ void MemoryWrap::WriteData (const FunctionCallbackInfo<Value>& args)
 	if (!Buffer::HasInstance (args[1]))
 		THROW (Type, "Invalid arguments");
 
-	auto address = (uintptr) args[0]->NumberValue();
-	auto length  = (uintptr) args[2]->NumberValue();
+	auto address = (uintptr) NUMBER_VALUE (args[0]);
+	auto length  = (uintptr) NUMBER_VALUE (args[2]);
 	auto flags   = Memory::Default;
 
 	if (args[3]->IsUint32())
-		flags = (Memory::Flags) args[3]->Uint32Value();
+		flags = (Memory::Flags) UINT32_VALUE (args[3]);
 
-	auto buffer = args[1]->ToObject();
+	auto buffer = TO_OBJECT (args[1]);
 	// Get data pointers from node buffer
 	auto data = Buffer::Data   (buffer);
 	auto size = Buffer::Length (buffer);
@@ -419,16 +419,16 @@ void MemoryWrap::ReadType (const FunctionCallbackInfo<Value>& args)
 		!args[4]->IsUndefined()))
 		THROW (Type, "Invalid arguments");
 
-	auto address = (uintptr ) args[0]->NumberValue();
-	auto type    = (DataType) args[1]->Uint32Value();
-	auto length  = (uint32  ) args[2]->Uint32Value();
+	auto address = (uintptr ) NUMBER_VALUE (args[0]);
+	auto type    = (DataType) UINT32_VALUE (args[1]);
+	auto length  = (uint32  ) UINT32_VALUE (args[2]);
 	auto count   = (uint32  ) 1;
 	auto stride  = (uint32  ) 0;
 
 	if (args[3]->IsUint32())
-		count  = (uint32) args[3]->Uint32Value();
+		count  = (uint32) UINT32_VALUE (args[3]);
 	if (args[4]->IsUint32())
-		stride = (uint32) args[4]->Uint32Value();
+		stride = (uint32) UINT32_VALUE (args[4]);
 
 	// Return null if there is nothing to read
 	if (count == 0 || length == 0) RETURN_NULL;
@@ -486,17 +486,17 @@ void MemoryWrap::ReadType (const FunctionCallbackInfo<Value>& args)
 	{
 		switch (type)
 		{
-			case TypeInt8  : res->Set (i, NEW_INT  ((int32 ) *(int8  *) offset)); continue;
-			case TypeInt16 : res->Set (i, NEW_INT  ((int32 ) *(int16 *) offset)); continue;
-			case TypeInt32 : res->Set (i, NEW_INT  ((int32 ) *(int32 *) offset)); continue;
-			case TypeInt64 : res->Set (i, NEW_NUM  ((double) *(int64 *) offset)); continue;
-			case TypeReal32: res->Set (i, NEW_NUM  ((double) *(real32*) offset)); continue;
-			case TypeReal64: res->Set (i, NEW_NUM  ((double) *(real64*) offset)); continue;
-			case TypeBool  : res->Set (i, NEW_BOOL ((bool  ) *(bool  *) offset)); continue;
+			case TypeInt8  : OBJECT_SET (res, i, NEW_INT  ((int32 ) *(int8  *) offset)); continue;
+			case TypeInt16 : OBJECT_SET (res, i, NEW_INT  ((int32 ) *(int16 *) offset)); continue;
+			case TypeInt32 : OBJECT_SET (res, i, NEW_INT  ((int32 ) *(int32 *) offset)); continue;
+			case TypeInt64 : OBJECT_SET (res, i, NEW_NUM  ((double) *(int64 *) offset)); continue;
+			case TypeReal32: OBJECT_SET (res, i, NEW_NUM  ((double) *(real32*) offset)); continue;
+			case TypeReal64: OBJECT_SET (res, i, NEW_NUM  ((double) *(real64*) offset)); continue;
+			case TypeBool  : OBJECT_SET (res, i, NEW_BOOL ((bool  ) *(bool  *) offset)); continue;
 			default: assert (false);
 		}
 
-		res->Set (i, NEW_STR (std::string (offset, length).data()));
+		OBJECT_SET (res, i, NEW_STR (std::string (offset, length).data()));
 	}
 
 	delete[] data;
@@ -515,9 +515,9 @@ void MemoryWrap::WriteType (const FunctionCallbackInfo<Value>& args)
 		!args[3]->IsUndefined()))
 		THROW (Type, "Invalid arguments");
 
-	auto address = (uintptr ) args[0]->NumberValue();
-	auto type    = (DataType) args[2]->Uint32Value();
-	auto length  = (uint32  ) args[3]->Uint32Value();
+	auto address = (uintptr ) NUMBER_VALUE (args[0]);
+	auto type    = (DataType) UINT32_VALUE (args[2]);
+	auto length  = (uint32  ) UINT32_VALUE (args[3]);
 
 	if (type == TypeString)
 	{
@@ -525,7 +525,7 @@ void MemoryWrap::WriteType (const FunctionCallbackInfo<Value>& args)
 		if (!args[1]->IsString())
 			THROW (Type, "Invalid arguments");
 
-		String::Utf8Value value (args[1]);
+		UTF8_VAR (value, args[1]);
 		auto data = *value ? *value : "";
 
 		// Set the required length
@@ -553,13 +553,13 @@ void MemoryWrap::WriteType (const FunctionCallbackInfo<Value>& args)
 		int64 data=0;
 		switch (type)
 		{
-			case TypeInt8  : *(int8  *) &data = (int8  ) args[1]->  Int32Value(); break;
-			case TypeInt16 : *(int16 *) &data = (int16 ) args[1]->  Int32Value(); break;
-			case TypeInt32 : *(int32 *) &data = (int32 ) args[1]->  Int32Value(); break;
-			case TypeInt64 : *(int64 *) &data = (int64 ) args[1]-> NumberValue(); break;
-			case TypeReal32: *(real32*) &data = (real32) args[1]-> NumberValue(); break;
-			case TypeReal64: *(real64*) &data = (real64) args[1]-> NumberValue(); break;
-			case TypeBool  : *(bool  *) &data = (bool  ) args[1]->BooleanValue(); break;
+			case TypeInt8  : *(int8  *) &data = (int8  ) INT32_VALUE   (args[1]); break;
+			case TypeInt16 : *(int16 *) &data = (int16 ) INT32_VALUE   (args[1]); break;
+			case TypeInt32 : *(int32 *) &data = (int32 ) INT32_VALUE   (args[1]); break;
+			case TypeInt64 : *(int64 *) &data = (int64 ) NUMBER_VALUE  (args[1]); break;
+			case TypeReal32: *(real32*) &data = (real32) NUMBER_VALUE  (args[1]); break;
+			case TypeReal64: *(real64*) &data = (real64) NUMBER_VALUE  (args[1]); break;
+			case TypeBool  : *(bool  *) &data = (bool  ) BOOLEAN_VALUE (args[1]); break;
 			default: assert (false);
 		}
 
@@ -589,10 +589,10 @@ void MemoryWrap::New (const FunctionCallbackInfo<Value>& args)
 
 		memory->Wrap (args.This());
 		auto m = &memory->mMemory;
-		args.This()->Set (NEW_STR ("_ptrSize"   ), NEW_NUM ((double) m->GetPtrSize   ()));
-		args.This()->Set (NEW_STR ("_minAddress"), NEW_NUM ((double) m->GetMinAddress()));
-		args.This()->Set (NEW_STR ("_maxAddress"), NEW_NUM ((double) m->GetMaxAddress()));
-		args.This()->Set (NEW_STR ("_pageSize"  ), NEW_NUM ((double) m->GetPageSize  ()));
+		OBJECT_SET (args.This(), NEW_STR ("_ptrSize"   ), NEW_NUM ((double) m->GetPtrSize   ()));
+		OBJECT_SET (args.This(), NEW_STR ("_minAddress"), NEW_NUM ((double) m->GetMinAddress()));
+		OBJECT_SET (args.This(), NEW_STR ("_maxAddress"), NEW_NUM ((double) m->GetMaxAddress()));
+		OBJECT_SET (args.This(), NEW_STR ("_pageSize"  ), NEW_NUM ((double) m->GetPageSize  ()));
 
 		REGISTER_ROBOT_TYPE;
 		RETURN (args.This());
@@ -602,14 +602,14 @@ void MemoryWrap::New (const FunctionCallbackInfo<Value>& args)
 	{
 		auto ctor = NEW_CTOR (Memory);
 		// Return as a new instance
-		RETURN (ctor->NewInstance (1,
+		RETURN (NEW_INSTANCE(ctor, 1,
 			   (_jsArgs[0] = args[0], _jsArgs)));
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void MemoryWrap::Initialize (Handle<Object> exports)
+void MemoryWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -654,7 +654,6 @@ void MemoryWrap::Initialize (Handle<Object> exports)
 	tpl->Set (NEW_STR ("AUTO_ACCESS" ), NEW_INT (Memory::AutoAccess));
 
 	// Assign function template to our class creator
-	constructor.Reset (isolate, tpl->GetFunction());
-	exports->Set
-		   (NEW_STR ("Memory"), tpl->GetFunction());
+	constructor.Reset (isolate, GET_FUNCTION (tpl));
+	OBJECT_SET (exports, NEW_STR ("Memory"), GET_FUNCTION (tpl));
 }
diff --git a/src/NodeMemory.h b/src/NodeMemory.h
index c79790a..91e577d 100644
--- a/src/NodeMemory.h
+++ b/src/NodeMemory.h
@@ -51,7 +51,7 @@ class MemoryWrap : public ObjectWrap
 	static void		New				(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 
 public:
 	Memory mMemory;
diff --git a/src/NodeMouse.cc b/src/NodeMouse.cc
index 5eac1c2..b7ecb24 100644
--- a/src/NodeMouse.cc
+++ b/src/NodeMouse.cc
@@ -30,9 +30,9 @@ void MouseWrap::Click (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsInt32())
 		THROW (Type, "Invalid arguments");
 
-	mMouse->AutoDelay.Min = args[1]->Int32Value();
-	mMouse->AutoDelay.Max = args[2]->Int32Value();
-	mMouse->Click ((Button) args[0]->Int32Value());
+	mMouse->AutoDelay.Min = INT32_VALUE (args[1]);
+	mMouse->AutoDelay.Max = INT32_VALUE (args[2]);
+	mMouse->Click ((Button) INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -45,9 +45,9 @@ void MouseWrap::Press (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsInt32())
 		THROW (Type, "Invalid arguments");
 
-	mMouse->AutoDelay.Min = args[1]->Int32Value();
-	mMouse->AutoDelay.Max = args[2]->Int32Value();
-	mMouse->Press ((Button) args[0]->Int32Value());
+	mMouse->AutoDelay.Min = INT32_VALUE (args[1]);
+	mMouse->AutoDelay.Max = INT32_VALUE (args[2]);
+	mMouse->Press ((Button) INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -60,9 +60,9 @@ void MouseWrap::Release (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsInt32())
 		THROW (Type, "Invalid arguments");
 
-	mMouse->AutoDelay.Min = args[1]->Int32Value();
-	mMouse->AutoDelay.Max = args[2]->Int32Value();
-	mMouse->Release ((Button) args[0]->Int32Value());
+	mMouse->AutoDelay.Min = INT32_VALUE (args[1]);
+	mMouse->AutoDelay.Max = INT32_VALUE (args[2]);
+	mMouse->Release ((Button) INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -75,9 +75,9 @@ void MouseWrap::ScrollH (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsInt32())
 		THROW (Type, "Invalid arguments");
 
-	mMouse->AutoDelay.Min = args[1]->Int32Value();
-	mMouse->AutoDelay.Max = args[2]->Int32Value();
-	mMouse->ScrollH (args[0]->Int32Value());
+	mMouse->AutoDelay.Min = INT32_VALUE (args[1]);
+	mMouse->AutoDelay.Max = INT32_VALUE (args[2]);
+	mMouse->ScrollH (INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -90,9 +90,9 @@ void MouseWrap::ScrollV (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsInt32())
 		THROW (Type, "Invalid arguments");
 
-	mMouse->AutoDelay.Min = args[1]->Int32Value();
-	mMouse->AutoDelay.Max = args[2]->Int32Value();
-	mMouse->ScrollV (args[0]->Int32Value());
+	mMouse->AutoDelay.Min = INT32_VALUE (args[1]);
+	mMouse->AutoDelay.Max = INT32_VALUE (args[2]);
+	mMouse->ScrollV (INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -110,8 +110,8 @@ void MouseWrap::GetPos (const FunctionCallbackInfo<Value>& args)
 void MouseWrap::SetPos (const FunctionCallbackInfo<Value>& args)
 {
 	ISOLATE; Mouse::SetPos
-		(args[0]->Int32Value(),
-		 args[1]->Int32Value());
+		(INT32_VALUE (args[0]),
+		 INT32_VALUE (args[1]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -129,7 +129,7 @@ void MouseWrap::GetState (const FunctionCallbackInfo<Value>& args)
 		{
 			// Loop every state and add it to resulting object
 			for (auto i = state.begin(); i != state.end(); ++i)
-				res->Set (NEW_INT (i->first), NEW_BOOL (i->second));
+				OBJECT_SET (res, NEW_INT (i->first), NEW_BOOL (i->second));
 		}
 
 		RETURN (res);
@@ -140,7 +140,7 @@ void MouseWrap::GetState (const FunctionCallbackInfo<Value>& args)
 	{
 		RETURN_BOOL (Mouse::GetState
 			// Get info about a single button
-			((Button) args[0]->Int32Value()));
+			((Button) INT32_VALUE (args[0])));
 	}
 
 	THROW (Type, "Invalid arguments");
@@ -155,7 +155,7 @@ void MouseWrap::New (const FunctionCallbackInfo<Value>& args)
 	if (args.IsConstructCall())
 	{
 		(new MouseWrap())->Wrap (args.This());
-		args.This()->Set (NEW_STR ("autoDelay"),
+		OBJECT_SET (args.This(), NEW_STR ("autoDelay"),
 						  NEW_RANGE ( 40,  90));
 
 		REGISTER_ROBOT_TYPE;
@@ -166,13 +166,13 @@ void MouseWrap::New (const FunctionCallbackInfo<Value>& args)
 	{
 		auto ctor = NEW_CTOR (Mouse);
 		// Return as a new instance
-		RETURN (ctor->NewInstance());
+		RETURN (NEW_INSTANCE(ctor, 0, NULL));
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void MouseWrap::Initialize (Handle<Object> exports)
+void MouseWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -193,7 +193,6 @@ void MouseWrap::Initialize (Handle<Object> exports)
 	NODE_SET_METHOD ((Local<Template>) tpl,  "getState", GetState);
 
 	// Assign function template to our class creator
-	constructor.Reset (isolate, tpl->GetFunction());
-	exports->Set
-			(NEW_STR ("Mouse"), tpl->GetFunction());
+	constructor.Reset (isolate, GET_FUNCTION (tpl));
+	OBJECT_SET (exports, NEW_STR ("Mouse"), GET_FUNCTION (tpl));
 }
diff --git a/src/NodeMouse.h b/src/NodeMouse.h
index 141ea44..015e83d 100644
--- a/src/NodeMouse.h
+++ b/src/NodeMouse.h
@@ -40,7 +40,7 @@ class MouseWrap : public ObjectWrap
 	static void		New				(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 
 public:
 	Mouse mMouse;
diff --git a/src/NodeProcess.cc b/src/NodeProcess.cc
index e2f477d..4ce93c2 100644
--- a/src/NodeProcess.cc
+++ b/src/NodeProcess.cc
@@ -33,7 +33,7 @@ void ProcessWrap::Open (const FunctionCallbackInfo<Value>& args)
 
 	// Try and open the process
 	RETURN_BOOL (mProcess->Open
-		(args[0]->Int32Value()));
+		(INT32_VALUE (args[0])));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -130,7 +130,7 @@ void ProcessWrap::GetModules (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	const char* regex = 0;
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	// Retrieve regex value
 	if (args[0]->IsString())
 		regex = *value ? *value : "";
@@ -147,15 +147,15 @@ void ProcessWrap::GetModules (const FunctionCallbackInfo<Value>& args)
 		const auto& current = list[i];
 
 		// Create a new module instance
-		auto obj = ctor->NewInstance();
-
-		obj->Set (NEW_STR ("_valid"), NEW_BOOL (current.IsValid()));
-		obj->Set (NEW_STR ("_name" ), NEW_STR  (current.GetName().data()));
-		obj->Set (NEW_STR ("_path" ), NEW_STR  (current.GetPath().data()));
-		obj->Set (NEW_STR ("_base" ), NEW_NUM  ((double) current.GetBase()));
-		obj->Set (NEW_STR ("_size" ), NEW_NUM  ((double) current.GetSize()));
-		obj->Set (NEW_STR ("_proc" ), args.Holder());
-		res->Set (i, obj);
+		auto obj = NEW_INSTANCE(ctor, 0, NULL);
+
+		OBJECT_SET (obj, NEW_STR ("_valid"), NEW_BOOL (current.IsValid()));
+		OBJECT_SET (obj, NEW_STR ("_name" ), NEW_STR  (current.GetName().data()));
+		OBJECT_SET (obj, NEW_STR ("_path" ), NEW_STR  (current.GetPath().data()));
+		OBJECT_SET (obj, NEW_STR ("_base" ), NEW_NUM  ((double) current.GetBase()));
+		OBJECT_SET (obj, NEW_STR ("_size" ), NEW_NUM  ((double) current.GetSize()));
+		OBJECT_SET (obj, NEW_STR ("_proc" ), args.Holder());
+		OBJECT_SET (res, i, obj);
 	}
 
 	RETURN (res);
@@ -174,7 +174,7 @@ void ProcessWrap::GetWindows (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	const char* regex = 0;
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	// Retrieve regex value
 	if (args[0]->IsString())
 		regex = *value ? *value : "";
@@ -188,12 +188,12 @@ void ProcessWrap::GetWindows (const FunctionCallbackInfo<Value>& args)
 	for (int i = 0; i < length; ++i)
 	{
 		// Create a new instance of wrapper
-		auto instance = ctor->NewInstance();
+		auto instance = NEW_INSTANCE(ctor, 0, NULL);
 		UNWRAP (Window, instance);
 
 		// Make wrapper use new window
 		mWindowWrap->mWindow = list[i];
-		res->Set (i, instance);
+		OBJECT_SET (res, i, instance);
 	}
 
 	RETURN (res);
@@ -207,7 +207,7 @@ void ProcessWrap::Equals (const FunctionCallbackInfo<Value>& args)
 	ProcessWrap* wrapper = nullptr;
 	if ((wrapper = UnwrapRobot<ProcessWrap> (args[0])))
 		RETURN_BOOL (*mProcess == wrapper->mProcess);
-		RETURN_BOOL (*mProcess == args[0]->Int32Value());
+		RETURN_BOOL (*mProcess == INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -223,7 +223,7 @@ void ProcessWrap::GetList (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	const char* regex = 0;
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	// Retrieve regex value
 	if (args[0]->IsString())
 		regex = *value ? *value : "";
@@ -237,12 +237,12 @@ void ProcessWrap::GetList (const FunctionCallbackInfo<Value>& args)
 	for (int i = 0; i < length; ++i)
 	{
 		// Create a new instance of wrapper
-		auto instance = ctor->NewInstance();
+		auto instance = NEW_INSTANCE(ctor, 0, NULL);
 		UNWRAP (Process, instance);
 
 		// Make wrapper use new process
 		mProcessWrap->mProcess = list[i];
-		res->Set (i, instance);
+		OBJECT_SET (res, i, instance);
 	}
 
 	RETURN (res);
@@ -256,7 +256,7 @@ void ProcessWrap::GetCurrent (const FunctionCallbackInfo<Value>& args)
 	auto ctor = NEW_CTOR (Process);
 
 	// Create a new instance of wrapper
-	auto instance = ctor->NewInstance();
+	auto instance = NEW_INSTANCE(ctor, 0, NULL);
 	UNWRAP (Process, instance);
 
 	auto process = Process::GetCurrent();
@@ -276,14 +276,14 @@ void ProcessWrap::IsSys64Bit (const FunctionCallbackInfo<Value>& args)
 
 void ProcessWrap::GetSegments (const FunctionCallbackInfo<Value>& args)
 {
-	ISOWRAP (Process, args[0]->ToObject());
+	ISOWRAP (Process, TO_OBJECT (args[0]));
 	auto ctor = Local<Function>::
 		 New (isolate, JsSegment);
 
 	// Create new module
 	Robot::Module module
 		(*mProcess, "", "", (uintptr)
-		 args[1]->NumberValue(), 0);
+		 NUMBER_VALUE (args[1]), 0);
 
 	// Retrieve the list of segments
 	auto list = module.GetSegments();
@@ -297,13 +297,13 @@ void ProcessWrap::GetSegments (const FunctionCallbackInfo<Value>& args)
 		const auto& current = list[i];
 
 		// Create a new module instance
-		auto obj = ctor->NewInstance();
+		auto obj = NEW_INSTANCE(ctor, 0, NULL);
 
-		obj->Set (NEW_STR ("valid"), NEW_BOOL (         current.Valid));
-		obj->Set (NEW_STR ("base" ), NEW_NUM  ((double) current.Base ));
-		obj->Set (NEW_STR ("size" ), NEW_NUM  ((double) current.Size ));
-		obj->Set (NEW_STR ("name" ), NEW_STR  (         current.Name ));
-		res->Set (i, obj);
+		OBJECT_SET (obj, NEW_STR ("valid"), NEW_BOOL (         current.Valid));
+		OBJECT_SET (obj, NEW_STR ("base" ), NEW_NUM  ((double) current.Base ));
+		OBJECT_SET (obj, NEW_STR ("size" ), NEW_NUM  ((double) current.Size ));
+		OBJECT_SET (obj, NEW_STR ("name" ), NEW_STR  (         current.Name ));
+		OBJECT_SET (res, i, obj);
 	}
 
 	RETURN (res);
@@ -328,7 +328,7 @@ void ProcessWrap::New (const FunctionCallbackInfo<Value>& args)
 
 		if (args[0]->IsInt32())
 			// Open process if argument available
-			process->Open (args[0]->Int32Value());
+			process->Open (INT32_VALUE (args[0]));
 
 		REGISTER_ROBOT_TYPE;
 		RETURN (args.This());
@@ -338,14 +338,14 @@ void ProcessWrap::New (const FunctionCallbackInfo<Value>& args)
 	{
 		auto ctor = NEW_CTOR (Process);
 		// Return as a new instance
-		RETURN (ctor->NewInstance (1,
+		RETURN (NEW_INSTANCE(ctor, 1,
 			   (_jsArgs[0] = args[0], _jsArgs)));
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void ProcessWrap::Initialize (Handle<Object> exports)
+void ProcessWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -380,7 +380,6 @@ void ProcessWrap::Initialize (Handle<Object> exports)
 	NODE_SET_METHOD ((Local<Template>) tpl, "_getSegments", GetSegments);
 
 	// Assign function template to our class creator
-	constructor.Reset (isolate, tpl->GetFunction());
-	exports->Set
-		  (NEW_STR ("Process"), tpl->GetFunction());
+	constructor.Reset (isolate, GET_FUNCTION (tpl));
+	OBJECT_SET (exports, NEW_STR ("Process"), GET_FUNCTION (tpl));
 }
diff --git a/src/NodeProcess.h b/src/NodeProcess.h
index ff0417c..246369f 100644
--- a/src/NodeProcess.h
+++ b/src/NodeProcess.h
@@ -54,7 +54,7 @@ class ProcessWrap : public ObjectWrap
 	static void		New				(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 
 public:
 	Process mProcess;
diff --git a/src/NodeRobot.cc b/src/NodeRobot.cc
index cc9f1ad..9615076 100644
--- a/src/NodeRobot.cc
+++ b/src/NodeRobot.cc
@@ -44,21 +44,21 @@ Persistent<Function> JsRegion;
 
 static void Prepare (const FunctionCallbackInfo<Value>& args)
 {
-	ISOLATE; auto jsRobot = args[0]->ToObject();
-	jsRobot->Set (NEW_STR ("ROBOT_VERSION"    ), NEW_INT (ROBOT_VERSION    ));
-	jsRobot->Set (NEW_STR ("ROBOT_VERSION_STR"), NEW_STR (ROBOT_VERSION_STR));
-
-	auto color   = Local<Function>::Cast (jsRobot->Get (NEW_STR ("Color"  )));
-	auto range   = Local<Function>::Cast (jsRobot->Get (NEW_STR ("Range"  )));
-	auto point   = Local<Function>::Cast (jsRobot->Get (NEW_STR ("Point"  )));
-	auto size    = Local<Function>::Cast (jsRobot->Get (NEW_STR ("Size"   )));
-	auto bounds  = Local<Function>::Cast (jsRobot->Get (NEW_STR ("Bounds" )));
-
-	auto module  = Local<Function>::Cast (jsRobot->Get (NEW_STR ("Module" )));
-	auto memory  = Local<Function>::Cast (jsRobot->Get (NEW_STR ("Memory" )));
-	auto segment = Local<Function>::Cast ( module->Get (NEW_STR ("Segment")));
-	auto stats   = Local<Function>::Cast ( memory->Get (NEW_STR ("Stats"  )));
-	auto region  = Local<Function>::Cast ( memory->Get (NEW_STR ("Region" )));
+	ISOLATE; auto jsRobot = TO_OBJECT (args[0]);
+	OBJECT_SET (jsRobot, NEW_STR ("ROBOT_VERSION"    ), NEW_INT (ROBOT_VERSION    ));
+	OBJECT_SET (jsRobot, NEW_STR ("ROBOT_VERSION_STR"), NEW_STR (ROBOT_VERSION_STR));
+
+	auto color   = Local<Function>::Cast (OBJECT_GET (jsRobot, NEW_STR ("Color"  )));
+	auto range   = Local<Function>::Cast (OBJECT_GET (jsRobot, NEW_STR ("Range"  )));
+	auto point   = Local<Function>::Cast (OBJECT_GET (jsRobot, NEW_STR ("Point"  )));
+	auto size    = Local<Function>::Cast (OBJECT_GET (jsRobot, NEW_STR ("Size"   )));
+	auto bounds  = Local<Function>::Cast (OBJECT_GET (jsRobot, NEW_STR ("Bounds" )));
+
+	auto module  = Local<Function>::Cast (OBJECT_GET (jsRobot, NEW_STR ("Module" )));
+	auto memory  = Local<Function>::Cast (OBJECT_GET (jsRobot, NEW_STR ("Memory" )));
+	auto segment = Local<Function>::Cast (OBJECT_GET (module,  NEW_STR ("Segment")));
+	auto stats   = Local<Function>::Cast (OBJECT_GET (memory,  NEW_STR ("Stats"  )));
+	auto region  = Local<Function>::Cast (OBJECT_GET (memory,  NEW_STR ("Region" )));
 
 	JsColor  .Reset (isolate, color  );
 	JsRange  .Reset (isolate, range  );
@@ -77,123 +77,123 @@ static void Prepare (const FunctionCallbackInfo<Value>& args)
 	// Key                                                                        //
 	//----------------------------------------------------------------------------//
 
-	jsRobot->Set (NEW_STR ("KEY_SPACE"		), NEW_INT (KeySpace		));
-	jsRobot->Set (NEW_STR ("KEY_ESCAPE"		), NEW_INT (KeyEscape		));
-
-	jsRobot->Set (NEW_STR ("KEY_TAB"		), NEW_INT (KeyTab			));
-	jsRobot->Set (NEW_STR ("KEY_ALT"		), NEW_INT (KeyAlt			));
-	jsRobot->Set (NEW_STR ("KEY_LALT"		), NEW_INT (KeyLAlt			));
-	jsRobot->Set (NEW_STR ("KEY_RALT"		), NEW_INT (KeyRAlt			));
-	jsRobot->Set (NEW_STR ("KEY_CONTROL"	), NEW_INT (KeyControl		));
-	jsRobot->Set (NEW_STR ("KEY_LCONTROL"	), NEW_INT (KeyLControl		));
-	jsRobot->Set (NEW_STR ("KEY_RCONTROL"	), NEW_INT (KeyRControl		));
-	jsRobot->Set (NEW_STR ("KEY_SHIFT"		), NEW_INT (KeyShift		));
-	jsRobot->Set (NEW_STR ("KEY_LSHIFT"		), NEW_INT (KeyLShift		));
-	jsRobot->Set (NEW_STR ("KEY_RSHIFT"		), NEW_INT (KeyRShift		));
-	jsRobot->Set (NEW_STR ("KEY_SYSTEM"		), NEW_INT (KeySystem		));
-	jsRobot->Set (NEW_STR ("KEY_LSYSTEM"	), NEW_INT (KeyLSystem		));
-	jsRobot->Set (NEW_STR ("KEY_RSYSTEM"	), NEW_INT (KeyRSystem		));
-
-	jsRobot->Set (NEW_STR ("KEY_F1"			), NEW_INT (KeyF1			));
-	jsRobot->Set (NEW_STR ("KEY_F2"			), NEW_INT (KeyF2			));
-	jsRobot->Set (NEW_STR ("KEY_F3"			), NEW_INT (KeyF3			));
-	jsRobot->Set (NEW_STR ("KEY_F4"			), NEW_INT (KeyF4			));
-	jsRobot->Set (NEW_STR ("KEY_F5"			), NEW_INT (KeyF5			));
-	jsRobot->Set (NEW_STR ("KEY_F6"			), NEW_INT (KeyF6			));
-	jsRobot->Set (NEW_STR ("KEY_F7"			), NEW_INT (KeyF7			));
-	jsRobot->Set (NEW_STR ("KEY_F8"			), NEW_INT (KeyF8			));
-	jsRobot->Set (NEW_STR ("KEY_F9"			), NEW_INT (KeyF9			));
-	jsRobot->Set (NEW_STR ("KEY_F10"		), NEW_INT (KeyF10			));
-	jsRobot->Set (NEW_STR ("KEY_F11"		), NEW_INT (KeyF11			));
-	jsRobot->Set (NEW_STR ("KEY_F12"		), NEW_INT (KeyF12			));
-
-	jsRobot->Set (NEW_STR ("KEY_0"			), NEW_INT (Key0			));
-	jsRobot->Set (NEW_STR ("KEY_1"			), NEW_INT (Key1			));
-	jsRobot->Set (NEW_STR ("KEY_2"			), NEW_INT (Key2			));
-	jsRobot->Set (NEW_STR ("KEY_3"			), NEW_INT (Key3			));
-	jsRobot->Set (NEW_STR ("KEY_4"			), NEW_INT (Key4			));
-	jsRobot->Set (NEW_STR ("KEY_5"			), NEW_INT (Key5			));
-	jsRobot->Set (NEW_STR ("KEY_6"			), NEW_INT (Key6			));
-	jsRobot->Set (NEW_STR ("KEY_7"			), NEW_INT (Key7			));
-	jsRobot->Set (NEW_STR ("KEY_8"			), NEW_INT (Key8			));
-	jsRobot->Set (NEW_STR ("KEY_9"			), NEW_INT (Key9			));
-
-	jsRobot->Set (NEW_STR ("KEY_A"			), NEW_INT (KeyA			));
-	jsRobot->Set (NEW_STR ("KEY_B"			), NEW_INT (KeyB			));
-	jsRobot->Set (NEW_STR ("KEY_C"			), NEW_INT (KeyC			));
-	jsRobot->Set (NEW_STR ("KEY_D"			), NEW_INT (KeyD			));
-	jsRobot->Set (NEW_STR ("KEY_E"			), NEW_INT (KeyE			));
-	jsRobot->Set (NEW_STR ("KEY_F"			), NEW_INT (KeyF			));
-	jsRobot->Set (NEW_STR ("KEY_G"			), NEW_INT (KeyG			));
-	jsRobot->Set (NEW_STR ("KEY_H"			), NEW_INT (KeyH			));
-	jsRobot->Set (NEW_STR ("KEY_I"			), NEW_INT (KeyI			));
-	jsRobot->Set (NEW_STR ("KEY_J"			), NEW_INT (KeyJ			));
-	jsRobot->Set (NEW_STR ("KEY_K"			), NEW_INT (KeyK			));
-	jsRobot->Set (NEW_STR ("KEY_L"			), NEW_INT (KeyL			));
-	jsRobot->Set (NEW_STR ("KEY_M"			), NEW_INT (KeyM			));
-	jsRobot->Set (NEW_STR ("KEY_N"			), NEW_INT (KeyN			));
-	jsRobot->Set (NEW_STR ("KEY_O"			), NEW_INT (KeyO			));
-	jsRobot->Set (NEW_STR ("KEY_P"			), NEW_INT (KeyP			));
-	jsRobot->Set (NEW_STR ("KEY_Q"			), NEW_INT (KeyQ			));
-	jsRobot->Set (NEW_STR ("KEY_R"			), NEW_INT (KeyR			));
-	jsRobot->Set (NEW_STR ("KEY_S"			), NEW_INT (KeyS			));
-	jsRobot->Set (NEW_STR ("KEY_T"			), NEW_INT (KeyT			));
-	jsRobot->Set (NEW_STR ("KEY_U"			), NEW_INT (KeyU			));
-	jsRobot->Set (NEW_STR ("KEY_V"			), NEW_INT (KeyV			));
-	jsRobot->Set (NEW_STR ("KEY_W"			), NEW_INT (KeyW			));
-	jsRobot->Set (NEW_STR ("KEY_X"			), NEW_INT (KeyX			));
-	jsRobot->Set (NEW_STR ("KEY_Y"			), NEW_INT (KeyY			));
-	jsRobot->Set (NEW_STR ("KEY_Z"			), NEW_INT (KeyZ			));
-
-	jsRobot->Set (NEW_STR ("KEY_GRAVE"		), NEW_INT (KeyGrave		));
-	jsRobot->Set (NEW_STR ("KEY_MINUS"		), NEW_INT (KeyMinus		));
-	jsRobot->Set (NEW_STR ("KEY_EQUAL"		), NEW_INT (KeyEqual		));
-	jsRobot->Set (NEW_STR ("KEY_BACKSPACE"	), NEW_INT (KeyBackspace	));
-	jsRobot->Set (NEW_STR ("KEY_LBRACKET"	), NEW_INT (KeyLBracket		));
-	jsRobot->Set (NEW_STR ("KEY_RBRACKET"	), NEW_INT (KeyRBracket		));
-	jsRobot->Set (NEW_STR ("KEY_BACKSLASH"	), NEW_INT (KeyBackslash	));
-	jsRobot->Set (NEW_STR ("KEY_SEMICOLON"	), NEW_INT (KeySemicolon	));
-	jsRobot->Set (NEW_STR ("KEY_QUOTE"		), NEW_INT (KeyQuote		));
-	jsRobot->Set (NEW_STR ("KEY_RETURN"		), NEW_INT (KeyReturn		));
-	jsRobot->Set (NEW_STR ("KEY_COMMA"		), NEW_INT (KeyComma		));
-	jsRobot->Set (NEW_STR ("KEY_PERIOD"		), NEW_INT (KeyPeriod		));
-	jsRobot->Set (NEW_STR ("KEY_SLASH"		), NEW_INT (KeySlash		));
-
-	jsRobot->Set (NEW_STR ("KEY_LEFT"		), NEW_INT (KeyLeft			));
-	jsRobot->Set (NEW_STR ("KEY_UP"			), NEW_INT (KeyUp			));
-	jsRobot->Set (NEW_STR ("KEY_RIGHT"		), NEW_INT (KeyRight		));
-	jsRobot->Set (NEW_STR ("KEY_DOWN"		), NEW_INT (KeyDown			));
-
-	jsRobot->Set (NEW_STR ("KEY_PRINT"		), NEW_INT (KeyPrint		));
-	jsRobot->Set (NEW_STR ("KEY_PAUSE"		), NEW_INT (KeyPause		));
-	jsRobot->Set (NEW_STR ("KEY_INSERT"		), NEW_INT (KeyInsert		));
-	jsRobot->Set (NEW_STR ("KEY_DELETE"		), NEW_INT (KeyDelete		));
-	jsRobot->Set (NEW_STR ("KEY_HOME"		), NEW_INT (KeyHome			));
-	jsRobot->Set (NEW_STR ("KEY_END"		), NEW_INT (KeyEnd			));
-	jsRobot->Set (NEW_STR ("KEY_PAGE_UP"	), NEW_INT (KeyPageUp		));
-	jsRobot->Set (NEW_STR ("KEY_PAGE_DOWN"	), NEW_INT (KeyPageDown		));
-
-	jsRobot->Set (NEW_STR ("KEY_ADD"		), NEW_INT (KeyAdd			));
-	jsRobot->Set (NEW_STR ("KEY_SUBTRACT"	), NEW_INT (KeySubtract		));
-	jsRobot->Set (NEW_STR ("KEY_MULTIPLY"	), NEW_INT (KeyMultiply		));
-	jsRobot->Set (NEW_STR ("KEY_DIVIDE"		), NEW_INT (KeyDivide		));
-	jsRobot->Set (NEW_STR ("KEY_DECIMAL"	), NEW_INT (KeyDecimal		));
-	jsRobot->Set (NEW_STR ("KEY_ENTER"		), NEW_INT (KeyEnter		));
-
-	jsRobot->Set (NEW_STR ("KEY_NUM0"		), NEW_INT (KeyNum0			));
-	jsRobot->Set (NEW_STR ("KEY_NUM1"		), NEW_INT (KeyNum1			));
-	jsRobot->Set (NEW_STR ("KEY_NUM2"		), NEW_INT (KeyNum2			));
-	jsRobot->Set (NEW_STR ("KEY_NUM3"		), NEW_INT (KeyNum3			));
-	jsRobot->Set (NEW_STR ("KEY_NUM4"		), NEW_INT (KeyNum4			));
-	jsRobot->Set (NEW_STR ("KEY_NUM5"		), NEW_INT (KeyNum5			));
-	jsRobot->Set (NEW_STR ("KEY_NUM6"		), NEW_INT (KeyNum6			));
-	jsRobot->Set (NEW_STR ("KEY_NUM7"		), NEW_INT (KeyNum7			));
-	jsRobot->Set (NEW_STR ("KEY_NUM8"		), NEW_INT (KeyNum8			));
-	jsRobot->Set (NEW_STR ("KEY_NUM9"		), NEW_INT (KeyNum9			));
-
-	jsRobot->Set (NEW_STR ("KEY_CAPS_LOCK"	), NEW_INT (KeyCapsLock		));
-	jsRobot->Set (NEW_STR ("KEY_SCROLL_LOCK"), NEW_INT (KeyScrollLock	));
-	jsRobot->Set (NEW_STR ("KEY_NUM_LOCK"	), NEW_INT (KeyNumLock		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_SPACE"		), NEW_INT (KeySpace		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_ESCAPE"		), NEW_INT (KeyEscape		));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_TAB"		), NEW_INT (KeyTab			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_ALT"		), NEW_INT (KeyAlt			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_LALT"		), NEW_INT (KeyLAlt			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_RALT"		), NEW_INT (KeyRAlt			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_CONTROL"	), NEW_INT (KeyControl		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_LCONTROL"	), NEW_INT (KeyLControl		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_RCONTROL"	), NEW_INT (KeyRControl		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_SHIFT"		), NEW_INT (KeyShift		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_LSHIFT"		), NEW_INT (KeyLShift		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_RSHIFT"		), NEW_INT (KeyRShift		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_SYSTEM"		), NEW_INT (KeySystem		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_LSYSTEM"	), NEW_INT (KeyLSystem		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_RSYSTEM"	), NEW_INT (KeyRSystem		));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F1"			), NEW_INT (KeyF1			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F2"			), NEW_INT (KeyF2			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F3"			), NEW_INT (KeyF3			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F4"			), NEW_INT (KeyF4			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F5"			), NEW_INT (KeyF5			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F6"			), NEW_INT (KeyF6			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F7"			), NEW_INT (KeyF7			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F8"			), NEW_INT (KeyF8			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F9"			), NEW_INT (KeyF9			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F10"		), NEW_INT (KeyF10			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F11"		), NEW_INT (KeyF11			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F12"		), NEW_INT (KeyF12			));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_0"			), NEW_INT (Key0			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_1"			), NEW_INT (Key1			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_2"			), NEW_INT (Key2			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_3"			), NEW_INT (Key3			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_4"			), NEW_INT (Key4			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_5"			), NEW_INT (Key5			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_6"			), NEW_INT (Key6			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_7"			), NEW_INT (Key7			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_8"			), NEW_INT (Key8			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_9"			), NEW_INT (Key9			));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_A"			), NEW_INT (KeyA			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_B"			), NEW_INT (KeyB			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_C"			), NEW_INT (KeyC			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_D"			), NEW_INT (KeyD			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_E"			), NEW_INT (KeyE			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_F"			), NEW_INT (KeyF			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_G"			), NEW_INT (KeyG			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_H"			), NEW_INT (KeyH			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_I"			), NEW_INT (KeyI			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_J"			), NEW_INT (KeyJ			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_K"			), NEW_INT (KeyK			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_L"			), NEW_INT (KeyL			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_M"			), NEW_INT (KeyM			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_N"			), NEW_INT (KeyN			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_O"			), NEW_INT (KeyO			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_P"			), NEW_INT (KeyP			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_Q"			), NEW_INT (KeyQ			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_R"			), NEW_INT (KeyR			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_S"			), NEW_INT (KeyS			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_T"			), NEW_INT (KeyT			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_U"			), NEW_INT (KeyU			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_V"			), NEW_INT (KeyV			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_W"			), NEW_INT (KeyW			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_X"			), NEW_INT (KeyX			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_Y"			), NEW_INT (KeyY			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_Z"			), NEW_INT (KeyZ			));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_GRAVE"		), NEW_INT (KeyGrave		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_MINUS"		), NEW_INT (KeyMinus		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_EQUAL"		), NEW_INT (KeyEqual		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_BACKSPACE"	), NEW_INT (KeyBackspace	));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_LBRACKET"	), NEW_INT (KeyLBracket		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_RBRACKET"	), NEW_INT (KeyRBracket		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_BACKSLASH"	), NEW_INT (KeyBackslash	));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_SEMICOLON"	), NEW_INT (KeySemicolon	));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_QUOTE"		), NEW_INT (KeyQuote		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_RETURN"		), NEW_INT (KeyReturn		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_COMMA"		), NEW_INT (KeyComma		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_PERIOD"		), NEW_INT (KeyPeriod		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_SLASH"		), NEW_INT (KeySlash		));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_LEFT"		), NEW_INT (KeyLeft			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_UP"			), NEW_INT (KeyUp			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_RIGHT"		), NEW_INT (KeyRight		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_DOWN"		), NEW_INT (KeyDown			));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_PRINT"		), NEW_INT (KeyPrint		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_PAUSE"		), NEW_INT (KeyPause		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_INSERT"		), NEW_INT (KeyInsert		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_DELETE"		), NEW_INT (KeyDelete		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_HOME"		), NEW_INT (KeyHome			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_END"		), NEW_INT (KeyEnd			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_PAGE_UP"	), NEW_INT (KeyPageUp		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_PAGE_DOWN"	), NEW_INT (KeyPageDown		));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_ADD"		), NEW_INT (KeyAdd			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_SUBTRACT"	), NEW_INT (KeySubtract		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_MULTIPLY"	), NEW_INT (KeyMultiply		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_DIVIDE"		), NEW_INT (KeyDivide		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_DECIMAL"	), NEW_INT (KeyDecimal		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_ENTER"		), NEW_INT (KeyEnter		));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM0"		), NEW_INT (KeyNum0			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM1"		), NEW_INT (KeyNum1			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM2"		), NEW_INT (KeyNum2			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM3"		), NEW_INT (KeyNum3			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM4"		), NEW_INT (KeyNum4			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM5"		), NEW_INT (KeyNum5			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM6"		), NEW_INT (KeyNum6			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM7"		), NEW_INT (KeyNum7			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM8"		), NEW_INT (KeyNum8			));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM9"		), NEW_INT (KeyNum9			));
+
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_CAPS_LOCK"	), NEW_INT (KeyCapsLock		));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_SCROLL_LOCK"), NEW_INT (KeyScrollLock	));
+	OBJECT_SET (jsRobot, NEW_STR ("KEY_NUM_LOCK"	), NEW_INT (KeyNumLock		));
 
 
 
@@ -201,19 +201,19 @@ static void Prepare (const FunctionCallbackInfo<Value>& args)
 	// Button                                                                     //
 	//----------------------------------------------------------------------------//
 
-	jsRobot->Set (NEW_STR ("BUTTON_LEFT"	), NEW_INT (ButtonLeft		));
-	jsRobot->Set (NEW_STR ("BUTTON_MID"		), NEW_INT (ButtonMid		));
-	jsRobot->Set (NEW_STR ("BUTTON_MIDDLE"	), NEW_INT (ButtonMiddle	));
-	jsRobot->Set (NEW_STR ("BUTTON_RIGHT"	), NEW_INT (ButtonRight		));
-	jsRobot->Set (NEW_STR ("BUTTON_X1"		), NEW_INT (ButtonX1		));
-	jsRobot->Set (NEW_STR ("BUTTON_X2"		), NEW_INT (ButtonX2		));
+	OBJECT_SET (jsRobot, NEW_STR ("BUTTON_LEFT"	), NEW_INT (ButtonLeft		));
+	OBJECT_SET (jsRobot, NEW_STR ("BUTTON_MID"		), NEW_INT (ButtonMid		));
+	OBJECT_SET (jsRobot, NEW_STR ("BUTTON_MIDDLE"	), NEW_INT (ButtonMiddle	));
+	OBJECT_SET (jsRobot, NEW_STR ("BUTTON_RIGHT"	), NEW_INT (ButtonRight		));
+	OBJECT_SET (jsRobot, NEW_STR ("BUTTON_X1"		), NEW_INT (ButtonX1		));
+	OBJECT_SET (jsRobot, NEW_STR ("BUTTON_X2"		), NEW_INT (ButtonX2		));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static void Sleep (const FunctionCallbackInfo<Value>& args)
 {
-	ISOLATE; Timer::Sleep (args[0]->Uint32Value());
+	ISOLATE; Timer::Sleep (UINT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -231,7 +231,7 @@ static void Clock (const FunctionCallbackInfo<Value>& args)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static void Initialize (Handle<Object> exports)
+static void Initialize (Local<Object> exports)
 {
 	NODE_SET_METHOD (exports, "prepare", Prepare);
 	NODE_SET_METHOD (exports, "sleep",   Sleep  );
diff --git a/src/NodeRobot.rc b/src/NodeRobot.rc
index 8409715..574d3d3 100644
--- a/src/NodeRobot.rc
+++ b/src/NodeRobot.rc
@@ -11,6 +11,7 @@
 // Prefaces                                                                   //
 //----------------------------------------------------------------------------//
 
+#include <node.h>
 #include <Windows.h>
 #define  STRINGIFY( s ) _STRINGIFY( s )
 #define _STRINGIFY( s ) #s
@@ -23,8 +24,8 @@
 
 VS_VERSION_INFO VERSIONINFO
 
-	PRODUCTVERSION	2, 0, 0, TARGET_MODULE_VERSION
-	   FILEVERSION	2, 0, 0, TARGET_MODULE_VERSION
+	PRODUCTVERSION	2, 0, 0, NODE_MODULE_VERSION
+	   FILEVERSION	2, 0, 0, NODE_MODULE_VERSION
 
 	FILEFLAGSMASK	VS_FFI_FILEFLAGSMASK
 #ifdef DEBUG
@@ -45,8 +46,8 @@ VS_VERSION_INFO VERSIONINFO
 				VALUE "ProductName",		"robot-js"
 				VALUE "FileDescription",	"robot-js"
 
-				VALUE "ProductVersion",		"2.0.0." STRINGIFY (TARGET_MODULE_VERSION)
-				VALUE    "FileVersion",		"2.0.0." STRINGIFY (TARGET_MODULE_VERSION)
+				VALUE "ProductVersion",		"2.0.0." STRINGIFY (NODE_MODULE_VERSION)
+				VALUE    "FileVersion",		"2.0.0." STRINGIFY (NODE_MODULE_VERSION)
 				VALUE   "RobotVersion",		"2.0.0." "0"
 
 				VALUE "CompanyName",		"Robot Developers"
diff --git a/src/NodeScreen.cc b/src/NodeScreen.cc
index 7e173c4..8867c9b 100644
--- a/src/NodeScreen.cc
+++ b/src/NodeScreen.cc
@@ -43,18 +43,18 @@ void ScreenWrap::Synchronize (const FunctionCallbackInfo<Value>& args)
 		auto obj = NEW_OBJ;
 		Bounds b = list[i]->GetBounds();
 		Bounds u = list[i]->GetUsable();
-		obj->Set (NEW_STR ("bounds"), NEW_BOUNDS (b.X, b.Y, b.W, b.H));
-		obj->Set (NEW_STR ("usable"), NEW_BOUNDS (u.X, u.Y, u.W, u.H));
-		screens->Set (i, obj);
+		OBJECT_SET (obj, NEW_STR ("bounds"), NEW_BOUNDS (b.X, b.Y, b.W, b.H));
+		OBJECT_SET (obj, NEW_STR ("usable"), NEW_BOUNDS (u.X, u.Y, u.W, u.H));
+		OBJECT_SET (screens, i, obj);
 	}
 
 	auto res = NEW_OBJ;
 	Bounds b = Screen::GetTotalBounds();
 	Bounds u = Screen::GetTotalUsable();
-	res->Set (NEW_STR ("screens"), screens);
-	res->Set (NEW_STR ("status" ), status );
-	res->Set (NEW_STR ("totalBounds"), NEW_BOUNDS (b.X, b.Y, b.W, b.H));
-	res->Set (NEW_STR ("totalUsable"), NEW_BOUNDS (u.X, u.Y, u.W, u.H));
+	OBJECT_SET (res, NEW_STR ("screens"), screens);
+	OBJECT_SET (res, NEW_STR ("status" ), status );
+	OBJECT_SET (res, NEW_STR ("totalBounds"), NEW_BOUNDS (b.X, b.Y, b.W, b.H));
+	OBJECT_SET (res, NEW_STR ("totalUsable"), NEW_BOUNDS (u.X, u.Y, u.W, u.H));
 	RETURN (res);
 }
 
@@ -67,8 +67,8 @@ void ScreenWrap::GrabScreen (const FunctionCallbackInfo<Value>& args)
 	auto win = UnwrapRobot<WindowWrap> (args[5]);
 
 	RETURN_BOOL (Screen::GrabScreen (img->mImage,
-		args[1]->Int32Value(), args[2]->Int32Value(),
-		args[3]->Int32Value(), args[4]->Int32Value(),
+		INT32_VALUE (args[1]), INT32_VALUE (args[2]),
+		INT32_VALUE (args[3]), INT32_VALUE (args[4]),
 		win ? win->mWindow : Window()));
 }
 
@@ -89,14 +89,13 @@ void ScreenWrap::SetCompositing (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsBoolean())
 		THROW (Type, "Invalid arguments");
 
-	bool ec =
-		args[0]->BooleanValue();
+	bool ec = BOOLEAN_VALUE (args[0]);
 	Screen::SetCompositing (ec);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void ScreenWrap::Initialize (Handle<Object> exports)
+void ScreenWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -111,5 +110,5 @@ void ScreenWrap::Initialize (Handle<Object> exports)
 	NODE_SET_METHOD (result, "setCompositing", SetCompositing);
 
 	// Export screen functions inside object
-	exports->Set (NEW_STR ("Screen"), result);
+	OBJECT_SET (exports, NEW_STR ("Screen"), result);
 }
diff --git a/src/NodeScreen.h b/src/NodeScreen.h
index dc78ae2..c4e7ef1 100644
--- a/src/NodeScreen.h
+++ b/src/NodeScreen.h
@@ -32,5 +32,5 @@ class ScreenWrap : public ObjectWrap
 	static void		SetCompositing	(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 };
diff --git a/src/NodeWindow.cc b/src/NodeWindow.cc
index 2273c1d..537e78b 100644
--- a/src/NodeWindow.cc
+++ b/src/NodeWindow.cc
@@ -79,7 +79,7 @@ void WindowWrap::SetTopMost (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	mWindow->SetTopMost
-		  (args[0]->BooleanValue());
+		  (BOOLEAN_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -92,7 +92,7 @@ void WindowWrap::SetBorderless (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	mWindow->SetBorderless
-		  (args[0]->BooleanValue());
+		  (BOOLEAN_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -105,7 +105,7 @@ void WindowWrap::SetMinimized (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	mWindow->SetMinimized
-		  (args[0]->BooleanValue());
+		  (BOOLEAN_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -118,7 +118,7 @@ void WindowWrap::SetMaximized (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	mWindow->SetMaximized
-		  (args[0]->BooleanValue());
+		  (BOOLEAN_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -129,7 +129,7 @@ void WindowWrap::GetProcess (const FunctionCallbackInfo<Value>& args)
 	auto ctor = NEW_CTOR (Process);
 
 	// Create a new instance of wrapper
-	auto instance = ctor->NewInstance();
+	auto instance = NEW_INSTANCE(ctor, 0, NULL);
 	UNWRAP (Process, instance);
 
 	auto process = mWindow->GetProcess();
@@ -166,7 +166,7 @@ void WindowWrap::SetHandle (const FunctionCallbackInfo<Value>& args)
 
 	// Attempt to set new win handle
 	RETURN_BOOL (mWindow->SetHandle
-		((uintptr) args[0]->NumberValue()));
+		((uintptr) NUMBER_VALUE (args[0])));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -187,7 +187,7 @@ void WindowWrap::SetTitle (const FunctionCallbackInfo<Value>& args)
 	if (!args[0]->IsString())
 		THROW (Type, "Invalid arguments");
 
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	auto title = *value ? *value : "";
 	mWindow->SetTitle (title);
 }
@@ -211,10 +211,10 @@ void WindowWrap::SetBounds (const FunctionCallbackInfo<Value>& args)
 	ISOWRAP (Window, args.Holder());
 
 	mWindow->SetBounds
-		(args[0]->Int32Value(),
-		 args[1]->Int32Value(),
-		 args[2]->Int32Value(),
-		 args[3]->Int32Value());
+		(INT32_VALUE (args[0]),
+		 INT32_VALUE (args[1]),
+		 INT32_VALUE (args[2]),
+		 INT32_VALUE (args[3]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -236,10 +236,10 @@ void WindowWrap::SetClient (const FunctionCallbackInfo<Value>& args)
 	ISOWRAP (Window, args.Holder());
 
 	mWindow->SetClient
-		(args[0]->Int32Value(),
-		 args[1]->Int32Value(),
-		 args[2]->Int32Value(),
-		 args[3]->Int32Value());
+		(INT32_VALUE (args[0]),
+		 INT32_VALUE (args[1]),
+		 INT32_VALUE (args[2]),
+		 INT32_VALUE (args[3]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -247,8 +247,8 @@ void WindowWrap::SetClient (const FunctionCallbackInfo<Value>& args)
 void WindowWrap::MapToClient (const FunctionCallbackInfo<Value>& args)
 {
 	ISOWRAP (Window, args.Holder());
-	Point position (args[0]->Int32Value(),
-					args[1]->Int32Value());
+	Point position (INT32_VALUE (args[0]),
+					INT32_VALUE (args[1]));
 
 	// Convert the screen point to client point
 	position = mWindow->MapToClient (position);
@@ -260,8 +260,8 @@ void WindowWrap::MapToClient (const FunctionCallbackInfo<Value>& args)
 void WindowWrap::MapToScreen (const FunctionCallbackInfo<Value>& args)
 {
 	ISOWRAP (Window, args.Holder());
-	Point position (args[0]->Int32Value(),
-					args[1]->Int32Value());
+	Point position (INT32_VALUE (args[0]),
+					INT32_VALUE (args[1]));
 
 	// Convert the client point to screen point
 	position = mWindow->MapToScreen (position);
@@ -276,7 +276,7 @@ void WindowWrap::Equals (const FunctionCallbackInfo<Value>& args)
 	WindowWrap* wrapper = nullptr;
 	if ((wrapper = UnwrapRobot<WindowWrap> (args[0])))
 		RETURN_BOOL (*mWindow == wrapper->mWindow);
-		RETURN_BOOL (*mWindow == args[0]->Int32Value());
+		RETURN_BOOL (*mWindow == INT32_VALUE (args[0]));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -292,7 +292,7 @@ void WindowWrap::GetList (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	const char* regex = 0;
-	String::Utf8Value value (args[0]);
+	UTF8_VAR (value, args[0]);
 	// Retrieve regex value
 	if (args[0]->IsString())
 		regex = *value ? *value : "";
@@ -306,12 +306,12 @@ void WindowWrap::GetList (const FunctionCallbackInfo<Value>& args)
 	for (int i = 0; i < length; ++i)
 	{
 		// Create a new instance of wrapper
-		auto instance = ctor->NewInstance();
+		auto instance = NEW_INSTANCE(ctor, 0, NULL);
 		UNWRAP (Window, instance);
 
 		// Make wrapper use new window
 		mWindowWrap->mWindow = list[i];
-		res->Set (i, instance);
+		OBJECT_SET (res, i, instance);
 	}
 
 	RETURN (res);
@@ -325,7 +325,7 @@ void WindowWrap::GetActive (const FunctionCallbackInfo<Value>& args)
 	auto ctor = NEW_CTOR (Window);
 
 	// Create a new instance of wrapper
-	auto instance = ctor->NewInstance();
+	auto instance = NEW_INSTANCE(ctor, 0, NULL);
 	UNWRAP (Window, instance);
 
 	auto window = Window::GetActive();
@@ -338,7 +338,7 @@ void WindowWrap::GetActive (const FunctionCallbackInfo<Value>& args)
 
 void WindowWrap::SetActive (const FunctionCallbackInfo<Value>& args)
 {
-	ISOWRAP (Window, args[0]->ToObject());
+	ISOWRAP (Window, TO_OBJECT (args[0]));
 	Window::SetActive (mWindowWrap->mWindow);
 }
 
@@ -353,7 +353,7 @@ void WindowWrap::IsAxEnabled (const FunctionCallbackInfo<Value>& args)
 		THROW (Type, "Invalid arguments");
 
 	bool options = args[0]->IsBoolean() ?
-		 args[0]->BooleanValue() : false;
+		 BOOLEAN_VALUE (args[0]) : false;
 	RETURN_BOOL (Window::IsAxEnabled (options));
 }
 
@@ -378,7 +378,7 @@ void WindowWrap::New (const FunctionCallbackInfo<Value>& args)
 		{
 			window->SetHandle
 				// Set the handle if arg available
-				((uintptr) args[0]->NumberValue());
+				((uintptr) NUMBER_VALUE (args[0]));
 		}
 
 		REGISTER_ROBOT_TYPE;
@@ -389,14 +389,14 @@ void WindowWrap::New (const FunctionCallbackInfo<Value>& args)
 	{
 		auto ctor = NEW_CTOR (Window);
 		// Return as a new instance
-		RETURN (ctor->NewInstance (1,
+		RETURN (NEW_INSTANCE(ctor, 1,
 			   (_jsArgs[0] = args[0], _jsArgs)));
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void WindowWrap::Initialize (Handle<Object> exports)
+void WindowWrap::Initialize (Local<Object> exports)
 {
 	// Get the current isolated V8 instance
 	Isolate* isolate = Isolate::GetCurrent();
@@ -441,7 +441,6 @@ void WindowWrap::Initialize (Handle<Object> exports)
 	NODE_SET_METHOD ((Local<Template>) tpl,  "isAxEnabled", IsAxEnabled);
 
 	// Assign function template to our class creator
-	constructor.Reset (isolate, tpl->GetFunction());
-	exports->Set
-		   (NEW_STR ("Window"), tpl->GetFunction());
+	constructor.Reset (isolate, GET_FUNCTION (tpl));
+	OBJECT_SET (exports, NEW_STR ("Window"), GET_FUNCTION (tpl));
 }
diff --git a/src/NodeWindow.h b/src/NodeWindow.h
index ce37001..90b4a18 100644
--- a/src/NodeWindow.h
+++ b/src/NodeWindow.h
@@ -64,7 +64,7 @@ class WindowWrap : public ObjectWrap
 	static void		New				(const FunctionCallbackInfo<Value>& args);
 
 public:
-	static void		Initialize		(Handle<Object> exports);
+	static void		Initialize		(Local<Object> exports);
 
 public:
 	Window mWindow;
diff --git a/src/robot b/src/robot
index a19be18..b7b2bf7 160000
--- a/src/robot
+++ b/src/robot
@@ -1 +1 @@
-Subproject commit a19be1863405fa4dd5c970946d0f3f59d06b74f1
+Subproject commit b7b2bf72db32e56f4cc4a9e948b02105db62e652