diff --git a/src/BackgroundSubtractor.cc b/src/BackgroundSubtractor.cc
index 27bc4e3..8ebecd5 100644
--- a/src/BackgroundSubtractor.cc
+++ b/src/BackgroundSubtractor.cc
@@ -66,7 +66,7 @@ void BackgroundSubtractorWrap::Init(Local<Object> target) {
   Nan::SetPrototypeMethod(ctor, "noiseSigma", NoiseSigma);
   Nan::SetPrototypeMethod(ctor, "backgroundRatio", BackgroundRatio);
 
-  target->Set(Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("BackgroundSubtractor").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(BackgroundSubtractorWrap::New) {
diff --git a/src/Calib3D.cc b/src/Calib3D.cc
index b4d2745..ef73f2d 100644
--- a/src/Calib3D.cc
+++ b/src/Calib3D.cc
@@ -14,8 +14,8 @@ inline cv::Size sizeFromArray(Local<Value> jsArray) {
   if (jsArray->IsArray()) {
     Local<Object> v8sz = jsArray->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
 
-    patternSize = cv::Size(v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-        v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+    patternSize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
+        v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
   } else {
     JSTHROW_TYPE("Size is not a valid array");
   }
@@ -50,7 +50,7 @@ inline std::vector<cv::Point3f> points3fFromArray(Local<Value> array) {
     Local<Array> pointsArray = Local<Array>::Cast(array->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
 
     for (unsigned int i = 0; i < pointsArray->Length(); i++) {
-      Local<Object> pt = pointsArray->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+      Local<Object> pt = pointsArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
       points.push_back(
           cv::Point3f(
               Nan::To<double>(Nan::Get(pt, Nan::New<String>("x").ToLocalChecked()).ToLocalChecked()).FromJust(),
@@ -73,7 +73,7 @@ inline std::vector<std::vector<cv::Point2f> > points2fFromArrayOfArrays(
     Local<Array> pointsArray = Local<Array>::Cast(array->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
 
     for (unsigned int i = 0; i < pointsArray->Length(); i++) {
-      points.push_back(points2fFromArray(pointsArray->Get(i)));
+      points.push_back(points2fFromArray(pointsArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()));
     }
   } else {
     JSTHROW_TYPE("Must pass array of object points for each frame")
@@ -89,7 +89,7 @@ inline std::vector<std::vector<cv::Point3f> > points3fFromArrayOfArrays(
     Local<Array> pointsArray = Local<Array>::Cast(array->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
 
     for (unsigned int i = 0; i < pointsArray->Length(); i++) {
-      points.push_back(points3fFromArray(pointsArray->Get(i)));
+      points.push_back(points3fFromArray(pointsArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()));
     }
   } else {
     JSTHROW_TYPE("Must pass array of object points for each frame")
@@ -113,7 +113,7 @@ void Calib3D::Init(Local<Object> target) {
   Nan::SetMethod(obj, "computeCorrespondEpilines", ComputeCorrespondEpilines);
   Nan::SetMethod(obj, "reprojectImageTo3d", ReprojectImageTo3D);
 
-  target->Set(Nan::New("calib3d").ToLocalChecked(), obj);
+  target->Set(Nan::GetCurrentContext(), Nan::New("calib3d").ToLocalChecked(), obj);
 }
 
 // cv::findChessboardCorners
@@ -138,18 +138,18 @@ NAN_METHOD(Calib3D::FindChessboardCorners) {
 
     // Make the return value
     Local<Object> ret = Nan::New<Object>();
-    ret->Set(Nan::New<String>("found").ToLocalChecked(), Nan::New<Boolean>(found));
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("found").ToLocalChecked(), Nan::New<Boolean>(found));
 
     Local<Array> cornersArray = Nan::New<Array>(corners.size());
     for (unsigned int i = 0; i < corners.size(); i++) {
       Local<Object> point_data = Nan::New<Object>();
-      point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(corners[i].x));
-      point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(corners[i].y));
+      point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(corners[i].x));
+      point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(corners[i].y));
 
-      cornersArray->Set(Nan::New<Number>(i), point_data);
+      cornersArray->Set(Nan::GetCurrentContext(), Nan::New<Number>(i), point_data);
     }
 
-    ret->Set(Nan::New<String>("corners").ToLocalChecked(), cornersArray);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("corners").ToLocalChecked(), cornersArray);
 
     info.GetReturnValue().Set(ret);
   } catch (cv::Exception &e) {
@@ -225,15 +225,15 @@ NAN_METHOD(Calib3D::CalibrateCamera) {
     Local<Object> ret = Nan::New<Object>();
 
     // Reprojection error
-    ret->Set(Nan::New<String>("reprojectionError").ToLocalChecked(), Nan::New<Number>(error));
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("reprojectionError").ToLocalChecked(), Nan::New<Number>(error));
 
     // K
     Local<Object> KMatrixWrap = Matrix::CreateWrappedFromMat(K);
-    ret->Set(Nan::New<String>("K").ToLocalChecked(), KMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("K").ToLocalChecked(), KMatrixWrap);
 
     // dist
     Local<Object> distMatrixWrap = Matrix::CreateWrappedFromMat(dist);
-    ret->Set(Nan::New<String>("distortion").ToLocalChecked(), distMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("distortion").ToLocalChecked(), distMatrixWrap);
 
     // Per frame R and t, skiping for now
 
@@ -279,11 +279,11 @@ NAN_METHOD(Calib3D::SolvePnP) {
 
     // rvec
     Local<Object> rMatrixWrap = Matrix::CreateWrappedFromMat(rvec);
-    ret->Set(Nan::New<String>("rvec").ToLocalChecked(), rMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("rvec").ToLocalChecked(), rMatrixWrap);
 
     // tvec
     Local<Object> tMatrixWrap = Matrix::CreateWrappedFromMat(tvec);
-    ret->Set(Nan::New<String>("tvec").ToLocalChecked(), tMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("tvec").ToLocalChecked(), tMatrixWrap);
 
     // Return
     info.GetReturnValue().Set(ret);
@@ -409,14 +409,14 @@ NAN_METHOD(Calib3D::StereoCalibrate) {
     Local<Object> FMatrixWrap = Matrix::CreateWrappedFromMat(F);
 
     // Add to return object
-    ret->Set(Nan::New<String>("K1").ToLocalChecked(), K1MatrixWrap);
-    ret->Set(Nan::New<String>("distortion1").ToLocalChecked(), d1MatrixWrap);
-    ret->Set(Nan::New<String>("K2").ToLocalChecked(), K2MatrixWrap);
-    ret->Set(Nan::New<String>("distortion2").ToLocalChecked(), d2MatrixWrap);
-    ret->Set(Nan::New<String>("R").ToLocalChecked(), RMatrixWrap);
-    ret->Set(Nan::New<String>("t").ToLocalChecked(), tMatrixWrap);
-    ret->Set(Nan::New<String>("E").ToLocalChecked(), EMatrixWrap);
-    ret->Set(Nan::New<String>("F").ToLocalChecked(), FMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("K1").ToLocalChecked(), K1MatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("distortion1").ToLocalChecked(), d1MatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("K2").ToLocalChecked(), K2MatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("distortion2").ToLocalChecked(), d2MatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("R").ToLocalChecked(), RMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("t").ToLocalChecked(), tMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("E").ToLocalChecked(), EMatrixWrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("F").ToLocalChecked(), FMatrixWrap);
 
     // Return
     info.GetReturnValue().Set(ret);
@@ -470,11 +470,11 @@ NAN_METHOD(Calib3D::StereoRectify) {
     // Make the return object
     Local<Object> ret = Nan::New<Object>();
 
-    ret->Set(Nan::New<String>("R1").ToLocalChecked(), Matrix::CreateWrappedFromMat(R1));
-    ret->Set(Nan::New<String>("R2").ToLocalChecked(), Matrix::CreateWrappedFromMat(R2));
-    ret->Set(Nan::New<String>("P1").ToLocalChecked(), Matrix::CreateWrappedFromMat(P1));
-    ret->Set(Nan::New<String>("P2").ToLocalChecked(), Matrix::CreateWrappedFromMat(P2));
-    ret->Set(Nan::New<String>("Q").ToLocalChecked(), Matrix::CreateWrappedFromMat(Q));
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("R1").ToLocalChecked(), Matrix::CreateWrappedFromMat(R1));
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("R2").ToLocalChecked(), Matrix::CreateWrappedFromMat(R2));
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("P1").ToLocalChecked(), Matrix::CreateWrappedFromMat(P1));
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("P2").ToLocalChecked(), Matrix::CreateWrappedFromMat(P2));
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("Q").ToLocalChecked(), Matrix::CreateWrappedFromMat(Q));
 
     // Return the rectification parameters
     info.GetReturnValue().Set(ret);
@@ -510,11 +510,11 @@ NAN_METHOD(Calib3D::ComputeCorrespondEpilines) {
     for(unsigned int i = 0; i < lines.size(); i++)
     {
       Local<Object> line_data = Nan::New<Object>();
-      line_data->Set(Nan::New<String>("a").ToLocalChecked(), Nan::New<Number>(lines[i][0]));
-      line_data->Set(Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(lines[i][1]));
-      line_data->Set(Nan::New<String>("c").ToLocalChecked(), Nan::New<Number>(lines[i][2]));
+      line_data->Set(Nan::GetCurrentContext(), Nan::New<String>("a").ToLocalChecked(), Nan::New<Number>(lines[i][0]));
+      line_data->Set(Nan::GetCurrentContext(), Nan::New<String>("b").ToLocalChecked(), Nan::New<Number>(lines[i][1]));
+      line_data->Set(Nan::GetCurrentContext(), Nan::New<String>("c").ToLocalChecked(), Nan::New<Number>(lines[i][2]));
 
-      linesArray->Set(Nan::New<Number>(i), line_data);
+      linesArray->Set(Nan::GetCurrentContext(), Nan::New<Number>(i), line_data);
     }
 
     // Return the lines
diff --git a/src/CamShift.cc b/src/CamShift.cc
index 12179a4..08bf4dd 100644
--- a/src/CamShift.cc
+++ b/src/CamShift.cc
@@ -33,7 +33,7 @@ void TrackedObject::Init(Local<Object> target) {
 
   Nan::SetPrototypeMethod(ctor, "track", Track);
 
-  target->Set(Nan::New("TrackedObject").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("TrackedObject").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(TrackedObject::New) {
@@ -50,10 +50,10 @@ NAN_METHOD(TrackedObject::New) {
   if (info[1]->IsArray()) {
     Local<Object> v8rec = info[1]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
     r = cv::Rect(
-        v8rec->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-        v8rec->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-        v8rec->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-        v8rec->Get(3)->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+        v8rec->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
+        v8rec->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
+        v8rec->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
+        v8rec->Get(Nan::GetCurrentContext(),3).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked() - v8rec->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
   } else {
     JSTHROW_TYPE("Must pass rectangle to track")
   }
@@ -61,8 +61,8 @@ NAN_METHOD(TrackedObject::New) {
   if (info[2]->IsObject()) {
     Local<Object> opts = info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
 
-    if (opts->Get(Nan::New("channel").ToLocalChecked())->IsString()) {
-      v8::String::Utf8Value c(v8::Isolate::GetCurrent(),opts->Get(Nan::New("channel").ToLocalChecked())->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
+    if (opts->Get(Nan::GetCurrentContext(),Nan::New("channel").ToLocalChecked()).ToLocalChecked()->IsString()) {
+      v8::String::Utf8Value c(v8::Isolate::GetCurrent(),opts->Get(Nan::GetCurrentContext(),Nan::New("channel").ToLocalChecked()).ToLocalChecked()->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
       std::string cc = std::string(*c);
 
       if (cc == "hue" || cc == "h") {
@@ -166,17 +166,17 @@ NAN_METHOD(TrackedObject::Track) {
 
   v8::Local<v8::Array> arr = Nan::New<Array>(4);
 
-  arr->Set(0, Nan::New<Number>(bounds.x));
-  arr->Set(1, Nan::New<Number>(bounds.y));
-  arr->Set(2, Nan::New<Number>(bounds.x + bounds.width));
-  arr->Set(3, Nan::New<Number>(bounds.y + bounds.height));
+  arr->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(bounds.x));
+  arr->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(bounds.y));
+  arr->Set(Nan::GetCurrentContext(),2, Nan::New<Number>(bounds.x + bounds.width));
+  arr->Set(Nan::GetCurrentContext(),3, Nan::New<Number>(bounds.y + bounds.height));
 
   /*
   cv::Point2f pts[4];
   r.points(pts);
 
   for (int i = 0; i < 8; i += 2) {
-    arr->Set(i, Nan::New<Number>(pts[i].x));
+    arr->Set(Nan::GetCurrentContext(), i, Nan::New<Number>(pts[i].x));
     arr->Set(i + 1, Nan::New<Number>(pts[i].y));
   } */
 
diff --git a/src/CascadeClassifierWrap.cc b/src/CascadeClassifierWrap.cc
index 4ffb18c..3fff563 100755
--- a/src/CascadeClassifierWrap.cc
+++ b/src/CascadeClassifierWrap.cc
@@ -24,7 +24,7 @@ void CascadeClassifierWrap::Init(Local<Object> target) {
 
   Nan::SetPrototypeMethod(ctor, "detectMultiScale", DetectMultiScale);
 
-  target->Set(Nan::New("CascadeClassifier").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("CascadeClassifier").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(CascadeClassifierWrap::New) {
@@ -95,11 +95,11 @@ public:
 
     for (unsigned int i = 0; i < this->res.size(); i++) {
       v8::Local < v8::Object > x = Nan::New<v8::Object>();
-      x->Set(Nan::New("x").ToLocalChecked(), Nan::New < Number > (this->res[i].x));
-      x->Set(Nan::New("y").ToLocalChecked(), Nan::New < Number > (this->res[i].y));
-      x->Set(Nan::New("width").ToLocalChecked(), Nan::New < Number > (this->res[i].width));
-      x->Set(Nan::New("height").ToLocalChecked(), Nan::New < Number > (this->res[i].height));
-      arr->Set(i, x);
+      x->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New < Number > (this->res[i].x));
+      x->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New < Number > (this->res[i].y));
+      x->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New < Number > (this->res[i].width));
+      x->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New < Number > (this->res[i].height));
+      arr->Set(Nan::GetCurrentContext(), i, x);
     }
 
     argv[0] = Nan::Null();
diff --git a/src/Constants.cc b/src/Constants.cc
index ab3d62e..df74f84 100644
--- a/src/Constants.cc
+++ b/src/Constants.cc
@@ -6,16 +6,16 @@
 #endif
 
 #define CONST(C) \
-  obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>(C));
+  obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>(C));
 
 #define CONST_INT(C) \
-  obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)C));
+  obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)C));
 
 #define CONST_DOUBLE(C) \
-  obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Number>(C));
+  obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Number>(C));
 
 #define CONST_ENUM(C) \
-  obj->Set(Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)(cv::C)));
+  obj->Set(Nan::GetCurrentContext(), Nan::New<String>(#C).ToLocalChecked(), Nan::New<Integer>((int)(cv::C)));
 
 void Constants::Init(Local<Object> target) {
   Nan::Persistent<Object> inner;
@@ -126,10 +126,10 @@ void Constants::Init(Local<Object> target) {
   CONST_ENUM(CMP_LE)
   CONST_ENUM(CMP_NE)
 
-  target->Set(Nan::New("TERM_CRITERIA_EPS").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::EPS));
-  target->Set(Nan::New("TERM_CRITERIA_COUNT").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::COUNT));
+  target->Set(Nan::GetCurrentContext(), Nan::New("TERM_CRITERIA_EPS").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::EPS));
+  target->Set(Nan::GetCurrentContext(), Nan::New("TERM_CRITERIA_COUNT").ToLocalChecked(), Nan::New<Integer>((int)cv::TermCriteria::COUNT));
 
-  target->Set(Nan::New("Constants").ToLocalChecked(), obj);
+  target->Set(Nan::GetCurrentContext(), Nan::New("Constants").ToLocalChecked(), obj);
 }
 
 #undef CONST
diff --git a/src/Contours.cc b/src/Contours.cc
index dec3ebc..0704aec 100755
--- a/src/Contours.cc
+++ b/src/Contours.cc
@@ -33,7 +33,7 @@ void Contour::Init(Local<Object> target) {
   Nan::SetPrototypeMethod(ctor, "hierarchy", Hierarchy);
   Nan::SetPrototypeMethod(ctor, "serialize", Serialize);
   Nan::SetPrototypeMethod(ctor, "deserialize", Deserialize);
-  target->Set(Nan::New("Contours").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("Contours").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 };
 
 NAN_METHOD(Contour::New) {
@@ -64,8 +64,8 @@ NAN_METHOD(Contour::Point) {
   cv::Point point = self->contours[pos][index];
 
   Local<Object> data = Nan::New<Object>();
-  data->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(point.x));
-  data->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(point.y));
+  data->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(point.x));
+  data->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(point.y));
 
   info.GetReturnValue().Set(data);
 }
@@ -81,10 +81,10 @@ NAN_METHOD(Contour::Points) {
 
   for (std::vector<int>::size_type i = 0; i != points.size(); i++) {
     Local<Object> point_data = Nan::New<Object>();
-    point_data->Set(Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(points[i].x));
-    point_data->Set(Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(points[i].y));
+    point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked(), Nan::New<Number>(points[i].x));
+    point_data->Set(Nan::GetCurrentContext(), Nan::New<String>("y").ToLocalChecked(), Nan::New<Number>(points[i].y));
 
-    data->Set(i, point_data);
+    data->Set(Nan::GetCurrentContext(), i, point_data);
   }
 
   info.GetReturnValue().Set(data);
@@ -115,7 +115,7 @@ NAN_METHOD(Contour::Area) {
 
   Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
   int pos = info[0].As<Number>()->Value();
-  bool orientation = (info.Length() > 1 && info[1]->BooleanValue( Nan::GetCurrentContext() ).FromJust());
+  bool orientation = (info.Length() > 1 && info[1]->BooleanValue( v8::Isolate::GetCurrent() ));
 
   // info.GetReturnValue().Set(Nan::New<Number>(contourArea(self->contours)));
   info.GetReturnValue().Set(Nan::New<Number>(contourArea(cv::Mat(self->contours[pos]), orientation)));
@@ -126,7 +126,7 @@ NAN_METHOD(Contour::ArcLength) {
 
   Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
   int pos = info[0].As<Number>()->Value();
-  bool isClosed = info[1]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
+  bool isClosed = info[1]->BooleanValue( v8::Isolate::GetCurrent() );
 
   info.GetReturnValue().Set(Nan::New<Number>(arcLength(cv::Mat(self->contours[pos]), isClosed)));
 }
@@ -137,7 +137,7 @@ NAN_METHOD(Contour::ApproxPolyDP) {
   Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
   int pos = info[0].As<Number>()->Value();
   double epsilon = info[1].As<Number>()->Value();
-  bool isClosed = info[2]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
+  bool isClosed = info[2]->BooleanValue( v8::Isolate::GetCurrent() );
 
   cv::Mat approxed;
   approxPolyDP(cv::Mat(self->contours[pos]), approxed, epsilon, isClosed);
@@ -152,7 +152,7 @@ NAN_METHOD(Contour::ConvexHull) {
   Contour *self = Nan::ObjectWrap::Unwrap<Contour>(info.This());
 
   int pos = info[0].As<Number>()->Value();
-  bool clockwise = info[1]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
+  bool clockwise = info[1]->BooleanValue( v8::Isolate::GetCurrent() );
 
   cv::Mat hull;
   cv::convexHull(cv::Mat(self->contours[pos]), hull, clockwise);
@@ -170,10 +170,10 @@ NAN_METHOD(Contour::BoundingRect) {
   cv::Rect bounding = cv::boundingRect(cv::Mat(self->contours[pos]));
   Local<Object> rect = Nan::New<Object>();
 
-  rect->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(bounding.x));
-  rect->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(bounding.y));
-  rect->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(bounding.width));
-  rect->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(bounding.height));
+  rect->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(bounding.x));
+  rect->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(bounding.y));
+  rect->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New<Number>(bounding.width));
+  rect->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New<Number>(bounding.height));
 
   info.GetReturnValue().Set(rect);
 }
@@ -187,16 +187,16 @@ NAN_METHOD(Contour::MinAreaRect) {
   cv::RotatedRect minimum = cv::minAreaRect(cv::Mat(self->contours[pos]));
 
   Local<Object> rect = Nan::New<Object>();
-  rect->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(minimum.angle));
+  rect->Set(Nan::GetCurrentContext(), Nan::New("angle").ToLocalChecked(), Nan::New<Number>(minimum.angle));
 
   Local<Object> size = Nan::New<Object>();
-  size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(minimum.size.height));
-  size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(minimum.size.width));
-  rect->Set(Nan::New("size").ToLocalChecked(), size);
+  size->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New<Number>(minimum.size.height));
+  size->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New<Number>(minimum.size.width));
+  rect->Set(Nan::GetCurrentContext(), Nan::New("size").ToLocalChecked(), size);
 
   Local<Object> center = Nan::New<Object>();
-  center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(minimum.center.x));
-  center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(minimum.center.y));
+  center->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(minimum.center.x));
+  center->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(minimum.center.y));
 
   v8::Local<v8::Array> points = Nan::New<Array>(4);
 
@@ -205,12 +205,12 @@ NAN_METHOD(Contour::MinAreaRect) {
 
   for (unsigned int i=0; i<4; i++) {
     Local<Object> point = Nan::New<Object>();
-    point->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(rect_points[i].x));
-    point->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(rect_points[i].y));
-    points->Set(i, point);
+    point->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(rect_points[i].x));
+    point->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(rect_points[i].y));
+    points->Set(Nan::GetCurrentContext(), i, point);
   }
 
-  rect->Set(Nan::New("points").ToLocalChecked(), points);
+  rect->Set(Nan::GetCurrentContext(), Nan::New("points").ToLocalChecked(), points);
 
   info.GetReturnValue().Set(rect);
 }
@@ -225,17 +225,17 @@ NAN_METHOD(Contour::FitEllipse) {
     cv::RotatedRect ellipse = cv::fitEllipse(cv::Mat(self->contours[pos]));
 
     Local<Object> jsEllipse = Nan::New<Object>();
-    jsEllipse->Set(Nan::New("angle").ToLocalChecked(), Nan::New<Number>(ellipse.angle));
+    jsEllipse->Set(Nan::GetCurrentContext(), Nan::New("angle").ToLocalChecked(), Nan::New<Number>(ellipse.angle));
 
     Local<Object> size = Nan::New<Object>();
-    size->Set(Nan::New("height").ToLocalChecked(), Nan::New<Number>(ellipse.size.height));
-    size->Set(Nan::New("width").ToLocalChecked(), Nan::New<Number>(ellipse.size.width));
-    jsEllipse->Set(Nan::New("size").ToLocalChecked(), size);
+    size->Set(Nan::GetCurrentContext(), Nan::New("height").ToLocalChecked(), Nan::New<Number>(ellipse.size.height));
+    size->Set(Nan::GetCurrentContext(), Nan::New("width").ToLocalChecked(), Nan::New<Number>(ellipse.size.width));
+    jsEllipse->Set(Nan::GetCurrentContext(), Nan::New("size").ToLocalChecked(), size);
 
     Local<Object> center = Nan::New<Object>();
-    center->Set(Nan::New("x").ToLocalChecked(), Nan::New<Number>(ellipse.center.x));
-    center->Set(Nan::New("y").ToLocalChecked(), Nan::New<Number>(ellipse.center.y));
-    jsEllipse->Set(Nan::New("center").ToLocalChecked(), center);
+    center->Set(Nan::GetCurrentContext(), Nan::New("x").ToLocalChecked(), Nan::New<Number>(ellipse.center.x));
+    center->Set(Nan::GetCurrentContext(), Nan::New("y").ToLocalChecked(), Nan::New<Number>(ellipse.center.y));
+    jsEllipse->Set(Nan::GetCurrentContext(), Nan::New("center").ToLocalChecked(), center);
 
     info.GetReturnValue().Set(jsEllipse);
   }
@@ -263,10 +263,10 @@ NAN_METHOD(Contour::Moments) {
 
   Local<Object> res = Nan::New<Object>();
 
-  res->Set(Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mu.m00));
-  res->Set(Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mu.m10));
-  res->Set(Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mu.m01));
-  res->Set(Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mu.m11));
+  res->Set(Nan::GetCurrentContext(), Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mu.m00));
+  res->Set(Nan::GetCurrentContext(), Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mu.m10));
+  res->Set(Nan::GetCurrentContext(), Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mu.m01));
+  res->Set(Nan::GetCurrentContext(), Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mu.m11));
 
   info.GetReturnValue().Set(res);
 }
@@ -281,10 +281,10 @@ NAN_METHOD(Contour::Hierarchy) {
 
   Local<Array> res = Nan::New<Array>(4);
 
-  res->Set(0, Nan::New<Number>(hierarchy[0]));
-  res->Set(1, Nan::New<Number>(hierarchy[1]));
-  res->Set(2, Nan::New<Number>(hierarchy[2]));
-  res->Set(3, Nan::New<Number>(hierarchy[3]));
+  res->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(hierarchy[0]));
+  res->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(hierarchy[1]));
+  res->Set(Nan::GetCurrentContext(),2, Nan::New<Number>(hierarchy[2]));
+  res->Set(Nan::GetCurrentContext(),3, Nan::New<Number>(hierarchy[3]));
 
   info.GetReturnValue().Set(res);
 }
@@ -302,28 +302,28 @@ NAN_METHOD(Contour::Serialize) {
 
     for (std::vector<int>::size_type j = 0; j != points.size(); j++) {
       Local<Array> point_data = Nan::New<Array>(2);
-      point_data->Set(0, Nan::New<Number>(points[j].x));
-      point_data->Set(1, Nan::New<Number>(points[j].y));
+      point_data->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(points[j].x));
+      point_data->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(points[j].y));
 
-      contour_data->Set(j, point_data);
+      contour_data->Set(Nan::GetCurrentContext(),j, point_data);
     }
-    contours_data->Set(i, contour_data);
+    contours_data->Set(Nan::GetCurrentContext(), i, contour_data);
   }
 
   Local<Array> hierarchy_data = Nan::New<Array>(self->hierarchy.size());
   for (std::vector<int>::size_type i = 0; i != self->hierarchy.size(); i++) {
     Local<Array> contour_data = Nan::New<Array>(4);
-    contour_data->Set(0, Nan::New<Number>(self->hierarchy[i][0]));
-    contour_data->Set(1, Nan::New<Number>(self->hierarchy[i][1]));
-    contour_data->Set(2, Nan::New<Number>(self->hierarchy[i][2]));
-    contour_data->Set(3, Nan::New<Number>(self->hierarchy[i][3]));
+    contour_data->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(self->hierarchy[i][0]));
+    contour_data->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(self->hierarchy[i][1]));
+    contour_data->Set(Nan::GetCurrentContext(),2, Nan::New<Number>(self->hierarchy[i][2]));
+    contour_data->Set(Nan::GetCurrentContext(),3, Nan::New<Number>(self->hierarchy[i][3]));
 
-    hierarchy_data->Set(i, contour_data);
+    hierarchy_data->Set(Nan::GetCurrentContext(), i, contour_data);
   }
 
   Local<Object> data = Nan::New<Object>();
-  data->Set(Nan::New<String>("contours").ToLocalChecked(), contours_data);
-  data->Set(Nan::New<String>("hierarchy").ToLocalChecked(), hierarchy_data);
+  data->Set(Nan::GetCurrentContext(), Nan::New<String>("contours").ToLocalChecked(), contours_data);
+  data->Set(Nan::GetCurrentContext(), Nan::New<String>("hierarchy").ToLocalChecked(), hierarchy_data);
 
   info.GetReturnValue().Set(data);
 }
@@ -335,21 +335,21 @@ NAN_METHOD(Contour::Deserialize) {
 
   Local<Object> data = Local<Object>::Cast(info[0]);
 
-  Local<Array> contours_data = Local<Array>::Cast(data->Get(Nan::New<String>("contours").ToLocalChecked()));
-  Local<Array> hierarchy_data = Local<Array>::Cast(data->Get(Nan::New<String>("hierarchy").ToLocalChecked()));
+  Local<Array> contours_data = Local<Array>::Cast(data->Get(Nan::GetCurrentContext(),Nan::New<String>("contours").ToLocalChecked()).ToLocalChecked());
+  Local<Array> hierarchy_data = Local<Array>::Cast(data->Get(Nan::GetCurrentContext(),Nan::New<String>("hierarchy").ToLocalChecked()).ToLocalChecked());
 
   std::vector<std::vector<cv::Point> > contours_res;
   int contours_length = contours_data->Length();
 
   for (int i = 0; i < contours_length; i++) {
-    Local<Array> contour_data = Local<Array>::Cast(contours_data->Get(i));
+    Local<Array> contour_data = Local<Array>::Cast(contours_data->Get(Nan::GetCurrentContext(),i).ToLocalChecked());
     std::vector<cv::Point> points;
 
     int contour_length = contour_data->Length();
     for (int j = 0; j < contour_length; j++) {
-      Local<Array> point_data = Local<Array>::Cast(contour_data->Get(j));
-      int x = point_data->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-      int y = point_data->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+      Local<Array> point_data = Local<Array>::Cast(contour_data->Get(Nan::GetCurrentContext(),j).ToLocalChecked());
+      int x = point_data->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+      int y = point_data->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
       points.push_back(cv::Point(x, y));
     }
 
@@ -360,11 +360,11 @@ NAN_METHOD(Contour::Deserialize) {
   int hierarchy_length = hierarchy_data->Length();
 
   for (int i = 0; i < hierarchy_length; i++) {
-    Local<Array> contour_data = Local<Array>::Cast(hierarchy_data->Get(i));
-    int a = contour_data->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    int b = contour_data->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    int c = contour_data->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    int d = contour_data->Get(3)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    Local<Array> contour_data = Local<Array>::Cast(hierarchy_data->Get(Nan::GetCurrentContext(),i).ToLocalChecked());
+    int a = contour_data->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int b = contour_data->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int c = contour_data->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int d = contour_data->Get(Nan::GetCurrentContext(),3).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
     hierarchy_res.push_back(cv::Vec4i(a, b, c, d));
   }
 
diff --git a/src/FaceRecognizer.cc b/src/FaceRecognizer.cc
index 201e3be..3be6431 100644
--- a/src/FaceRecognizer.cc
+++ b/src/FaceRecognizer.cc
@@ -81,7 +81,7 @@ void FaceRecognizerWrap::Init(Local<Object> target) {
 
   Nan::SetPrototypeMethod(ctor, "getMat", GetMat);
 
-  target->Set(Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("FaceRecognizer").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 };
 
 NAN_METHOD(FaceRecognizerWrap::New) {
@@ -191,7 +191,7 @@ Local<Value> UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info,
 
   const uint32_t length = tuples->Length();
   for (uint32_t i = 0; i < length; ++i) {
-    const Local<Value> val = tuples->Get(i);
+    const Local<Value> val = tuples->Get(Nan::GetCurrentContext(),i).ToLocalChecked();
 
     if (!val->IsArray()) {
       JSTHROW("train takes a list of [label, image] tuples")
@@ -199,12 +199,12 @@ Local<Value> UnwrapTrainingData(Nan::NAN_METHOD_ARGS_TYPE info,
 
     Local<Array> valarr = Local<Array>::Cast(val);
 
-    if (valarr->Length() != 2 || !valarr->Get(0)->IsInt32()) {
+    if (valarr->Length() != 2 || !valarr->Get(Nan::GetCurrentContext(),0)->IsInt32()) {
       JSTHROW("train takes a list of [label, image] tuples")
     }
 
-    int label = valarr->Get(0)->Uint32Value(Nan::GetCurrentContext()).ToChecked();
-    cv::Mat im = fromMatrixOrFilename(valarr->Get(1)); //this is ok because we clone the image
+    int label = valarr->Get(Nan::GetCurrentContext(),0)->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+    cv::Mat im = fromMatrixOrFilename(valarr->Get(Nan::GetCurrentContext(),1)); //this is ok because we clone the image
     im = im.clone();
     if (im.channels() == 3) {
       cv::cvtColor(im, im, CV_RGB2GRAY);
@@ -332,8 +332,8 @@ NAN_METHOD(FaceRecognizerWrap::PredictSync) {
 #endif
 
   v8::Local<v8::Object> res = Nan::New<Object>();
-  res->Set(Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
-  res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
+  res->Set(Nan::GetCurrentContext(), Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
+  res->Set(Nan::GetCurrentContext(), Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
 
   info.GetReturnValue().Set(res);
 }
@@ -372,8 +372,8 @@ public:
     matrix = NULL;
 
     v8::Local<v8::Object> res = Nan::New<Object>();
-    res->Set(Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
-    res->Set(Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
+    res->Set(Nan::GetCurrentContext(), Nan::New("id").ToLocalChecked(), Nan::New<Number>(predictedLabel));
+    res->Set(Nan::GetCurrentContext(), Nan::New("confidence").ToLocalChecked(), Nan::New<Number>(confidence));
 
     Local<Value> argv[] = {
       res
diff --git a/src/HighGUI.cc b/src/HighGUI.cc
index 4ff775c..fec42c8 100644
--- a/src/HighGUI.cc
+++ b/src/HighGUI.cc
@@ -21,7 +21,7 @@ void NamedWindow::Init(Local<Object> target) {
   Nan::SetPrototypeMethod(ctor, "blockingWaitKey", BlockingWaitKey);
   Nan::SetPrototypeMethod(ctor, "resizeWindow", ResizeWindow);
 
-  target->Set(Nan::New("NamedWindow").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("NamedWindow").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 };
 
 NAN_METHOD(NamedWindow::New) {
diff --git a/src/Histogram.cc b/src/Histogram.cc
index debf5ed..e55580c 100644
--- a/src/Histogram.cc
+++ b/src/Histogram.cc
@@ -9,7 +9,7 @@ void Histogram::Init(Local<Object> target) {
   Nan::SetMethod(obj, "calcHist", CalcHist);
   Nan::SetMethod(obj, "emd", Emd);
 
-  target->Set(Nan::New("histogram").ToLocalChecked(), obj);
+  target->Set(Nan::GetCurrentContext(), Nan::New("histogram").ToLocalChecked(), obj);
 }
 
 NAN_METHOD(Histogram::CalcHist) {
@@ -33,14 +33,14 @@ NAN_METHOD(Histogram::CalcHist) {
     // in vs, can't create an array of non-constant size; but since we have dims<3, just use 3..
     int channels[3];
     for (unsigned int i = 0; i < dims; i++) {
-      channels[i] = nodeChannels->Get(i)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+      channels[i] = nodeChannels->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
     }
 
     // Arg 2 is histogram sizes in each dimension
     Local<Array> nodeHistSizes = Local<Array>::Cast(info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
     int histSize[3];
     for (unsigned int i = 0; i < dims; i++) {
-      histSize[i] = nodeHistSizes->Get(i)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+      histSize[i] = nodeHistSizes->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
     }
 
     // Arg 3 is array of the histogram bin boundaries in each dimension
@@ -50,16 +50,16 @@ NAN_METHOD(Histogram::CalcHist) {
     const float* ranges[3];
 
     for (unsigned int i = 0; i < dims; i++) {
-      Local<Array> nodeRange = Local<Array>::Cast(nodeRanges->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
-      float lower = nodeRange->Get(0).As<Number>()->Value();
-      float higher = nodeRange->Get(1).As<Number>()->Value();
+      Local<Array> nodeRange = Local<Array>::Cast(nodeRanges->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
+      float lower = nodeRange->Get(Nan::GetCurrentContext(),0).ToLocalChecked().As<Number>()->Value();
+      float higher = nodeRange->Get(Nan::GetCurrentContext(),1).ToLocalChecked().As<Number>()->Value();
       histRanges[i][0] = lower;
       histRanges[i][1] = higher;
       ranges[i] = histRanges[i];
     }
 
     // Arg 4 is uniform flag
-    bool uniform = info[4]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
+    bool uniform = info[4]->BooleanValue( v8::Isolate::GetCurrent() );
 
     // Make a mat to hold the result image
     cv::Mat outputHist;
@@ -72,21 +72,21 @@ NAN_METHOD(Histogram::CalcHist) {
 
     for (unsigned int i=0; i < (unsigned int) histSize[0]; i++) {
       if(dims <= 1){
-        arr->Set(i, Nan::New<Number>(outputHist.at<float>(i)));
+        arr->Set(Nan::GetCurrentContext(), i, Nan::New<Number>(outputHist.at<float>(i)));
       } else {
         v8::Local<v8::Array> arr2 = Nan::New<Array>(dims);
         for (unsigned int j=0; j < (unsigned int) histSize[1]; j++) {
           if(dims <= 2){
-            arr2->Set(j, Nan::New<Number>(outputHist.at<float>(i,j)));
+            arr2->Set(Nan::GetCurrentContext(),j, Nan::New<Number>(outputHist.at<float>(i,j)));
           } else {
             v8::Local<v8::Array> arr3 = Nan::New<Array>(dims);
             for (unsigned int k=0; k < (unsigned int) histSize[1]; k++) {
-              arr3->Set(k, Nan::New<Number>(outputHist.at<float>(i,j,k)));
+              arr3->Set(Nan::GetCurrentContext(),k, Nan::New<Number>(outputHist.at<float>(i,j,k)));
             }
-            arr2->Set(j, arr3);
+            arr2->Set(Nan::GetCurrentContext(),j, arr3);
           }
         }
-        arr->Set(i, arr2);
+        arr->Set(Nan::GetCurrentContext(), i, arr2);
       }
     }
 
diff --git a/src/ImgProc.cc b/src/ImgProc.cc
index 898b13e..aa952c8 100644
--- a/src/ImgProc.cc
+++ b/src/ImgProc.cc
@@ -14,7 +14,7 @@ void ImgProc::Init(Local<Object> target) {
   Nan::SetMethod(obj, "distanceTransform", DistanceTransform);
   Nan::SetMethod(obj, "getStructuringElement", GetStructuringElement);
 
-  target->Set(Nan::New("imgproc").ToLocalChecked(), obj);
+  target->Set(Nan::GetCurrentContext(), Nan::New("imgproc").ToLocalChecked(), obj);
 }
 
 // cv::distanceTransform
@@ -109,7 +109,7 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) {
     cv::Size imageSize;
     if (info[4]->IsArray()) {
       Local<Object> v8sz = info[4]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-      imageSize = cv::Size(v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+      imageSize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
     } else {
       JSTHROW_TYPE("Must pass image size");
     }
@@ -129,8 +129,8 @@ NAN_METHOD(ImgProc::InitUndistortRectifyMap) {
 
     // Make a return object with the two maps
     Local<Object> ret = Nan::New<Object>();
-    ret->Set(Nan::New<String>("map1").ToLocalChecked(), map1Wrap);
-    ret->Set(Nan::New<String>("map2").ToLocalChecked(), map2Wrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("map1").ToLocalChecked(), map1Wrap);
+    ret->Set(Nan::GetCurrentContext(), Nan::New<String>("map2").ToLocalChecked(), map2Wrap);
 
     // Return the maps
     info.GetReturnValue().Set(ret);
@@ -206,7 +206,7 @@ NAN_METHOD(ImgProc::GetStructuringElement) {
       JSTHROW_TYPE("'ksize' argument must be a 2 double array");
     }
     Local<Object> v8sz = info[1]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-    ksize = cv::Size(v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+    ksize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
 
     // GetStructuringElement
     cv::Mat mat = cv::getStructuringElement(shape, ksize);
diff --git a/src/LDAWrap.cc b/src/LDAWrap.cc
index a9de8cf..1db6720 100644
--- a/src/LDAWrap.cc
+++ b/src/LDAWrap.cc
@@ -28,7 +28,7 @@ void LDAWrap::Init(Local<Object> target) {
   Nan::SetMethod(ctor, "subspaceProject", SubspaceProject);
   Nan::SetMethod(ctor, "subspaceReconstruct", SubspaceReconstruct);
 
-  target->Set(Nan::New("LDA").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("LDA").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 };
 
 NAN_METHOD(LDAWrap::New) {
diff --git a/src/Matrix.cc b/src/Matrix.cc
index fe8215a..5ef541c 100755
--- a/src/Matrix.cc
+++ b/src/Matrix.cc
@@ -133,7 +133,7 @@ void Matrix::Init(Local<Object> target) {
   Nan::SetPrototypeMethod(ctor, "div", Div);
   Nan::SetPrototypeMethod(ctor, "pow", Pow);
 
-  target->Set(Nan::New("Matrix").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  Nan::Set(target, Nan::New("Matrix").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 };
 
 NAN_METHOD(Matrix::New) {
@@ -225,14 +225,20 @@ Matrix::Matrix(int rows, int cols, int type, Local<Object> scalarObj) {
   mat = cv::Mat(rows, cols, type);
   Nan::AdjustExternalMemory(mat.dataend - mat.datastart);
   if (mat.channels() == 3) {
-    mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-        scalarObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-        scalarObj->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked()));
+    mat.setTo(cv::Scalar(  
+        Nan::To<double>( Nan::Get(scalarObj,0).ToLocalChecked() ).FromJust(),
+        Nan::To<double>( Nan::Get(scalarObj,1).ToLocalChecked() ).FromJust(),
+        Nan::To<double>( Nan::Get(scalarObj,2).ToLocalChecked() ).FromJust() 
+    ));
   } else if (mat.channels() == 2) {
-    mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-        scalarObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked()));
+    mat.setTo(cv::Scalar(
+        Nan::To<double>( Nan::Get(scalarObj,0).ToLocalChecked() ).FromJust(),
+        Nan::To<double>( Nan::Get(scalarObj,1).ToLocalChecked() ).FromJust()
+    ));
   } else if (mat.channels() == 1) {
-    mat.setTo(cv::Scalar(scalarObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked()));
+    mat.setTo(cv::Scalar(
+        Nan::To<double>( Nan::Get(scalarObj,0).ToLocalChecked() ).FromJust()
+    ));
   } else {
     Nan::ThrowError("Only 1-3 channels are supported");
   }
@@ -305,13 +311,13 @@ NAN_METHOD(Matrix::Pixel) {
 
     if (self->mat.channels() == 3) {
       self->mat.at<cv::Vec3b>(y, x)[0] =
-          (uchar) objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+          (uchar) Nan::To<uint32_t>( Nan::Get(objColor,0).ToLocalChecked() ).FromJust();
       self->mat.at<cv::Vec3b>(y, x)[1] =
-          (uchar) objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+          (uchar) Nan::To<uint32_t>( Nan::Get(objColor,1).ToLocalChecked() ).FromJust();
       self->mat.at<cv::Vec3b>(y, x)[2] =
-          (uchar) objColor->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+          (uchar) Nan::To<uint32_t>( Nan::Get(objColor,2).ToLocalChecked() ).FromJust();
     } else if (self->mat.channels() == 1)
-      self->mat.at<uchar>(y, x) = (uchar) objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+      self->mat.at<uchar>(y, x) = Nan::To<uint32_t>( Nan::Get(objColor,0).ToLocalChecked() ).FromJust();;
 
     info.GetReturnValue().Set(info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
   } else {
@@ -319,9 +325,9 @@ NAN_METHOD(Matrix::Pixel) {
       cv::Vec3b intensity = self->mat.at<cv::Vec3b>(y, x);
 
       v8::Local < v8::Array > arr = Nan::New<v8::Array>(3);
-      arr->Set(0, Nan::New<Number>(intensity[0]));
-      arr->Set(1, Nan::New<Number>(intensity[1]));
-      arr->Set(2, Nan::New<Number>(intensity[2]));
+      Nan::Set(arr, 0, Nan::New<Number>(intensity[0]));
+      Nan::Set(arr, 1, Nan::New<Number>(intensity[1]));
+      Nan::Set(arr, 2, Nan::New<Number>(intensity[2]));
       info.GetReturnValue().Set(arr);
     } else if (self->mat.channels() == 1) {
       uchar intensity = self->mat.at<uchar>(y, x);
@@ -353,17 +359,17 @@ NAN_METHOD(Matrix::GetPixel) {
   if (self->mat.channels() == 4) {
     v8::Local < v8::Array > arr = Nan::New<Array>(4);
     cv::Vec4b pixel = self->mat.at<cv::Vec4b>(y, x);
-    arr->Set(0, Nan::New<Number>((double) pixel.val[0]));
-    arr->Set(1, Nan::New<Number>((double) pixel.val[1]));
-    arr->Set(2, Nan::New<Number>((double) pixel.val[2]));
-    arr->Set(3, Nan::New<Number>((double) pixel.val[3]));
+     Nan::Set(arr, 0, Nan::New<Number>((double) pixel.val[0]));
+     Nan::Set(arr, 1, Nan::New<Number>((double) pixel.val[1]));
+     Nan::Set(arr, 2, Nan::New<Number>((double) pixel.val[2]));
+     Nan::Set(arr, 3, Nan::New<Number>((double) pixel.val[3]));
     info.GetReturnValue().Set(arr);
   } else if (self->mat.channels() == 3) {
     v8::Local < v8::Array > arr = Nan::New<Array>(3);
     cv::Vec3b pixel = self->mat.at<cv::Vec3b>(y, x);
-    arr->Set(0, Nan::New<Number>((double) pixel.val[0]));
-    arr->Set(1, Nan::New<Number>((double) pixel.val[1]));
-    arr->Set(2, Nan::New<Number>((double) pixel.val[2]));
+     Nan::Set(arr, 0, Nan::New<Number>((double) pixel.val[0]));
+     Nan::Set(arr, 1, Nan::New<Number>((double) pixel.val[1]));
+     Nan::Set(arr, 2, Nan::New<Number>((double) pixel.val[2]));
     info.GetReturnValue().Set(arr);
   } else if(self->mat.channels() == 1) {
     int pixel = (int)self->mat.at<unsigned char>(y, x);
@@ -439,7 +445,7 @@ NAN_METHOD(Matrix::GetData) {
   }
 
   v8::Local<v8::Object> globalObj = Nan::GetCurrentContext()->Global();
-  v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
+  v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(Nan::Get(globalObj,Nan::New<String>("Buffer").ToLocalChecked()).ToLocalChecked());
   v8::Local<v8::Value> constructorArgs[3] = {buf, Nan::New<v8::Integer>((unsigned) size), Nan::New<v8::Integer>(0)};
   v8::Local<v8::Object> actualBuffer = Nan::NewInstance(bufferConstructor, 3, constructorArgs).ToLocalChecked();
 
@@ -596,8 +602,8 @@ NAN_METHOD(Matrix::Size) {
   SETUP_FUNCTION(Matrix)
 
   v8::Local < v8::Array > arr = Nan::New<Array>(2);
-  arr->Set(0, Nan::New<Number>(self->mat.size().height));
-  arr->Set(1, Nan::New<Number>(self->mat.size().width));
+   Nan::Set(arr, 0, Nan::New<Number>(self->mat.size().height));
+   Nan::Set(arr, 1, Nan::New<Number>(self->mat.size().width));
 
   info.GetReturnValue().Set(arr);
 }
@@ -646,7 +652,7 @@ NAN_METHOD(Matrix::Row) {
 
   for (int x = 0; x < width; x++) {
     double v = Matrix::DblGet(self->mat, y, x);
-    arr->Set(x, Nan::New<Number>(v));
+     Nan::Set(arr, x, Nan::New<Number>(v));
   }
 
   info.GetReturnValue().Set(arr);
@@ -664,25 +670,25 @@ NAN_METHOD(Matrix::PixelRow) {
     for (int x = 0; x < width; x++) {
       cv::Vec4b pixel = self->mat.at<cv::Vec4b>(y, x);
       int offset = x * 4;
-      arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
-      arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
-      arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
-      arr->Set(offset + 3, Nan::New<Number>((double) pixel.val[3]));
+       Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
+       Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
+       Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
+       Nan::Set(arr, offset + 3, Nan::New<Number>((double) pixel.val[3]));
     }
   } else if(self->mat.channels() == 3){
     arr = Nan::New<Array>(width * 3);
     for (int x = 0; x < width; x++) {
       cv::Vec3b pixel = self->mat.at<cv::Vec3b>(y, x);
       int offset = x * 3;
-      arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
-      arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
-      arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
+       Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
+       Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
+       Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
     }
   } else if(self->mat.channels() == 1){
     arr = Nan::New<Array>(width);
     for (int x = 0; x < width; x++) {
       int pixel = (int)self->mat.at<unsigned char>(y, x);
-      arr->Set(x, Nan::New<Number>(pixel));
+       Nan::Set(arr, x, Nan::New<Number>(pixel));
     }
   } else {
       Nan::ThrowTypeError("Only 4, 3 and 1 channel matrix are supported");
@@ -700,7 +706,7 @@ NAN_METHOD(Matrix::Col) {
 
   for (int y = 0; y < height; y++) {
     double v = Matrix::DblGet(self->mat, y, x);
-    arr->Set(y, Nan::New<Number>(v));
+     Nan::Set(arr, y, Nan::New<Number>(v));
   }
   info.GetReturnValue().Set(arr);
 }
@@ -717,25 +723,25 @@ NAN_METHOD(Matrix::PixelCol) {
     for (int y = 0; y < height; y++) {
       cv::Vec4b pixel = self->mat.at<cv::Vec4b>(y, x);
       int offset = y * 4;
-      arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
-      arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
-      arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
-      arr->Set(offset + 3, Nan::New<Number>((double) pixel.val[3]));
+       Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
+       Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
+       Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
+       Nan::Set(arr, offset + 3, Nan::New<Number>((double) pixel.val[3]));
     }
   } else if (self->mat.channels() == 3) {
     arr = Nan::New<Array>(height * 3);
     for (int y = 0; y < height; y++) {
       cv::Vec3b pixel = self->mat.at<cv::Vec3b>(y, x);
       int offset = y * 3;
-      arr->Set(offset, Nan::New<Number>((double) pixel.val[0]));
-      arr->Set(offset + 1, Nan::New<Number>((double) pixel.val[1]));
-      arr->Set(offset + 2, Nan::New<Number>((double) pixel.val[2]));
+       Nan::Set(arr, offset, Nan::New<Number>((double) pixel.val[0]));
+       Nan::Set(arr, offset + 1, Nan::New<Number>((double) pixel.val[1]));
+       Nan::Set(arr, offset + 2, Nan::New<Number>((double) pixel.val[2]));
     }
   } else if(self->mat.channels() == 1) {
     arr = Nan::New<Array>(height);
     for (int y = 0; y < height; y++) {
       int pixel = (int)self->mat.at<unsigned char>(y, x);
-      arr->Set(y, Nan::New<Number>(pixel));
+       Nan::Set(arr, y, Nan::New<Number>(pixel));
     }
   } else {
     Nan::ThrowTypeError("Only 4, 3 and 1 channel matrix are supported");
@@ -788,19 +794,19 @@ NAN_METHOD(Matrix::ToBuffer) {
     // If the extension (image format) is provided
     if (options->Has( Nan::GetCurrentContext(), Nan::New<String>("ext").ToLocalChecked()).ToChecked() ) {
       v8::String::Utf8Value str(v8::Isolate::GetCurrent(),
-          options->Get(Nan::New<String>("ext").ToLocalChecked())->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("ext").ToLocalChecked()).ToLocalChecked()->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
       optExt = *str;
       ext = (const char *) optExt.c_str();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("jpegQuality").ToLocalChecked()).ToChecked() ) {
       int compression =
-          options->Get(Nan::New<String>("jpegQuality").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("jpegQuality").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
       params.push_back(CV_IMWRITE_JPEG_QUALITY);
       params.push_back(compression);
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("pngCompression").ToLocalChecked()).ToChecked() ) {
       int compression =
-          options->Get(Nan::New<String>("pngCompression").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("pngCompression").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
       params.push_back(CV_IMWRITE_PNG_COMPRESSION);
       params.push_back(compression);
     }
@@ -817,7 +823,7 @@ NAN_METHOD(Matrix::ToBuffer) {
 
   v8::Local < v8::Object > globalObj = Nan::GetCurrentContext()->Global();
   v8::Local < v8::Function > bufferConstructor = v8::Local < v8::Function
-      > ::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
+      > ::Cast(globalObj->Get(Nan::GetCurrentContext(), Nan::New<String>("Buffer").ToLocalChecked()).ToLocalChecked());
   v8::Local<v8::Value> constructorArgs[3] =
       {buf, Nan::New<v8::Integer>((unsigned)vec.size()), Nan::New<v8::Integer>(0)};
   v8::Local < v8::Object > actualBuffer = Nan::NewInstance(bufferConstructor, 3, constructorArgs).ToLocalChecked();
@@ -857,7 +863,7 @@ public:
     memcpy(data, &res[0], res.size());
 
     v8::Local<v8::Object> globalObj = Nan::GetCurrentContext()->Global();
-    v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::New<String>("Buffer").ToLocalChecked()));
+    v8::Local<v8::Function> bufferConstructor = v8::Local<v8::Function>::Cast(globalObj->Get(Nan::GetCurrentContext(), Nan::New<String>("Buffer").ToLocalChecked()).ToLocalChecked());
     v8::Local<v8::Value> constructorArgs[3] = {buf, Nan::New<v8::Integer>((unsigned)res.size()), Nan::New<v8::Integer>(0)};
     v8::Local<v8::Object> actualBuffer = Nan::NewInstance(bufferConstructor, 3, constructorArgs).ToLocalChecked();;
 
@@ -896,19 +902,19 @@ NAN_METHOD(Matrix::ToBufferAsync) {
     // If the extension (image format) is provided
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("ext").ToLocalChecked()).ToChecked() ) {
       v8::String::Utf8Value str(v8::Isolate::GetCurrent(),
-          options->Get(Nan::New<String>("ext").ToLocalChecked())->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("ext").ToLocalChecked()).ToLocalChecked()->ToString(Nan::GetCurrentContext()).FromMaybe(v8::Local<v8::String>()));
       std::string str2 = std::string(*str);
       ext = str2;
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("jpegQuality").ToLocalChecked()).ToChecked() ) {
       int compression =
-          options->Get(Nan::New<String>("jpegQuality").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("jpegQuality").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
       params.push_back(CV_IMWRITE_JPEG_QUALITY);
       params.push_back(compression);
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("pngCompression").ToLocalChecked()).ToChecked() ) {
       int compression =
-          options->Get(Nan::New<String>("pngCompression").ToLocalChecked())->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("pngCompression").ToLocalChecked()).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
       params.push_back(CV_IMWRITE_PNG_COMPRESSION);
       params.push_back(compression);
     }
@@ -939,36 +945,36 @@ NAN_METHOD(Matrix::Ellipse) {
     v8::Local < v8::Object > options = v8::Local<v8::Object>::Cast(info[0]);
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("center").ToLocalChecked()).ToChecked() ) {
       Local < Object > center =
-          options->Get(Nan::New<String>("center").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-      x = center->Get(Nan::New<String>("x").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
-      y = center->Get(Nan::New<String>("y").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("center").ToLocalChecked()).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+      x = center->Get(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+      y = center->Get(Nan::GetCurrentContext(), Nan::New<String>("y").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("axes").ToLocalChecked()).ToChecked() ) {
-      Local < Object > axes = options->Get(Nan::New<String>("axes").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-      width = axes->Get(Nan::New<String>("width").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
-      height = axes->Get(Nan::New<String>("height").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+      Local < Object > axes = options->Get(Nan::GetCurrentContext(), Nan::New<String>("axes").ToLocalChecked()).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+      width = axes->Get(Nan::GetCurrentContext(), Nan::New<String>("width").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+      height = axes->Get(Nan::GetCurrentContext(), Nan::New<String>("height").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("thickness").ToLocalChecked()).ToChecked() ) {
-      thickness = options->Get(Nan::New<String>("thickness").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+      thickness = options->Get(Nan::GetCurrentContext(), Nan::New<String>("thickness").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("angle").ToLocalChecked()).ToChecked() ) {
-      angle = options->Get(Nan::New<String>("angle").ToLocalChecked()).As<Number>()->Value();
+      angle = options->Get(Nan::GetCurrentContext(), Nan::New<String>("angle").ToLocalChecked()).ToLocalChecked().As<Number>()->Value();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("startAngle").ToLocalChecked()).ToChecked() ) {
-      startAngle = options->Get(Nan::New<String>("startAngle").ToLocalChecked()).As<Number>()->Value();
+      startAngle = options->Get(Nan::GetCurrentContext(), Nan::New<String>("startAngle").ToLocalChecked()).ToLocalChecked().As<Number>()->Value();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("endAngle").ToLocalChecked()).ToChecked() ) {
-      endAngle = options->Get(Nan::New<String>("endAngle").ToLocalChecked()).As<Number>()->Value();
+      endAngle = options->Get(Nan::GetCurrentContext(), Nan::New<String>("endAngle").ToLocalChecked()).ToLocalChecked().As<Number>()->Value();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("lineType").ToLocalChecked()).ToChecked() ) {
-      lineType = options->Get(Nan::New<String>("lineType").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+      lineType = options->Get(Nan::GetCurrentContext(), Nan::New<String>("lineType").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("shift").ToLocalChecked()).ToChecked() ) {
-      shift = options->Get(Nan::New<String>("shift").ToLocalChecked())->Uint32Value(Nan::GetCurrentContext()).ToChecked();
+      shift = options->Get(Nan::GetCurrentContext(), Nan::New<String>("shift").ToLocalChecked()).ToLocalChecked()->Uint32Value(Nan::GetCurrentContext()).ToChecked();
     }
     if (options->Has( Nan::GetCurrentContext(),Nan::New<String>("color").ToLocalChecked()).ToChecked() ) {
       Local < Object > objColor =
-          options->Get(Nan::New<String>("color").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+          options->Get(Nan::GetCurrentContext(), Nan::New<String>("color").ToLocalChecked()).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
       color = setColor(objColor);
     }
   } else {
@@ -1005,11 +1011,11 @@ NAN_METHOD(Matrix::Rectangle) {
       color = setColor(objColor);
     }
 
-    int x = xy->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    int y = xy->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int x = xy->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int y = xy->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
 
-    int width = width_height->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    int height = width_height->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int width = width_height->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int height = width_height->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
 
     int thickness = 1;
 
@@ -1037,11 +1043,11 @@ NAN_METHOD(Matrix::Line) {
       color = setColor(objColor);
     }
 
-    int x1 = xy1->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    int y1 = xy1->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int x1 = xy1->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int y1 = xy1->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
 
-    int x2 = xy2->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    int y2 = xy2->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int x2 = xy2->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    int y2 = xy2->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
 
     int thickness = 1;
 
@@ -1063,14 +1069,14 @@ NAN_METHOD(Matrix::FillPoly) {
     cv::Point **polygons = new cv::Point*[polyArray->Length()];
     int *polySizes = new int[polyArray->Length()];
     for (unsigned int i = 0; i < polyArray->Length(); i++) {
-      Local<Array> singlePoly = Local<Array> ::Cast(polyArray->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
+      Local<Array> singlePoly = Local<Array> ::Cast(polyArray->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
       polygons[i] = new cv::Point[singlePoly->Length()];
       polySizes[i] = singlePoly->Length();
 
       for (unsigned int j = 0; j < singlePoly->Length(); j++) {
-        Local<Array> point = Local<Array> ::Cast(singlePoly->Get(j)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
-        polygons[i][j].x = point->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-        polygons[i][j].y = point->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+        Local<Array> point = Local<Array> ::Cast(singlePoly->Get(Nan::GetCurrentContext(),j).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
+        polygons[i][j].x = point->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+        polygons[i][j].y = point->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
       }
     }
 
@@ -1258,8 +1264,8 @@ NAN_METHOD(Matrix::GaussianBlur) {
     }
     Local<Object> array = Nan::To<v8::Object>(info[0]).ToLocalChecked();
     // TODO: Length check
-    Local<Value> x = array->Get(0);
-    Local<Value> y = array->Get(1);
+    Local<Value> x = array->Get(Nan::GetCurrentContext(),0).ToLocalChecked();
+    Local<Value> y = array->Get(Nan::GetCurrentContext(),1).ToLocalChecked();
     if (!x->IsNumber() || !y->IsNumber()) {
       Nan::ThrowTypeError("'ksize' argument must be a 2 double array");
     }
@@ -1577,32 +1583,32 @@ NAN_METHOD(Matrix::Moments) {
 
   Local<Object> res = Nan::New<Object>();
 
-  res->Set(Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mo.m00));
-  res->Set(Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mo.m10));
-  res->Set(Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mo.m01));
-  res->Set(Nan::New("m20").ToLocalChecked(), Nan::New<Number>(mo.m20));
-  res->Set(Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mo.m11));
-  res->Set(Nan::New("m02").ToLocalChecked(), Nan::New<Number>(mo.m02));
-  res->Set(Nan::New("m30").ToLocalChecked(), Nan::New<Number>(mo.m30));
-  res->Set(Nan::New("m21").ToLocalChecked(), Nan::New<Number>(mo.m21));
-  res->Set(Nan::New("m12").ToLocalChecked(), Nan::New<Number>(mo.m12));
-  res->Set(Nan::New("m03").ToLocalChecked(), Nan::New<Number>(mo.m03));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m00").ToLocalChecked(), Nan::New<Number>(mo.m00));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m10").ToLocalChecked(), Nan::New<Number>(mo.m10));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m01").ToLocalChecked(), Nan::New<Number>(mo.m01));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m20").ToLocalChecked(), Nan::New<Number>(mo.m20));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m11").ToLocalChecked(), Nan::New<Number>(mo.m11));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m02").ToLocalChecked(), Nan::New<Number>(mo.m02));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m30").ToLocalChecked(), Nan::New<Number>(mo.m30));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m21").ToLocalChecked(), Nan::New<Number>(mo.m21));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m12").ToLocalChecked(), Nan::New<Number>(mo.m12));
+  res->Set(Nan::GetCurrentContext(),Nan::New("m03").ToLocalChecked(), Nan::New<Number>(mo.m03));
 
-  res->Set(Nan::New("mu20").ToLocalChecked(), Nan::New<Number>(mo.mu20));
-  res->Set(Nan::New("mu11").ToLocalChecked(), Nan::New<Number>(mo.mu11));
-  res->Set(Nan::New("mu02").ToLocalChecked(), Nan::New<Number>(mo.mu02));
-  res->Set(Nan::New("mu30").ToLocalChecked(), Nan::New<Number>(mo.mu30));
-  res->Set(Nan::New("mu21").ToLocalChecked(), Nan::New<Number>(mo.mu21));
-  res->Set(Nan::New("mu12").ToLocalChecked(), Nan::New<Number>(mo.mu12));
-  res->Set(Nan::New("mu03").ToLocalChecked(), Nan::New<Number>(mo.mu03));
+  res->Set(Nan::GetCurrentContext(),Nan::New("mu20").ToLocalChecked(), Nan::New<Number>(mo.mu20));
+  res->Set(Nan::GetCurrentContext(),Nan::New("mu11").ToLocalChecked(), Nan::New<Number>(mo.mu11));
+  res->Set(Nan::GetCurrentContext(),Nan::New("mu02").ToLocalChecked(), Nan::New<Number>(mo.mu02));
+  res->Set(Nan::GetCurrentContext(),Nan::New("mu30").ToLocalChecked(), Nan::New<Number>(mo.mu30));
+  res->Set(Nan::GetCurrentContext(),Nan::New("mu21").ToLocalChecked(), Nan::New<Number>(mo.mu21));
+  res->Set(Nan::GetCurrentContext(),Nan::New("mu12").ToLocalChecked(), Nan::New<Number>(mo.mu12));
+  res->Set(Nan::GetCurrentContext(),Nan::New("mu03").ToLocalChecked(), Nan::New<Number>(mo.mu03));
 
-  res->Set(Nan::New("nu20").ToLocalChecked(), Nan::New<Number>(mo.nu20));
-  res->Set(Nan::New("nu11").ToLocalChecked(), Nan::New<Number>(mo.nu11));
-  res->Set(Nan::New("nu02").ToLocalChecked(), Nan::New<Number>(mo.nu02));
-  res->Set(Nan::New("nu30").ToLocalChecked(), Nan::New<Number>(mo.nu30));
-  res->Set(Nan::New("nu21").ToLocalChecked(), Nan::New<Number>(mo.nu21));
-  res->Set(Nan::New("nu12").ToLocalChecked(), Nan::New<Number>(mo.nu12));
-  res->Set(Nan::New("nu03").ToLocalChecked(), Nan::New<Number>(mo.nu03));
+  res->Set(Nan::GetCurrentContext(),Nan::New("nu20").ToLocalChecked(), Nan::New<Number>(mo.nu20));
+  res->Set(Nan::GetCurrentContext(),Nan::New("nu11").ToLocalChecked(), Nan::New<Number>(mo.nu11));
+  res->Set(Nan::GetCurrentContext(),Nan::New("nu02").ToLocalChecked(), Nan::New<Number>(mo.nu02));
+  res->Set(Nan::GetCurrentContext(),Nan::New("nu30").ToLocalChecked(), Nan::New<Number>(mo.nu30));
+  res->Set(Nan::GetCurrentContext(),Nan::New("nu21").ToLocalChecked(), Nan::New<Number>(mo.nu21));
+  res->Set(Nan::GetCurrentContext(),Nan::New("nu12").ToLocalChecked(), Nan::New<Number>(mo.nu12));
+  res->Set(Nan::GetCurrentContext(),Nan::New("nu03").ToLocalChecked(), Nan::New<Number>(mo.nu03));
 
   info.GetReturnValue().Set(res);
 }
@@ -1735,7 +1741,7 @@ NAN_METHOD(Matrix::GoodFeaturesToTrack) {
   double qualityLevel = info.Length() >= 2 ? (double) info[1].As<Number>()->Value() : 0.01;
   double minDistance = info.Length() >= 3 ? (double) info[2].As<Number>()->Value() : 10;
   int blockSize = info.Length() >= 4 ? info[3]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 3;
-  bool useHarrisDetector = info.Length() >= 5 ? info[4]->BooleanValue( Nan::GetCurrentContext() ).FromJust() : false;
+  bool useHarrisDetector = info.Length() >= 5 ? info[4]->BooleanValue( v8::Isolate::GetCurrent() ) : false;
   double k = info.Length() >= 6 ? (double) info[5].As<Number>()->Value() : 0.04;
 
   std::vector<cv::Point2f> corners;
@@ -1753,9 +1759,9 @@ NAN_METHOD(Matrix::GoodFeaturesToTrack) {
 
   for (unsigned int i=0; i<corners.size(); i++) {
     v8::Local<v8::Array> pt = Nan::New<Array>(2);
-    pt->Set(0, Nan::New<Number>((double) corners[i].x));
-    pt->Set(1, Nan::New<Number>((double) corners[i].y));
-    arr->Set(i, pt);
+    pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) corners[i].x));
+    pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) corners[i].y));
+     Nan::Set(arr, i, pt);
   }
 
   info.GetReturnValue().Set(arr);
@@ -1771,14 +1777,14 @@ NAN_METHOD(Matrix::CalcOpticalFlowPyrLK) {
   std::vector<cv::Point2f> old_points;
 
   for (unsigned int i=0; i<points->Length(); i++) {
-    Local<Object> pt = points->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-    old_points.push_back(cv::Point2f(pt->Get(0).As<Number>()->Value(), pt->Get(1).As<Number>()->Value()));
+    Local<Object> pt = points->Get(Nan::GetCurrentContext(),i).ToLocalChecked()->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+    old_points.push_back(cv::Point2f(pt->Get(Nan::GetCurrentContext(),0).ToLocalChecked().As<Number>()->Value(), pt->Get(Nan::GetCurrentContext(),1).ToLocalChecked().As<Number>()->Value()));
   }
 
   cv::Size winSize;
   if (info.Length() >= 3 && info[2]->IsArray()) {
     Local<Object> winSizeObj = info[2]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-    winSize = cv::Size(winSizeObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), winSizeObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+    winSize = cv::Size(winSizeObj->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), winSizeObj->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
   } else {
     winSize = cv::Size(21, 21);
   }
@@ -1788,7 +1794,7 @@ NAN_METHOD(Matrix::CalcOpticalFlowPyrLK) {
   cv::TermCriteria criteria;
   if (info.Length() >= 5 && info[4]->IsArray()) {
     Local<Object> criteriaObj = info[4]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-    criteria = cv::TermCriteria(criteriaObj->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), criteriaObj->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), (double) criteriaObj->Get(2).As<Number>()->Value());
+    criteria = cv::TermCriteria(criteriaObj->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), criteriaObj->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), (double) criteriaObj->Get(Nan::GetCurrentContext(),2).ToLocalChecked().As<Number>()->Value());
   } else {
     criteria = cv::TermCriteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, 0.01);
   }
@@ -1814,27 +1820,27 @@ NAN_METHOD(Matrix::CalcOpticalFlowPyrLK) {
 
   for (unsigned int i=0; i<old_points.size(); i++) {
     v8::Local<v8::Array> pt = Nan::New<Array>(2);
-    pt->Set(0, Nan::New<Number>((double) old_points[i].x));
-    pt->Set(1, Nan::New<Number>((double) old_points[i].y));
-    old_arr->Set(i, pt);
+    pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) old_points[i].x));
+    pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) old_points[i].y));
+    new_arr->Set(Nan::GetCurrentContext(), i, pt);
   }
 
   for (unsigned int i=0; i<new_points.size(); i++) {
     v8::Local<v8::Array> pt = Nan::New<Array>(2);
-    pt->Set(0, Nan::New<Number>((double) new_points[i].x));
-    pt->Set(1, Nan::New<Number>((double) new_points[i].y));
-    new_arr->Set(i, pt);
+    pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) new_points[i].x));
+    pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) new_points[i].y));
+    new_arr->Set(Nan::GetCurrentContext(), i, pt);
   }
 
   for (unsigned int i=0; i<status.size(); i++) {
     v8::Local<v8::Integer> pt = Nan::New<Integer>((int)status[i]);
-    found->Set(i, pt);
+    found->Set(Nan::GetCurrentContext(),i, pt);
   }
 
   Local<Object> data = Nan::New<Object>();
-  data->Set(Nan::New<String>("old_points").ToLocalChecked(), old_arr);
-  data->Set(Nan::New<String>("new_points").ToLocalChecked(), new_arr);
-  data->Set(Nan::New<String>("found").ToLocalChecked(), found);
+  data->Set(Nan::GetCurrentContext(),Nan::New<String>("old_points").ToLocalChecked(), old_arr);
+  data->Set(Nan::GetCurrentContext(),Nan::New<String>("new_points").ToLocalChecked(), new_arr);
+  data->Set(Nan::GetCurrentContext(),Nan::New<String>("found").ToLocalChecked(), found);
 
   info.GetReturnValue().Set(data);
 }
@@ -1861,11 +1867,11 @@ NAN_METHOD(Matrix::HoughLinesP) {
 
   for (unsigned int i=0; i<lines.size(); i++) {
     v8::Local<v8::Array> pt = Nan::New<Array>(4);
-    pt->Set(0, Nan::New<Number>((double) lines[i][0]));
-    pt->Set(1, Nan::New<Number>((double) lines[i][1]));
-    pt->Set(2, Nan::New<Number>((double) lines[i][2]));
-    pt->Set(3, Nan::New<Number>((double) lines[i][3]));
-    arr->Set(i, pt);
+    pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) lines[i][0]));
+    pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) lines[i][1]));
+    pt->Set(Nan::GetCurrentContext(),2, Nan::New<Number>((double) lines[i][2]));
+    pt->Set(Nan::GetCurrentContext(),3, Nan::New<Number>((double) lines[i][3]));
+     Nan::Set(arr, i, pt);
   }
 
   info.GetReturnValue().Set(arr);
@@ -1895,10 +1901,10 @@ NAN_METHOD(Matrix::HoughCircles) {
 
   for (unsigned int i=0; i < circles.size(); i++) {
     v8::Local<v8::Array> pt = Nan::New<Array>(3);
-    pt->Set(0, Nan::New<Number>((double) circles[i][0]));  // center x
-    pt->Set(1, Nan::New<Number>((double) circles[i][1]));// center y
-    pt->Set(2, Nan::New<Number>((double) circles[i][2]));// radius
-    arr->Set(i, pt);
+    pt->Set(Nan::GetCurrentContext(),0, Nan::New<Number>((double) circles[i][0]));  // center x
+    pt->Set(Nan::GetCurrentContext(),1, Nan::New<Number>((double) circles[i][1]));// center y
+    pt->Set(Nan::GetCurrentContext(),2, Nan::New<Number>((double) circles[i][2]));// radius
+     Nan::Set(arr, i, pt);
   }
 
   info.GetReturnValue().Set(arr);
@@ -1910,43 +1916,43 @@ cv::Scalar setColor(Local<Object> objColor) {
   // We'll accomodate a channel count up to 4 and fall back to the old
   // "assume it's always 3" in the default case
   if (!objColor->HasRealIndexedProperty( Nan::GetCurrentContext() , 1).ToChecked()) {
-    channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[0] = objColor->Get(Nan::GetCurrentContext(), 0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
   } else if (!objColor->HasRealIndexedProperty( Nan::GetCurrentContext() , 2).ToChecked()) {
-    channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    channels[1] = objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[0] = objColor->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[1] = objColor->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
   } else if (!objColor->HasRealIndexedProperty( Nan::GetCurrentContext() , 4).ToChecked()) {
-    channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    channels[1] = objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    channels[2] = objColor->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    channels[3] = objColor->Get(3)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[0] = objColor->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[1] = objColor->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[2] = objColor->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[3] = objColor->Get(Nan::GetCurrentContext(),3).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
   } else {
-    channels[0] = objColor->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    channels[1] = objColor->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-    channels[2] = objColor->Get(2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[0] = objColor->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[1] = objColor->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+    channels[2] = objColor->Get(Nan::GetCurrentContext(),2).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
   }
 
   return cv::Scalar(channels[0], channels[1], channels[2], channels[3]);
 }
 
 cv::Point setPoint(Local<Object> objPoint) {
-  return cv::Point(objPoint->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
-      objPoint->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+  return cv::Point(objPoint->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),
+      objPoint->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
 }
 
 cv::Rect* setRect(Local<Object> objRect, cv::Rect &result) {
-  if (!objRect->IsArray() || !objRect->Get(0)->IsArray()
-      || !objRect->Get(0)->IsArray()) {
+  if (!objRect->IsArray() || !objRect->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IsArray()
+      || !objRect->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IsArray()) {
     printf("error");
     return 0;
   };
 
-  Local < Object > point = objRect->Get(0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-  Local < Object > size = objRect->Get(1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+  Local < Object > point =  Nan::To<Object>( Nan::Get(objRect,0).ToLocalChecked() ).ToLocalChecked();;
+  Local < Object > size =  Nan::To<Object>( Nan::Get(objRect,1).ToLocalChecked() ).ToLocalChecked();
 
-  result.x = point->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-  result.y = point->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-  result.width = size->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
-  result.height = size->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked();
+  result.x = Nan::To<int32_t>( Nan::Get(point,0).ToLocalChecked() ).FromJust();
+  result.y = Nan::To<int32_t>( Nan::Get(point,1).ToLocalChecked() ).FromJust();
+  result.width = Nan::To<int32_t>( Nan::Get(size,0).ToLocalChecked() ).FromJust();
+  result.height = Nan::To<int32_t>( Nan::Get(size,1).ToLocalChecked() ).FromJust();
 
   return &result;
 }
@@ -2259,10 +2265,10 @@ NAN_METHOD(Matrix::LocateROI) {
   self->mat.locateROI(wholeSize, ofs);
 
   v8::Local < v8::Array > arr = Nan::New<Array>(4);
-  arr->Set(0, Nan::New<Number>(wholeSize.width));
-  arr->Set(1, Nan::New<Number>(wholeSize.height));
-  arr->Set(2, Nan::New<Number>(ofs.x));
-  arr->Set(3, Nan::New<Number>(ofs.y));
+   Nan::Set(arr, 0, Nan::New<Number>(wholeSize.width));
+   Nan::Set(arr, 1, Nan::New<Number>(wholeSize.height));
+   Nan::Set(arr, 2, Nan::New<Number>(ofs.x));
+   Nan::Set(arr, 3, Nan::New<Number>(ofs.y));
 
   info.GetReturnValue().Set(arr);
 }
@@ -2374,8 +2380,8 @@ NAN_METHOD(Matrix::MeanStdDev) {
   cv::meanStdDev(self->mat, meanMat, stddevMat);
 
   Local<Object> data = Nan::New<Object>();
-  data->Set(Nan::New<String>("mean").ToLocalChecked(), CreateWrappedFromMat(meanMat));
-  data->Set(Nan::New<String>("stddev").ToLocalChecked(), CreateWrappedFromMat(stddevMat));
+  Nan::Set(data,Nan::New<String>("mean").ToLocalChecked(), CreateWrappedFromMat(meanMat));
+  Nan::Set(data,Nan::New<String>("stddev").ToLocalChecked(), CreateWrappedFromMat(stddevMat));
 
   info.GetReturnValue().Set(data);
 }
@@ -2536,7 +2542,7 @@ NAN_METHOD(Matrix::Split) {
   v8::Local<v8::Array> arrChannels = Nan::New<Array>(size);
   for (unsigned int i = 0; i < size; i++) {
     Local<Object> matObject = Matrix::CreateWrappedFromMatIfNotReferenced(channels[i], 1);
-    arrChannels->Set(i, matObject);
+    Nan::Set(arrChannels, i, matObject);
   }
 
   info.GetReturnValue().Set(arrChannels);
@@ -2557,7 +2563,7 @@ NAN_METHOD(Matrix::Merge) {
   unsigned int L = jsChannels->Length();
   std::vector<cv::Mat> vChannels(L);
   for (unsigned int i = 0; i < L; i++) {
-    Matrix * matObject = Nan::ObjectWrap::Unwrap<Matrix>(jsChannels->Get(i)->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
+    Matrix * matObject = Nan::ObjectWrap::Unwrap<Matrix>( Nan::To<v8::Object>(  Nan::Get(jsChannels,i).ToLocalChecked() ).ToLocalChecked() );
     vChannels[i] = matObject->mat;
   }
   cv::merge(vChannels, self->mat);
@@ -2581,7 +2587,7 @@ NAN_METHOD(Matrix::EqualizeHist) {
 
 NAN_METHOD(Matrix::FloodFill) {
   SETUP_FUNCTION(Matrix)
-  // obj->Get(Nan::New<String>("x").ToLocalChecked())
+  // obj->Get(Nan::GetCurrentContext(), Nan::New<String>("x").ToLocalChecked())
   // int cv::floodFill(cv::InputOutputArray, cv::Point, cv::Scalar, cv::Rect*, cv::Scalar, cv::Scalar, int)
 
   /*  mat.floodFill( {seedPoint: [1,1] ,
@@ -2599,24 +2605,32 @@ NAN_METHOD(Matrix::FloodFill) {
   cv::Rect rect;
 
   int ret = cv::floodFill(self->mat,
-      setPoint(obj->Get(Nan::New<String>("seedPoint").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()),
-      setColor(obj->Get(Nan::New<String>("newColor").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()),
-      obj->Get(Nan::New<String>("rect").ToLocalChecked())->IsUndefined() ?
-          0 : setRect(obj->Get(Nan::New<String>("rect").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked(), rect),
-      setColor(obj->Get(Nan::New<String>("loDiff").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()),
-      setColor(obj->Get(Nan::New<String>("upDiff").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked()), 4);
+      setPoint( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("seedPoint").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()),
+      setColor( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("newColor").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()),
+      Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).IsEmpty() ?
+          0 : setRect( Nan::To<Object>( Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked(), rect),
+      setColor( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("loDiff").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()),
+      setColor( Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("upDiff").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked()), 
+      
+      4);
 
   // Documentation notes that parameter "rect" is an optional output
   // parameter which will hold the smallest possible bounding box of
   // affected pixels. If "rect" was provided, let's update the values.
   // (https://docs.opencv.org/2.4/modules/imgproc/doc/miscellaneous_transformations.html#floodfill)
-  if (!obj->Get(Nan::New<String>("rect").ToLocalChecked())->IsUndefined()) {
-    Local< Object > rectArgument =
-      obj->Get(Nan::New<String>("rect").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-    rectArgument->Get(0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(0, Nan::New<Number>(rect.x));
-    rectArgument->Get(0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(1, Nan::New<Number>(rect.y));
-    rectArgument->Get(1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(0, Nan::New<Number>(rect.width));
-    rectArgument->Get(1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(1, Nan::New<Number>(rect.height));
+  if (! Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).IsEmpty()) {
+    Local< Object > rectArgument = Nan::To<v8::Object>( Nan::Get(obj,Nan::New<String>("rect").ToLocalChecked()).ToLocalChecked() ).ToLocalChecked();
+    //obj->Get(Nan::GetCurrentContext(), Nan::New<String>("rect").ToLocalChecked())->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
+
+    
+    //Nan::Get(rectArgument,0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(rect.x));
+     Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,0).ToLocalChecked() ).ToLocalChecked(), 0, Nan::New<Number>(rect.x) );
+    //Nan::Get(rectArgument,0)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(rect.y));
+     Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,0).ToLocalChecked() ).ToLocalChecked(), 1, Nan::New<Number>(rect.y) );
+    //Nan::Get(rectArgument,1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),0, Nan::New<Number>(rect.width));
+     Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,1).ToLocalChecked() ).ToLocalChecked(), 0, Nan::New<Number>(rect.width) );
+    //Nan::Get(rectArgument,1)->ToObject(Nan::GetCurrentContext()).ToLocalChecked()->Set(Nan::GetCurrentContext(),1, Nan::New<Number>(rect.height));
+     Nan::Set( Nan::To<v8::Object>( Nan::Get(rectArgument,1).ToLocalChecked() ).ToLocalChecked(), 1, Nan::New<Number>(rect.height) );
   }
 
   info.GetReturnValue().Set(Nan::New<Number>(ret));
@@ -2635,7 +2649,7 @@ NAN_METHOD(Matrix::TemplateMatches) {
   double min_probability = filter_min_probability ? info[0].As<Number>()->Value() : 0;
   double max_probability = filter_max_probability ? info[1].As<Number>()->Value() : 0;
   int limit = (info.Length() >= 3) ? info[2]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 0;
-  bool ascending = (info.Length() >= 4) ? info[3]->BooleanValue( Nan::GetCurrentContext() ).FromJust() : false;
+  bool ascending = (info.Length() >= 4) ? Nan::To<bool>(info[3] ).FromJust() : false;
   int min_x_distance = (info.Length() >= 5) ? info[4]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 0;
   int min_y_distance = (info.Length() >= 6) ? info[5]->IntegerValue( Nan::GetCurrentContext() ).ToChecked() : 0;
 
@@ -2709,11 +2723,11 @@ NAN_METHOD(Matrix::TemplateMatches) {
     Local<Value> probability_value = Nan::New<Number>(probability);
 
     Local < Object > probability_object = Nan::New<Object>();
-    probability_object->Set(Nan::New<String>("x").ToLocalChecked(), x_value);
-    probability_object->Set(Nan::New<String>("y").ToLocalChecked(), y_value);
-    probability_object->Set(Nan::New<String>("probability").ToLocalChecked(), probability_value);
+    Nan::Set(probability_object,Nan::New<String>("x").ToLocalChecked(), x_value);
+    Nan::Set(probability_object,Nan::New<String>("y").ToLocalChecked(), y_value);
+    Nan::Set(probability_object,Nan::New<String>("probability").ToLocalChecked(), probability_value);
 
-    probabilites_array->Set(index, probability_object);
+    Nan::Set(probabilites_array,index, probability_object);
     index++;
   }
 
@@ -2807,11 +2821,11 @@ NAN_METHOD(Matrix::MatchTemplate) {
   result.convertTo(result, CV_8UC1, 255, 0);
 
   v8::Local <v8::Array> arr = Nan::New<v8::Array>(5);
-  arr->Set(0, CreateWrappedFromMat(result));
-  arr->Set(1, Nan::New<Number>(roi_x));
-  arr->Set(2, Nan::New<Number>(roi_y));
-  arr->Set(3, Nan::New<Number>(roi_width));
-  arr->Set(4, Nan::New<Number>(roi_height));
+   Nan::Set(arr, 0, CreateWrappedFromMat(result));
+   Nan::Set(arr, 1, Nan::New<Number>(roi_x));
+   Nan::Set(arr, 2, Nan::New<Number>(roi_y));
+   Nan::Set(arr, 3, Nan::New<Number>(roi_width));
+   Nan::Set(arr, 4, Nan::New<Number>(roi_height));
 
   info.GetReturnValue().Set(arr);
 }
@@ -2833,19 +2847,19 @@ NAN_METHOD(Matrix::MinMaxLoc) {
   Local<Value> v_maxLoc_y = Nan::New<Number>(maxLoc.y);
 
   Local<Object> o_minLoc = Nan::New<Object>();
-  o_minLoc->Set(Nan::New<String>("x").ToLocalChecked(), v_minLoc_x);
-  o_minLoc->Set(Nan::New<String>("y").ToLocalChecked(), v_minLoc_y);
+  Nan::Set(o_minLoc,Nan::New<String>("x").ToLocalChecked(), v_minLoc_x);
+  Nan::Set(o_minLoc,Nan::New<String>("y").ToLocalChecked(), v_minLoc_y);
 
   Local<Object> o_maxLoc = Nan::New<Object>();
-  o_maxLoc->Set(Nan::New<String>("x").ToLocalChecked(), v_maxLoc_x);
-  o_maxLoc->Set(Nan::New<String>("y").ToLocalChecked(), v_maxLoc_y);
+  Nan::Set(o_maxLoc,Nan::New<String>("x").ToLocalChecked(), v_maxLoc_x);
+  Nan::Set(o_maxLoc,Nan::New<String>("y").ToLocalChecked(), v_maxLoc_y);
 
   // Output result object
   Local<Object> result = Nan::New<Object>();
-  result->Set(Nan::New<String>("minVal").ToLocalChecked(), v_minVal);
-  result->Set(Nan::New<String>("maxVal").ToLocalChecked(), v_maxVal);
-  result->Set(Nan::New<String>("minLoc").ToLocalChecked(), o_minLoc);
-  result->Set(Nan::New<String>("maxLoc").ToLocalChecked(), o_maxLoc);
+  Nan::Set(result,Nan::New<String>("minVal").ToLocalChecked(), v_minVal);
+  Nan::Set(result,Nan::New<String>("maxVal").ToLocalChecked(), v_maxVal);
+  Nan::Set(result,Nan::New<String>("minLoc").ToLocalChecked(), o_minLoc);
+  Nan::Set(result, Nan::New<String>("maxLoc").ToLocalChecked(), o_maxLoc);
 
   info.GetReturnValue().Set(result);
 }
@@ -2913,10 +2927,10 @@ NAN_METHOD(Matrix::GetPerspectiveTransform) {
   std::vector<cv::Point2f> src_corners(4);
   std::vector<cv::Point2f> tgt_corners(4);
   for (unsigned int i = 0; i < 4; i++) {
-    src_corners[i] = cvPoint(srcArray->Get(i*2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),srcArray->Get(i*2+1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
-    tgt_corners[i] = cvPoint(tgtArray->Get(i*2)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(),tgtArray->Get(i*2+1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+    src_corners[i] = cvPoint(Nan::To<int32_t>( Nan::Get(srcArray,i*2).ToLocalChecked()).FromJust(), Nan::To<int32_t>( Nan::Get(srcArray,i*2+1).ToLocalChecked()).FromJust());
+    tgt_corners[i] = cvPoint(Nan::To<int32_t>( Nan::Get(tgtArray,i*2).ToLocalChecked()).FromJust(), Nan::To<int32_t>( Nan::Get(tgtArray,i*2+1).ToLocalChecked()).FromJust());
   }
-
+ 
   Local<Object> xfrm = Matrix::CreateWrappedFromMat(cv::getPerspectiveTransform(src_corners, tgt_corners));
 
   info.GetReturnValue().Set(xfrm);
@@ -2969,10 +2983,9 @@ NAN_METHOD(Matrix::SetWithMask) {
   // param 0 - target value:
   Local < Object > valArray = Nan::To<v8::Object>(info[0]).ToLocalChecked();
   cv::Scalar newvals;
-  newvals.val[0] = valArray->Get(0).As<Number>()->Value();
-  newvals.val[1] = valArray->Get(1).As<Number>()->Value();
-  newvals.val[2] = valArray->Get(2).As<Number>()->Value();
-
+  newvals.val[0] = Nan::To<double>( Nan::Get(valArray,0).ToLocalChecked()).FromJust() ;
+  newvals.val[1] = Nan::To<double>( Nan::Get(valArray,1).ToLocalChecked()).FromJust() ;
+  newvals.val[2] = Nan::To<double>( Nan::Get(valArray,2).ToLocalChecked()).FromJust() ;
   // param 1 - mask. same size as src and dest
   Matrix *mask = Nan::ObjectWrap::Unwrap<Matrix>(info[1]->ToObject(Nan::GetCurrentContext()).ToLocalChecked());
 
@@ -2989,10 +3002,10 @@ NAN_METHOD(Matrix::MeanWithMask) {
 
   cv::Scalar means = cv::mean(self->mat, mask->mat);
   v8::Local < v8::Array > arr = Nan::New<Array>(4);
-  arr->Set(0, Nan::New<Number>(means[0]));
-  arr->Set(1, Nan::New<Number>(means[1]));
-  arr->Set(2, Nan::New<Number>(means[2]));
-  arr->Set(3, Nan::New<Number>(means[3]));
+   Nan::Set(arr, 0, Nan::New<Number>(means[0]));
+   Nan::Set(arr, 1, Nan::New<Number>(means[1]));
+   Nan::Set(arr, 2, Nan::New<Number>(means[2]));
+   Nan::Set(arr, 3, Nan::New<Number>(means[3]));
 
   info.GetReturnValue().Set(arr);
 }
@@ -3002,10 +3015,10 @@ NAN_METHOD(Matrix::Mean) {
 
   cv::Scalar means = cv::mean(self->mat);
   v8::Local<v8::Array> arr = Nan::New<Array>(4);
-  arr->Set(0, Nan::New<Number>(means[0]));
-  arr->Set(1, Nan::New<Number>(means[1]));
-  arr->Set(2, Nan::New<Number>(means[2]));
-  arr->Set(3, Nan::New<Number>(means[3]));
+   Nan::Set(arr, 0, Nan::New<Number>(means[0]));
+   Nan::Set(arr, 1, Nan::New<Number>(means[1]));
+   Nan::Set(arr, 2, Nan::New<Number>(means[2]));
+   Nan::Set(arr, 3, Nan::New<Number>(means[3]));
 
   info.GetReturnValue().Set(arr);
 }
@@ -3031,9 +3044,9 @@ NAN_METHOD(Matrix::CopyMakeBorder) {
       v8::Local<v8::Array> objColor = v8::Local<v8::Array>::Cast(info[5]);
       unsigned int length = objColor->Length();
 
-      Local<Value> valB = objColor->Get(0);
-      Local<Value> valG = objColor->Get(1);
-      Local<Value> valR = objColor->Get(2);
+      Local<Value> valB = Nan::Get(objColor,0).ToLocalChecked();
+      Local<Value> valG = Nan::Get(objColor,1).ToLocalChecked();
+      Local<Value> valR = Nan::Get(objColor,2).ToLocalChecked();
 
       if (length == 3) {
         value = cv::Scalar(
@@ -3042,7 +3055,7 @@ NAN_METHOD(Matrix::CopyMakeBorder) {
           valR->IntegerValue( Nan::GetCurrentContext() ).ToChecked() 
         );
       } else if (length == 4) {
-        Local<Value> valA = objColor->Get(3);
+        Local<Value> valA = Nan::Get(objColor,3).ToLocalChecked();
 
         value = cv::Scalar(
           Nan::To<int>(valB).FromJust(),
diff --git a/src/OpenCV.cc b/src/OpenCV.cc
index b9f779c..28c575e 100755
--- a/src/OpenCV.cc
+++ b/src/OpenCV.cc
@@ -8,7 +8,7 @@ void OpenCV::Init(Local<Object> target) {
   // Version string.
   char out [21];
   int n = sprintf(out, "%i.%i", CV_MAJOR_VERSION, CV_MINOR_VERSION);
-  target->Set(Nan::New<String>("version").ToLocalChecked(), Nan::New<String>(out, n).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New<String>("version").ToLocalChecked(), Nan::New<String>(out, n).ToLocalChecked());
 
   Nan::SetMethod(target, "readImage", ReadImage);
   Nan::SetMethod(target, "readImageAsync", ReadImageAsync);
@@ -369,7 +369,7 @@ NAN_METHOD(OpenCV::ReadImageMulti) {
 
   for (std::vector<cv::Mat>::size_type i = 0; i < mats.size(); i ++) {
     Local<Object> im_h = Matrix::CreateWrappedFromMat(mats[i]);
-    output->Set(i, im_h);
+    output->Set(Nan::GetCurrentContext(), i, im_h);
   }
 
   Nan::TryCatch try_catch;
diff --git a/src/Point.cc b/src/Point.cc
index 4ef8a1a..7cdc034 100755
--- a/src/Point.cc
+++ b/src/Point.cc
@@ -19,7 +19,7 @@ void Point::Init(Local<Object> target) {
 
   Nan::SetPrototypeMethod(ctor, "dot", Dot);
 
-  target->Set(Nan::New("Point").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("Point").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 };
 
 NAN_METHOD(Point::New) {
diff --git a/src/Stereo.cc b/src/Stereo.cc
index 567d91f..495c326 100644
--- a/src/Stereo.cc
+++ b/src/Stereo.cc
@@ -32,7 +32,7 @@ void StereoBM::Init(Local<Object> target) {
   ctor->Set(Nan::New<String>("FISH_EYE_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::FISH_EYE_PRESET));
   ctor->Set(Nan::New<String>("NARROW_PRESET").ToLocalChecked(), Nan::New<Integer>((int)cv::StereoBM::NARROW_PRESET));
 
-  target->Set(Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(),Nan::New("StereoBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(StereoBM::New) {
@@ -117,7 +117,7 @@ void StereoSGBM::Init(Local<Object> target) {
 
   Nan::SetPrototypeMethod(ctor, "compute", Compute);
 
-  target->Set(Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("StereoSGBM").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(StereoSGBM::New) {
@@ -249,7 +249,7 @@ void StereoGC::Init(Local<Object> target) {
 
   Nan::SetPrototypeMethod(ctor, "compute", Compute);
 
-  target->Set(Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(),Nan::New("StereoGC").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(StereoGC::New) {
diff --git a/src/VideoCaptureWrap.cc b/src/VideoCaptureWrap.cc
index c91391b..1f2482e 100755
--- a/src/VideoCaptureWrap.cc
+++ b/src/VideoCaptureWrap.cc
@@ -48,7 +48,7 @@ void VideoCaptureWrap::Init(Local<Object> target) {
   Nan::SetPrototypeMethod(ctor, "grab", Grab);
   Nan::SetPrototypeMethod(ctor, "retrieve", Retrieve);
 
-  target->Set(Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("VideoCapture").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(VideoCaptureWrap::New) {
diff --git a/src/VideoWriterWrap.cc b/src/VideoWriterWrap.cc
index c2125df..60e847a 100755
--- a/src/VideoWriterWrap.cc
+++ b/src/VideoWriterWrap.cc
@@ -34,7 +34,7 @@ void VideoWriterWrap::Init(Local<Object> target) {
   Nan::SetPrototypeMethod(ctor, "writeSync", WriteSync);
   Nan::SetPrototypeMethod(ctor, "release", Release);
 
-  target->Set(Nan::New("VideoWriter").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
+  target->Set(Nan::GetCurrentContext(), Nan::New("VideoWriter").ToLocalChecked(), ctor->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }
 
 NAN_METHOD(VideoWriterWrap::New) {
@@ -60,13 +60,13 @@ NAN_METHOD(VideoWriterWrap::New) {
     cv::Size imageSize;
     if (info[3]->IsArray()) {
       Local<Object> v8sz = info[3]->ToObject(Nan::GetCurrentContext()).ToLocalChecked();
-      imageSize = cv::Size(v8sz->Get(1)->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(0)->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
+      imageSize = cv::Size(v8sz->Get(Nan::GetCurrentContext(),1).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked(), v8sz->Get(Nan::GetCurrentContext(),0).ToLocalChecked()->IntegerValue( Nan::GetCurrentContext() ).ToChecked());
     } else {
       JSTHROW_TYPE("Must pass image size");
     }
 
     // Arg 4 is the color flag
-    bool isColor = info[4]->BooleanValue( Nan::GetCurrentContext() ).FromJust();
+    bool isColor = info[4]->BooleanValue( v8::Isolate::GetCurrent() );
     v = new VideoWriterWrap(filename, fourcc,  fps, imageSize, isColor);
 
     v->Wrap(info.This());
diff --git a/test/nativemat.cc b/test/nativemat.cc
index bb6351e..6166691 100644
--- a/test/nativemat.cc
+++ b/test/nativemat.cc
@@ -6,14 +6,14 @@ void Size(const Nan::FunctionCallbackInfo<v8::Value>& info) {
   cv::Mat mat = Nan::ObjectWrap::Unwrap<node_opencv::Matrix>(Nan::To<v8::Object>(info[0]).ToLocalChecked())->mat;
 
   v8::Local < v8::Array > arr = Nan::New<v8::Array>(2);
-  arr->Set(0, Nan::New<v8::Number>(mat.size().height));
-  arr->Set(1, Nan::New<v8::Number>(mat.size().width));
+  arr->Set(Nan::GetCurrentContext(),0, Nan::New<v8::Number>(mat.size().height));
+  arr->Set(Nan::GetCurrentContext(),1, Nan::New<v8::Number>(mat.size().width));
 
   info.GetReturnValue().Set(arr);
 }
 
 void Init(v8::Local<v8::Object> exports) {
-  exports->Set(Nan::New("size").ToLocalChecked(),
+  exports->Set(Nan::GetCurrentContext(), Nan::New("size").ToLocalChecked(),
                Nan::New<v8::FunctionTemplate>(Size)->GetFunction( Nan::GetCurrentContext() ).ToLocalChecked());
 }