From e1e961f6745f64ff143905db716ebfa3e5f80610 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 06:07:15 +0000
Subject: [PATCH 01/14] Initial migration using node-addon-api conversion
 script

The script used was:

https://github.com/nodejs/node-addon-api/blob/36150414236cc0ffdac5c2521fbed9cfb3851762/tools/conversion.js
---
 binding.gyp  |  10 +-
 package.json |   2 +-
 src/raw.cc   | 470 ++++++++++++++++++++++++++++-----------------------
 src/raw.h    |  40 ++---
 4 files changed, 292 insertions(+), 230 deletions(-)

diff --git a/binding.gyp b/binding.gyp
index 651ff59..5d8ad7f 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -2,11 +2,19 @@
   'targets': [
     {
       'target_name': 'raw',
+      'cflags!': [ '-fno-exceptions' ],
+      'cflags_cc!': [ '-fno-exceptions' ],
+      'xcode_settings': { 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'MACOSX_DEPLOYMENT_TARGET': '10.7',
+      },
+      'msvs_settings': {
+        'VCCLCompilerTool': { 'ExceptionHandling': 1 },
+      },
       'sources': [
         'src/raw.cc'
       ],
       "include_dirs" : [
-        "<!(node -e \"require('nan')\")"
       ],
       'conditions' : [
         ['OS=="win"', {
diff --git a/package.json b/package.json
index 1728564..96def3f 100644
--- a/package.json
+++ b/package.json
@@ -7,7 +7,7 @@
     "example": "example"
   },
   "dependencies": {
-    "nan": "2.14.*"
+    "node-addon-api": "4.0.0",
   },
   "contributors": [
     {
diff --git a/src/raw.cc b/src/raw.cc
index b8e4850..d57738b 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -43,67 +43,75 @@ static uint16_t checksum (uint16_t start_with, unsigned char *buffer,
 
 namespace raw {
 
-static Nan::Persistent<FunctionTemplate> SocketWrap_constructor;
+static Napi::FunctionReference SocketWrap_constructor;
 
-void InitAll (Local<Object> exports) {
+void InitAll (Napi::Object exports) {
 	ExportConstants (exports);
 	ExportFunctions (exports);
 
 	SocketWrap::Init (exports);
 }
 
-NODE_MODULE(raw, InitAll)
+NODE_API_MODULE(raw, InitAll)
 
-NAN_METHOD(CreateChecksum) {
-	Nan::HandleScope scope;
+Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 2) {
-		Nan::ThrowError("At least one argument is required");
+		Napi::Error::New(env, "At least one argument is required").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[0]->IsUint32 ()) {
-		Nan::ThrowTypeError("Start with argument must be an unsigned integer");
+	if (! info[0].IsUint32 ()) {
+		Napi::TypeError::New(env, "Start with argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	uint32_t start_with = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
+	uint32_t start_with = Napi::To<Uint32>(info[0])->Value();
 
 	if (start_with > 65535) {
-		Nan::ThrowRangeError("Start with argument cannot be larger than 65535");
+		Napi::RangeError::New(env, "Start with argument cannot be larger than 65535").ThrowAsJavaScriptException();
+
 		return;
 	}
 
 	if (! node::Buffer::HasInstance (info[1])) {
-		Nan::ThrowTypeError("Buffer argument must be a node Buffer object");
+		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	Local<Object> buffer = Nan::To<Object>(info[1]).ToLocalChecked();
+	Napi::Object buffer = info[1].To<Napi::Object>();
 	char *data = node::Buffer::Data (buffer);
 	size_t length = node::Buffer::Length (buffer);
 	unsigned int offset = 0;
 	
 	if (info.Length () > 2) {
-		if (! info[2]->IsUint32 ()) {
-			Nan::ThrowTypeError("Offset argument must be an unsigned integer");
+		if (! info[2].IsUint32 ()) {
+			Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 			return;
 		}
-		offset = Nan::To<Uint32>(info[2]).ToLocalChecked()->Value();
+		offset = Napi::To<Uint32>(info[2])->Value();
 		if (offset >= length) {
-			Nan::ThrowRangeError("Offset argument must be smaller than length of the buffer");
+			Napi::RangeError::New(env, "Offset argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
+
 			return;
 		}
 	}
 	
 	if (info.Length () > 3) {
-		if (! info[3]->IsUint32 ()) {
-			Nan::ThrowTypeError("Length argument must be an unsigned integer");
+		if (! info[3].IsUint32 ()) {
+			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 			return;
 		}
-		unsigned int new_length = Nan::To<Uint32>(info[3]).ToLocalChecked()->Value();
+		unsigned int new_length = Napi::To<Uint32>(info[3])->Value();
 		if (new_length > length) {
-			Nan::ThrowRangeError("Length argument must be smaller than length of the buffer");
+			Napi::RangeError::New(env, "Length argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
+
 			return;
 		}
 		length = new_length;
@@ -112,158 +120,168 @@ NAN_METHOD(CreateChecksum) {
 	uint16_t sum = checksum ((uint16_t) start_with,
 			(unsigned char *) data + offset, length);
 
-	Local<Integer> number = Nan::New<Uint32>(sum);
+	Local<Integer> number = Napi::Uint32::New(env, sum);
 	
-	info.GetReturnValue().Set(number);
+	return number;
 }
 
-NAN_METHOD(Htonl) {
-	Nan::HandleScope scope;
+Napi::Value Htonl(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 
 	if (info.Length () < 1) {
-		Nan::ThrowError("One arguments is required");
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[0]->IsUint32 ()) {
-		Nan::ThrowTypeError("Number must be a 32 unsigned integer");
+	if (! info[0].IsUint32 ()) {
+		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	unsigned int number = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
-	Local<Uint32> converted = Nan::New<Uint32>((unsigned int) htonl (number));
+	unsigned int number = Napi::To<Uint32>(info[0])->Value();
+	Local<Uint32> converted = Napi::Uint32::New(env, (unsigned int) htonl (number));
 
-	info.GetReturnValue().Set(converted);
+	return converted;
 }
 
-NAN_METHOD(Htons) {
-	Nan::HandleScope scope;
+Napi::Value Htons(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
-		Nan::ThrowError("One arguments is required");
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[0]->IsUint32 ()) {
-		Nan::ThrowTypeError("Number must be a 16 unsigned integer");
+	if (! info[0].IsUint32 ()) {
+		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	unsigned int number = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
+	unsigned int number = Napi::To<Uint32>(info[0])->Value();
 	
 	if (number > 65535) {
-		Nan::ThrowRangeError("Number cannot be larger than 65535");
+		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	Local<Uint32> converted = Nan::New<Uint32>(htons (number));
+	Local<Uint32> converted = Napi::Uint32::New(env, htons (number));
 
-	info.GetReturnValue().Set(converted);
+	return converted;
 }
 
-NAN_METHOD(Ntohl) {
-	Nan::HandleScope scope;
+Napi::Value Ntohl(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
-		Nan::ThrowError("One arguments is required");
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[0]->IsUint32 ()) {
-		Nan::ThrowTypeError("Number must be a 32 unsigned integer");
+	if (! info[0].IsUint32 ()) {
+		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	unsigned int number = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
-	Local<Uint32> converted = Nan::New<Uint32>((unsigned int) ntohl (number));
+	unsigned int number = Napi::To<Uint32>(info[0])->Value();
+	Local<Uint32> converted = Napi::Uint32::New(env, (unsigned int) ntohl (number));
 
-	info.GetReturnValue().Set(converted);
+	return converted;
 }
 
-NAN_METHOD(Ntohs) {
-	Nan::HandleScope scope;
+Napi::Value Ntohs(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
-		Nan::ThrowError("One arguments is required");
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[0]->IsUint32 ()) {
-		Nan::ThrowTypeError("Number must be a 16 unsigned integer");
+	if (! info[0].IsUint32 ()) {
+		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	unsigned int number = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
+	unsigned int number = Napi::To<Uint32>(info[0])->Value();
 	
 	if (number > 65535) {
-		Nan::ThrowRangeError("Number cannot be larger than 65535");
+		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	Local<Uint32> converted = Nan::New<Uint32>(htons (number));
+	Local<Uint32> converted = Napi::Uint32::New(env, htons (number));
 
-	info.GetReturnValue().Set(converted);
+	return converted;
 }
 
-void ExportConstants (Local<Object> target) {
-	Local<Object> socket_level = Nan::New<Object>();
-	Local<Object> socket_option = Nan::New<Object>();
+void ExportConstants (Napi::Object target) {
+	Napi::Object socket_level = Napi::Object::New(env);
+	Napi::Object socket_option = Napi::Object::New(env);
 
-	Nan::Set(target, Nan::New("SocketLevel").ToLocalChecked(), socket_level);
-	Nan::Set(target, Nan::New("SocketOption").ToLocalChecked(), socket_option);
+	(target).Set(Napi::String::New(env, "SocketLevel"), socket_level);
+	(target).Set(Napi::String::New(env, "SocketOption"), socket_option);
 
-	Nan::Set(socket_level, Nan::New("SOL_SOCKET").ToLocalChecked(), Nan::New<Number>(SOL_SOCKET));
-	Nan::Set(socket_level, Nan::New("IPPROTO_IP").ToLocalChecked(), Nan::New<Number>(IPPROTO_IP + 0));
-	Nan::Set(socket_level, Nan::New("IPPROTO_IPV6").ToLocalChecked(), Nan::New<Number>(IPPROTO_IPV6 + 0));
+	(socket_level).Set(Napi::String::New(env, "SOL_SOCKET"), Napi::Number::New(env, SOL_SOCKET));
+	(socket_level).Set(Napi::String::New(env, "IPPROTO_IP"), Napi::Number::New(env, IPPROTO_IP + 0));
+	(socket_level).Set(Napi::String::New(env, "IPPROTO_IPV6"), Napi::Number::New(env, IPPROTO_IPV6 + 0));
 
-	Nan::Set(socket_option, Nan::New("SO_BROADCAST").ToLocalChecked(), Nan::New<Number>(SO_BROADCAST));
-	Nan::Set(socket_option, Nan::New("SO_RCVBUF").ToLocalChecked(), Nan::New<Number>(SO_RCVBUF));
-	Nan::Set(socket_option, Nan::New("SO_RCVTIMEO").ToLocalChecked(), Nan::New<Number>(SO_RCVTIMEO));
-	Nan::Set(socket_option, Nan::New("SO_SNDBUF").ToLocalChecked(), Nan::New<Number>(SO_SNDBUF));
-	Nan::Set(socket_option, Nan::New("SO_SNDTIMEO").ToLocalChecked(), Nan::New<Number>(SO_SNDTIMEO));
+	(socket_option).Set(Napi::String::New(env, "SO_BROADCAST"), Napi::Number::New(env, SO_BROADCAST));
+	(socket_option).Set(Napi::String::New(env, "SO_RCVBUF"), Napi::Number::New(env, SO_RCVBUF));
+	(socket_option).Set(Napi::String::New(env, "SO_RCVTIMEO"), Napi::Number::New(env, SO_RCVTIMEO));
+	(socket_option).Set(Napi::String::New(env, "SO_SNDBUF"), Napi::Number::New(env, SO_SNDBUF));
+	(socket_option).Set(Napi::String::New(env, "SO_SNDTIMEO"), Napi::Number::New(env, SO_SNDTIMEO));
 
 #ifdef __linux__
-	Nan::Set(socket_option, Nan::New("SO_BINDTODEVICE").ToLocalChecked(), Nan::New<Number>(SO_BINDTODEVICE));
+	(socket_option).Set(Napi::String::New(env, "SO_BINDTODEVICE"), Napi::Number::New(env, SO_BINDTODEVICE));
 #endif
 
-	Nan::Set(socket_option, Nan::New("IP_HDRINCL").ToLocalChecked(), Nan::New<Number>(IP_HDRINCL));
-	Nan::Set(socket_option, Nan::New("IP_OPTIONS").ToLocalChecked(), Nan::New<Number>(IP_OPTIONS));
-	Nan::Set(socket_option, Nan::New("IP_TOS").ToLocalChecked(), Nan::New<Number>(IP_TOS));
-	Nan::Set(socket_option, Nan::New("IP_TTL").ToLocalChecked(), Nan::New<Number>(IP_TTL));
+	(socket_option).Set(Napi::String::New(env, "IP_HDRINCL"), Napi::Number::New(env, IP_HDRINCL));
+	(socket_option).Set(Napi::String::New(env, "IP_OPTIONS"), Napi::Number::New(env, IP_OPTIONS));
+	(socket_option).Set(Napi::String::New(env, "IP_TOS"), Napi::Number::New(env, IP_TOS));
+	(socket_option).Set(Napi::String::New(env, "IP_TTL"), Napi::Number::New(env, IP_TTL));
 
 #ifdef _WIN32
-	Nan::Set(socket_option, Nan::New("IPV6_HDRINCL").ToLocalChecked(), Nan::New<Number>(IPV6_HDRINCL));
+	(socket_option).Set(Napi::String::New(env, "IPV6_HDRINCL"), Napi::Number::New(env, IPV6_HDRINCL));
 #endif
-	Nan::Set(socket_option, Nan::New("IPV6_TTL").ToLocalChecked(), Nan::New<Number>(IPV6_UNICAST_HOPS));
-	Nan::Set(socket_option, Nan::New("IPV6_UNICAST_HOPS").ToLocalChecked(), Nan::New<Number>(IPV6_UNICAST_HOPS));
-	Nan::Set(socket_option, Nan::New("IPV6_V6ONLY").ToLocalChecked(), Nan::New<Number>(IPV6_V6ONLY));
+	(socket_option).Set(Napi::String::New(env, "IPV6_TTL"), Napi::Number::New(env, IPV6_UNICAST_HOPS));
+	(socket_option).Set(Napi::String::New(env, "IPV6_UNICAST_HOPS"), Napi::Number::New(env, IPV6_UNICAST_HOPS));
+	(socket_option).Set(Napi::String::New(env, "IPV6_V6ONLY"), Napi::Number::New(env, IPV6_V6ONLY));
 }
 
-void ExportFunctions (Local<Object> target) {
-	Nan::Set(target, Nan::New("createChecksum").ToLocalChecked(), Nan::GetFunction(Nan::New<FunctionTemplate>(CreateChecksum)).ToLocalChecked());
+void ExportFunctions (Napi::Object target) {
+	(target).Set(Napi::String::New(env, "createChecksum"), Napi::GetFunction(Napi::Function::New(env, CreateChecksum)));
 	
-	Nan::Set(target, Nan::New("htonl").ToLocalChecked(), Nan::GetFunction(Nan::New<FunctionTemplate>(Htonl)).ToLocalChecked());
-	Nan::Set(target, Nan::New("htons").ToLocalChecked(), Nan::GetFunction(Nan::New<FunctionTemplate>(Htons)).ToLocalChecked());
-	Nan::Set(target, Nan::New("ntohl").ToLocalChecked(), Nan::GetFunction(Nan::New<FunctionTemplate>(Ntohl)).ToLocalChecked());
-	Nan::Set(target, Nan::New("ntohs").ToLocalChecked(), Nan::GetFunction(Nan::New<FunctionTemplate>(Ntohs)).ToLocalChecked());
+	(target).Set(Napi::String::New(env, "htonl"), Napi::GetFunction(Napi::Function::New(env, Htonl)));
+	(target).Set(Napi::String::New(env, "htons"), Napi::GetFunction(Napi::Function::New(env, Htons)));
+	(target).Set(Napi::String::New(env, "ntohl"), Napi::GetFunction(Napi::Function::New(env, Ntohl)));
+	(target).Set(Napi::String::New(env, "ntohs"), Napi::GetFunction(Napi::Function::New(env, Ntohs)));
 }
 
-void SocketWrap::Init (Local<Object> exports) {
-	Nan::HandleScope scope;
+void SocketWrap::Init (Napi::Object exports) {
+	Napi::HandleScope scope(env);
 
-	Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(SocketWrap::New);
-	tpl->SetClassName(Nan::New("SocketWrap").ToLocalChecked());
-	tpl->InstanceTemplate()->SetInternalFieldCount(1);
+	Napi::FunctionReference tpl = Napi::Function::New(env, SocketWrap::New);
+	tpl->SetClassName(Napi::String::New(env, "SocketWrap"));
 
-	Nan::SetPrototypeMethod(tpl, "close", Close);
-	Nan::SetPrototypeMethod(tpl, "getOption", GetOption);
-	Nan::SetPrototypeMethod(tpl, "pause", Pause);
-	Nan::SetPrototypeMethod(tpl, "recv", Recv);
-	Nan::SetPrototypeMethod(tpl, "send", Send);
-	Nan::SetPrototypeMethod(tpl, "setOption", SetOption);
+
+	InstanceMethod("close", &Close),
+	InstanceMethod("getOption", &GetOption),
+	InstanceMethod("pause", &Pause),
+	InstanceMethod("recv", &Recv),
+	InstanceMethod("send", &Send),
+	InstanceMethod("setOption", &SetOption),
 
 	SocketWrap_constructor.Reset(tpl);
-	Nan::Set(exports, Nan::New("SocketWrap").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
+	(exports).Set(Napi::String::New(env, "SocketWrap"), Napi::GetFunction(tpl));
 }
 
 SocketWrap::SocketWrap () {
@@ -275,19 +293,19 @@ SocketWrap::~SocketWrap () {
 	this->CloseSocket ();
 }
 
-NAN_METHOD(SocketWrap::Close) {
-	Nan::HandleScope scope;
+Napi::Value SocketWrap::Close(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
 	
 	socket->CloseSocket ();
 
-	Local<Value> args[1];
-	args[0] = Nan::New<String>("close").ToLocalChecked();
+	Napi::Value args[1];
+	args[0] = Napi::String::New(env, "close");
 
-	Nan::Call(Nan::New<String>("emit").ToLocalChecked(), info.This(), 1, args);
+	Napi::Call(Napi::String::New(env, "emit"), info.This(), 1, args);
 
-	info.GetReturnValue().Set(info.This());
+	return info.This();
 }
 
 void SocketWrap::CloseSocket (void) {
@@ -346,42 +364,47 @@ int SocketWrap::CreateSocket (void) {
 	return 0;
 }
 
-NAN_METHOD(SocketWrap::GetOption) {
-	Nan::HandleScope scope;
+Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
 	
 	if (info.Length () < 3) {
-		Nan::ThrowError("Three arguments are required");
+		Napi::Error::New(env, "Three arguments are required").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[0]->IsNumber ()) {
-		Nan::ThrowTypeError("Level argument must be a number");
+	if (! info[0].IsNumber ()) {
+		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[1]->IsNumber ()) {
-		Nan::ThrowTypeError("Option argument must be a number");
+	if (! info[1].IsNumber ()) {
+		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	int level = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
-	int option = Nan::To<Uint32>(info[1]).ToLocalChecked()->Value();
+	int level = Napi::To<Uint32>(info[0])->Value();
+	int option = Napi::To<Uint32>(info[1])->Value();
 	SOCKET_OPT_TYPE val = NULL;
 	unsigned int ival = 0;
 	SOCKET_LEN_TYPE len;
 
 	if (! node::Buffer::HasInstance (info[2])) {
-		Nan::ThrowTypeError("Value argument must be a node Buffer object if length is provided");
+		Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	Local<Object> buffer = Nan::To<Object>(info[2]).ToLocalChecked();
+	Napi::Object buffer = info[2].To<Napi::Object>();
 	val = node::Buffer::Data (buffer);
 
-	if (! info[3]->IsInt32 ()) {
-		Nan::ThrowTypeError("Length argument must be an unsigned integer");
+	if (! info[3].IsInt32 ()) {
+		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 
@@ -391,21 +414,22 @@ NAN_METHOD(SocketWrap::GetOption) {
 			(val ? val : (SOCKET_OPT_TYPE) &ival), &len);
 
 	if (rc == SOCKET_ERROR) {
-		Nan::ThrowError(raw_strerror (SOCKET_ERRNO));
+		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	Local<Number> got = Nan::New<Uint32>(len);
+	Napi::Number got = Napi::Uint32::New(env, len);
 	
-	info.GetReturnValue().Set(got);
+	return got;
 }
 
 void SocketWrap::HandleIOEvent (int status, int revents) {
-	Nan::HandleScope scope;
+	Napi::HandleScope scope(env);
 
 	if (status) {
-		Local<Value> args[2];
-		args[0] = Nan::New<String>("error").ToLocalChecked();
+		Napi::Value args[2];
+		args[0] = Napi::String::New(env, "error");
 		
 		/**
 		 ** The uv_last_error() function doesn't seem to be available in recent
@@ -415,44 +439,47 @@ void SocketWrap::HandleIOEvent (int status, int revents) {
 		 **/
 		char status_str[32];
 		sprintf(status_str, "%d", status);
-		args[1] = Nan::Error(status_str);
+		args[1] = Napi::Error::New(env, status_str);
 
-		Nan::Call(Nan::New<String>("emit").ToLocalChecked(), handle(), 1, args);
+		Napi::Call(Napi::String::New(env, "emit"), handle(), 1, args);
 	} else {
-		Local<Value> args[1];
+		Napi::Value args[1];
 		if (revents & UV_READABLE)
-			args[0] = Nan::New<String>("recvReady").ToLocalChecked();
+			args[0] = Napi::String::New(env, "recvReady");
 		else
-			args[0] = Nan::New<String>("sendReady").ToLocalChecked();
+			args[0] = Napi::String::New(env, "sendReady");
 
-		Nan::Call(Nan::New<String>("emit").ToLocalChecked(), handle(), 1, args);
+		Napi::Call(Napi::String::New(env, "emit"), handle(), 1, args);
 	}
 }
 
-NAN_METHOD(SocketWrap::New) {
-	Nan::HandleScope scope;
+Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = new SocketWrap ();
 	int rc, family = AF_INET;
 	
 	if (info.Length () < 1) {
-		Nan::ThrowError("One argument is required");
+		Napi::Error::New(env, "One argument is required").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	if (! info[0]->IsUint32 ()) {
-		Nan::ThrowTypeError("Protocol argument must be an unsigned integer");
+	if (! info[0].IsUint32 ()) {
+		Napi::TypeError::New(env, "Protocol argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	} else {
-		socket->protocol_ = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
+		socket->protocol_ = Napi::To<Uint32>(info[0])->Value();
 	}
 
 	if (info.Length () > 1) {
-		if (! info[1]->IsUint32 ()) {
-			Nan::ThrowTypeError("Address family argument must be an unsigned integer");
+		if (! info[1].IsUint32 ()) {
+			Napi::TypeError::New(env, "Address family argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 			return;
 		} else {
-			if (Nan::To<Uint32>(info[1]).ToLocalChecked()->Value() == 2)
+			if (Napi::To<Uint32>(info[1])->Value() == 2)
 				family = AF_INET6;
 		}
 	}
@@ -465,40 +492,44 @@ NAN_METHOD(SocketWrap::New) {
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
-		Nan::ThrowError(raw_strerror (rc));
+		Napi::Error::New(env, raw_strerror (rc)).ThrowAsJavaScriptException();
+
 		return;
 	}
 
 	socket->Wrap (info.This ());
 
-	info.GetReturnValue().Set(info.This());
+	return info.This();
 }
 
 void SocketWrap::OnClose (uv_handle_t *handle) {
 	delete handle;
 }
 
-NAN_METHOD(SocketWrap::Pause) {
-	Nan::HandleScope scope;
+Napi::Value SocketWrap::Pause(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
 
 	if (info.Length () < 2) {
-		Nan::ThrowError("Two arguments are required");
+		Napi::Error::New(env, "Two arguments are required").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	if (! info[0]->IsBoolean ()) {
-		Nan::ThrowTypeError("Recv argument must be a boolean");
+	if (! info[0].IsBoolean ()) {
+		Napi::TypeError::New(env, "Recv argument must be a boolean").ThrowAsJavaScriptException();
+
 		return;
 	}
-	bool pause_recv = Nan::To<Boolean>(info[0]).ToLocalChecked()->Value();
+	bool pause_recv = info[0].To<Napi::Boolean>()->Value();
+
+	if (! info[1].IsBoolean ()) {
+		Napi::TypeError::New(env, "Send argument must be a boolean").ThrowAsJavaScriptException();
 
-	if (! info[1]->IsBoolean ()) {
-		Nan::ThrowTypeError("Send argument must be a boolean");
 		return;
 	}
-	bool pause_send = Nan::To<Boolean>(info[1]).ToLocalChecked()->Value();
+	bool pause_send = info[1].To<Napi::Boolean>()->Value();
 	
 	int events = (pause_recv ? 0 : UV_READABLE)
 			| (pause_send ? 0 : UV_WRITABLE);
@@ -509,14 +540,14 @@ NAN_METHOD(SocketWrap::Pause) {
 			uv_poll_start (socket->poll_watcher_, events, IoEvent);
 	}
 	
-	info.GetReturnValue().Set(info.This());
+	return info.This();
 }
 
-NAN_METHOD(SocketWrap::Recv) {
-	Nan::HandleScope scope;
+Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
-	Local<Object> buffer;
+	Napi::Object buffer;
 	sockaddr_in sin_address;
 	sockaddr_in6 sin6_address;
 	char addr[50];
@@ -532,25 +563,29 @@ NAN_METHOD(SocketWrap::Recv) {
 #endif
 	
 	if (info.Length () < 2) {
-		Nan::ThrowError("Five arguments are required");
+		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
 	if (! node::Buffer::HasInstance (info[0])) {
-		Nan::ThrowTypeError("Buffer argument must be a node Buffer object");
+		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
+
 		return;
 	} else {
-		buffer = Nan::To<Object>(info[0]).ToLocalChecked();
+		buffer = info[0].To<Napi::Object>();
 	}
 
-	if (! info[1]->IsFunction ()) {
-		Nan::ThrowTypeError("Callback argument must be a function");
+	if (! info[1].IsFunction ()) {
+		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
+
 		return;
 	}
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
-		Nan::ThrowError(raw_strerror (errno));
+		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
+
 		return;
 	}
 
@@ -567,7 +602,8 @@ NAN_METHOD(SocketWrap::Recv) {
 	}
 	
 	if (rc == SOCKET_ERROR) {
-		Nan::ThrowError(raw_strerror (SOCKET_ERRNO));
+		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
+
 		return;
 	}
 	
@@ -576,66 +612,73 @@ NAN_METHOD(SocketWrap::Recv) {
 	else
 		uv_ip4_name (&sin_address, addr, 50);
 	
-	Local<Function> cb = Local<Function>::Cast (info[1]);
+	Napi::Function cb = Napi::Function::Cast (info[1]);
 	const unsigned argc = 3;
-	Local<Value> argv[argc];
+	Napi::Value argv[argc];
 	argv[0] = info[0];
-	argv[1] = Nan::New<Number>(rc);
-	argv[2] = Nan::New(addr).ToLocalChecked();
-	Nan::Call(Nan::Callback(cb), argc, argv);
+	argv[1] = Napi::Number::New(env, rc);
+	argv[2] = Napi::New(env, addr);
+	Napi::Call(Napi::FunctionReference(cb), argc, argv);
 	
-	info.GetReturnValue().Set(info.This());
+	return info.This();
 }
 
-NAN_METHOD(SocketWrap::Send) {
-	Nan::HandleScope scope;
+Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
-	Local<Object> buffer;
+	Napi::Object buffer;
 	uint32_t offset;
 	uint32_t length;
 	int rc;
 	char *data;
 	
 	if (info.Length () < 5) {
-		Nan::ThrowError("Five arguments are required");
+		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
 	if (! node::Buffer::HasInstance (info[0])) {
-		Nan::ThrowTypeError("Buffer argument must be a node Buffer object");
+		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	if (! info[1]->IsUint32 ()) {
-		Nan::ThrowTypeError("Offset argument must be an unsigned integer");
+	if (! info[1].IsUint32 ()) {
+		Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[2]->IsUint32 ()) {
-		Nan::ThrowTypeError("Length argument must be an unsigned integer");
+	if (! info[2].IsUint32 ()) {
+		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[3]->IsString ()) {
-		Nan::ThrowTypeError("Address argument must be a string");
+	if (! info[3].IsString ()) {
+		Napi::TypeError::New(env, "Address argument must be a string").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[4]->IsFunction ()) {
-		Nan::ThrowTypeError("Callback argument must be a function");
+	if (! info[4].IsFunction ()) {
+		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
+
 		return;
 	}
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
-		Nan::ThrowError(raw_strerror (errno));
+		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	buffer = Nan::To<Object>(info[0]).ToLocalChecked();
-	offset = Nan::To<Uint32>(info[1]).ToLocalChecked()->Value();
-	length = Nan::To<Uint32>(info[2]).ToLocalChecked()->Value();
+	buffer = info[0].To<Napi::Object>();
+	offset = Napi::To<Uint32>(info[1])->Value();
+	length = Napi::To<Uint32>(info[2])->Value();
 
 	data = node::Buffer::Data (buffer) + offset;
 	
@@ -643,7 +686,7 @@ NAN_METHOD(SocketWrap::Send) {
 #if UV_VERSION_MAJOR > 0
 		struct sockaddr_in6 addr;
 
-		uv_ip6_addr(*Nan::Utf8String(info[3]), 0, &addr);
+		uv_ip6_addr(info[3].As<Napi::String>().Utf8Value().c_str(), 0, &addr);
 #else
 		String::Utf8String address (args[3]);
 		struct sockaddr_in6 addr = uv_ip6_addr (*address, 0);
@@ -654,7 +697,7 @@ NAN_METHOD(SocketWrap::Send) {
 	} else {
 #if UV_VERSION_MAJOR > 0
 		struct sockaddr_in addr;
-		uv_ip4_addr(*Nan::Utf8String(info[3]), 0, &addr);
+		uv_ip4_addr(info[3].As<Napi::String>().Utf8Value().c_str(), 0, &addr);
 #else
 		String::Utf8String address (info[3]);
 		struct sockaddr_in addr = uv_ip4_addr (*address, 0);
@@ -665,72 +708,80 @@ NAN_METHOD(SocketWrap::Send) {
 	}
 	
 	if (rc == SOCKET_ERROR) {
-		Nan::ThrowError(raw_strerror (SOCKET_ERRNO));
+		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	Local<Function> cb = Local<Function>::Cast (info[4]);
+	Napi::Function cb = Napi::Function::Cast (info[4]);
 	const unsigned argc = 1;
-	Local<Value> argv[argc];
-	argv[0] = Nan::New<Number>(rc);
-	Nan::Call(Nan::Callback(cb), argc, argv);
+	Napi::Value argv[argc];
+	argv[0] = Napi::Number::New(env, rc);
+	Napi::Call(Napi::FunctionReference(cb), argc, argv);
 	
-	info.GetReturnValue().Set(info.This());
+	return info.This();
 }
 
-NAN_METHOD(SocketWrap::SetOption) {
-	Nan::HandleScope scope;
+Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
+	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
 	
 	if (info.Length () < 3) {
-		Nan::ThrowError("Three or four arguments are required");
+		Napi::Error::New(env, "Three or four arguments are required").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[0]->IsNumber ()) {
-		Nan::ThrowTypeError("Level argument must be a number");
+	if (! info[0].IsNumber ()) {
+		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	if (! info[1]->IsNumber ()) {
-		Nan::ThrowTypeError("Option argument must be a number");
+	if (! info[1].IsNumber ()) {
+		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
+
 		return;
 	}
 
-	int level = Nan::To<Uint32>(info[0]).ToLocalChecked()->Value();
-	int option = Nan::To<Uint32>(info[1]).ToLocalChecked()->Value();
+	int level = Napi::To<Uint32>(info[0])->Value();
+	int option = Napi::To<Uint32>(info[1])->Value();
 	SOCKET_OPT_TYPE val = NULL;
 	unsigned int ival = 0;
 	SOCKET_LEN_TYPE len;
 
 	if (info.Length () > 3) {
 		if (! node::Buffer::HasInstance (info[2])) {
-			Nan::ThrowTypeError("Value argument must be a node Buffer object if length is provided");
+			Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
+
 			return;
 		}
 		
-		Local<Object> buffer = Nan::To<Object>(info[2]).ToLocalChecked();
+		Napi::Object buffer = info[2].To<Napi::Object>();
 		val = node::Buffer::Data (buffer);
 
-		if (! info[3]->IsInt32 ()) {
-			Nan::ThrowTypeError("Length argument must be an unsigned integer");
+		if (! info[3].IsInt32 ()) {
+			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+
 			return;
 		}
 
-		len = Nan::To<Uint32>(info[3]).ToLocalChecked()->Value();
+		len = Napi::To<Uint32>(info[3])->Value();
 
 		if (len > node::Buffer::Length (buffer)) {
-			Nan::ThrowTypeError("Length argument is larger than buffer length");
+			Napi::TypeError::New(env, "Length argument is larger than buffer length").ThrowAsJavaScriptException();
+
 			return;
 		}
 	} else {
-		if (! info[2]->IsUint32 ()) {
-			Nan::ThrowTypeError("Value argument must be a unsigned integer");
+		if (! info[2].IsUint32 ()) {
+			Napi::TypeError::New(env, "Value argument must be a unsigned integer").ThrowAsJavaScriptException();
+
 			return;
 		}
 
-		ival = Nan::To<Uint32>(info[2]).ToLocalChecked()->Value();
+		ival = Napi::To<Uint32>(info[2])->Value();
 		len = 4;
 	}
 
@@ -738,11 +789,12 @@ NAN_METHOD(SocketWrap::SetOption) {
 			(val ? val : (SOCKET_OPT_TYPE) &ival), len);
 
 	if (rc == SOCKET_ERROR) {
-		Nan::ThrowError(raw_strerror(SOCKET_ERRNO));
+		Napi::Error::New(env, raw_strerror(SOCKET_ERRNO)).ThrowAsJavaScriptException();
+
 		return;
 	}
 	
-	info.GetReturnValue().Set(info.This());
+	return info.This();
 }
 
 static void IoEvent (uv_poll_t* watcher, int status, int revents) {
diff --git a/src/raw.h b/src/raw.h
index ff1928a..98d2b8a 100644
--- a/src/raw.h
+++ b/src/raw.h
@@ -18,9 +18,11 @@
 
 #include <string>
 
-#include <node.h>
+#include <napi.h>
+#include <uv.h>
 #include <node_buffer.h>
-#include <nan.h>
+#include <napi.h>
+#include <uv.h>
 
 #ifdef _WIN32
 #include <winsock2.h>
@@ -45,45 +47,45 @@
 #define SOCKET_LEN_TYPE socklen_t
 #endif
 
-using namespace v8;
+using namespace Napi;
 
 namespace raw {
 
-NAN_METHOD(CreateChecksum);
+Napi::Value CreateChecksum(const Napi::CallbackInfo& info);
 
-void ExportConstants (Local<Object> target);
-void ExportFunctions (Local<Object> target);
+void ExportConstants (Napi::Object target);
+void ExportFunctions (Napi::Object target);
 
-NAN_METHOD(Htonl);
-NAN_METHOD(Htons);
-NAN_METHOD(Ntohl);
-NAN_METHOD(Ntohs);
+Napi::Value Htonl(const Napi::CallbackInfo& info);
+Napi::Value Htons(const Napi::CallbackInfo& info);
+Napi::Value Ntohl(const Napi::CallbackInfo& info);
+Napi::Value Ntohs(const Napi::CallbackInfo& info);
 
-class SocketWrap : public Nan::ObjectWrap {
+class SocketWrap : public Napi::ObjectWrap<SocketWrap> {
 public:
 	void HandleIOEvent (int status, int revents);
-	static void Init (Local<Object> exports);
+	static void Init (Napi::Object exports);
 
 private:
 	SocketWrap ();
 	~SocketWrap ();
 
-	static NAN_METHOD(Close);
+	static Napi::Value Close(const Napi::CallbackInfo& info);
 
 	void CloseSocket (void);
 	
 	int CreateSocket (void);
 
-	static NAN_METHOD(GetOption);
+	static Napi::Value GetOption(const Napi::CallbackInfo& info);
 
-	static NAN_METHOD(New);
+	static Napi::Value New(const Napi::CallbackInfo& info);
 
 	static void OnClose (uv_handle_t *handle);
 
-	static NAN_METHOD(Pause);
-	static NAN_METHOD(Recv);
-	static NAN_METHOD(Send);
-	static NAN_METHOD(SetOption);
+	static Napi::Value Pause(const Napi::CallbackInfo& info);
+	static Napi::Value Recv(const Napi::CallbackInfo& info);
+	static Napi::Value Send(const Napi::CallbackInfo& info);
+	static Napi::Value SetOption(const Napi::CallbackInfo& info);
 
 	bool no_ip_header_;
 

From b52f5b24a0cca5257ed498baa6418323ad3cabcf Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 06:07:34 +0000
Subject: [PATCH 02/14] Fix syntax error in generated package.json

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 96def3f..08b59c8 100644
--- a/package.json
+++ b/package.json
@@ -7,7 +7,7 @@
     "example": "example"
   },
   "dependencies": {
-    "node-addon-api": "4.0.0",
+    "node-addon-api": "4.0.0"
   },
   "contributors": [
     {

From 8f3a33368b744b34c2921fab000c943b15be56b4 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 06:08:05 +0000
Subject: [PATCH 03/14] Fix node-addon-api include directory reference

---
 binding.gyp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/binding.gyp b/binding.gyp
index 5d8ad7f..531c3c1 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -15,6 +15,7 @@
         'src/raw.cc'
       ],
       "include_dirs" : [
+        "<!(node -p \"require('node-addon-api').include_dir\")"
       ],
       'conditions' : [
         ['OS=="win"', {

From 585ffdac431360f4ea89b13c1e536b9c66933039 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 06:12:20 +0000
Subject: [PATCH 04/14] Fix conversion newline issues

---
 src/raw.cc | 104 ++++++++++++++++++++++++++---------------------------
 src/raw.h  |   4 +--
 2 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index d57738b..87f887d 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -58,13 +58,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 2) {
-		Napi::Error::New(env, "At least one argument is required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "At least one argument is required").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[0].IsUint32 ()) {
-		Napi::TypeError::New(env, "Start with argument must be an unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Start with argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -72,13 +72,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	uint32_t start_with = Napi::To<Uint32>(info[0])->Value();
 
 	if (start_with > 65535) {
-		Napi::RangeError::New(env, "Start with argument cannot be larger than 65535").ThrowAsJavaScriptException();
+		Napi::RangeError::New(env, "Start with argument cannot be larger than 65535").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! node::Buffer::HasInstance (info[1])) {
-		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -90,13 +90,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	
 	if (info.Length () > 2) {
 		if (! info[2].IsUint32 ()) {
-			Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
+			Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
 		offset = Napi::To<Uint32>(info[2])->Value();
 		if (offset >= length) {
-			Napi::RangeError::New(env, "Offset argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
+			Napi::RangeError::New(env, "Offset argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
 
 			return;
 		}
@@ -104,13 +104,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	
 	if (info.Length () > 3) {
 		if (! info[3].IsUint32 ()) {
-			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
 		unsigned int new_length = Napi::To<Uint32>(info[3])->Value();
 		if (new_length > length) {
-			Napi::RangeError::New(env, "Length argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
+			Napi::RangeError::New(env, "Length argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
 
 			return;
 		}
@@ -129,13 +129,13 @@ Napi::Value Htonl(const Napi::CallbackInfo& info) {
 	Napi::HandleScope scope(env);
 
 	if (info.Length () < 1) {
-		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[0].IsUint32 ()) {
-		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -150,13 +150,13 @@ Napi::Value Htons(const Napi::CallbackInfo& info) {
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
-		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[0].IsUint32 ()) {
-		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -164,7 +164,7 @@ Napi::Value Htons(const Napi::CallbackInfo& info) {
 	unsigned int number = Napi::To<Uint32>(info[0])->Value();
 	
 	if (number > 65535) {
-		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
+		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -178,13 +178,13 @@ Napi::Value Ntohl(const Napi::CallbackInfo& info) {
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
-		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[0].IsUint32 ()) {
-		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -199,13 +199,13 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info) {
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
-		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[0].IsUint32 ()) {
-		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -213,7 +213,7 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info) {
 	unsigned int number = Napi::To<Uint32>(info[0])->Value();
 	
 	if (number > 65535) {
-		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
+		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -370,19 +370,19 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
 	
 	if (info.Length () < 3) {
-		Napi::Error::New(env, "Three arguments are required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "Three arguments are required").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[0].IsNumber ()) {
-		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[1].IsNumber ()) {
-		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -394,7 +394,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	SOCKET_LEN_TYPE len;
 
 	if (! node::Buffer::HasInstance (info[2])) {
-		Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -403,7 +403,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	val = node::Buffer::Data (buffer);
 
 	if (! info[3].IsInt32 ()) {
-		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -414,7 +414,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 			(val ? val : (SOCKET_OPT_TYPE) &ival), &len);
 
 	if (rc == SOCKET_ERROR) {
-		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
+		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -460,13 +460,13 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 	int rc, family = AF_INET;
 	
 	if (info.Length () < 1) {
-		Napi::Error::New(env, "One argument is required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "One argument is required").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
 	if (! info[0].IsUint32 ()) {
-		Napi::TypeError::New(env, "Protocol argument must be an unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Protocol argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	} else {
@@ -475,7 +475,7 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 
 	if (info.Length () > 1) {
 		if (! info[1].IsUint32 ()) {
-			Napi::TypeError::New(env, "Address family argument must be an unsigned integer").ThrowAsJavaScriptException();
+			Napi::TypeError::New(env, "Address family argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		} else {
@@ -492,7 +492,7 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
-		Napi::Error::New(env, raw_strerror (rc)).ThrowAsJavaScriptException();
+		Napi::Error::New(env, raw_strerror (rc)).ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -512,20 +512,20 @@ Napi::Value SocketWrap::Pause(const Napi::CallbackInfo& info) {
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
 
 	if (info.Length () < 2) {
-		Napi::Error::New(env, "Two arguments are required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "Two arguments are required").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
 	if (! info[0].IsBoolean ()) {
-		Napi::TypeError::New(env, "Recv argument must be a boolean").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Recv argument must be a boolean").ThrowAsJavaScriptException();
 
 		return;
 	}
 	bool pause_recv = info[0].To<Napi::Boolean>()->Value();
 
 	if (! info[1].IsBoolean ()) {
-		Napi::TypeError::New(env, "Send argument must be a boolean").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Send argument must be a boolean").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -563,13 +563,13 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 #endif
 	
 	if (info.Length () < 2) {
-		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
 	if (! node::Buffer::HasInstance (info[0])) {
-		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
 		return;
 	} else {
@@ -577,14 +577,14 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	}
 
 	if (! info[1].IsFunction ()) {
-		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
-		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
+		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -602,7 +602,7 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	}
 	
 	if (rc == SOCKET_ERROR) {
-		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
+		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -634,44 +634,44 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 	char *data;
 	
 	if (info.Length () < 5) {
-		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
 	if (! node::Buffer::HasInstance (info[0])) {
-		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
 	if (! info[1].IsUint32 ()) {
-		Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[2].IsUint32 ()) {
-		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[3].IsString ()) {
-		Napi::TypeError::New(env, "Address argument must be a string").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Address argument must be a string").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[4].IsFunction ()) {
-		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
-		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
+		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -708,7 +708,7 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 	}
 	
 	if (rc == SOCKET_ERROR) {
-		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
+		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -728,19 +728,19 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
 	
 	if (info.Length () < 3) {
-		Napi::Error::New(env, "Three or four arguments are required").ThrowAsJavaScriptException();
+		Napi::Error::New(env, "Three or four arguments are required").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[0].IsNumber ()) {
-		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
 
 		return;
 	}
 
 	if (! info[1].IsNumber ()) {
-		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
+		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
 
 		return;
 	}
@@ -753,7 +753,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 
 	if (info.Length () > 3) {
 		if (! node::Buffer::HasInstance (info[2])) {
-			Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
+			Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
 
 			return;
 		}
@@ -762,7 +762,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 		val = node::Buffer::Data (buffer);
 
 		if (! info[3].IsInt32 ()) {
-			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
+			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
@@ -770,13 +770,13 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 		len = Napi::To<Uint32>(info[3])->Value();
 
 		if (len > node::Buffer::Length (buffer)) {
-			Napi::TypeError::New(env, "Length argument is larger than buffer length").ThrowAsJavaScriptException();
+			Napi::TypeError::New(env, "Length argument is larger than buffer length").ThrowAsJavaScriptException();
 
 			return;
 		}
 	} else {
 		if (! info[2].IsUint32 ()) {
-			Napi::TypeError::New(env, "Value argument must be a unsigned integer").ThrowAsJavaScriptException();
+			Napi::TypeError::New(env, "Value argument must be a unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
@@ -789,7 +789,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 			(val ? val : (SOCKET_OPT_TYPE) &ival), len);
 
 	if (rc == SOCKET_ERROR) {
-		Napi::Error::New(env, raw_strerror(SOCKET_ERRNO)).ThrowAsJavaScriptException();
+		Napi::Error::New(env, raw_strerror(SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
 		return;
 	}
diff --git a/src/raw.h b/src/raw.h
index 98d2b8a..022e67f 100644
--- a/src/raw.h
+++ b/src/raw.h
@@ -18,10 +18,10 @@
 
 #include <string>
 
-#include <napi.h>
+#include <napi.h>
 #include <uv.h>
 #include <node_buffer.h>
-#include <napi.h>
+#include <napi.h>
 #include <uv.h>
 
 #ifdef _WIN32

From b8b76f07a45aa0f13e7d2f9c50d6196ad66ce754 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 07:02:59 +0000
Subject: [PATCH 05/14] Pass through env

---
 src/raw.cc | 30 ++++++++++++++++++++++--------
 src/raw.h  |  6 +++---
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index 87f887d..8a68a9f 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -45,16 +45,19 @@ namespace raw {
 
 static Napi::FunctionReference SocketWrap_constructor;
 
-void InitAll (Napi::Object exports) {
-	ExportConstants (exports);
-	ExportFunctions (exports);
+Napi::Object InitAll (Napi::Env env, Napi::Object exports) {
+	ExportConstants (env, exports);
+	ExportFunctions (env, exports);
 
-	SocketWrap::Init (exports);
+	SocketWrap::Init (env, exports);
+
+	return exports;
 }
 
 NODE_API_MODULE(raw, InitAll)
 
 Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 2) {
@@ -126,6 +129,7 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value Htonl(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 
 	if (info.Length () < 1) {
@@ -147,6 +151,7 @@ Napi::Value Htonl(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value Htons(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
@@ -175,6 +180,7 @@ Napi::Value Htons(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value Ntohl(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
@@ -196,6 +202,7 @@ Napi::Value Ntohl(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value Ntohs(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	if (info.Length () < 1) {
@@ -223,7 +230,7 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info) {
 	return converted;
 }
 
-void ExportConstants (Napi::Object target) {
+void ExportConstants (Napi::Env env, Napi::Object target) {
 	Napi::Object socket_level = Napi::Object::New(env);
 	Napi::Object socket_option = Napi::Object::New(env);
 
@@ -257,7 +264,7 @@ void ExportConstants (Napi::Object target) {
 	(socket_option).Set(Napi::String::New(env, "IPV6_V6ONLY"), Napi::Number::New(env, IPV6_V6ONLY));
 }
 
-void ExportFunctions (Napi::Object target) {
+void ExportFunctions (Napi::Env env, Napi::Object target) {
 	(target).Set(Napi::String::New(env, "createChecksum"), Napi::GetFunction(Napi::Function::New(env, CreateChecksum)));
 	
 	(target).Set(Napi::String::New(env, "htonl"), Napi::GetFunction(Napi::Function::New(env, Htonl)));
@@ -266,7 +273,7 @@ void ExportFunctions (Napi::Object target) {
 	(target).Set(Napi::String::New(env, "ntohs"), Napi::GetFunction(Napi::Function::New(env, Ntohs)));
 }
 
-void SocketWrap::Init (Napi::Object exports) {
+void SocketWrap::Init (Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
 	Napi::FunctionReference tpl = Napi::Function::New(env, SocketWrap::New);
@@ -281,7 +288,7 @@ void SocketWrap::Init (Napi::Object exports) {
 	InstanceMethod("setOption", &SetOption),
 
 	SocketWrap_constructor.Reset(tpl);
-	(exports).Set(Napi::String::New(env, "SocketWrap"), Napi::GetFunction(tpl));
+	(exports).Set(Napi::String::New(env, "SocketWrap"), tpl);
 }
 
 SocketWrap::SocketWrap () {
@@ -294,6 +301,7 @@ SocketWrap::~SocketWrap () {
 }
 
 Napi::Value SocketWrap::Close(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
@@ -365,6 +373,7 @@ int SocketWrap::CreateSocket (void) {
 }
 
 Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
@@ -454,6 +463,7 @@ void SocketWrap::HandleIOEvent (int status, int revents) {
 }
 
 Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = new SocketWrap ();
@@ -507,6 +517,7 @@ void SocketWrap::OnClose (uv_handle_t *handle) {
 }
 
 Napi::Value SocketWrap::Pause(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
@@ -544,6 +555,7 @@ Napi::Value SocketWrap::Pause(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
@@ -624,6 +636,7 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
@@ -723,6 +736,7 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 }
 
 Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
+	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
diff --git a/src/raw.h b/src/raw.h
index 022e67f..df78168 100644
--- a/src/raw.h
+++ b/src/raw.h
@@ -53,8 +53,8 @@ namespace raw {
 
 Napi::Value CreateChecksum(const Napi::CallbackInfo& info);
 
-void ExportConstants (Napi::Object target);
-void ExportFunctions (Napi::Object target);
+void ExportConstants (Napi::Env env, Napi::Object target);
+void ExportFunctions (Napi::Env env, Napi::Object target);
 
 Napi::Value Htonl(const Napi::CallbackInfo& info);
 Napi::Value Htons(const Napi::CallbackInfo& info);
@@ -64,7 +64,7 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info);
 class SocketWrap : public Napi::ObjectWrap<SocketWrap> {
 public:
 	void HandleIOEvent (int status, int revents);
-	static void Init (Napi::Object exports);
+	static void Init (Napi::Env env, Napi::Object exports);
 
 private:
 	SocketWrap ();

From b647dd2a0c594536462f032341e398e5fe791a70 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 07:47:15 +0000
Subject: [PATCH 06/14] Migrate casts

---
 src/raw.cc | 94 +++++++++++++++++++++++++++---------------------------
 1 file changed, 47 insertions(+), 47 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index 8a68a9f..54bdcf2 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -66,13 +66,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 		return;
 	}
 
-	if (! info[0].IsUint32 ()) {
+	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Start with argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
-	uint32_t start_with = Napi::To<Uint32>(info[0])->Value();
+	uint32_t start_with = info[0].As<Napi::Number>();
 
 	if (start_with > 65535) {
 		Napi::RangeError::New(env, "Start with argument cannot be larger than 65535").ThrowAsJavaScriptException();
@@ -86,18 +86,18 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	Napi::Object buffer = info[1].To<Napi::Object>();
+	Napi::Object buffer = info[1].As<Napi::Object>();
 	char *data = node::Buffer::Data (buffer);
 	size_t length = node::Buffer::Length (buffer);
 	unsigned int offset = 0;
 	
 	if (info.Length () > 2) {
-		if (! info[2].IsUint32 ()) {
+		if (! info[2].IsNumber ()) {
 			Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
-		offset = Napi::To<Uint32>(info[2])->Value();
+		offset = info[2].As<Napi::Number>();
 		if (offset >= length) {
 			Napi::RangeError::New(env, "Offset argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
 
@@ -106,12 +106,12 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	}
 	
 	if (info.Length () > 3) {
-		if (! info[3].IsUint32 ()) {
+		if (! info[3].IsNumber ()) {
 			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
-		unsigned int new_length = Napi::To<Uint32>(info[3])->Value();
+		unsigned int new_length = info[3].As<Napi::Number>();
 		if (new_length > length) {
 			Napi::RangeError::New(env, "Length argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
 
@@ -138,13 +138,13 @@ Napi::Value Htonl(const Napi::CallbackInfo& info) {
 		return;
 	}
 
-	if (! info[0].IsUint32 ()) {
+	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 
-	unsigned int number = Napi::To<Uint32>(info[0])->Value();
+	unsigned int number = info[0].As<Napi::Number>();
 	Local<Uint32> converted = Napi::Uint32::New(env, (unsigned int) htonl (number));
 
 	return converted;
@@ -160,13 +160,13 @@ Napi::Value Htons(const Napi::CallbackInfo& info) {
 		return;
 	}
 
-	if (! info[0].IsUint32 ()) {
+	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
-	unsigned int number = Napi::To<Uint32>(info[0])->Value();
+	unsigned int number = info[0].As<Napi::Number>();
 	
 	if (number > 65535) {
 		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
@@ -189,13 +189,13 @@ Napi::Value Ntohl(const Napi::CallbackInfo& info) {
 		return;
 	}
 
-	if (! info[0].IsUint32 ()) {
+	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 
-	unsigned int number = Napi::To<Uint32>(info[0])->Value();
+	unsigned int number = info[0].As<Napi::Number>();
 	Local<Uint32> converted = Napi::Uint32::New(env, (unsigned int) ntohl (number));
 
 	return converted;
@@ -211,13 +211,13 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info) {
 		return;
 	}
 
-	if (! info[0].IsUint32 ()) {
+	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 	
-	unsigned int number = Napi::To<Uint32>(info[0])->Value();
+	unsigned int number = info[0].As<Napi::Number>();
 	
 	if (number > 65535) {
 		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
@@ -265,19 +265,19 @@ void ExportConstants (Napi::Env env, Napi::Object target) {
 }
 
 void ExportFunctions (Napi::Env env, Napi::Object target) {
-	(target).Set(Napi::String::New(env, "createChecksum"), Napi::GetFunction(Napi::Function::New(env, CreateChecksum)));
+	(target).Set(Napi::String::New(env, "createChecksum"), Napi::Function::New(env, CreateChecksum));
 	
-	(target).Set(Napi::String::New(env, "htonl"), Napi::GetFunction(Napi::Function::New(env, Htonl)));
-	(target).Set(Napi::String::New(env, "htons"), Napi::GetFunction(Napi::Function::New(env, Htons)));
-	(target).Set(Napi::String::New(env, "ntohl"), Napi::GetFunction(Napi::Function::New(env, Ntohl)));
-	(target).Set(Napi::String::New(env, "ntohs"), Napi::GetFunction(Napi::Function::New(env, Ntohs)));
+	(target).Set(Napi::String::New(env, "htonl"), Napi::Function::New(env, Htonl));
+	(target).Set(Napi::String::New(env, "htons"), Napi::Function::New(env, Htons));
+	(target).Set(Napi::String::New(env, "ntohl"), Napi::Function::New(env, Ntohl));
+	(target).Set(Napi::String::New(env, "ntohs"), Napi::Function::New(env, Ntohs));
 }
 
 void SocketWrap::Init (Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
-	Napi::FunctionReference tpl = Napi::Function::New(env, SocketWrap::New);
-	tpl->SetClassName(Napi::String::New(env, "SocketWrap"));
+	Napi::FunctionReference tpl = Napi::Persistent(Napi::Function::New(env, SocketWrap::New));
+	tpl.Value().SetClassName(Napi::String::New(env, "SocketWrap"));
 
 
 	InstanceMethod("close", &Close),
@@ -396,8 +396,8 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 		return;
 	}
 
-	int level = Napi::To<Uint32>(info[0])->Value();
-	int option = Napi::To<Uint32>(info[1])->Value();
+	int level = info[0].As<Napi::Number>();
+	int option = info[1].As<Napi::Number>();
 	SOCKET_OPT_TYPE val = NULL;
 	unsigned int ival = 0;
 	SOCKET_LEN_TYPE len;
@@ -408,10 +408,10 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	Napi::Object buffer = info[2].To<Napi::Object>();
+	Napi::Object buffer = info[2].As<Napi::Object>();
 	val = node::Buffer::Data (buffer);
 
-	if (! info[3].IsInt32 ()) {
+	if (! info[3].IsNumber ()) {
 		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
@@ -428,7 +428,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	Napi::Number got = Napi::Uint32::New(env, len);
+	Napi::Number got = Napi::Number::New(env, len);
 	
 	return got;
 }
@@ -475,21 +475,21 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	if (! info[0].IsUint32 ()) {
+	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Protocol argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	} else {
-		socket->protocol_ = Napi::To<Uint32>(info[0])->Value();
+		socket->protocol_ = info[0].As<Napi::Number>();
 	}
 
 	if (info.Length () > 1) {
-		if (! info[1].IsUint32 ()) {
+		if (! info[1].IsNumber ()) {
 			Napi::TypeError::New(env, "Address family argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		} else {
-			if (Napi::To<Uint32>(info[1])->Value() == 2)
+			if (uint32_t(info[1].As<Napi::Number>()) == 2)
 				family = AF_INET6;
 		}
 	}
@@ -533,14 +533,14 @@ Napi::Value SocketWrap::Pause(const Napi::CallbackInfo& info) {
 
 		return;
 	}
-	bool pause_recv = info[0].To<Napi::Boolean>()->Value();
+	bool pause_recv = info[0].As<Napi::Boolean>();
 
 	if (! info[1].IsBoolean ()) {
 		Napi::TypeError::New(env, "Send argument must be a boolean").ThrowAsJavaScriptException();
 
 		return;
 	}
-	bool pause_send = info[1].To<Napi::Boolean>()->Value();
+	bool pause_send = info[1].As<Napi::Boolean>();
 	
 	int events = (pause_recv ? 0 : UV_READABLE)
 			| (pause_send ? 0 : UV_WRITABLE);
@@ -585,7 +585,7 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 
 		return;
 	} else {
-		buffer = info[0].To<Napi::Object>();
+		buffer = info[0].As<Napi::Object>();
 	}
 
 	if (! info[1].IsFunction ()) {
@@ -639,7 +639,7 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
-	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
+	SocketWrap* socket = this;
 	Napi::Object buffer;
 	uint32_t offset;
 	uint32_t length;
@@ -658,13 +658,13 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	if (! info[1].IsUint32 ()) {
+	if (! info[1].IsNumber ()) {
 		Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
 	}
 
-	if (! info[2].IsUint32 ()) {
+	if (! info[2].IsNumber ()) {
 		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 		return;
@@ -689,9 +689,9 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	buffer = info[0].To<Napi::Object>();
-	offset = Napi::To<Uint32>(info[1])->Value();
-	length = Napi::To<Uint32>(info[2])->Value();
+	buffer = info[0].As<Napi::Object>();
+	offset = info[1].As<Napi::Number>();
+	length = info[2].As<Napi::Number>();
 
 	data = node::Buffer::Data (buffer) + offset;
 	
@@ -759,8 +759,8 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 		return;
 	}
 
-	int level = Napi::To<Uint32>(info[0])->Value();
-	int option = Napi::To<Uint32>(info[1])->Value();
+	int level = info[0].As<Napi::Number>();
+	int option = info[1].As<Napi::Number>();
 	SOCKET_OPT_TYPE val = NULL;
 	unsigned int ival = 0;
 	SOCKET_LEN_TYPE len;
@@ -772,16 +772,16 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 			return;
 		}
 		
-		Napi::Object buffer = info[2].To<Napi::Object>();
+		Napi::Object buffer = info[2].As<Napi::Object>();
 		val = node::Buffer::Data (buffer);
 
-		if (! info[3].IsInt32 ()) {
+		if (! info[3].IsNumber ()) {
 			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
 
-		len = Napi::To<Uint32>(info[3])->Value();
+		len = info[3].As<Napi::Number>();
 
 		if (len > node::Buffer::Length (buffer)) {
 			Napi::TypeError::New(env, "Length argument is larger than buffer length").ThrowAsJavaScriptException();
@@ -789,13 +789,13 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 			return;
 		}
 	} else {
-		if (! info[2].IsUint32 ()) {
+		if (! info[2].IsNumber ()) {
 			Napi::TypeError::New(env, "Value argument must be a unsigned integer").ThrowAsJavaScriptException();
 
 			return;
 		}
 
-		ival = Napi::To<Uint32>(info[2])->Value();
+		ival = info[2].As<Napi::Number>();
 		len = 4;
 	}
 

From 3130c0c142105f6b922bab3c6d1a364b8a25dcc1 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 07:53:59 +0000
Subject: [PATCH 07/14] Migrate Local numeric transformations

---
 src/raw.cc | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index 54bdcf2..a10662a 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -123,8 +123,7 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	uint16_t sum = checksum ((uint16_t) start_with,
 			(unsigned char *) data + offset, length);
 
-	Local<Integer> number = Napi::Uint32::New(env, sum);
-	
+	Napi::Number number = Napi::Number::New(env, sum);
 	return number;
 }
 
@@ -145,7 +144,7 @@ Napi::Value Htonl(const Napi::CallbackInfo& info) {
 	}
 
 	unsigned int number = info[0].As<Napi::Number>();
-	Local<Uint32> converted = Napi::Uint32::New(env, (unsigned int) htonl (number));
+	Napi::Number converted = Napi::Number::New(env, (unsigned int) htonl (number));
 
 	return converted;
 }
@@ -174,7 +173,7 @@ Napi::Value Htons(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	Local<Uint32> converted = Napi::Uint32::New(env, htons (number));
+	Napi::Number converted = Napi::Number::New(env, htons (number));
 
 	return converted;
 }
@@ -196,7 +195,7 @@ Napi::Value Ntohl(const Napi::CallbackInfo& info) {
 	}
 
 	unsigned int number = info[0].As<Napi::Number>();
-	Local<Uint32> converted = Napi::Uint32::New(env, (unsigned int) ntohl (number));
+	Napi::Number converted = Napi::Number::New(env, (unsigned int) ntohl (number));
 
 	return converted;
 }
@@ -225,7 +224,7 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info) {
 		return;
 	}
 	
-	Local<Uint32> converted = Napi::Uint32::New(env, htons (number));
+	Napi::Number converted = Napi::Number::New(env, ntohs (number));
 
 	return converted;
 }

From 1a707f055b82c52b3173f6abfd443ae6f308a4ae Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 08:00:14 +0000
Subject: [PATCH 08/14] Return undefined from throwing callbacks

---
 src/raw.cc | 106 ++++++++++++++++++++++++++---------------------------
 1 file changed, 53 insertions(+), 53 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index a10662a..6d9cdc4 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -63,13 +63,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	if (info.Length () < 2) {
 		Napi::Error::New(env, "At least one argument is required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Start with argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	uint32_t start_with = info[0].As<Napi::Number>();
@@ -77,13 +77,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 	if (start_with > 65535) {
 		Napi::RangeError::New(env, "Start with argument cannot be larger than 65535").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! node::Buffer::HasInstance (info[1])) {
 		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	Napi::Object buffer = info[1].As<Napi::Object>();
@@ -95,13 +95,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 		if (! info[2].IsNumber ()) {
 			Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 		offset = info[2].As<Napi::Number>();
 		if (offset >= length) {
 			Napi::RangeError::New(env, "Offset argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 	}
 	
@@ -109,13 +109,13 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 		if (! info[3].IsNumber ()) {
 			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 		unsigned int new_length = info[3].As<Napi::Number>();
 		if (new_length > length) {
 			Napi::RangeError::New(env, "Length argument must be smaller than length of the buffer").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 		length = new_length;
 	}
@@ -134,13 +134,13 @@ Napi::Value Htonl(const Napi::CallbackInfo& info) {
 	if (info.Length () < 1) {
 		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	unsigned int number = info[0].As<Napi::Number>();
@@ -156,13 +156,13 @@ Napi::Value Htons(const Napi::CallbackInfo& info) {
 	if (info.Length () < 1) {
 		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	unsigned int number = info[0].As<Napi::Number>();
@@ -170,7 +170,7 @@ Napi::Value Htons(const Napi::CallbackInfo& info) {
 	if (number > 65535) {
 		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	Napi::Number converted = Napi::Number::New(env, htons (number));
@@ -185,13 +185,13 @@ Napi::Value Ntohl(const Napi::CallbackInfo& info) {
 	if (info.Length () < 1) {
 		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 32 unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	unsigned int number = info[0].As<Napi::Number>();
@@ -207,13 +207,13 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info) {
 	if (info.Length () < 1) {
 		Napi::Error::New(env, "One arguments is required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Number must be a 16 unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	unsigned int number = info[0].As<Napi::Number>();
@@ -221,7 +221,7 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info) {
 	if (number > 65535) {
 		Napi::RangeError::New(env, "Number cannot be larger than 65535").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	Napi::Number converted = Napi::Number::New(env, ntohs (number));
@@ -380,19 +380,19 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	if (info.Length () < 3) {
 		Napi::Error::New(env, "Three arguments are required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[1].IsNumber ()) {
 		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	int level = info[0].As<Napi::Number>();
@@ -404,7 +404,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	if (! node::Buffer::HasInstance (info[2])) {
 		Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	Napi::Object buffer = info[2].As<Napi::Object>();
@@ -413,7 +413,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	if (! info[3].IsNumber ()) {
 		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	len = (SOCKET_LEN_TYPE) node::Buffer::Length (buffer);
@@ -424,7 +424,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	if (rc == SOCKET_ERROR) {
 		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	Napi::Number got = Napi::Number::New(env, len);
@@ -471,13 +471,13 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 	if (info.Length () < 1) {
 		Napi::Error::New(env, "One argument is required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Protocol argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	} else {
 		socket->protocol_ = info[0].As<Napi::Number>();
 	}
@@ -486,7 +486,7 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 		if (! info[1].IsNumber ()) {
 			Napi::TypeError::New(env, "Address family argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		} else {
 			if (uint32_t(info[1].As<Napi::Number>()) == 2)
 				family = AF_INET6;
@@ -503,7 +503,7 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 	if (rc != 0) {
 		Napi::Error::New(env, raw_strerror (rc)).ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	socket->Wrap (info.This ());
@@ -524,20 +524,20 @@ Napi::Value SocketWrap::Pause(const Napi::CallbackInfo& info) {
 	if (info.Length () < 2) {
 		Napi::Error::New(env, "Two arguments are required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	if (! info[0].IsBoolean ()) {
 		Napi::TypeError::New(env, "Recv argument must be a boolean").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	bool pause_recv = info[0].As<Napi::Boolean>();
 
 	if (! info[1].IsBoolean ()) {
 		Napi::TypeError::New(env, "Send argument must be a boolean").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	bool pause_send = info[1].As<Napi::Boolean>();
 	
@@ -571,18 +571,18 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	socklen_t sin_length = socket->family_ == AF_INET6
 			? sizeof (sin6_address)
 			: sizeof (sin_address);
-#endif
+#endif

 	
 	if (info.Length () < 2) {
 		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	if (! node::Buffer::HasInstance (info[0])) {
 		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	} else {
 		buffer = info[0].As<Napi::Object>();
 	}
@@ -590,14 +590,14 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	if (! info[1].IsFunction ()) {
 		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
 		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (socket->family_ == AF_INET6) {
@@ -615,7 +615,7 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	if (rc == SOCKET_ERROR) {
 		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	if (socket->family_ == AF_INET6)
@@ -648,44 +648,44 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 	if (info.Length () < 5) {
 		Napi::Error::New(env, "Five arguments are required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	if (! node::Buffer::HasInstance (info[0])) {
 		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	if (! info[1].IsNumber ()) {
 		Napi::TypeError::New(env, "Offset argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[2].IsNumber ()) {
 		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[3].IsString ()) {
 		Napi::TypeError::New(env, "Address argument must be a string").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[4].IsFunction ()) {
 		Napi::TypeError::New(env, "Callback argument must be a function").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	rc = socket->CreateSocket ();
 	if (rc != 0) {
 		Napi::Error::New(env, raw_strerror (errno)).ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	buffer = info[0].As<Napi::Object>();
@@ -722,7 +722,7 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 	if (rc == SOCKET_ERROR) {
 		Napi::Error::New(env, raw_strerror (SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	Napi::Function cb = Napi::Function::Cast (info[4]);
@@ -743,19 +743,19 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 	if (info.Length () < 3) {
 		Napi::Error::New(env, "Three or four arguments are required").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Level argument must be a number").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	if (! info[1].IsNumber ()) {
 		Napi::TypeError::New(env, "Option argument must be a number").ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 
 	int level = info[0].As<Napi::Number>();
@@ -768,7 +768,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 		if (! node::Buffer::HasInstance (info[2])) {
 			Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 		
 		Napi::Object buffer = info[2].As<Napi::Object>();
@@ -777,7 +777,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 		if (! info[3].IsNumber ()) {
 			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 
 		len = info[3].As<Napi::Number>();
@@ -785,13 +785,13 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 		if (len > node::Buffer::Length (buffer)) {
 			Napi::TypeError::New(env, "Length argument is larger than buffer length").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 	} else {
 		if (! info[2].IsNumber ()) {
 			Napi::TypeError::New(env, "Value argument must be a unsigned integer").ThrowAsJavaScriptException();
 
-			return;
+			return env.Undefined();
 		}
 
 		ival = info[2].As<Napi::Number>();
@@ -804,7 +804,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 	if (rc == SOCKET_ERROR) {
 		Napi::Error::New(env, raw_strerror(SOCKET_ERRNO)).ThrowAsJavaScriptException();
 
-		return;
+		return env.Undefined();
 	}
 	
 	return info.This();

From 91ca57b7a2db92eb33862ad18ea5120f460f0c98 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 08:08:13 +0000
Subject: [PATCH 09/14] Migrate Buffer operations

---
 src/raw.cc | 48 ++++++++++++++++++++++++------------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index 6d9cdc4..ee49093 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -80,15 +80,15 @@ Napi::Value CreateChecksum(const Napi::CallbackInfo& info) {
 		return env.Undefined();
 	}
 
-	if (! node::Buffer::HasInstance (info[1])) {
+	if (! info[1].IsBuffer()) {
 		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
 		return env.Undefined();
 	}
 	
-	Napi::Object buffer = info[1].As<Napi::Object>();
-	char *data = node::Buffer::Data (buffer);
-	size_t length = node::Buffer::Length (buffer);
+	Napi::Buffer<char> buffer = info[1].As<Napi::Buffer<char> >();
+	char *data = buffer.Data();
+	size_t length = buffer.Length();
 	unsigned int offset = 0;
 	
 	if (info.Length () > 2) {
@@ -401,14 +401,14 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	unsigned int ival = 0;
 	SOCKET_LEN_TYPE len;
 
-	if (! node::Buffer::HasInstance (info[2])) {
+	if (! info[2].IsBuffer()) {
 		Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
 
 		return env.Undefined();
 	}
 	
-	Napi::Object buffer = info[2].As<Napi::Object>();
-	val = node::Buffer::Data (buffer);
+	Napi::Buffer<char> buffer = info[2].As<Napi::Buffer<char> >();
+	val = buffer.Data();
 
 	if (! info[3].IsNumber ()) {
 		Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
@@ -416,7 +416,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 		return env.Undefined();
 	}
 
-	len = (SOCKET_LEN_TYPE) node::Buffer::Length (buffer);
+	len = (SOCKET_LEN_TYPE) buffer.Length();
 
 	int rc = getsockopt (socket->poll_fd_, level, option,
 			(val ? val : (SOCKET_OPT_TYPE) &ival), &len);
@@ -557,8 +557,8 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
-	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
-	Napi::Object buffer;
+	SocketWrap* socket = this;
+	Napi::Buffer<char> buffer;
 	sockaddr_in sin_address;
 	sockaddr_in6 sin6_address;
 	char addr[50];
@@ -579,12 +579,12 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 		return env.Undefined();
 	}
 	
-	if (! node::Buffer::HasInstance (info[0])) {
+	if (! info[0].IsBuffer()) {
 		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
 		return env.Undefined();
 	} else {
-		buffer = info[0].As<Napi::Object>();
+		buffer = info[0].As<Napi::Buffer<char> >();
 	}
 
 	if (! info[1].IsFunction ()) {
@@ -602,13 +602,13 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 
 	if (socket->family_ == AF_INET6) {
 		memset (&sin6_address, 0, sizeof (sin6_address));
-		rc = recvfrom (socket->poll_fd_, node::Buffer::Data (buffer),
-				(int) node::Buffer::Length (buffer), 0, (sockaddr *) &sin6_address,
+		rc = recvfrom (socket->poll_fd_, buffer.Data(),
+				(int) buffer.Length(), 0, (sockaddr *) &sin6_address,
 				&sin_length);
 	} else {
 		memset (&sin_address, 0, sizeof (sin_address));
-		rc = recvfrom (socket->poll_fd_, node::Buffer::Data (buffer),
-				(int) node::Buffer::Length (buffer), 0, (sockaddr *) &sin_address,
+		rc = recvfrom (socket->poll_fd_, buffer.Data(),
+				(int) buffer.Length(), 0, (sockaddr *) &sin_address,
 				&sin_length);
 	}
 	
@@ -639,7 +639,7 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 	Napi::HandleScope scope(env);
 	
 	SocketWrap* socket = this;
-	Napi::Object buffer;
+	Napi::Buffer<char> buffer;
 	uint32_t offset;
 	uint32_t length;
 	int rc;
@@ -651,7 +651,7 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 		return env.Undefined();
 	}
 	
-	if (! node::Buffer::HasInstance (info[0])) {
+	if (! info[0].IsBuffer()) {
 		Napi::TypeError::New(env, "Buffer argument must be a node Buffer object").ThrowAsJavaScriptException();
 
 		return env.Undefined();
@@ -688,11 +688,11 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 		return env.Undefined();
 	}
 	
-	buffer = info[0].As<Napi::Object>();
+	buffer = info[0].As<Napi::Buffer<char> >();
 	offset = info[1].As<Napi::Number>();
 	length = info[2].As<Napi::Number>();
 
-	data = node::Buffer::Data (buffer) + offset;
+	data = buffer.Data() + offset;
 	
 	if (socket->family_ == AF_INET6) {
 #if UV_VERSION_MAJOR > 0
@@ -765,14 +765,14 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 	SOCKET_LEN_TYPE len;
 
 	if (info.Length () > 3) {
-		if (! node::Buffer::HasInstance (info[2])) {
+		if (! info[2].IsBuffer()) {
 			Napi::TypeError::New(env, "Value argument must be a node Buffer object if length is provided").ThrowAsJavaScriptException();
 
 			return env.Undefined();
 		}
 		
-		Napi::Object buffer = info[2].As<Napi::Object>();
-		val = node::Buffer::Data (buffer);
+		Napi::Buffer<char> buffer = info[2].As<Napi::Buffer<char> >();
+		val = buffer.Data();
 
 		if (! info[3].IsNumber ()) {
 			Napi::TypeError::New(env, "Length argument must be an unsigned integer").ThrowAsJavaScriptException();
@@ -782,7 +782,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 
 		len = info[3].As<Napi::Number>();
 
-		if (len > node::Buffer::Length (buffer)) {
+		if (len > buffer.Length()) {
 			Napi::TypeError::New(env, "Length argument is larger than buffer length").ThrowAsJavaScriptException();
 
 			return env.Undefined();

From 404e361a3a59b2230fc063ee9775862fa79e2b45 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 08:30:26 +0000
Subject: [PATCH 10/14] Fix InstanceMethod migration syntax

---
 src/raw.cc | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index ee49093..e31e5bc 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -279,12 +279,12 @@ void SocketWrap::Init (Napi::Env env, Napi::Object exports) {
 	tpl.Value().SetClassName(Napi::String::New(env, "SocketWrap"));
 
 
-	InstanceMethod("close", &Close),
-	InstanceMethod("getOption", &GetOption),
-	InstanceMethod("pause", &Pause),
-	InstanceMethod("recv", &Recv),
-	InstanceMethod("send", &Send),
-	InstanceMethod("setOption", &SetOption),
+	InstanceMethod("close", &Close);
+	InstanceMethod("getOption", &GetOption);
+	InstanceMethod("pause", &Pause);
+	InstanceMethod("recv", &Recv);
+	InstanceMethod("send", &Send);
+	InstanceMethod("setOption", &SetOption);
 
 	SocketWrap_constructor.Reset(tpl);
 	(exports).Set(Napi::String::New(env, "SocketWrap"), tpl);

From c3236d5dda10b9fbc42d883500351c16b26651b8 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 08:58:41 +0000
Subject: [PATCH 11/14] Migrate class following instructions from "Major
 Reconstructions" in NAPI README

---
 src/raw.cc | 49 ++++++++++++++++++++-----------------------------
 src/raw.h  | 21 ++++++++++-----------
 2 files changed, 30 insertions(+), 40 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index e31e5bc..dce09f4 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -275,25 +275,20 @@ void ExportFunctions (Napi::Env env, Napi::Object target) {
 void SocketWrap::Init (Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
 
-	Napi::FunctionReference tpl = Napi::Persistent(Napi::Function::New(env, SocketWrap::New));
-	tpl.Value().SetClassName(Napi::String::New(env, "SocketWrap"));
+	Napi::Function tpl = DefineClass(env, "SocketWrap", {
+			InstanceMethod<&SocketWrap::Close>("close"),
+			InstanceMethod<&SocketWrap::GetOption>("getOption"),
+			InstanceMethod<&SocketWrap::Pause>("pause"),
+			InstanceMethod<&SocketWrap::Recv>("recv"),
+			InstanceMethod<&SocketWrap::Send>("send"),
+			InstanceMethod<&SocketWrap::SetOption>("setOption")
+	});
+	SocketWrap_constructor = Napi::Persistent(tpl);
+	SocketWrap_constructor.SuppressDestruct();
 
-
-	InstanceMethod("close", &Close);
-	InstanceMethod("getOption", &GetOption);
-	InstanceMethod("pause", &Pause);
-	InstanceMethod("recv", &Recv);
-	InstanceMethod("send", &Send);
-	InstanceMethod("setOption", &SetOption);
-
-	SocketWrap_constructor.Reset(tpl);
 	(exports).Set(Napi::String::New(env, "SocketWrap"), tpl);
 }
 
-SocketWrap::SocketWrap () {
-	deconstructing_ = false;
-}
-
 SocketWrap::~SocketWrap () {
 	deconstructing_ = true;
 	this->CloseSocket ();
@@ -303,7 +298,7 @@ Napi::Value SocketWrap::Close(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
-	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
+	SocketWrap* socket = this;
 	
 	socket->CloseSocket ();
 
@@ -375,7 +370,7 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
-	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
+	SocketWrap* socket = this;
 	
 	if (info.Length () < 3) {
 		Napi::Error::New(env, "Three arguments are required").ThrowAsJavaScriptException();
@@ -461,23 +456,23 @@ void SocketWrap::HandleIOEvent (int status, int revents) {
 	}
 }
 
-Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
+SocketWrap::SocketWrap(const Napi::CallbackInfo& info) : Napi::ObjectWrap<SocketWrap>(info), deconstructing_(false) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
-	SocketWrap* socket = new SocketWrap ();
+	SocketWrap* socket = this;
 	int rc, family = AF_INET;
 	
 	if (info.Length () < 1) {
 		Napi::Error::New(env, "One argument is required").ThrowAsJavaScriptException();
 
-		return env.Undefined();
+		return;
 	}
 	
 	if (! info[0].IsNumber ()) {
 		Napi::TypeError::New(env, "Protocol argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-		return env.Undefined();
+		return;
 	} else {
 		socket->protocol_ = info[0].As<Napi::Number>();
 	}
@@ -486,7 +481,7 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 		if (! info[1].IsNumber ()) {
 			Napi::TypeError::New(env, "Address family argument must be an unsigned integer").ThrowAsJavaScriptException();
 
-			return env.Undefined();
+			return;
 		} else {
 			if (uint32_t(info[1].As<Napi::Number>()) == 2)
 				family = AF_INET6;
@@ -503,12 +498,8 @@ Napi::Value SocketWrap::New(const Napi::CallbackInfo& info) {
 	if (rc != 0) {
 		Napi::Error::New(env, raw_strerror (rc)).ThrowAsJavaScriptException();
 
-		return env.Undefined();
+		return;
 	}
-
-	socket->Wrap (info.This ());
-
-	return info.This();
 }
 
 void SocketWrap::OnClose (uv_handle_t *handle) {
@@ -519,7 +510,7 @@ Napi::Value SocketWrap::Pause(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
-	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
+	SocketWrap* socket = this;
 
 	if (info.Length () < 2) {
 		Napi::Error::New(env, "Two arguments are required").ThrowAsJavaScriptException();
@@ -738,7 +729,7 @@ Napi::Value SocketWrap::SetOption(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 	
-	SocketWrap* socket = SocketWrap::Unwrap<SocketWrap> (info.This ());
+	SocketWrap* socket = this;
 	
 	if (info.Length () < 3) {
 		Napi::Error::New(env, "Three or four arguments are required").ThrowAsJavaScriptException();
diff --git a/src/raw.h b/src/raw.h
index df78168..2847235 100644
--- a/src/raw.h
+++ b/src/raw.h
@@ -63,29 +63,28 @@ Napi::Value Ntohs(const Napi::CallbackInfo& info);
 
 class SocketWrap : public Napi::ObjectWrap<SocketWrap> {
 public:
+	SocketWrap(const Napi::CallbackInfo& info);
+	virtual ~SocketWrap ();
+
 	void HandleIOEvent (int status, int revents);
 	static void Init (Napi::Env env, Napi::Object exports);
 
-private:
-	SocketWrap ();
-	~SocketWrap ();
 
-	static Napi::Value Close(const Napi::CallbackInfo& info);
+private:
+	Napi::Value Close(const Napi::CallbackInfo& info);
 
 	void CloseSocket (void);
 	
 	int CreateSocket (void);
 
-	static Napi::Value GetOption(const Napi::CallbackInfo& info);
-
-	static Napi::Value New(const Napi::CallbackInfo& info);
+	Napi::Value GetOption(const Napi::CallbackInfo& info);
 
 	static void OnClose (uv_handle_t *handle);
 
-	static Napi::Value Pause(const Napi::CallbackInfo& info);
-	static Napi::Value Recv(const Napi::CallbackInfo& info);
-	static Napi::Value Send(const Napi::CallbackInfo& info);
-	static Napi::Value SetOption(const Napi::CallbackInfo& info);
+	Napi::Value Pause(const Napi::CallbackInfo& info);
+	Napi::Value Recv(const Napi::CallbackInfo& info);
+	Napi::Value Send(const Napi::CallbackInfo& info);
+	Napi::Value SetOption(const Napi::CallbackInfo& info);
 
 	bool no_ip_header_;
 

From 455525ff7a32b5db51be95f6beabb4ac9095b6a2 Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 10:01:45 +0000
Subject: [PATCH 12/14] Migrate HandleIOEvent environment and handle
 passthrough

---
 src/raw.cc | 5 +++++
 src/raw.h  | 2 ++
 2 files changed, 7 insertions(+)

diff --git a/src/raw.cc b/src/raw.cc
index dce09f4..72146f4 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -427,7 +427,12 @@ Napi::Value SocketWrap::GetOption(const Napi::CallbackInfo& info) {
 	return got;
 }
 
+Napi::Value SocketWrap::handle() {
+	return Value();
+}
+
 void SocketWrap::HandleIOEvent (int status, int revents) {
+	Napi::Env env = Env();
 	Napi::HandleScope scope(env);
 
 	if (status) {
diff --git a/src/raw.h b/src/raw.h
index 2847235..3de5c6b 100644
--- a/src/raw.h
+++ b/src/raw.h
@@ -86,6 +86,8 @@ class SocketWrap : public Napi::ObjectWrap<SocketWrap> {
 	Napi::Value Send(const Napi::CallbackInfo& info);
 	Napi::Value SetOption(const Napi::CallbackInfo& info);
 
+	Napi::Value handle();
+
 	bool no_ip_header_;
 
 	uint32_t family_;

From fc260f5c51805ecba787cb15dd75e4bad0f3a9db Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 10:29:41 +0000
Subject: [PATCH 13/14] Migrate calls and function casts

---
 src/raw.cc | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/raw.cc b/src/raw.cc
index 72146f4..cb51e5f 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -305,11 +305,10 @@ Napi::Value SocketWrap::Close(const Napi::CallbackInfo& info) {
 	Napi::Value args[1];
 	args[0] = Napi::String::New(env, "close");
 
-	Napi::Call(Napi::String::New(env, "emit"), info.This(), 1, args);
+	Napi::Value(info.This().As<Napi::Object>()["emit"]).As<Napi::Function>().Call(info.This(), std::initializer_list<napi_value>{ args[0] });
 
 	return info.This();
 }
-
 void SocketWrap::CloseSocket (void) {
 	if (this->poll_initialised_) {
 		uv_close ((uv_handle_t *) this->poll_watcher_, OnClose);
@@ -447,9 +446,10 @@ void SocketWrap::HandleIOEvent (int status, int revents) {
 		 **/
 		char status_str[32];
 		sprintf(status_str, "%d", status);
-		args[1] = Napi::Error::New(env, status_str);
+		Napi::Error error = Napi::Error::New(env, status_str);
+		args[1] = error.Value();
 
-		Napi::Call(Napi::String::New(env, "emit"), handle(), 1, args);
+		Napi::Value(handle().As<Napi::Object>()["emit"]).As<Napi::Function>().Call(handle(), std::initializer_list<napi_value>{ args[0] });
 	} else {
 		Napi::Value args[1];
 		if (revents & UV_READABLE)
@@ -457,7 +457,7 @@ void SocketWrap::HandleIOEvent (int status, int revents) {
 		else
 			args[0] = Napi::String::New(env, "sendReady");
 
-		Napi::Call(Napi::String::New(env, "emit"), handle(), 1, args);
+		Napi::Value(handle().As<Napi::Object>()["emit"]).As<Napi::Function>().Call(handle(), std::initializer_list<napi_value>{ args[0] });
 	}
 }
 
@@ -619,13 +619,13 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	else
 		uv_ip4_name (&sin_address, addr, 50);
 	
-	Napi::Function cb = Napi::Function::Cast (info[1]);
+	Napi::Function cb = info[1].As<Napi::Function>();
 	const unsigned argc = 3;
 	Napi::Value argv[argc];
 	argv[0] = info[0];
 	argv[1] = Napi::Number::New(env, rc);
 	argv[2] = Napi::New(env, addr);
-	Napi::Call(Napi::FunctionReference(cb), argc, argv);
+	cb.Call(std::initializer_list<napi_value>{ argv[0], argv[1], argv[2] });
 	
 	return info.This();
 }
@@ -721,12 +721,12 @@ Napi::Value SocketWrap::Send(const Napi::CallbackInfo& info) {
 		return env.Undefined();
 	}
 	
-	Napi::Function cb = Napi::Function::Cast (info[4]);
+	Napi::Function cb = info[4].As<Napi::Function>();
 	const unsigned argc = 1;
 	Napi::Value argv[argc];
 	argv[0] = Napi::Number::New(env, rc);
-	Napi::Call(Napi::FunctionReference(cb), argc, argv);
 	
+	cb.Call(std::initializer_list<napi_value>{ argv[0] });
 	return info.This();
 }
 

From 86c26c754e6242042e927719ff733a203f437c5e Mon Sep 17 00:00:00 2001
From: Sergey Zakharchenko <szakharchenko@digital-loggers.com>
Date: Wed, 11 Aug 2021 10:49:05 +0000
Subject: [PATCH 14/14] Resolve former application of Nan::New: we're creating
 a string from ASCIZ here

---
 src/raw.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/raw.cc b/src/raw.cc
index cb51e5f..283c069 100644
--- a/src/raw.cc
+++ b/src/raw.cc
@@ -624,7 +624,7 @@ Napi::Value SocketWrap::Recv(const Napi::CallbackInfo& info) {
 	Napi::Value argv[argc];
 	argv[0] = info[0];
 	argv[1] = Napi::Number::New(env, rc);
-	argv[2] = Napi::New(env, addr);
+	argv[2] = Napi::String::New(env, addr);
 	cb.Call(std::initializer_list<napi_value>{ argv[0], argv[1], argv[2] });
 	
 	return info.This();