@nativescript/canvas 2.0.0-alpha.21 → 2.0.0-alpha.23

package/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp

@@ -122,12 +122,12 @@ v8::Local<v8::Value> WebGLRenderingContext::GetParameterInternal(v8::Isolate *is
                 value == 0) {
                 return scope.Escape(v8::Null(isolate));
             }
-            return scope.Escape(v8::Number::New(isolate, (double) value));
+            return scope.Escape(v8::Integer::New(isolate, value));
         }
         case (uint32_t) GLConstants::UNPACK_COLORSPACE_CONVERSION_WEBGL:
-            return scope.Escape(v8::Number::New(isolate,
-                                                (double) canvas_native_webgl_state_get_unpack_colorspace_conversion_webgl(
-                                                        this->GetState())));
+            return scope.Escape(v8::Integer::New(isolate,
+                                                 canvas_native_webgl_state_get_unpack_colorspace_conversion_webgl(
+                                                         this->GetState())));
         case GL_ALIASED_LINE_WIDTH_RANGE:
         case GL_ALIASED_POINT_SIZE_RANGE:
         case GL_BLEND_COLOR:
@@ -307,7 +307,7 @@ void WebGLRenderingContext::ActiveTexture(const v8::FunctionCallbackInfo<v8::Val
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    auto texture = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto texture = args[0]->Uint32Value(context).ToChecked();
     canvas_native_webgl_active_texture(texture,
                                        ptr->GetState());
 }
@@ -322,32 +322,33 @@ void WebGLRenderingContext::AttachShader(const v8::FunctionCallbackInfo<v8::Valu
 
     auto programValue = args[0];
     auto shaderValue = args[1];
-    if (programValue->IsObject() && shaderValue->IsObject()) {
-        WebGLProgram *program = nullptr;
-        WebGLShader *shader = nullptr;
-        if (GetNativeType(isolate, programValue.As<v8::Object>()) == NativeType::WebGLProgram) {
-            program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-        }
 
-        if (GetNativeType(isolate, shaderValue.As<v8::Object>()) == NativeType::WebGLShader) {
-            shader = WebGLShader::GetPointer(shaderValue.As<v8::Object>());
-        }
+    auto programType = GetNativeType(isolate, programValue);
+    auto shaderType = GetNativeType(isolate, shaderValue);
 
-        if (program == nullptr) {
-            return;
-        }
+    WebGLProgram *program = nullptr;
+    WebGLShader *shader = nullptr;
+    if (programType == NativeType::WebGLProgram) {
+        program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+    }
 
-        if (shader == nullptr) {
-            return;
-        }
+    if (shaderType == NativeType::WebGLShader) {
+        shader = WebGLShader::GetPointer(shaderValue.As<v8::Object>());
+    }
 
-        canvas_native_webgl_attach_shader(
-                program->GetProgram(),
-                shader->GetShader(),
-                ptr->GetState()
-        );
+    if (program == nullptr) {
+        return;
+    }
 
+    if (shader == nullptr) {
+        return;
     }
+
+    canvas_native_webgl_attach_shader(
+            program->GetProgram(),
+            shader->GetShader(),
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::BindAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -359,23 +360,20 @@ void WebGLRenderingContext::BindAttribLocation(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 2) {
-        auto programValue = args[0];
-        auto type = GetNativeType(isolate, programValue);
-        if (type == NativeType::WebGLProgram && args[1]->IsNumber() &&
-            args[2]->IsString()) {
-            auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
 
-            auto index = (uint32_t) args[1]->NumberValue(context).ToChecked();
-            auto name = ConvertFromV8String(isolate, args[2]);
-            canvas_native_webgl_bind_attrib_location(
-                    program->GetProgram(),
-                    index,
-                    name.c_str(),
-                    ptr->GetState()
-            );
+        auto index = args[1]->Uint32Value(context).ToChecked();
+        auto name = ConvertFromV8String(isolate, args[2]);
+        canvas_native_webgl_bind_attrib_location(
+                program->GetProgram(),
+                index,
+                name.c_str(),
+                ptr->GetState()
+        );
 
-        }
     }
 }
 
@@ -388,33 +386,29 @@ void WebGLRenderingContext::BindBuffer(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        if (args[0]->IsNumber()) {
-            auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-            if (!args[1]->IsNull() &&
-                args[1]->IsObject()) {
-                auto type = GetNativeType(isolate, args[1].As<v8::Object>());
-                if (type == NativeType::WebGLBuffer) {
-                    auto buffer = WebGLBuffer::GetPointer(args[1].As<v8::Object>());
-                    if (buffer ==
-                        nullptr) { return; }
-                    canvas_native_webgl_bind_buffer(
-                            target,
-                            buffer->GetBuffer(),
-                            ptr->GetState()
-                    );
-                }
-
-            } else {
-                // unbind
-                // check for null or undefined ?
-                canvas_native_webgl_bind_buffer(
-                        target,
-                        0,
-                        ptr->GetState()
-                );
-            }
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    if (!args[1]->IsNull() &&
+        args[1]->IsObject()) {
+        auto type = GetNativeType(isolate, args[1].As<v8::Object>());
+        if (type == NativeType::WebGLBuffer) {
+            auto buffer = WebGLBuffer::GetPointer(args[1].As<v8::Object>());
+            if (buffer ==
+                nullptr) { return; }
+            canvas_native_webgl_bind_buffer(
+                    target,
+                    buffer->GetBuffer(),
+                    ptr->GetState()
+            );
         }
+
+    } else {
+        // unbind
+        // check for null or undefined ?
+        canvas_native_webgl_bind_buffer(
+                target,
+                0,
+                ptr->GetState()
+        );
     }
 }
 
@@ -427,28 +421,26 @@ void WebGLRenderingContext::BindFramebuffer(const v8::FunctionCallbackInfo<v8::V
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        if (args[0]->IsNumber()) {
-            auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-            if (args[1]->IsObject()) {
-                auto type = GetNativeType(isolate, args[1].As<v8::Object>());
-                if (type == NativeType::WebGLFramebuffer) {
-                    auto framebuffer = WebGLFramebuffer::GetPointer(args[1].As<v8::Object>());
-                    canvas_native_webgl_bind_frame_buffer(
-                            target,
-                            framebuffer->GetFrameBuffer(),
-                            ptr->GetState()
-                    );
-                }
-            } else {
-                // null value
-                // unbind
+    if (args[0]->IsNumber()) {
+        auto target = args[0]->Uint32Value(context).ToChecked();
+        if (args[1]->IsObject()) {
+            auto type = GetNativeType(isolate, args[1]);
+            if (type == NativeType::WebGLFramebuffer) {
+                auto framebuffer = WebGLFramebuffer::GetPointer(args[1].As<v8::Object>());
                 canvas_native_webgl_bind_frame_buffer(
                         target,
-                        0,
+                        framebuffer->GetFrameBuffer(),
                         ptr->GetState()
                 );
             }
+        } else {
+            // null value
+            // unbind
+            canvas_native_webgl_bind_frame_buffer(
+                    target,
+                    0,
+                    ptr->GetState()
+            );
         }
     }
 }
@@ -462,30 +454,26 @@ void WebGLRenderingContext::BindRenderbuffer(const v8::FunctionCallbackInfo<v8::
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        if (args[0]->IsNumber()) {
-            auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-            if (args[1]->IsObject()) {
-                auto type = GetNativeType(isolate, args[1].As<v8::Object>());
-                if (type == NativeType::WebGLRenderbuffer) {
-                    auto renderbuffer = WebGLRenderbuffer::GetPointer(args[1].As<v8::Object>());
-
-                    if (renderbuffer ==
-                        nullptr) { return; }
-                    canvas_native_webgl_bind_render_buffer(
-                            target,
-                            renderbuffer->GetRenderBuffer(),
-                            ptr->GetState()
-                    );
-                }
-            } else {
-                canvas_native_webgl_bind_render_buffer(
-                        target,
-                        0,
-                        ptr->GetState()
-                );
-            }
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    if (args[1]->IsObject()) {
+        auto type = GetNativeType(isolate, args[1].As<v8::Object>());
+        if (type == NativeType::WebGLRenderbuffer) {
+            auto renderbuffer = WebGLRenderbuffer::GetPointer(args[1].As<v8::Object>());
+
+            if (renderbuffer ==
+                nullptr) { return; }
+            canvas_native_webgl_bind_render_buffer(
+                    target,
+                    renderbuffer->GetRenderBuffer(),
+                    ptr->GetState()
+            );
         }
+    } else {
+        canvas_native_webgl_bind_render_buffer(
+                target,
+                0,
+                ptr->GetState()
+        );
     }
 }
 
@@ -498,27 +486,23 @@ void WebGLRenderingContext::BindTexture(const v8::FunctionCallbackInfo<v8::Value
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        if (args[0]->IsNumber()) {
-            auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-            if (args[1]->IsObject()) {
-                auto type = GetNativeType(isolate, args[1].As<v8::Object>());
-                if (type == NativeType::WebGLTexture) {
-                    auto texture = WebGLTexture::GetPointer(args[1].As<v8::Object>());
-                    canvas_native_webgl_bind_texture(
-                            target,
-                            texture->GetTexture(),
-                            ptr->GetState()
-                    );
-                }
-            } else {
-                canvas_native_webgl_bind_texture(
-                        target,
-                        0,
-                        ptr->GetState()
-                );
-            }
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    if (args[1]->IsObject()) {
+        auto type = GetNativeType(isolate, args[1].As<v8::Object>());
+        if (type == NativeType::WebGLTexture) {
+            auto texture = WebGLTexture::GetPointer(args[1].As<v8::Object>());
+            canvas_native_webgl_bind_texture(
+                    target,
+                    texture->GetTexture(),
+                    ptr->GetState()
+            );
         }
+    } else {
+        canvas_native_webgl_bind_texture(
+                target,
+                0,
+                ptr->GetState()
+        );
     }
 }
 
@@ -531,20 +515,18 @@ void WebGLRenderingContext::BlendColor(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto red = args[0]->NumberValue(context).ToChecked();
-        auto green = args[1]->NumberValue(context).ToChecked();
-        auto blue = args[2]->NumberValue(context).ToChecked();
-        auto alpha = args[3]->NumberValue(context).ToChecked();
-
-        canvas_native_webgl_blend_color(
-                static_cast<float>(red),
-                static_cast<float>(green),
-                static_cast<float>(blue),
-                static_cast<float>(alpha),
-                ptr->GetState()
-        );
-    }
+    auto red = args[0]->NumberValue(context).ToChecked();
+    auto green = args[1]->NumberValue(context).ToChecked();
+    auto blue = args[2]->NumberValue(context).ToChecked();
+    auto alpha = args[3]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_blend_color(
+            static_cast<float>(red),
+            static_cast<float>(green),
+            static_cast<float>(blue),
+            static_cast<float>(alpha),
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::BlendEquationSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -556,16 +538,14 @@ void WebGLRenderingContext::BlendEquationSeparate(const v8::FunctionCallbackInfo
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto modeRGB = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto modeAlpha = (uint32_t) args[1]->NumberValue(context).ToChecked();
+    auto modeRGB = args[0]->Uint32Value(context).ToChecked();
+    auto modeAlpha = args[1]->Uint32Value(context).ToChecked();
 
-        canvas_native_webgl_blend_equation_separate(
-                modeRGB,
-                modeAlpha,
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_blend_equation_separate(
+            modeRGB,
+            modeAlpha,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::BlendEquation(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -577,13 +557,11 @@ void WebGLRenderingContext::BlendEquation(const v8::FunctionCallbackInfo<v8::Val
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 0) {
-        auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        canvas_native_webgl_blend_equation(
-                mode,
-                ptr->GetState()
-        );
-    }
+    auto mode = args[0]->Uint32Value(context).ToChecked();
+    canvas_native_webgl_blend_equation(
+            mode,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::BlendFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -595,20 +573,18 @@ void WebGLRenderingContext::BlendFuncSeparate(const v8::FunctionCallbackInfo<v8:
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto srcRGB = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto dstRGB = (uint32_t) args[1]->NumberValue(context).ToChecked();
-        auto srcAlpha = (uint32_t) args[2]->NumberValue(context).ToChecked();
-        auto dstAlpha = (uint32_t) args[3]->NumberValue(context).ToChecked();
-
-        canvas_native_webgl_blend_func_separate(
-                srcRGB,
-                dstRGB,
-                srcAlpha,
-                dstAlpha,
-                ptr->GetState()
-        );
-    }
+    auto srcRGB = args[0]->Uint32Value(context).ToChecked();
+    auto dstRGB = args[1]->Uint32Value(context).ToChecked();
+    auto srcAlpha = args[2]->Uint32Value(context).ToChecked();
+    auto dstAlpha = args[3]->Uint32Value(context).ToChecked();
+
+    canvas_native_webgl_blend_func_separate(
+            srcRGB,
+            dstRGB,
+            srcAlpha,
+            dstAlpha,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::BlendFunc(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -620,16 +596,14 @@ void WebGLRenderingContext::BlendFunc(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto sfactor = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto dfactor = (uint32_t) args[1]->NumberValue(context).ToChecked();
+    auto sfactor = args[0]->Uint32Value(context).ToChecked();
+    auto dfactor = args[1]->Uint32Value(context).ToChecked();
 
-        canvas_native_webgl_blend_func(
-                sfactor,
-                dfactor,
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_blend_func(
+            sfactor,
+            dfactor,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -644,8 +618,8 @@ void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value>
     auto count = args.Length();
 
     if (count == 2) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto usage = (uint32_t) args[1]->NumberValue(context).ToChecked();
+        auto target = args[0]->Uint32Value(context).ToChecked();
+        auto usage = args[1]->Uint32Value(context).ToChecked();
 
         canvas_native_webgl_buffer_data_none(
                 target,
@@ -654,9 +628,9 @@ void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value>
                 ptr->GetState()
         );
     } else if (count == 3) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto target = args[0]->Uint32Value(context).ToChecked();
 
-        auto usage = (uint32_t) args[2]->NumberValue(context).ToChecked();
+        auto usage = args[2]->Uint32Value(context).ToChecked();
 
         if (args[1]->IsObject()) {
 
@@ -668,7 +642,8 @@ void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value>
                     auto array = buf->Buffer();
                     auto offset = buf->ByteOffset();
                     auto size = buf->Length();
-                    auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                    auto data_ptr =
+                            static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                     auto data = static_cast<uint16_t *>((void *) data_ptr);
 
                     canvas_native_webgl_buffer_data_u16(
@@ -683,7 +658,8 @@ void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value>
                     auto array = buf->Buffer();
                     auto offset = buf->ByteOffset();
                     auto size = buf->Length();
-                    auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                    auto data_ptr =
+                            static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                     auto data = static_cast<float *>((void *) data_ptr);
 
                     canvas_native_webgl_buffer_data_f32(
@@ -698,7 +674,8 @@ void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value>
                     auto array = buf->Buffer();
                     auto offset = buf->ByteOffset();
                     auto size = buf->ByteLength();
-                    auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                    auto data_ptr =
+                            static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                     auto data = static_cast<uint8_t *>((void *) data_ptr);
 
 
@@ -747,7 +724,7 @@ void WebGLRenderingContext::BufferSubData(const v8::FunctionCallbackInfo<v8::Val
     auto count = args.Length();
 
     if (count == 2) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto target = args[0]->Uint32Value(context).ToChecked();
         auto offset = args[1]->NumberValue(context).ToChecked();
 
         canvas_native_webgl_buffer_sub_data_none(
@@ -756,7 +733,7 @@ void WebGLRenderingContext::BufferSubData(const v8::FunctionCallbackInfo<v8::Val
                 ptr->GetState()
         );
     } else if (count == 3) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto target = args[0]->Uint32Value(context).ToChecked();
         auto offset = args[1]->NumberValue(context).ToChecked();
 
         if (args[2]->IsObject()) {
@@ -809,19 +786,16 @@ WebGLRenderingContext::CheckFramebufferStatus(const v8::FunctionCallbackInfo<v8:
 
     auto count = args.Length();
 
-    if (count > 0) {
+    if (args[0]->IsNumber()) {
+        auto target = args[0]->Uint32Value(context).ToChecked();
 
-        if (args[0]->IsNumber()) {
-            auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-
-            auto ret = canvas_native_webgl_check_frame_buffer_status(
-                    target,
-                    ptr->GetState()
-            );
+        auto ret = canvas_native_webgl_check_frame_buffer_status(
+                target,
+                ptr->GetState()
+        );
 
-            args.GetReturnValue().Set((int32_t) ret);
-            return;
-        }
+        args.GetReturnValue().Set(ret);
+        return;
     }
 
     args.GetReturnValue().Set(0);
@@ -836,20 +810,18 @@ void WebGLRenderingContext::ClearColor(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto red = args[0]->NumberValue(context).ToChecked();
-        auto green = args[1]->NumberValue(context).ToChecked();
-        auto blue = args[2]->NumberValue(context).ToChecked();
-        auto alpha = args[3]->NumberValue(context).ToChecked();
-
-        canvas_native_webgl_clear_color(
-                static_cast<float>(red),
-                static_cast<float>(green),
-                static_cast<float>(blue),
-                static_cast<float>(alpha),
-                ptr->GetState()
-        );
-    }
+    auto red = args[0]->NumberValue(context).ToChecked();
+    auto green = args[1]->NumberValue(context).ToChecked();
+    auto blue = args[2]->NumberValue(context).ToChecked();
+    auto alpha = args[3]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_clear_color(
+            static_cast<float>(red),
+            static_cast<float>(green),
+            static_cast<float>(blue),
+            static_cast<float>(alpha),
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::ClearDepth(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -861,14 +833,12 @@ void WebGLRenderingContext::ClearDepth(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 0) {
-        auto depth = args[0]->NumberValue(context).ToChecked();
+    auto depth = args[0]->NumberValue(context).ToChecked();
 
-        canvas_native_webgl_clear_depth(
-                static_cast<float>(depth),
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_clear_depth(
+            static_cast<float>(depth),
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::ClearStencil(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -880,13 +850,11 @@ void WebGLRenderingContext::ClearStencil(const v8::FunctionCallbackInfo<v8::Valu
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 0) {
-        auto stencil = (int32_t) args[0]->NumberValue(context).ToChecked();
-        canvas_native_webgl_clear_stencil(
-                stencil,
-                ptr->GetState()
-        );
-    }
+    auto stencil = args[0]->Int32Value(context).ToChecked();
+    canvas_native_webgl_clear_stencil(
+            stencil,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::Clear(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -898,8 +866,7 @@ void WebGLRenderingContext::Clear(const v8::FunctionCallbackInfo<v8::Value> &arg
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    //if (count > 0) {
-    auto mask = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto mask = args[0]->Uint32Value(context).ToChecked();
 
     canvas_native_webgl_clear(
             mask,
@@ -907,7 +874,6 @@ void WebGLRenderingContext::Clear(const v8::FunctionCallbackInfo<v8::Value> &arg
     );
 
     ptr->UpdateInvalidateState();
-    // }
 }
 
 void WebGLRenderingContext::ColorMask(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -918,20 +884,18 @@ void WebGLRenderingContext::ColorMask(const v8::FunctionCallbackInfo<v8::Value>
 
     auto isolate = args.GetIsolate();
 
-    if (args.Length() > 3) {
-        auto red = args[0]->BooleanValue(isolate);
-        auto green = args[1]->BooleanValue(isolate);
-        auto blue = args[2]->BooleanValue(isolate);
-        auto alpha = args[3]->BooleanValue(isolate);
+    auto red = args[0]->BooleanValue(isolate);
+    auto green = args[1]->BooleanValue(isolate);
+    auto blue = args[2]->BooleanValue(isolate);
+    auto alpha = args[3]->BooleanValue(isolate);
 
-        canvas_native_webgl_color_mask(
-                red,
-                green,
-                blue,
-                alpha,
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_color_mask(
+            red,
+            green,
+            blue,
+            alpha,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::Commit(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -947,14 +911,12 @@ void WebGLRenderingContext::CompileShader(const v8::FunctionCallbackInfo<v8::Val
         return;
     }
 
-    if (args.Length() > 0) {
-        auto shader = WebGLShader::GetPointer(args[0].As<v8::Object>());
-        if (shader != nullptr) {
-            canvas_native_webgl_compile_shader(
-                    shader->GetShader(),
-                    ptr->GetState()
-            );
-        }
+    auto shader = WebGLShader::GetPointer(args[0].As<v8::Object>());
+    if (shader != nullptr) {
+        canvas_native_webgl_compile_shader(
+                shader->GetShader(),
+                ptr->GetState()
+        );
     }
 }
 
@@ -970,12 +932,12 @@ void WebGLRenderingContext::CompressedTexImage2D(const v8::FunctionCallbackInfo<
     auto count = args.Length();
 
     if (count == 6) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(context).ToChecked();
-        auto internalformat = (uint32_t) args[2]->NumberValue(context).ToChecked();
-        auto width = (int32_t) args[3]->NumberValue(context).ToChecked();
-        auto height = (int32_t) args[4]->NumberValue(context).ToChecked();
-        auto border = (int32_t) args[5]->NumberValue(context).ToChecked();
+        auto target = args[0]->Uint32Value(context).ToChecked();
+        auto level = args[1]->Int32Value(context).ToChecked();
+        auto internalformat = args[2]->Uint32Value(context).ToChecked();
+        auto width = args[3]->Int32Value(context).ToChecked();
+        auto height = args[4]->Int32Value(context).ToChecked();
+        auto border = args[5]->Int32Value(context).ToChecked();
 
         canvas_native_webgl_compressed_tex_image2d_none(
                 target,
@@ -987,12 +949,12 @@ void WebGLRenderingContext::CompressedTexImage2D(const v8::FunctionCallbackInfo<
                 ptr->GetState()
         );
     } else if (count > 6) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(context).ToChecked();
-        auto internalformat = (uint32_t) args[2]->NumberValue(context).ToChecked();
-        auto width = (int32_t) args[3]->NumberValue(context).ToChecked();
-        auto height = (int32_t) args[4]->NumberValue(context).ToChecked();
-        auto border = (int32_t) args[5]->NumberValue(context).ToChecked();
+        auto target = args[0]->Uint32Value(context).ToChecked();
+        auto level = args[1]->Int32Value(context).ToChecked();
+        auto internalformat = args[2]->Uint32Value(context).ToChecked();
+        auto width = args[3]->Int32Value(context).ToChecked();
+        auto height = args[4]->Int32Value(context).ToChecked();
+        auto border = args[5]->Int32Value(context).ToChecked();
         auto pixels = args[6];
         if (pixels->IsObject()) {
             if (pixels->IsArrayBufferView()) {
@@ -1001,7 +963,7 @@ void WebGLRenderingContext::CompressedTexImage2D(const v8::FunctionCallbackInfo<
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->ByteLength();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<uint8_t *>((void *) data_ptr);
 
 
@@ -1047,55 +1009,50 @@ WebGLRenderingContext::CompressedTexSubImage2D(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto count = args.Length();
-
-
-    if (count > 7) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(context).ToChecked();
-        auto xoffset = (int32_t) args[2]->NumberValue(context).ToChecked();
-        auto yoffset = (int32_t) args[3]->NumberValue(context).ToChecked();
-        auto width = (int32_t) args[4]->NumberValue(context).ToChecked();
-        auto height = (int32_t) args[5]->NumberValue(context).ToChecked();
-        auto format = (uint32_t) args[6]->NumberValue(context).ToChecked();
-        if (args[7]->IsObject()) {
-            auto pixels = args[7];
-            if (pixels->IsArrayBufferView()) {
-                auto buf = pixels.As<v8::ArrayBufferView>();
-                auto array = buf->Buffer();
-                auto offset = buf->ByteOffset();
-                auto size = array->ByteLength();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
-                auto data = static_cast<uint8_t *>((void *) data_ptr);
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    auto level = args[1]->Int32Value(context).ToChecked();
+    auto xoffset = args[2]->Int32Value(context).ToChecked();
+    auto yoffset = args[3]->Int32Value(context).ToChecked();
+    auto width = args[4]->Int32Value(context).ToChecked();
+    auto height = args[5]->Int32Value(context).ToChecked();
+    auto format = args[6]->Uint32Value(context).ToChecked();
+    if (args[7]->IsObject()) {
+        auto pixels = args[7];
+        if (pixels->IsArrayBufferView()) {
+            auto buf = pixels.As<v8::ArrayBufferView>();
+            auto array = buf->Buffer();
+            auto offset = buf->ByteOffset();
+            auto size = array->ByteLength();
+            auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
+            auto data = static_cast<uint8_t *>((void *) data_ptr);
 
-                canvas_native_webgl_compressed_tex_sub_image2d(
-                        target,
-                        level,
-                        xoffset,
-                        yoffset,
-                        width,
-                        height,
-                        format,
-                        data, size,
-                        ptr->GetState()
-                );
-            } else if (pixels->IsArrayBuffer()) {
-                auto array = pixels.As<v8::ArrayBuffer>();
-                auto size = array->ByteLength();
-                auto data = (uint8_t *) array->GetBackingStore()->Data();
+            canvas_native_webgl_compressed_tex_sub_image2d(
+                    target,
+                    level,
+                    xoffset,
+                    yoffset,
+                    width,
+                    height,
+                    format,
+                    data, size,
+                    ptr->GetState()
+            );
+        } else if (pixels->IsArrayBuffer()) {
+            auto array = pixels.As<v8::ArrayBuffer>();
+            auto size = array->ByteLength();
+            auto data = (uint8_t *) array->GetBackingStore()->Data();
 
-                canvas_native_webgl_compressed_tex_sub_image2d(
-                        target,
-                        level,
-                        xoffset,
-                        yoffset,
-                        width,
-                        height,
-                        format,
-                        data, size,
-                        ptr->GetState()
-                );
-            }
+            canvas_native_webgl_compressed_tex_sub_image2d(
+                    target,
+                    level,
+                    xoffset,
+                    yoffset,
+                    width,
+                    height,
+                    format,
+                    data, size,
+                    ptr->GetState()
+            );
         }
     }
 
@@ -1113,28 +1070,26 @@ void WebGLRenderingContext::CopyTexImage2D(const v8::FunctionCallbackInfo<v8::Va
     auto count = args.Length();
 
 
-    if (count > 7) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(context).ToChecked();
-        auto internalformat = (uint32_t) args[2]->NumberValue(context).ToChecked();
-        auto x = (int32_t) args[3]->NumberValue(context).ToChecked();
-        auto y = (int32_t) args[4]->NumberValue(context).ToChecked();
-        auto width = (int32_t) args[5]->NumberValue(context).ToChecked();
-        auto height = (int32_t) args[6]->NumberValue(context).ToChecked();
-        auto border = (int32_t) args[7]->NumberValue(context).ToChecked();
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    auto level = args[1]->Int32Value(context).ToChecked();
+    auto internalformat = args[2]->Uint32Value(context).ToChecked();
+    auto x = args[3]->Int32Value(context).ToChecked();
+    auto y = args[4]->Int32Value(context).ToChecked();
+    auto width = args[5]->Int32Value(context).ToChecked();
+    auto height = args[6]->Int32Value(context).ToChecked();
+    auto border = args[7]->Int32Value(context).ToChecked();
 
-        canvas_native_webgl_copy_tex_image2d(
-                target,
-                level,
-                internalformat,
-                x,
-                y,
-                width,
-                height,
-                border,
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_copy_tex_image2d(
+            target,
+            level,
+            internalformat,
+            x,
+            y,
+            width,
+            height,
+            border,
+            ptr->GetState()
+    );
 
 }
 
@@ -1150,28 +1105,26 @@ void WebGLRenderingContext::CopyTexSubImage2D(const v8::FunctionCallbackInfo<v8:
     auto count = args.Length();
 
 
-    if (count > 7) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(context).ToChecked();
-        auto xoffset = (int32_t) args[2]->NumberValue(context).ToChecked();
-        auto yoffset = (int32_t) args[3]->NumberValue(context).ToChecked();
-        auto x = (int32_t) args[4]->NumberValue(context).ToChecked();
-        auto y = (int32_t) args[5]->NumberValue(context).ToChecked();
-        auto width = (int32_t) args[6]->NumberValue(context).ToChecked();
-        auto height = (int32_t) args[7]->NumberValue(context).ToChecked();
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    auto level = args[1]->Int32Value(context).ToChecked();
+    auto xoffset = args[2]->Int32Value(context).ToChecked();
+    auto yoffset = args[3]->Int32Value(context).ToChecked();
+    auto x = args[4]->Int32Value(context).ToChecked();
+    auto y = args[5]->Int32Value(context).ToChecked();
+    auto width = args[6]->Int32Value(context).ToChecked();
+    auto height = args[7]->Int32Value(context).ToChecked();
 
-        canvas_native_webgl_copy_tex_sub_image2d(
-                target,
-                level,
-                xoffset,
-                yoffset,
-                x,
-                y,
-                width,
-                height,
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_copy_tex_sub_image2d(
+            target,
+            level,
+            xoffset,
+            yoffset,
+            x,
+            y,
+            width,
+            height,
+            ptr->GetState()
+    );
 
 }
 
@@ -1284,7 +1237,7 @@ void WebGLRenderingContext::CreateShader(const v8::FunctionCallbackInfo<v8::Valu
         return;
     }
 
-    auto type = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto type = args[0]->Uint32Value(context).ToChecked();
     auto shader = canvas_native_webgl_create_shader(
             type, ptr->GetState());
     if (shader != 0) {
@@ -1331,14 +1284,12 @@ void WebGLRenderingContext::CullFace(const v8::FunctionCallbackInfo<v8::Value> &
     auto context = isolate->GetCurrentContext();
 
 
-    if (args.Length() > 0) {
-        auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
-
-        canvas_native_webgl_cull_face(
-                mode,
-                ptr->GetState()
-        );
-    }
+    auto mode = args[0]->Uint32Value(context).ToChecked();
+
+    canvas_native_webgl_cull_face(
+            mode,
+            ptr->GetState()
+    );
 
 }
 
@@ -1351,19 +1302,15 @@ void WebGLRenderingContext::DeleteBuffer(const v8::FunctionCallbackInfo<v8::Valu
     auto isolate = args.GetIsolate();
 
 
-    if (args.Length() > 0) {
-        auto value = args[0];
-        if (value->IsObject()) {
-            auto type = GetNativeType(isolate, value.As<v8::Object>());
-            if (type == NativeType::WebGLBuffer) {
-                auto buffer = WebGLBuffer::GetPointer(value.As<v8::Object>());
-                if (buffer != nullptr) {
-                    canvas_native_webgl_delete_buffer(
-                            buffer->GetBuffer(),
-                            ptr->GetState()
-                    );
-                }
-            }
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value.As<v8::Object>());
+    if (type == NativeType::WebGLBuffer) {
+        auto buffer = WebGLBuffer::GetPointer(value.As<v8::Object>());
+        if (buffer != nullptr) {
+            canvas_native_webgl_delete_buffer(
+                    buffer->GetBuffer(),
+                    ptr->GetState()
+            );
         }
     }
 
@@ -1501,14 +1448,12 @@ void WebGLRenderingContext::DepthFunc(const v8::FunctionCallbackInfo<v8::Value>
 
     auto value = args[0];
 
-    if (args.Length() > 0) {
-        auto func = (uint32_t) value->NumberValue(context).ToChecked();
+    auto func = value->Uint32Value(context).ToChecked();
 
-        canvas_native_webgl_depth_func(
-                func,
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_depth_func(
+            func,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::DepthMask(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -1519,16 +1464,12 @@ void WebGLRenderingContext::DepthMask(const v8::FunctionCallbackInfo<v8::Value>
 
     auto isolate = args.GetIsolate();
 
-    auto value = args[0];
-
-    if (args.Length() > 0) {
-        auto mask = value->BooleanValue(isolate);
+    auto mask = args[0]->BooleanValue(isolate);
 
-        canvas_native_webgl_depth_mask(
-                mask,
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_depth_mask(
+            mask,
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::DepthRange(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -1543,14 +1484,11 @@ void WebGLRenderingContext::DepthRange(const v8::FunctionCallbackInfo<v8::Value>
     auto zNear = args[0];
     auto zFar = args[1];
 
-    if (args.Length() > 1) {
-
-        canvas_native_webgl_depth_range(
-                static_cast<float>(zNear->NumberValue(context).ToChecked()),
-                static_cast<float>(zFar->NumberValue(context).ToChecked()),
-                ptr->GetState()
-        );
-    }
+    canvas_native_webgl_depth_range(
+            static_cast<float>(zNear->NumberValue(context).ToChecked()),
+            static_cast<float>(zFar->NumberValue(context).ToChecked()),
+            ptr->GetState()
+    );
 }
 
 void WebGLRenderingContext::DetachShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -1565,27 +1503,24 @@ void WebGLRenderingContext::DetachShader(const v8::FunctionCallbackInfo<v8::Valu
     auto programValue = args[0];
     auto shaderValue = args[1];
 
-    if (programValue->IsObject() &&
-        shaderValue->IsObject()) {
-        auto programType = GetNativeType(isolate, programValue);
-        auto shaderType = GetNativeType(isolate, shaderValue);
-        WebGLProgram *program = nullptr;
-        WebGLShader *shader = nullptr;
-        if (programType == NativeType::WebGLProgram) {
-            program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-        }
-        if (shaderType == NativeType::WebGLShader) {
-            shader = WebGLShader::GetPointer(shaderValue.As<v8::Object>());
-        }
+    auto programType = GetNativeType(isolate, programValue);
+    auto shaderType = GetNativeType(isolate, shaderValue);
+    WebGLProgram *program = nullptr;
+    WebGLShader *shader = nullptr;
+    if (programType == NativeType::WebGLProgram) {
+        program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+    }
+    if (shaderType == NativeType::WebGLShader) {
+        shader = WebGLShader::GetPointer(shaderValue.As<v8::Object>());
+    }
 
-        if (program != nullptr &&
-            shader != nullptr) {
-            canvas_native_webgl_detach_shader(
-                    program->GetProgram(),
-                    shader->GetShader(),
-                    ptr->GetState()
-            );
-        }
+    if (program != nullptr &&
+        shader != nullptr) {
+        canvas_native_webgl_detach_shader(
+                program->GetProgram(),
+                shader->GetShader(),
+                ptr->GetState()
+        );
     }
 }
 
@@ -1600,7 +1535,7 @@ WebGLRenderingContext::DisableVertexAttribArray(const v8::FunctionCallbackInfo<v
     auto context = isolate->GetCurrentContext();
 
 
-    auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto index = args[0]->Uint32Value(context).ToChecked();
 
     canvas_native_webgl_disable_vertex_attrib_array(
             index,
@@ -1617,7 +1552,7 @@ void WebGLRenderingContext::Disable(const v8::FunctionCallbackInfo<v8::Value> &a
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto cap = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto cap = args[0]->Uint32Value(context).ToChecked();
 
     canvas_native_webgl_disable(
             cap,
@@ -1634,9 +1569,9 @@ void WebGLRenderingContext::DrawArrays(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
-    auto first = (int32_t) args[1]->NumberValue(context).ToChecked();
-    auto count = (int32_t) args[2]->NumberValue(context).ToChecked();
+    auto mode = args[0]->Uint32Value(context).ToChecked();
+    auto first = args[1]->Int32Value(context).ToChecked();
+    auto count = args[2]->Int32Value(context).ToChecked();
 
     canvas_native_webgl_draw_arrays(
             mode,
@@ -1657,9 +1592,9 @@ void WebGLRenderingContext::DrawElements(const v8::FunctionCallbackInfo<v8::Valu
     auto context = isolate->GetCurrentContext();
 
 
-    auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
-    auto count = (int32_t) args[1]->NumberValue(context).ToChecked();
-    auto type = (uint32_t) args[2]->NumberValue(context).ToChecked();
+    auto mode = args[0]->Uint32Value(context).ToChecked();
+    auto count = args[1]->Int32Value(context).ToChecked();
+    auto type = args[2]->Int32Value(context).ToChecked();
     auto offset = args[3]->NumberValue(context).ToChecked();
 
     canvas_native_webgl_draw_elements(
@@ -1682,7 +1617,7 @@ WebGLRenderingContext::EnableVertexAttribArray(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto index = args[0]->Uint32Value(context).ToChecked();
 
     canvas_native_webgl_enable_vertex_attrib_array(
             index,
@@ -1699,7 +1634,7 @@ void WebGLRenderingContext::Enable(const v8::FunctionCallbackInfo<v8::Value> &ar
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto cap = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto cap = args[0]->Uint32Value(context).ToChecked();
 
     canvas_native_webgl_enable(
             cap,
@@ -1739,9 +1674,9 @@ WebGLRenderingContext::FramebufferRenderbuffer(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-    auto attachment = (uint32_t) args[1]->NumberValue(context).ToChecked();
-    auto renderbuffertarget = (uint32_t) args[2]->NumberValue(context).ToChecked();
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    auto attachment = args[1]->Uint32Value(context).ToChecked();
+    auto renderbuffertarget = args[2]->Uint32Value(context).ToChecked();
     auto renderbufferValue = args[3];
     auto type = GetNativeType(isolate, renderbufferValue);
     if (type == NativeType::WebGLRenderbuffer) {
@@ -1767,10 +1702,10 @@ void WebGLRenderingContext::FramebufferTexture2D(const v8::FunctionCallbackInfo<
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-    auto attachment = (uint32_t) args[1]->NumberValue(context).ToChecked();
-    auto textarget = (uint32_t) args[2]->NumberValue(context).ToChecked();
-    auto level = (int32_t) args[4]->NumberValue(context).ToChecked();
+    auto target = args[0]->Uint32Value(context).ToChecked();
+    auto attachment = args[1]->Uint32Value(context).ToChecked();
+    auto textarget = args[2]->Uint32Value(context).ToChecked();
+    auto level = args[4]->Int32Value(context).ToChecked();
     auto textureValue = args[3];
     auto type = GetNativeType(isolate, textureValue);
     if (type == NativeType::WebGLTexture) {
@@ -1797,7 +1732,7 @@ void WebGLRenderingContext::FrontFace(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto mode = args[0]->Uint32Value(context).ToChecked();
 
     canvas_native_webgl_front_face(
             mode,
@@ -1814,7 +1749,7 @@ void WebGLRenderingContext::GenerateMipmap(const v8::FunctionCallbackInfo<v8::Va
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto target = args[0]->Uint32Value(context).ToChecked();
 
     canvas_native_webgl_generate_mipmap(
             target,
@@ -1834,7 +1769,7 @@ void WebGLRenderingContext::GetActiveAttrib(const v8::FunctionCallbackInfo<v8::V
     auto programValue = args[0];
     auto type = GetNativeType(isolate, programValue);
     if (type == NativeType::WebGLProgram) {
-        auto index = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto index = args[1]->Int32Value(context).ToChecked();
         auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
         if (program != nullptr) {
             auto info = canvas_native_webgl_get_active_attrib(
@@ -1865,7 +1800,7 @@ void WebGLRenderingContext::GetActiveUniform(const v8::FunctionCallbackInfo<v8::
     auto programValue = args[0];
     auto type = GetNativeType(isolate, programValue);
     if (type == NativeType::WebGLProgram) {
-        auto index = (int32_t) args[1]->NumberValue(
+        auto index = args[1]->Int32Value(
                 context).ToChecked();
         auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
         if (program != nullptr) {
@@ -1963,23 +1898,18 @@ void WebGLRenderingContext::GetBufferParameter(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto target = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-
-        auto param = canvas_native_webgl_get_buffer_parameter(
-                target,
-                pname,
-                ptr->GetState()
-        );
+    auto target = args[0]->Uint32Value(
+            context).ToChecked();
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
 
-        args.GetReturnValue().Set(param);
-        return;
-    }
+    auto param = canvas_native_webgl_get_buffer_parameter(
+            target,
+            pname,
+            ptr->GetState()
+    );
 
-    args.GetReturnValue().SetUndefined();
+    args.GetReturnValue().Set(param);
 
 }
 
@@ -2076,7 +2006,7 @@ void WebGLRenderingContext::GetError(const v8::FunctionCallbackInfo<v8::Value> &
     auto ret = canvas_native_webgl_get_error(
             ptr->GetState());
 
-    args.GetReturnValue().Set((int32_t) ret);
+    args.GetReturnValue().Set(ret);
 
 }
 
@@ -2327,11 +2257,11 @@ void WebGLRenderingContext::GetFramebufferAttachmentParameter(
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto target = (uint32_t) args[0]->NumberValue(
+    auto target = args[0]->Uint32Value(
             context).ToChecked();
-    auto attachment = (uint32_t) args[1]->NumberValue(
+    auto attachment = args[1]->Uint32Value(
             context).ToChecked();
-    auto pname = (uint32_t) args[2]->NumberValue(
+    auto pname = args[2]->Uint32Value(
             context).ToChecked();
     auto ret = canvas_native_webgl_get_framebuffer_attachment_parameter(
             target,
@@ -2389,22 +2319,17 @@ void WebGLRenderingContext::GetParameter(const v8::FunctionCallbackInfo<v8::Valu
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    // TODO remove extra allocations
-    if (args.Length() > 0) {
-        auto pname = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto result = canvas_native_webgl_get_parameter(
-                pname,
-                ptr->GetState());
+    auto pname = args[0]->Uint32Value(
+            context).ToChecked();
+    auto result = canvas_native_webgl_get_parameter(
+            pname,
+            ptr->GetState());
 
-        auto ret = ptr->GetParameterInternal(isolate, pname, result);
+    auto ret = ptr->GetParameterInternal(isolate, pname, result);
 
-        canvas_native_webgl_WebGLResult_destroy(result);
+    canvas_native_webgl_WebGLResult_destroy(result);
 
-        args.GetReturnValue().Set(ret);
-        return;
-    }
-    args.GetReturnValue().SetNull();
+    args.GetReturnValue().Set(ret);
 }
 
 void WebGLRenderingContext::GetProgramInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -2416,31 +2341,28 @@ void WebGLRenderingContext::GetProgramInfoLog(const v8::FunctionCallbackInfo<v8:
 
     auto isolate = args.GetIsolate();
 
-    if (args.Length() > 0) {
-        auto programValue = args[0];
-        auto type = GetNativeType(isolate, programValue);
-        if (type == NativeType::WebGLProgram) {
-            auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-            if (program != nullptr) {
-                auto log = canvas_native_webgl_get_program_info_log(
-                        program->GetProgram(),
-                        ptr->GetState()
-                );
-
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        if (program != nullptr) {
+            auto log = canvas_native_webgl_get_program_info_log(
+                    program->GetProgram(),
+                    ptr->GetState()
+            );
 
-                if (strlen(log) == 0) {
-                    args.GetReturnValue().SetEmptyString();
-                    canvas_native_string_destroy((char *) log);
-                    return;
-                }
 
-                args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, (char *) log));
+            if (strlen(log) == 0) {
+                args.GetReturnValue().SetEmptyString();
+                canvas_native_string_destroy((char *) log);
                 return;
             }
+
+            args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, (char *) log));
+            return;
         }
     }
 
-    // todo check return
     args.GetReturnValue().SetEmptyString();
 }
 
@@ -2454,48 +2376,46 @@ void WebGLRenderingContext::GetProgramParameter(const v8::FunctionCallbackInfo<v
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto programValue = args[0];
-        auto type = GetNativeType(isolate, programValue);
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        if (type == NativeType::WebGLProgram) {
-            auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-            if (program != nullptr) {
-                auto ret = canvas_native_webgl_get_program_parameter(
-                        program->GetProgram(),
-                        pname,
-                        ptr->GetState()
-                );
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        if (program != nullptr) {
+            auto ret = canvas_native_webgl_get_program_parameter(
+                    program->GetProgram(),
+                    pname,
+                    ptr->GetState()
+            );
 
 
-                if (canvas_native_webgl_result_get_is_none(
-                        ret)) {
-                    args.GetReturnValue().SetNull();
+            if (canvas_native_webgl_result_get_is_none(
+                    ret)) {
+                args.GetReturnValue().SetNull();
+
+                canvas_native_webgl_WebGLResult_destroy(ret);
+                return;
+            }
+            switch (pname) {
+                case GL_DELETE_STATUS:
+                case GL_LINK_STATUS:
+                case GL_VALIDATE_STATUS:
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                            ret));
+                    canvas_native_webgl_WebGLResult_destroy(ret);
+                    return;
+                default:
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                            ret));
 
                     canvas_native_webgl_WebGLResult_destroy(ret);
                     return;
-                }
-                switch (pname) {
-                    case GL_DELETE_STATUS:
-                    case GL_LINK_STATUS:
-                    case GL_VALIDATE_STATUS:
-                        args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
-                                ret));
-                        canvas_native_webgl_WebGLResult_destroy(ret);
-                        return;
-                    default:
-                        args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
-                                ret));
-
-                        canvas_native_webgl_WebGLResult_destroy(ret);
-                        return;
-                }
             }
         }
     }
 
-    // todo check return
+
     args.GetReturnValue().SetNull();
 }
 
@@ -2511,9 +2431,9 @@ WebGLRenderingContext::GetRenderbufferParameter(const v8::FunctionCallbackInfo<v
     auto context = isolate->GetCurrentContext();
 
     if (args.Length() > 1) {
-        auto target = (uint32_t) args[0]->NumberValue(
+        auto target = args[0]->Uint32Value(
                 context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
+        auto pname = args[1]->Uint32Value(
                 context).ToChecked();
         auto ret = canvas_native_webgl_get_renderbuffer_parameter(
                 target,
@@ -2537,31 +2457,28 @@ void WebGLRenderingContext::GetShaderInfoLog(const v8::FunctionCallbackInfo<v8::
 
     auto isolate = args.GetIsolate();
 
-    if (args.Length() > 0) {
-        auto value = args[0];
-        auto type = GetNativeType(isolate, value);
-        if (type == NativeType::WebGLShader) {
-            auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
-            if (shader != nullptr) {
-                auto log = canvas_native_webgl_get_shader_info_log(
-                        shader->GetShader(),
-                        ptr->GetState()
-                );
-
-                if (strlen(log) == 0) {
-                    args.GetReturnValue().SetEmptyString();
-                    canvas_native_string_destroy((char *) log);
-                    return;
-                }
-
-                args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, (char *) log));
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLShader) {
+        auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
+        if (shader != nullptr) {
+            auto log = canvas_native_webgl_get_shader_info_log(
+                    shader->GetShader(),
+                    ptr->GetState()
+            );
 
+            if (strlen(log) == 0) {
+                args.GetReturnValue().SetEmptyString();
+                canvas_native_string_destroy((char *) log);
                 return;
             }
+
+            args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, (char *) log));
+
+            return;
         }
     }
 
-    // todo check return
     args.GetReturnValue().SetEmptyString();
 }
 
@@ -2575,50 +2492,48 @@ void WebGLRenderingContext::GetShaderParameter(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto value = args[0];
-        auto type = GetNativeType(isolate, value);
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        if (type == NativeType::WebGLShader) {
-            auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
-            if (shader != nullptr) {
-                auto ret = canvas_native_webgl_get_shader_parameter(
-                        shader->GetShader(),
-                        pname,
-                        ptr->GetState()
-                );
-
-                if (canvas_native_webgl_result_get_is_none(
-                        ret)) {
-                    args.GetReturnValue().SetNull();
-
-                    canvas_native_webgl_WebGLResult_destroy(ret);
-                    return;
-                }
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
+    if (type == NativeType::WebGLShader) {
+        auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
+        if (shader != nullptr) {
+            auto ret = canvas_native_webgl_get_shader_parameter(
+                    shader->GetShader(),
+                    pname,
+                    ptr->GetState()
+            );
 
-                if (pname ==
-                    GL_DELETE_STATUS ||
-                    pname ==
-                    GL_COMPILE_STATUS) {
-                    args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
-                            ret));
+            if (canvas_native_webgl_result_get_is_none(
+                    ret)) {
+                args.GetReturnValue().SetNull();
 
-                    canvas_native_webgl_WebGLResult_destroy(ret);
-                    return;
-                }
+                canvas_native_webgl_WebGLResult_destroy(ret);
+                return;
+            }
 
-                args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+            if (pname ==
+                GL_DELETE_STATUS ||
+                pname ==
+                GL_COMPILE_STATUS) {
+                args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
                         ret));
 
                 canvas_native_webgl_WebGLResult_destroy(ret);
-
                 return;
             }
+
+            args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                    ret));
+
+            canvas_native_webgl_WebGLResult_destroy(ret);
+
+            return;
         }
     }
 
-    // todo check return
+
     args.GetReturnValue().SetNull();
 }
 
@@ -2633,25 +2548,19 @@ WebGLRenderingContext::GetShaderPrecisionFormat(const v8::FunctionCallbackInfo<v
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto shaderType = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto precisionType = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto ret = canvas_native_webgl_get_shader_precision_format(
-                shaderType,
-                precisionType,
-                ptr->GetState()
-        );
-        auto shader = WebGLShaderPrecisionFormatImpl::NewInstance(isolate,
-                                                                  new WebGLShaderPrecisionFormatImpl(
-                                                                          ret));
-        args.GetReturnValue().Set(shader);
-        return;
-    }
-
-    // todo check return
-    args.GetReturnValue().SetNull();
+    auto shaderType = args[0]->Uint32Value(
+            context).ToChecked();
+    auto precisionType = args[1]->Uint32Value(
+            context).ToChecked();
+    auto ret = canvas_native_webgl_get_shader_precision_format(
+            shaderType,
+            precisionType,
+            ptr->GetState()
+    );
+    auto shader = WebGLShaderPrecisionFormatImpl::NewInstance(isolate,
+                                                              new WebGLShaderPrecisionFormatImpl(
+                                                                      ret));
+    args.GetReturnValue().Set(shader);
 }
 
 void WebGLRenderingContext::GetShaderSource(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -2663,30 +2572,27 @@ void WebGLRenderingContext::GetShaderSource(const v8::FunctionCallbackInfo<v8::V
 
     auto isolate = args.GetIsolate();
 
-    if (args.Length() > 0) {
-        auto value = args[0];
-        auto type = GetNativeType(isolate, value);
-        if (type == NativeType::WebGLShader) {
-            auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
-
-            if (shader != nullptr) {
-                auto source = canvas_native_webgl_get_shader_source(
-                        shader->GetShader(),
-                        ptr->GetState()
-                );
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLShader) {
+        auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
 
-                if (strlen(source) == 0) {
-                    args.GetReturnValue().SetEmptyString();
-                    canvas_native_string_destroy((char *) source);
-                    return;
-                }
+        if (shader != nullptr) {
+            auto source = canvas_native_webgl_get_shader_source(
+                    shader->GetShader(),
+                    ptr->GetState()
+            );
 
-                args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, (char *) source));
+            if (strlen(source) == 0) {
+                args.GetReturnValue().SetEmptyString();
+                canvas_native_string_destroy((char *) source);
                 return;
             }
+
+            args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, (char *) source));
+            return;
         }
     }
-
     // todo check return
     args.GetReturnValue().SetEmptyString();
 }
@@ -2751,22 +2657,16 @@ WebGLRenderingContext::GetTexParameter(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto target = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto ret = canvas_native_webgl_get_tex_parameter(
-                target,
-                pname,
-                ptr->GetState()
-        );
-        args.GetReturnValue().Set(ret);
-        return;
-    }
-
-    // todo check return
-    args.GetReturnValue().SetNull();
+    auto target = args[0]->Uint32Value(
+            context).ToChecked();
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
+    auto ret = canvas_native_webgl_get_tex_parameter(
+            target,
+            pname,
+            ptr->GetState()
+    );
+    args.GetReturnValue().Set(ret);
 }
 
 void
@@ -2779,27 +2679,25 @@ WebGLRenderingContext::GetUniformLocation(const v8::FunctionCallbackInfo<v8::Val
 
     auto isolate = args.GetIsolate();
 
-    if (args.Length() > 1) {
-        auto programValue = args[0];
-        auto type = GetNativeType(isolate, programValue);
-        auto nameValue = args[1];
-        if (type == NativeType::WebGLProgram && nameValue->IsString()) {
-            auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-            if (program != nullptr) {
-                auto name = ConvertFromV8String(isolate, args[1]);
-
-                auto ret = canvas_native_webgl_get_uniform_location(
-                        program->GetProgram(),
-                        name.c_str(),
-                        ptr->GetState()
-                );
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+    auto nameValue = args[1];
+    if (type == NativeType::WebGLProgram && nameValue->IsString()) {
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        if (program != nullptr) {
+            auto name = ConvertFromV8String(isolate, args[1]);
 
-                auto location = WebGLUniformLocation::NewInstance(isolate, new WebGLUniformLocation(
-                        ret));
+            auto ret = canvas_native_webgl_get_uniform_location(
+                    program->GetProgram(),
+                    name.c_str(),
+                    ptr->GetState()
+            );
 
-                args.GetReturnValue().Set(location);
-                return;
-            }
+            auto location = WebGLUniformLocation::NewInstance(isolate, new WebGLUniformLocation(
+                    ret));
+
+            args.GetReturnValue().Set(location);
+            return;
         }
     }
 
@@ -2818,183 +2716,181 @@ WebGLRenderingContext::GetUniform(const v8::FunctionCallbackInfo<v8::Value> &arg
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto programValue = args[0];
-        auto programType = GetNativeType(isolate, programValue);
-        auto locationValue = args[1];
-        auto locationType = GetNativeType(isolate, locationValue);
-        if (programType == NativeType::WebGLProgram &&
-            locationType == NativeType::WebGLUniformLocation) {
+    auto programValue = args[0];
+    auto programType = GetNativeType(isolate, programValue);
+    auto locationValue = args[1];
+    auto locationType = GetNativeType(isolate, locationValue);
+    if (programType == NativeType::WebGLProgram &&
+        locationType == NativeType::WebGLUniformLocation) {
 
-            auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-            auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
 
 
-            if (program != nullptr &&
-                location != nullptr) {
+        if (program != nullptr &&
+            location != nullptr) {
 
-                auto val = canvas_native_webgl_get_uniform(
-                        program->GetProgram(),
-                        location->GetUniformLocation(),
-                        ptr->GetState());
+            auto val = canvas_native_webgl_get_uniform(
+                    program->GetProgram(),
+                    location->GetUniformLocation(),
+                    ptr->GetState());
 
-                switch (canvas_native_webgl_result_get_type(
-                        val)) {
-                    case WebGLResultType::WebGLResultTypeBoolean:
-                        args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
-                                val));
-                        canvas_native_webgl_WebGLResult_destroy(val);
-                        return;
-                    case WebGLResultType::WebGLResultTypeNone:
-                        args.GetReturnValue().SetNull();
-                        canvas_native_webgl_WebGLResult_destroy(val);
-                        return;
-                    case WebGLResultType::WebGLResultTypeString: {
-                        auto str = canvas_native_webgl_result_get_string(
-                                val);
-
-                        args.GetReturnValue().Set(
-                                ConvertToV8OneByteString(isolate, (char *) str));
-                        canvas_native_webgl_WebGLResult_destroy(val);
-                        return;
-                    }
-                    case WebGLResultType::WebGLResultTypeBooleanArray: {
-                        auto ret = canvas_native_webgl_result_get_bool_array(
-                                val);
-                        auto len = canvas_native_u8_buffer_get_length(ret);
-                        auto buf = canvas_native_u8_buffer_get_bytes(ret);
-                        auto array = v8::Array::New(
-                                isolate, (int) len);
-                        for (int i = 0;
-                             i < len; ++i) {
-                            auto item = buf[i];
-                            array->Set(
-                                    context, i,
-                                    v8::Boolean::New(isolate,
-                                                     item ==
-                                                     1));
-                        }
-                        args.GetReturnValue().Set(array);
-                        canvas_native_webgl_WebGLResult_destroy(val);
-                        return;
+            switch (canvas_native_webgl_result_get_type(
+                    val)) {
+                case WebGLResultType::WebGLResultTypeBoolean:
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                            val));
+                    canvas_native_webgl_WebGLResult_destroy(val);
+                    return;
+                case WebGLResultType::WebGLResultTypeNone:
+                    args.GetReturnValue().SetNull();
+                    canvas_native_webgl_WebGLResult_destroy(val);
+                    return;
+                case WebGLResultType::WebGLResultTypeString: {
+                    auto str = canvas_native_webgl_result_get_string(
+                            val);
+
+                    args.GetReturnValue().Set(
+                            ConvertToV8OneByteString(isolate, (char *) str));
+                    canvas_native_webgl_WebGLResult_destroy(val);
+                    return;
+                }
+                case WebGLResultType::WebGLResultTypeBooleanArray: {
+                    auto ret = canvas_native_webgl_result_get_bool_array(
+                            val);
+                    auto len = canvas_native_u8_buffer_get_length(ret);
+                    auto buf = canvas_native_u8_buffer_get_bytes(ret);
+                    auto array = v8::Array::New(
+                            isolate, (int) len);
+                    for (int i = 0;
+                         i < len; ++i) {
+                        auto item = buf[i];
+                        array->Set(
+                                context, i,
+                                v8::Boolean::New(isolate,
+                                                 item ==
+                                                 1));
                     }
-                    case WebGLResultType::WebGLResultTypeF32Array: {
-                        auto ret = canvas_native_webgl_result_get_f32_array(
-                                val);
+                    args.GetReturnValue().Set(array);
+                    canvas_native_webgl_WebGLResult_destroy(val);
+                    return;
+                }
+                case WebGLResultType::WebGLResultTypeF32Array: {
+                    auto ret = canvas_native_webgl_result_get_f32_array(
+                            val);
 
 
-                        auto buf = (uint8_t *) canvas_native_f32_buffer_get_bytes_mut(ret);
-                        auto size = canvas_native_f32_buffer_get_length(ret);
-                        auto bytes_size = size * sizeof(float);
+                    auto buf = (uint8_t *) canvas_native_f32_buffer_get_bytes_mut(ret);
+                    auto size = canvas_native_f32_buffer_get_length(ret);
+                    auto bytes_size = size * sizeof(float);
 
 
-                        auto store = v8::ArrayBuffer::NewBackingStore(buf,
-                                                                      bytes_size,
-                                                                      [](void *data, size_t length,
-                                                                         void *deleter_data) {
-                                                                          if (deleter_data !=
-                                                                              nullptr) {
-                                                                              canvas_native_f32_buffer_destroy(
-                                                                                      (F32Buffer *) deleter_data);
-                                                                          }
-                                                                      },
-                                                                      ret);
+                    auto store = v8::ArrayBuffer::NewBackingStore(buf,
+                                                                  bytes_size,
+                                                                  [](void *data, size_t length,
+                                                                     void *deleter_data) {
+                                                                      if (deleter_data !=
+                                                                          nullptr) {
+                                                                          canvas_native_f32_buffer_destroy(
+                                                                                  (F32Buffer *) deleter_data);
+                                                                      }
+                                                                  },
+                                                                  ret);
 
-                        auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+                    auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
 
-                        args.GetReturnValue().Set(
-                                v8::Float32Array::New(arraybuffer, 0, size)
-                        );
+                    args.GetReturnValue().Set(
+                            v8::Float32Array::New(arraybuffer, 0, size)
+                    );
 
-                        canvas_native_webgl_WebGLResult_destroy(val);
+                    canvas_native_webgl_WebGLResult_destroy(val);
 
-                        return;
-                    }
-                    case WebGLResultType::WebGLResultTypeI32Array: {
-                        auto ret = canvas_native_webgl_result_get_i32_array(
-                                val);
+                    return;
+                }
+                case WebGLResultType::WebGLResultTypeI32Array: {
+                    auto ret = canvas_native_webgl_result_get_i32_array(
+                            val);
 
 
-                        auto buf = (uint8_t *) canvas_native_i32_buffer_get_bytes_mut(ret);
-                        auto size = canvas_native_i32_buffer_get_length(ret);
-                        auto bytes_size = size * sizeof(int32_t);
+                    auto buf = (uint8_t *) canvas_native_i32_buffer_get_bytes_mut(ret);
+                    auto size = canvas_native_i32_buffer_get_length(ret);
+                    auto bytes_size = size * sizeof(int32_t);
 
 
-                        auto store = v8::ArrayBuffer::NewBackingStore(buf, bytes_size,
-                                                                      [](void *data, size_t length,
-                                                                         void *deleter_data) {
-                                                                          if (deleter_data !=
-                                                                              nullptr) {
-                                                                              canvas_native_i32_buffer_destroy(
-                                                                                      (I32Buffer *) deleter_data);
-                                                                          }
-                                                                      },
-                                                                      ret);
+                    auto store = v8::ArrayBuffer::NewBackingStore(buf, bytes_size,
+                                                                  [](void *data, size_t length,
+                                                                     void *deleter_data) {
+                                                                      if (deleter_data !=
+                                                                          nullptr) {
+                                                                          canvas_native_i32_buffer_destroy(
+                                                                                  (I32Buffer *) deleter_data);
+                                                                      }
+                                                                  },
+                                                                  ret);
 
-                        auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+                    auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
 
 
-                        args.GetReturnValue().Set(
-                                v8::Int32Array::New(arraybuffer, 0, size)
-                        );
+                    args.GetReturnValue().Set(
+                            v8::Int32Array::New(arraybuffer, 0, size)
+                    );
 
-                        canvas_native_webgl_WebGLResult_destroy(val);
+                    canvas_native_webgl_WebGLResult_destroy(val);
 
-                        return;
-                    }
-                    case WebGLResultType::WebGLResultTypeU32Array: {
-                        auto ret = canvas_native_webgl_result_get_u32_array(
-                                val);
+                    return;
+                }
+                case WebGLResultType::WebGLResultTypeU32Array: {
+                    auto ret = canvas_native_webgl_result_get_u32_array(
+                            val);
 
-                        auto buf = (uint8_t *) canvas_native_u32_buffer_get_bytes_mut(ret);
-                        auto size = canvas_native_u32_buffer_get_length(ret);
-                        auto bytes_size = size * sizeof(uint32_t);
+                    auto buf = (uint8_t *) canvas_native_u32_buffer_get_bytes_mut(ret);
+                    auto size = canvas_native_u32_buffer_get_length(ret);
+                    auto bytes_size = size * sizeof(uint32_t);
 
 
-                        auto store = v8::ArrayBuffer::NewBackingStore(buf, bytes_size,
-                                                                      [](void *data, size_t length,
-                                                                         void *deleter_data) {
-                                                                          if (deleter_data !=
-                                                                              nullptr) {
-                                                                              canvas_native_u32_buffer_destroy(
-                                                                                      (U32Buffer *) deleter_data);
-                                                                          }
-                                                                      },
-                                                                      ret);
+                    auto store = v8::ArrayBuffer::NewBackingStore(buf, bytes_size,
+                                                                  [](void *data, size_t length,
+                                                                     void *deleter_data) {
+                                                                      if (deleter_data !=
+                                                                          nullptr) {
+                                                                          canvas_native_u32_buffer_destroy(
+                                                                                  (U32Buffer *) deleter_data);
+                                                                      }
+                                                                  },
+                                                                  ret);
 
-                        auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+                    auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
 
 
-                        args.GetReturnValue().Set(
-                                v8::Uint32Array::New(arraybuffer, 0, size)
-                        );
+                    args.GetReturnValue().Set(
+                            v8::Uint32Array::New(arraybuffer, 0, size)
+                    );
 
 
-                        canvas_native_webgl_WebGLResult_destroy(val);
+                    canvas_native_webgl_WebGLResult_destroy(val);
 
-                        return;
+                    return;
 
 
-                    }
-                    case WebGLResultType::WebGLResultTypeF32:
-                        args.GetReturnValue().Set((double) canvas_native_webgl_result_get_f32(
-                                val));
-
-                        canvas_native_webgl_WebGLResult_destroy(val);
-                        return;
-                    case WebGLResultType::WebGLResultTypeI32:
-                        args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
-                                val));
-
-                        canvas_native_webgl_WebGLResult_destroy(val);
-                        return;
-                    case WebGLResultType::WebGLResultTypeU32:
-                        args.GetReturnValue().Set(canvas_native_webgl_result_get_u32(
-                                val));
-
-                        canvas_native_webgl_WebGLResult_destroy(val);
-                        return;
                 }
+                case WebGLResultType::WebGLResultTypeF32:
+                    args.GetReturnValue().Set((double) canvas_native_webgl_result_get_f32(
+                            val));
+
+                    canvas_native_webgl_WebGLResult_destroy(val);
+                    return;
+                case WebGLResultType::WebGLResultTypeI32:
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                            val));
+
+                    canvas_native_webgl_WebGLResult_destroy(val);
+                    return;
+                case WebGLResultType::WebGLResultTypeU32:
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_u32(
+                            val));
+
+                    canvas_native_webgl_WebGLResult_destroy(val);
+                    return;
             }
         }
     }
@@ -3014,21 +2910,15 @@ WebGLRenderingContext::GetVertexAttribOffset(const v8::FunctionCallbackInfo<v8::
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto ret = canvas_native_webgl_get_vertex_attrib_offset(
-                index,
-                pname,
-                ptr->GetState());
-        args.GetReturnValue().Set(static_cast<double>(ret));
-        return;
-    }
-
-    // todo check return
-    args.GetReturnValue().SetNull();
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
+    auto ret = canvas_native_webgl_get_vertex_attrib_offset(
+            index,
+            pname,
+            ptr->GetState());
+    args.GetReturnValue().Set(static_cast<double>(ret));
 }
 
 void
@@ -3043,63 +2933,58 @@ WebGLRenderingContext::GetVertexAttrib(const v8::FunctionCallbackInfo<v8::Value>
     auto context = isolate->GetCurrentContext();
 
 
-    if (args.Length() > 1) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto ret = canvas_native_webgl_get_vertex_attrib(
-                index,
-                pname,
-                ptr->GetState());
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
+    auto ret = canvas_native_webgl_get_vertex_attrib(
+            index,
+            pname,
+            ptr->GetState());
 
-        if (pname ==
-            GL_CURRENT_VERTEX_ATTRIB) {
-            auto val = canvas_native_webgl_result_get_f32_array(
-                    ret);
+    if (pname ==
+        GL_CURRENT_VERTEX_ATTRIB) {
+        auto val = canvas_native_webgl_result_get_f32_array(
+                ret);
 
 
-            auto buf = (uint8_t *) canvas_native_f32_buffer_get_bytes_mut(val);
-            auto size = canvas_native_f32_buffer_get_length(val);
-            auto bytes_size = size * sizeof(float);
+        auto buf = (uint8_t *) canvas_native_f32_buffer_get_bytes_mut(val);
+        auto size = canvas_native_f32_buffer_get_length(val);
+        auto bytes_size = size * sizeof(float);
 
-            auto store = v8::ArrayBuffer::NewBackingStore(buf, bytes_size,
-                                                          [](void *data, size_t length,
-                                                             void *deleter_data) {
-                                                              if (deleter_data != nullptr) {
-                                                                  canvas_native_f32_buffer_destroy(
-                                                                          (F32Buffer *) deleter_data);
-                                                              }
-                                                          },
-                                                          val);
+        auto store = v8::ArrayBuffer::NewBackingStore(buf, bytes_size,
+                                                      [](void *data, size_t length,
+                                                         void *deleter_data) {
+                                                          if (deleter_data != nullptr) {
+                                                              canvas_native_f32_buffer_destroy(
+                                                                      (F32Buffer *) deleter_data);
+                                                          }
+                                                      },
+                                                      val);
 
-            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+        auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
 
 
-            args.GetReturnValue().Set(
-                    v8::Float32Array::New(arraybuffer, 0, size)
-            );
+        args.GetReturnValue().Set(
+                v8::Float32Array::New(arraybuffer, 0, size)
+        );
 
-            canvas_native_webgl_WebGLResult_destroy(ret);
-            return;
-        } else if (pname ==
-                   GL_VERTEX_ATTRIB_ARRAY_ENABLED ||
-                   pname ==
-                   GL_VERTEX_ATTRIB_ARRAY_NORMALIZED) {
-            args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
-                    ret));
-            canvas_native_webgl_WebGLResult_destroy(ret);
-            return;
-        } else {
-            args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
-                    ret));
-            canvas_native_webgl_WebGLResult_destroy(ret);
-            return;
-        }
+        canvas_native_webgl_WebGLResult_destroy(ret);
+        return;
+    } else if (pname ==
+               GL_VERTEX_ATTRIB_ARRAY_ENABLED ||
+               pname ==
+               GL_VERTEX_ATTRIB_ARRAY_NORMALIZED) {
+        args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                ret));
+        canvas_native_webgl_WebGLResult_destroy(ret);
+        return;
+    } else {
+        args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                ret));
+        canvas_native_webgl_WebGLResult_destroy(ret);
+        return;
     }
-
-    // todo check return
-    args.GetReturnValue().SetNull();
 }
 
 void
@@ -3113,15 +2998,13 @@ WebGLRenderingContext::Hint(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto target = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto mode = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_hint(target,
-                                 mode,
-                                 ptr->GetState());
-    }
+    auto target = args[0]->Uint32Value(
+            context).ToChecked();
+    auto mode = args[1]->Uint32Value(
+            context).ToChecked();
+    canvas_native_webgl_hint(target,
+                             mode,
+                             ptr->GetState());
 }
 
 void
@@ -3176,15 +3059,11 @@ WebGLRenderingContext::IsEnabled(const v8::FunctionCallbackInfo<v8::Value> &args
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 0) {
-        auto cap = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto ret = canvas_native_webgl_is_enabled(
-                cap, ptr->GetState());
-        args.GetReturnValue().Set(ret);
-        return;
-    }
-    args.GetReturnValue().Set(false);
+    auto cap = args[0]->Uint32Value(
+            context).ToChecked();
+    auto ret = canvas_native_webgl_is_enabled(
+            cap, ptr->GetState());
+    args.GetReturnValue().Set(ret);
 }
 
 void
@@ -3334,13 +3213,11 @@ WebGLRenderingContext::LineWidth(const v8::FunctionCallbackInfo<v8::Value> &args
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 0) {
-        auto width = args[0]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_line_width(
-                static_cast<float>(width),
-                ptr->GetState());
-    }
+    auto width = args[0]->NumberValue(
+            context).ToChecked();
+    canvas_native_webgl_line_width(
+            static_cast<float>(width),
+            ptr->GetState());
 
 }
 
@@ -3374,26 +3251,23 @@ WebGLRenderingContext::PixelStorei(const v8::FunctionCallbackInfo<v8::Value> &ar
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto pname = (uint32_t) args[0]->NumberValue(
+    auto pname = args[0]->Uint32Value(
+            context).ToChecked();
+    if (args[1]->IsBoolean()) {
+        auto param = args[1]->BooleanValue(isolate);
+        canvas_native_webgl_pixel_storei(
+                pname,
+                param ? 1 : 0,
+                ptr->GetState()
+        );
+    } else {
+        auto param = args[1]->Int32Value(
                 context).ToChecked();
-        if (args[1]->IsBoolean()) {
-            auto param = args[1]->BooleanValue(isolate);
-            canvas_native_webgl_pixel_storei(
-                    pname,
-                    param ? 1 : 0,
-                    ptr->GetState()
-            );
-        } else {
-            auto param = (int32_t) args[1]->NumberValue(
-                    context).ToChecked();
-            canvas_native_webgl_pixel_storei(
-                    pname,
-                    param,
-                    ptr->GetState()
-            );
-        }
-
+        canvas_native_webgl_pixel_storei(
+                pname,
+                param,
+                ptr->GetState()
+        );
     }
 }
 
@@ -3407,17 +3281,15 @@ WebGLRenderingContext::PolygonOffset(const v8::FunctionCallbackInfo<v8::Value> &
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto factor = args[0]->NumberValue(
-                context).ToChecked();
-        auto units = args[1]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_polygon_offset(
-                static_cast<float>(factor),
-                static_cast<float>(units),
-                ptr->GetState()
-        );
-    }
+    auto factor = args[0]->NumberValue(
+            context).ToChecked();
+    auto units = args[1]->NumberValue(
+            context).ToChecked();
+    canvas_native_webgl_polygon_offset(
+            static_cast<float>(factor),
+            static_cast<float>(units),
+            ptr->GetState()
+    );
 
 }
 
@@ -3432,62 +3304,60 @@ WebGLRenderingContext::ReadPixels(const v8::FunctionCallbackInfo<v8::Value> &arg
     auto context = isolate->GetCurrentContext();
 
 
-    if (args.Length() > 6) {
-        auto x = (int32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto y = (int32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto width = (int32_t) args[2]->NumberValue(
-                context).ToChecked();
-        auto height = (int32_t) args[3]->NumberValue(
-                context).ToChecked();
-        auto format = (uint32_t) args[4]->NumberValue(
-                context).ToChecked();
-        auto type = (uint32_t) args[5]->NumberValue(
-                context).ToChecked();
+    auto x = args[0]->Int32Value(
+            context).ToChecked();
+    auto y = args[1]->Int32Value(
+            context).ToChecked();
+    auto width = args[2]->Int32Value(
+            context).ToChecked();
+    auto height = args[3]->Int32Value(
+            context).ToChecked();
+    auto format = args[4]->Uint32Value(
+            context).ToChecked();
+    auto type = args[5]->Uint32Value(
+            context).ToChecked();
 
-        auto pixels = args[6];
-        if (pixels->IsArrayBufferView()) {
-            auto buf = pixels.As<v8::ArrayBufferView>();
+    auto pixels = args[6];
+    if (pixels->IsArrayBufferView()) {
+        auto buf = pixels.As<v8::ArrayBufferView>();
 
-            auto array = buf->Buffer();
-            auto offset = buf->ByteOffset();
-            auto size = array->ByteLength();
-            auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
-            auto data = static_cast<uint8_t *>((void *) data_ptr);
+        auto array = buf->Buffer();
+        auto offset = buf->ByteOffset();
+        auto size = array->ByteLength();
+        auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
+        auto data = static_cast<uint8_t *>((void *) data_ptr);
 
 
-            canvas_native_webgl_read_pixels_u8(
-                    x,
-                    y,
-                    width,
-                    height,
-                    format,
-                    type,
-                    data, size,
-                    ptr->GetState()
-            );
-            return;
-        }
+        canvas_native_webgl_read_pixels_u8(
+                x,
+                y,
+                width,
+                height,
+                format,
+                type,
+                data, size,
+                ptr->GetState()
+        );
+        return;
+    }
 
 
-        if (pixels->IsArrayBuffer()) {
-            auto array = pixels.As<v8::ArrayBuffer>();
+    if (pixels->IsArrayBuffer()) {
+        auto array = pixels.As<v8::ArrayBuffer>();
 
-            auto size = array->ByteLength();
-            auto data = (uint8_t *) array->GetBackingStore()->Data();
+        auto size = array->ByteLength();
+        auto data = (uint8_t *) array->GetBackingStore()->Data();
 
-            canvas_native_webgl_read_pixels_u8(
-                    x,
-                    y,
-                    width,
-                    height,
-                    format,
-                    type,
-                    data, size,
-                    ptr->GetState()
-            );
-        }
+        canvas_native_webgl_read_pixels_u8(
+                x,
+                y,
+                width,
+                height,
+                format,
+                type,
+                data, size,
+                ptr->GetState()
+        );
     }
 
 }
@@ -3502,23 +3372,21 @@ WebGLRenderingContext::RenderbufferStorage(const v8::FunctionCallbackInfo<v8::Va
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto target = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto internalFormat = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto width = (int32_t) args[2]->NumberValue(
-                context).ToChecked();
-        auto height = (int32_t) args[3]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_renderbuffer_storage(
-                target,
-                internalFormat,
-                width,
-                height,
-                ptr->GetState()
-        );
-    }
+    auto target = args[0]->Uint32Value(
+            context).ToChecked();
+    auto internalFormat = args[1]->Uint32Value(
+            context).ToChecked();
+    auto width = args[2]->Int32Value(
+            context).ToChecked();
+    auto height = args[3]->Int32Value(
+            context).ToChecked();
+    canvas_native_webgl_renderbuffer_storage(
+            target,
+            internalFormat,
+            width,
+            height,
+            ptr->GetState()
+    );
 
 }
 
@@ -3532,16 +3400,14 @@ WebGLRenderingContext::SampleCoverage(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto value = args[0]->NumberValue(
-                context).ToChecked();
-        auto invert = args[1]->BooleanValue(isolate);
-        canvas_native_webgl_sample_coverage(
-                static_cast<float>(value),
-                invert,
-                ptr->GetState()
-        );
-    }
+    auto value = args[0]->NumberValue(
+            context).ToChecked();
+    auto invert = args[1]->BooleanValue(isolate);
+    canvas_native_webgl_sample_coverage(
+            static_cast<float>(value),
+            invert,
+            ptr->GetState()
+    );
 
 }
 
@@ -3555,24 +3421,22 @@ WebGLRenderingContext::Scissor(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto x = (int32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto y = (int32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto width = (int32_t) args[2]->NumberValue(
-                context).ToChecked();
-        auto height = (int32_t) args[3]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_scissor(
-                x,
-                y,
-                width,
-                height,
-                ptr->GetState()
-        );
-    }
-
+    auto x = args[0]->Int32Value(
+            context).ToChecked();
+    auto y = args[1]->Int32Value(
+            context).ToChecked();
+    auto width = args[2]->Int32Value(
+            context).ToChecked();
+    auto height = args[3]->Int32Value(
+            context).ToChecked();
+    canvas_native_webgl_scissor(
+            x,
+            y,
+            width,
+            height,
+            ptr->GetState()
+    );
+
 }
 
 void
@@ -3587,7 +3451,7 @@ WebGLRenderingContext::ShaderSource(const v8::FunctionCallbackInfo<v8::Value> &a
     auto value = args[0];
     auto type = GetNativeType(isolate, value);
     auto sourceValue = args[1];
-    if (type == NativeType::WebGLShader && sourceValue->IsString()) {
+    if (type == NativeType::WebGLShader) {
         auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
         auto source = ConvertFromV8String(isolate, sourceValue);
         if (shader != nullptr) {
@@ -3610,23 +3474,21 @@ WebGLRenderingContext::StencilFuncSeparate(const v8::FunctionCallbackInfo<v8::Va
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto face = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto func = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto ref = (int32_t) args[2]->NumberValue(
-                context).ToChecked();
-        auto mask = (uint32_t) args[3]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_stencil_func_separate(
-                face,
-                func,
-                ref,
-                mask,
-                ptr->GetState()
-        );
-    }
+    auto face = args[0]->Uint32Value(
+            context).ToChecked();
+    auto func = args[1]->Uint32Value(
+            context).ToChecked();
+    auto ref = args[2]->Int32Value(
+            context).ToChecked();
+    auto mask = args[3]->Uint32Value(
+            context).ToChecked();
+    canvas_native_webgl_stencil_func_separate(
+            face,
+            func,
+            ref,
+            mask,
+            ptr->GetState()
+    );
 
 }
 
@@ -3640,20 +3502,18 @@ WebGLRenderingContext::StencilFunc(const v8::FunctionCallbackInfo<v8::Value> &ar
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 2) {
-        auto func = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto ref = (int32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto mask = (uint32_t) args[2]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_stencil_func(
-                func,
-                ref,
-                mask,
-                ptr->GetState()
-        );
-    }
+    auto func = args[0]->Uint32Value(
+            context).ToChecked();
+    auto ref = args[1]->Int32Value(
+            context).ToChecked();
+    auto mask = args[2]->Uint32Value(
+            context).ToChecked();
+    canvas_native_webgl_stencil_func(
+            func,
+            ref,
+            mask,
+            ptr->GetState()
+    );
 
 }
 
@@ -3667,17 +3527,15 @@ WebGLRenderingContext::StencilMaskSeparate(const v8::FunctionCallbackInfo<v8::Va
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto face = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto mask = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_stencil_mask_separate(
-                face,
-                mask,
-                ptr->GetState()
-        );
-    }
+    auto face = args[0]->Uint32Value(
+            context).ToChecked();
+    auto mask = args[1]->Uint32Value(
+            context).ToChecked();
+    canvas_native_webgl_stencil_mask_separate(
+            face,
+            mask,
+            ptr->GetState()
+    );
 
 }
 
@@ -3691,14 +3549,12 @@ WebGLRenderingContext::StencilMask(const v8::FunctionCallbackInfo<v8::Value> &ar
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 0) {
-        auto mask = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_stencil_mask(
-                mask,
-                ptr->GetState()
-        );
-    }
+    auto mask = args[0]->Uint32Value(
+            context).ToChecked();
+    canvas_native_webgl_stencil_mask(
+            mask,
+            ptr->GetState()
+    );
 
 }
 
@@ -3713,23 +3569,21 @@ WebGLRenderingContext::StencilOpSeparate(const v8::FunctionCallbackInfo<v8::Valu
     auto context = isolate->GetCurrentContext();
 
 
-    if (args.Length() > 3) {
-        auto face = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto fail = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto zfail = (uint32_t) args[2]->NumberValue(
-                context).ToChecked();
-        auto zpass = (uint32_t) args[3]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_stencil_op_separate(
-                face,
-                fail,
-                zfail,
-                zpass,
-                ptr->GetState()
-        );
-    }
+    auto face = args[0]->Uint32Value(
+            context).ToChecked();
+    auto fail = args[1]->Uint32Value(
+            context).ToChecked();
+    auto zfail = args[2]->Uint32Value(
+            context).ToChecked();
+    auto zpass = args[3]->Uint32Value(
+            context).ToChecked();
+    canvas_native_webgl_stencil_op_separate(
+            face,
+            fail,
+            zfail,
+            zpass,
+            ptr->GetState()
+    );
 
 }
 
@@ -3743,20 +3597,18 @@ WebGLRenderingContext::StencilOp(const v8::FunctionCallbackInfo<v8::Value> &args
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 2) {
-        auto fail = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto zfail = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto zpass = (uint32_t) args[2]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_stencil_op(
-                fail,
-                zfail,
-                zpass,
-                ptr->GetState()
-        );
-    }
+    auto fail = args[0]->Uint32Value(
+            context).ToChecked();
+    auto zfail = args[1]->Uint32Value(
+            context).ToChecked();
+    auto zpass = args[2]->Uint32Value(
+            context).ToChecked();
+    canvas_native_webgl_stencil_op(
+            fail,
+            zfail,
+            zpass,
+            ptr->GetState()
+    );
 
 }
 
@@ -3776,15 +3628,15 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
     // TODO tidy
 
     if (count == 5) {
-        auto target = (int32_t) args[0]->NumberValue(
+        auto target = args[0]->Int32Value(
                 context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(
+        auto level = args[1]->Int32Value(
                 context).ToChecked();
-        auto internalformat = (int32_t) args[2]->NumberValue(
+        auto internalformat = args[2]->Int32Value(
                 context).ToChecked();
-        auto format = (int32_t) args[3]->NumberValue(
+        auto format = args[3]->Int32Value(
                 context).ToChecked();
-        auto type = (int32_t) args[4]->NumberValue(
+        auto type = args[4]->Int32Value(
                 context).ToChecked();
 
         canvas_native_webgl_tex_image2d_image_none(
@@ -3797,15 +3649,15 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
         );
 
     } else if (count == 6) {
-        auto target = (int32_t) args[0]->NumberValue(
+        auto target = args[0]->Int32Value(
                 context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(
+        auto level = args[1]->Int32Value(
                 context).ToChecked();
-        auto internalformat = (int32_t) args[2]->NumberValue(
+        auto internalformat = args[2]->Int32Value(
                 context).ToChecked();
-        auto format = (int32_t) args[3]->NumberValue(
+        auto format = args[3]->Int32Value(
                 context).ToChecked();
-        auto type = (int32_t) args[4]->NumberValue(
+        auto type = args[4]->Int32Value(
                 context).ToChecked();
 
         auto pixels = args[5];
@@ -3886,21 +3738,21 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
                 break;
         }
     } else if (count == 8) {
-        auto target = (int32_t) args[0]->NumberValue(
+        auto target = args[0]->Int32Value(
                 context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(
+        auto level = args[1]->Int32Value(
                 context).ToChecked();
-        auto internalformat = (int32_t) args[2]->NumberValue(
+        auto internalformat = args[2]->Int32Value(
                 context).ToChecked();
-        auto width = (int32_t) args[3]->NumberValue(
+        auto width = args[3]->Int32Value(
                 context).ToChecked();
-        auto height = (int32_t) args[4]->NumberValue(
+        auto height = args[4]->Int32Value(
                 context).ToChecked();
-        auto border = (int32_t) args[5]->NumberValue(
+        auto border = args[5]->Int32Value(
                 context).ToChecked();
-        auto format = (int32_t) args[6]->NumberValue(
+        auto format = args[6]->Int32Value(
                 context).ToChecked();
-        auto type = (int32_t) args[7]->NumberValue(
+        auto type = args[7]->Int32Value(
                 context).ToChecked();
         canvas_native_webgl_tex_image2d_none(
                 target,
@@ -3914,21 +3766,21 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
                 ptr->GetState()
         );
     } else if (count == 9) {
-        auto target = (int32_t) args[0]->NumberValue(
+        auto target = args[0]->Int32Value(
                 context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(
+        auto level = args[1]->Int32Value(
                 context).ToChecked();
-        auto internalformat = (int32_t) args[2]->NumberValue(
+        auto internalformat = args[2]->Int32Value(
                 context).ToChecked();
-        auto width = (int32_t) args[3]->NumberValue(
+        auto width = args[3]->Int32Value(
                 context).ToChecked();
-        auto height = (int32_t) args[4]->NumberValue(
+        auto height = args[4]->Int32Value(
                 context).ToChecked();
-        auto border = (int32_t) args[5]->NumberValue(
+        auto border = args[5]->Int32Value(
                 context).ToChecked();
-        auto format = (int32_t) args[6]->NumberValue(
+        auto format = args[6]->Int32Value(
                 context).ToChecked();
-        auto type = (int32_t) args[7]->NumberValue(
+        auto type = args[7]->Int32Value(
                 context).ToChecked();
 
 
@@ -3951,7 +3803,7 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
             auto array = buf->Buffer();
             auto offset = buf->ByteOffset();
             auto size = array->ByteLength();
-            auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+            auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
             auto data = static_cast<uint8_t *>((void *) data_ptr);
 
 
@@ -4003,20 +3855,18 @@ WebGLRenderingContext::TexParameterf(const v8::FunctionCallbackInfo<v8::Value> &
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 2) {
-        auto target = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto param = args[2]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_tex_parameterf(
-                target,
-                pname,
-                static_cast<float>(param),
-                ptr->GetState()
-        );
-    }
+    auto target =  args[0]->Uint32Value(
+            context).ToChecked();
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
+    auto param = args[2]->NumberValue(
+            context).ToChecked();
+    canvas_native_webgl_tex_parameterf(
+            target,
+            pname,
+            static_cast<float>(param),
+            ptr->GetState()
+    );
 
 }
 
@@ -4030,20 +3880,18 @@ WebGLRenderingContext::TexParameteri(const v8::FunctionCallbackInfo<v8::Value> &
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 2) {
-        auto target = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto param = (int32_t) args[2]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_tex_parameteri(
-                target,
-                pname,
-                param,
-                ptr->GetState()
-        );
-    }
+    auto target = args[0]->Uint32Value(
+            context).ToChecked();
+    auto pname = args[1]->Uint32Value(
+            context).ToChecked();
+    auto param = args[2]->Int32Value(
+            context).ToChecked();
+    canvas_native_webgl_tex_parameteri(
+            target,
+            pname,
+            param,
+            ptr->GetState()
+    );
 
 }
 
@@ -4059,17 +3907,17 @@ WebGLRenderingContext::TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &
 
     auto count = args.Length();
     if (count == 7) {
-        auto target = (uint32_t) args[0]->NumberValue(
+        auto target = args[0]->Uint32Value(
                 context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(
+        auto level = args[1]->Int32Value(
                 context).ToChecked();
-        auto xoffset = (int32_t) args[2]->NumberValue(
+        auto xoffset = args[2]->Int32Value(
                 context).ToChecked();
-        auto yoffset = (int32_t) args[3]->NumberValue(
+        auto yoffset = args[3]->Int32Value(
                 context).ToChecked();
-        auto format = (uint32_t) args[4]->NumberValue(
+        auto format = args[4]->Uint32Value(
                 context).ToChecked();
-        auto type = (int32_t) args[5]->NumberValue(
+        auto type = args[5]->Int32Value(
                 context).ToChecked();
 
 
@@ -4150,21 +3998,21 @@ WebGLRenderingContext::TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &
         }
 
     } else if (count == 9) {
-        auto target = (uint32_t) args[0]->NumberValue(
+        auto target = args[0]->Uint32Value(
                 context).ToChecked();
-        auto level = (int32_t) args[1]->NumberValue(
+        auto level = args[1]->Int32Value(
                 context).ToChecked();
-        auto xoffset = (int32_t) args[2]->NumberValue(
+        auto xoffset = args[2]->Int32Value(
                 context).ToChecked();
-        auto yoffset = (int32_t) args[3]->NumberValue(
+        auto yoffset = args[3]->Int32Value(
                 context).ToChecked();
-        auto width = (int32_t) args[4]->NumberValue(
+        auto width = args[4]->Int32Value(
                 context).ToChecked();
-        auto height = (int32_t) args[5]->NumberValue(
+        auto height = args[5]->Int32Value(
                 context).ToChecked();
-        auto format = (uint32_t) args[6]->NumberValue(
+        auto format = args[6]->Uint32Value(
                 context).ToChecked();
-        auto type = (int32_t) args[7]->NumberValue(
+        auto type = args[7]->Int32Value(
                 context).ToChecked();
 
         auto pixels = args[8];
@@ -4176,7 +4024,7 @@ WebGLRenderingContext::TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &
             auto array = buf->Buffer();
             auto offset = buf->ByteOffset();
             auto size = array->ByteLength();
-            auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+            auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
             auto data = static_cast<uint8_t *>((void *) data_ptr);
 
 
@@ -4227,14 +4075,12 @@ WebGLRenderingContext::VertexAttrib1f(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto v0 = static_cast<float>(args[1]->NumberValue(
-                context).ToChecked());
-        canvas_native_webgl_vertex_attrib1f(
-                index, v0, ptr->GetState());
-    }
+    auto index =  args[0]->Uint32Value(
+            context).ToChecked();
+    auto v0 = static_cast<float>(args[1]->NumberValue(
+            context).ToChecked());
+    canvas_native_webgl_vertex_attrib1f(
+            index, v0, ptr->GetState());
 
 }
 
@@ -4248,17 +4094,15 @@ WebGLRenderingContext::VertexAttrib2f(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 2) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto v0 = static_cast<float>(args[1]->NumberValue(
-                context).ToChecked());
-        auto v1 = static_cast<float>(args[2]->NumberValue(
-                context).ToChecked());
-        canvas_native_webgl_vertex_attrib2f(
-                index, v0, v1,
-                ptr->GetState());
-    }
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
+    auto v0 = static_cast<float>(args[1]->NumberValue(
+            context).ToChecked());
+    auto v1 = static_cast<float>(args[2]->NumberValue(
+            context).ToChecked());
+    canvas_native_webgl_vertex_attrib2f(
+            index, v0, v1,
+            ptr->GetState());
 
 }
 
@@ -4272,19 +4116,17 @@ WebGLRenderingContext::VertexAttrib3f(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto v0 = static_cast<float>(args[1]->NumberValue(
-                context).ToChecked());
-        auto v1 = static_cast<float>(args[2]->NumberValue(
-                context).ToChecked());
-        auto v2 = static_cast<float>(args[3]->NumberValue(
-                context).ToChecked());
-        canvas_native_webgl_vertex_attrib3f(
-                index, v0, v1, v2,
-                ptr->GetState());
-    }
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
+    auto v0 = static_cast<float>(args[1]->NumberValue(
+            context).ToChecked());
+    auto v1 = static_cast<float>(args[2]->NumberValue(
+            context).ToChecked());
+    auto v2 = static_cast<float>(args[3]->NumberValue(
+            context).ToChecked());
+    canvas_native_webgl_vertex_attrib3f(
+            index, v0, v1, v2,
+            ptr->GetState());
 
 }
 
@@ -4298,21 +4140,19 @@ WebGLRenderingContext::VertexAttrib4f(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 4) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto v0 = static_cast<float>(args[1]->NumberValue(
-                context).ToChecked());
-        auto v1 = static_cast<float>(args[2]->NumberValue(
-                context).ToChecked());
-        auto v2 = static_cast<float>(args[3]->NumberValue(
-                context).ToChecked());
-        auto v3 = static_cast<float>(args[4]->NumberValue(
-                context).ToChecked());
-        canvas_native_webgl_vertex_attrib4f(
-                index, v0, v1, v2, v3,
-                ptr->GetState());
-    }
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
+    auto v0 = static_cast<float>(args[1]->NumberValue(
+            context).ToChecked());
+    auto v1 = static_cast<float>(args[2]->NumberValue(
+            context).ToChecked());
+    auto v2 = static_cast<float>(args[3]->NumberValue(
+            context).ToChecked());
+    auto v3 = static_cast<float>(args[4]->NumberValue(
+            context).ToChecked());
+    canvas_native_webgl_vertex_attrib4f(
+            index, v0, v1, v2, v3,
+            ptr->GetState());
 
 }
 
@@ -4326,25 +4166,23 @@ WebGLRenderingContext::VertexAttrib1fv(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
 
-        auto value = args[1];
-        if (value->IsFloat32Array()) {
-            auto buf = value.As<v8::Float32Array>();
+    auto value = args[1];
+    if (value->IsFloat32Array()) {
+        auto buf = value.As<v8::Float32Array>();
 
-            auto array = buf->Buffer();
-            auto offset = buf->ByteOffset();
-            auto size = buf->Length();
-            auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
-            auto data = static_cast<float *>((void *) data_ptr);
+        auto array = buf->Buffer();
+        auto offset = buf->ByteOffset();
+        auto size = buf->Length();
+        auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
+        auto data = static_cast<float *>((void *) data_ptr);
 
 
-            canvas_native_webgl_vertex_attrib1fv(
-                    index, data, size,
-                    ptr->GetState());
-        }
+        canvas_native_webgl_vertex_attrib1fv(
+                index, data, size,
+                ptr->GetState());
     }
 }
 
@@ -4358,25 +4196,23 @@ WebGLRenderingContext::VertexAttrib2fv(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
 
-        auto value = args[1];
-        if (value->IsFloat32Array()) {
-            auto buf = value.As<v8::Float32Array>();
+    auto value = args[1];
+    if (value->IsFloat32Array()) {
+        auto buf = value.As<v8::Float32Array>();
 
-            auto array = buf->Buffer();
-            auto offset = buf->ByteOffset();
-            auto size = buf->Length();
-            auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
-            auto data = static_cast<float *>((void *) data_ptr);
+        auto array = buf->Buffer();
+        auto offset = buf->ByteOffset();
+        auto size = buf->Length();
+        auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
+        auto data = static_cast<float *>((void *) data_ptr);
 
 
-            canvas_native_webgl_vertex_attrib2fv(
-                    index, data, size,
-                    ptr->GetState());
-        }
+        canvas_native_webgl_vertex_attrib2fv(
+                index, data, size,
+                ptr->GetState());
     }
 }
 
@@ -4390,25 +4226,23 @@ WebGLRenderingContext::VertexAttrib3fv(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
 
-        auto value = args[1];
-        if (value->IsFloat32Array()) {
-            auto buf = value.As<v8::Float32Array>();
+    auto value = args[1];
+    if (value->IsFloat32Array()) {
+        auto buf = value.As<v8::Float32Array>();
 
-            auto array = buf->Buffer();
-            auto offset = buf->ByteOffset();
-            auto size = buf->Length();
-            auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
-            auto data = static_cast<float *>((void *) data_ptr);
+        auto array = buf->Buffer();
+        auto offset = buf->ByteOffset();
+        auto size = buf->Length();
+        auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
+        auto data = static_cast<float *>((void *) data_ptr);
 
 
-            canvas_native_webgl_vertex_attrib3fv(
-                    index, data, size,
-                    ptr->GetState());
-        }
+        canvas_native_webgl_vertex_attrib3fv(
+                index, data, size,
+                ptr->GetState());
     }
 }
 
@@ -4422,25 +4256,23 @@ WebGLRenderingContext::VertexAttrib4fv(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
 
-        auto value = args[1];
-        if (value->IsFloat32Array()) {
-            auto buf = value.As<v8::Float32Array>();
+    auto value = args[1];
+    if (value->IsFloat32Array()) {
+        auto buf = value.As<v8::Float32Array>();
 
-            auto array = buf->Buffer();
-            auto offset = buf->ByteOffset();
-            auto size = buf->Length();
-            auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
-            auto data = static_cast<float *>((void *) data_ptr);
+        auto array = buf->Buffer();
+        auto offset = buf->ByteOffset();
+        auto size = buf->Length();
+        auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
+        auto data = static_cast<float *>((void *) data_ptr);
 
 
-            canvas_native_webgl_vertex_attrib4fv(
-                    index, data, size,
-                    ptr->GetState());
-        }
+        canvas_native_webgl_vertex_attrib4fv(
+                index, data, size,
+                ptr->GetState());
     }
 }
 
@@ -4454,23 +4286,21 @@ WebGLRenderingContext::VertexAttribPointer(const v8::FunctionCallbackInfo<v8::Va
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 5) {
-        auto index = (uint32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto size = (int32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto type = (uint32_t) args[2]->NumberValue(
-                context).ToChecked();
-        auto normalized = args[3]->BooleanValue(isolate);
-        auto stride = (int32_t) args[4]->NumberValue(
-                context).ToChecked();
-        auto offset = static_cast<ssize_t>(args[5]->NumberValue(
-                context).ToChecked());
-        canvas_native_webgl_vertex_attrib_pointer(
-                index, size, type, normalized,
-                stride, offset,
-                ptr->GetState());
-    }
+    auto index = args[0]->Uint32Value(
+            context).ToChecked();
+    auto size = args[1]->Int32Value(
+            context).ToChecked();
+    auto type = args[2]->Uint32Value(
+            context).ToChecked();
+    auto normalized = args[3]->BooleanValue(isolate);
+    auto stride = args[4]->Int32Value(
+            context).ToChecked();
+    auto offset = static_cast<ssize_t>(args[5]->NumberValue(
+            context).ToChecked());
+    canvas_native_webgl_vertex_attrib_pointer(
+            index, size, type, normalized,
+            stride, offset,
+            ptr->GetState());
 }
 
 void
@@ -4484,8 +4314,7 @@ WebGLRenderingContext::Uniform1f(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
+
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
     auto v0 = args[1]->NumberValue(
             context).ToChecked();
@@ -4496,8 +4325,6 @@ WebGLRenderingContext::Uniform1f(const v8::FunctionCallbackInfo<v8::Value> &args
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4511,8 +4338,7 @@ WebGLRenderingContext::Uniform2f(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
+
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
     auto v0 = args[1]->NumberValue(
             context).ToChecked();
@@ -4526,8 +4352,6 @@ WebGLRenderingContext::Uniform2f(const v8::FunctionCallbackInfo<v8::Value> &args
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4541,8 +4365,6 @@ WebGLRenderingContext::Uniform3f(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
     auto v0 = args[1]->NumberValue(
             context).ToChecked();
@@ -4559,8 +4381,6 @@ WebGLRenderingContext::Uniform3f(const v8::FunctionCallbackInfo<v8::Value> &args
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4574,8 +4394,6 @@ WebGLRenderingContext::Uniform4f(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
     auto v0 = args[1]->NumberValue(
             context).ToChecked();
@@ -4595,8 +4413,6 @@ WebGLRenderingContext::Uniform4f(const v8::FunctionCallbackInfo<v8::Value> &args
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4624,7 +4440,7 @@ WebGLRenderingContext::Uniform1fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<float *>((void *) data_ptr);
 
 
@@ -4641,15 +4457,10 @@ WebGLRenderingContext::Uniform1fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                      i < len; ++i) {
                     auto item = array->Get(
                             context, i).ToLocalChecked();
-                    if (!item->IsNumber()) {
-                        buf.push_back(
-                                nanf(""));
-                    } else {
-                        auto value = item->NumberValue(
-                                context).ToChecked();
-                        buf.push_back(
-                                static_cast<float>(value));
-                    }
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<float>(value));
                 }
 
                 canvas_native_webgl_uniform1fv(
@@ -4686,7 +4497,7 @@ WebGLRenderingContext::Uniform2fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<float *>((void *) data_ptr);
 
 
@@ -4703,15 +4514,10 @@ WebGLRenderingContext::Uniform2fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                      i < len; ++i) {
                     auto item = array->Get(
                             context, i).ToLocalChecked();
-                    if (!item->IsNumber()) {
-                        buf.push_back(
-                                nanf(""));
-                    } else {
-                        auto value = item->NumberValue(
-                                context).ToChecked();
-                        buf.push_back(
-                                static_cast<float>(value));
-                    }
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<float>(value));
                 }
 
                 canvas_native_webgl_uniform2fv(
@@ -4748,7 +4554,7 @@ WebGLRenderingContext::Uniform3fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<float *>((void *) data_ptr);
 
 
@@ -4765,15 +4571,10 @@ WebGLRenderingContext::Uniform3fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                      i < len; ++i) {
                     auto item = array->Get(
                             context, i).ToLocalChecked();
-                    if (!item->IsNumber()) {
-                        buf.push_back(
-                                nanf(""));
-                    } else {
-                        auto value = item->NumberValue(
-                                context).ToChecked();
-                        buf.push_back(
-                                static_cast<float>(value));
-                    }
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<float>(value));
                 }
                 canvas_native_webgl_uniform3fv(
                         location->GetUniformLocation(),
@@ -4809,7 +4610,7 @@ WebGLRenderingContext::Uniform4fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<float *>((void *) data_ptr);
 
 
@@ -4826,15 +4627,10 @@ WebGLRenderingContext::Uniform4fv(const v8::FunctionCallbackInfo<v8::Value> &arg
                      i < len; ++i) {
                     auto item = array->Get(
                             context, i).ToLocalChecked();
-                    if (!item->IsNumber()) {
-                        buf.push_back(
-                                nanf(""));
-                    } else {
-                        auto value = item->NumberValue(
-                                context).ToChecked();
-                        buf.push_back(
-                                static_cast<float>(value));
-                    }
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<float>(value));
                 }
                 canvas_native_webgl_uniform4fv(
                         location->GetUniformLocation(),
@@ -4857,20 +4653,16 @@ WebGLRenderingContext::Uniform1i(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
-    auto v0 = args[1]->NumberValue(
+    auto v0 = args[1]->Int32Value(
             context).ToChecked();
     if (location != nullptr) {
         canvas_native_webgl_uniform1i(
                 location->GetUniformLocation(),
-                static_cast<int32_t>(v0),
+                v0,
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4884,23 +4676,19 @@ WebGLRenderingContext::Uniform2i(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
-    auto v0 = args[1]->NumberValue(
+    auto v0 = args[1]->Int32Value(
             context).ToChecked();
-    auto v1 = args[2]->NumberValue(
+    auto v1 = args[2]->Int32Value(
             context).ToChecked();
     if (location != nullptr) {
         canvas_native_webgl_uniform2i(
                 location->GetUniformLocation(),
-                static_cast<int32_t>(v0),
-                static_cast<int32_t>(v1),
+                v0,
+                v1,
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4914,26 +4702,22 @@ WebGLRenderingContext::Uniform3i(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
-    auto v0 = args[1]->NumberValue(
+    auto v0 = args[1]->Int32Value(
             context).ToChecked();
-    auto v1 = args[2]->NumberValue(
+    auto v1 = args[2]->Int32Value(
             context).ToChecked();
-    auto v2 = args[3]->NumberValue(
+    auto v2 = args[3]->Int32Value(
             context).ToChecked();
     if (location != nullptr) {
         canvas_native_webgl_uniform3i(
                 location->GetUniformLocation(),
-                static_cast<int32_t>(v0),
-                static_cast<int32_t>(v1),
-                static_cast<int32_t>(v2),
+                v0,
+                v1,
+                v2,
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4947,29 +4731,25 @@ WebGLRenderingContext::Uniform4i(const v8::FunctionCallbackInfo<v8::Value> &args
     auto context = isolate->GetCurrentContext();
 
     auto value = args[0];
-    //if (count > 1) {
-    //   if (args[0].isObject()) {
     auto location = WebGLUniformLocation::GetPointer(value.As<v8::Object>());
-    auto v0 = args[1]->NumberValue(
+    auto v0 = args[1]->Int32Value(
             context).ToChecked();
-    auto v1 = args[2]->NumberValue(
+    auto v1 = args[2]->Int32Value(
             context).ToChecked();
-    auto v2 = args[3]->NumberValue(
+    auto v2 = args[3]->Int32Value(
             context).ToChecked();
-    auto v3 = args[4]->NumberValue(
+    auto v3 = args[4]->Int32Value(
             context).ToChecked();
     if (location != nullptr) {
         canvas_native_webgl_uniform4i(
                 location->GetUniformLocation(),
-                static_cast<int32_t>(v0),
-                static_cast<int32_t>(v1),
-                static_cast<int32_t>(v2),
-                static_cast<int32_t>(v3),
+                v0,
+                v1,
+                v2,
+                v3,
                 ptr->GetState()
         );
     }
-    //   }
-    // }
 }
 
 void
@@ -4997,7 +4777,7 @@ WebGLRenderingContext::Uniform1iv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<int32_t *>((void *) data_ptr);
 
 
@@ -5055,7 +4835,7 @@ WebGLRenderingContext::Uniform2iv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<int32_t *>((void *) data_ptr);
 
                 canvas_native_webgl_uniform2iv(
@@ -5111,7 +4891,7 @@ WebGLRenderingContext::Uniform3iv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<int32_t *>((void *) data_ptr);
 
 
@@ -5169,7 +4949,7 @@ WebGLRenderingContext::Uniform4iv(const v8::FunctionCallbackInfo<v8::Value> &arg
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<int32_t *>((void *) data_ptr);
 
 
@@ -5226,7 +5006,7 @@ WebGLRenderingContext::UniformMatrix2fv(const v8::FunctionCallbackInfo<v8::Value
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<float *>((void *) data_ptr);
 
                 canvas_native_webgl_uniform_matrix2fv(
@@ -5242,15 +5022,9 @@ WebGLRenderingContext::UniformMatrix2fv(const v8::FunctionCallbackInfo<v8::Value
                 for (int i = 0;
                      i < len; i++) {
                     auto item = array->Get(context, i).ToLocalChecked();
-                    if (item->IsNumber()) {
-                        buf.push_back(
-                                static_cast<float>(item->NumberValue(
-                                        context).ToChecked()));
-                    } else {
-                        buf.push_back(
-                                std::nanf(
-                                        ""));
-                    }
+                    buf.push_back(
+                            static_cast<float>(item->NumberValue(
+                                    context).ToChecked()));
                 }
 
                 canvas_native_webgl_uniform_matrix2fv(
@@ -5288,7 +5062,7 @@ WebGLRenderingContext::UniformMatrix3fv(const v8::FunctionCallbackInfo<v8::Value
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<float *>((void *) data_ptr);
 
                 canvas_native_webgl_uniform_matrix3fv(
@@ -5304,15 +5078,9 @@ WebGLRenderingContext::UniformMatrix3fv(const v8::FunctionCallbackInfo<v8::Value
                 for (int i = 0;
                      i < len; i++) {
                     auto item = array->Get(context, i).ToLocalChecked();
-                    if (item->IsNumber()) {
-                        buf.push_back(
-                                static_cast<float>(item->NumberValue(
-                                        context).ToChecked()));
-                    } else {
-                        buf.push_back(
-                                std::nanf(
-                                        ""));
-                    }
+                    buf.push_back(
+                            static_cast<float>(item->NumberValue(
+                                    context).ToChecked()));
                 }
 
 
@@ -5351,7 +5119,7 @@ WebGLRenderingContext::UniformMatrix4fv(const v8::FunctionCallbackInfo<v8::Value
                 auto array = buf->Buffer();
                 auto offset = buf->ByteOffset();
                 auto size = buf->Length();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
+                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
                 auto data = static_cast<float *>((void *) data_ptr);
 
 
@@ -5368,15 +5136,9 @@ WebGLRenderingContext::UniformMatrix4fv(const v8::FunctionCallbackInfo<v8::Value
                 for (int i = 0;
                      i < len; i++) {
                     auto item = array->Get(context, i).ToLocalChecked();
-                    if (item->IsNumber()) {
-                        buf.push_back(
-                                static_cast<float>(item->NumberValue(
-                                        context).ToChecked()));
-                    } else {
-                        buf.push_back(
-                                std::nanf(
-                                        ""));
-                    }
+                    buf.push_back(
+                            static_cast<float>(item->NumberValue(
+                                    context).ToChecked()));
                 }
 
 
@@ -5399,24 +5161,22 @@ WebGLRenderingContext::UseProgram(const v8::FunctionCallbackInfo<v8::Value> &arg
 
     auto isolate = args.GetIsolate();
 
-    if (args.Length() > 0) {
-        auto value = args[0];
-        if (value->IsNull()) {
-            canvas_native_webgl_use_program(0,
-                                            ptr->GetState());
+    auto value = args[0];
+    if (value->IsNull()) {
+        canvas_native_webgl_use_program(0,
+                                        ptr->GetState());
 
-            return;
-        }
+        return;
+    }
 
-        auto type = GetNativeType(isolate, value);
-        if (type == NativeType::WebGLProgram) {
-            auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
-            if (program != nullptr) {
-                canvas_native_webgl_use_program(
-                        program->GetProgram(),
-                        ptr->GetState()
-                );
-            }
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
+        if (program != nullptr) {
+            canvas_native_webgl_use_program(
+                    program->GetProgram(),
+                    ptr->GetState()
+            );
         }
     }
 
@@ -5455,20 +5215,18 @@ WebGLRenderingContext::Viewport(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 3) {
-        auto x = (int32_t) args[0]->NumberValue(
-                context).ToChecked();
-        auto y = (int32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto width = (int32_t) args[2]->NumberValue(
-                context).ToChecked();
-        auto height = (int32_t) args[3]->NumberValue(
-                context).ToChecked();
-        canvas_native_webgl_viewport(x, y,
-                                     width,
-                                     height,
-                                     ptr->GetState());
-    }
+    auto x = args[0]->Int32Value(
+            context).ToChecked();
+    auto y = args[1]->Int32Value(
+            context).ToChecked();
+    auto width = args[2]->Int32Value(
+            context).ToChecked();
+    auto height = args[3]->Int32Value(
+            context).ToChecked();
+    canvas_native_webgl_viewport(x, y,
+                                 width,
+                                 height,
+                                 ptr->GetState());
 
 }
 
@@ -5506,446 +5264,473 @@ WebGLRenderingContext::__ToDataURL(const v8::FunctionCallbackInfo<v8::Value> &ar
 
 void WebGLRenderingContext::SetConstants(v8::Isolate *isolate,
                                          const v8::Local<v8::ObjectTemplate> &tmpl) {
-    tmpl->Set(isolate, "DEPTH_BUFFER_BIT", v8::Uint32::New(isolate, 0x00000100));
+    tmpl->Set(isolate, "DEPTH_BUFFER_BIT", v8::Integer::NewFromUnsigned(isolate, 0x00000100));
 
-    tmpl->Set(isolate, "STENCIL_BUFFER_BIT", v8::Uint32::New(isolate, 0x00000400));
+    tmpl->Set(isolate, "STENCIL_BUFFER_BIT", v8::Integer::NewFromUnsigned(isolate, 0x00000400));
 
-    tmpl->Set(isolate, "COLOR_BUFFER_BIT", v8::Uint32::New(isolate, 0x00004000));
+    tmpl->Set(isolate, "COLOR_BUFFER_BIT", v8::Integer::NewFromUnsigned(isolate, 0x00004000));
 
-    tmpl->Set(isolate, "POINTS", v8::Uint32::New(isolate, 0x0000));
+    tmpl->Set(isolate, "POINTS", v8::Integer::NewFromUnsigned(isolate, 0x0000));
 
-    tmpl->Set(isolate, "LINES", v8::Uint32::New(isolate, 0x0001));
+    tmpl->Set(isolate, "LINES", v8::Integer::NewFromUnsigned(isolate, 0x0001));
 
-    tmpl->Set(isolate, "LINE_LOOP", v8::Uint32::New(isolate, 0x0002));
+    tmpl->Set(isolate, "LINE_LOOP", v8::Integer::NewFromUnsigned(isolate, 0x0002));
 
-    tmpl->Set(isolate, "LINE_STRIP", v8::Uint32::New(isolate, 0x0003));
+    tmpl->Set(isolate, "LINE_STRIP", v8::Integer::NewFromUnsigned(isolate, 0x0003));
 
-    tmpl->Set(isolate, "TRIANGLES", v8::Uint32::New(isolate, 0x0004));
+    tmpl->Set(isolate, "TRIANGLES", v8::Integer::NewFromUnsigned(isolate, 0x0004));
 
-    tmpl->Set(isolate, "TRIANGLE_STRIP", v8::Uint32::New(isolate, 0x0005));
+    tmpl->Set(isolate, "TRIANGLE_STRIP", v8::Integer::NewFromUnsigned(isolate, 0x0005));
 
-    tmpl->Set(isolate, "TRIANGLE_FAN", v8::Uint32::New(isolate, 0x0006));
+    tmpl->Set(isolate, "TRIANGLE_FAN", v8::Integer::NewFromUnsigned(isolate, 0x0006));
 
-    tmpl->Set(isolate, "ZERO", v8::Uint32::New(isolate, 0));
+    tmpl->Set(isolate, "ZERO", v8::Integer::NewFromUnsigned(isolate, 0));
 
-    tmpl->Set(isolate, "ONE", v8::Uint32::New(isolate, 1));
+    tmpl->Set(isolate, "ONE", v8::Integer::NewFromUnsigned(isolate, 1));
 
-    tmpl->Set(isolate, "SRC_COLOR", v8::Uint32::New(isolate, 0x0300));
+    tmpl->Set(isolate, "SRC_COLOR", v8::Integer::NewFromUnsigned(isolate, 0x0300));
 
-    tmpl->Set(isolate, "ONE_MINUS_SRC_COLOR", v8::Uint32::New(isolate, 0x0301));
+    tmpl->Set(isolate, "ONE_MINUS_SRC_COLOR", v8::Integer::NewFromUnsigned(isolate, 0x0301));
 
-    tmpl->Set(isolate, "SRC_ALPHA", v8::Uint32::New(isolate, 0x0302));
+    tmpl->Set(isolate, "SRC_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x0302));
 
-    tmpl->Set(isolate, "ONE_MINUS_SRC_ALPHA", v8::Uint32::New(isolate, 0x0303));
+    tmpl->Set(isolate, "ONE_MINUS_SRC_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x0303));
 
-    tmpl->Set(isolate, "DST_ALPHA", v8::Uint32::New(isolate, 0x0304));
+    tmpl->Set(isolate, "DST_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x0304));
 
-    tmpl->Set(isolate, "ONE_MINUS_DST_ALPHA", v8::Uint32::New(isolate, 0x0305));
+    tmpl->Set(isolate, "ONE_MINUS_DST_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x0305));
 
-    tmpl->Set(isolate, "DST_COLOR", v8::Uint32::New(isolate, 0x0306));
+    tmpl->Set(isolate, "DST_COLOR", v8::Integer::NewFromUnsigned(isolate, 0x0306));
 
-    tmpl->Set(isolate, "ONE_MINUS_DST_COLOR", v8::Uint32::New(isolate, 0x0307));
+    tmpl->Set(isolate, "ONE_MINUS_DST_COLOR", v8::Integer::NewFromUnsigned(isolate, 0x0307));
 
-    tmpl->Set(isolate, "SRC_ALPHA_SATURATE", v8::Uint32::New(isolate, 0x0308));
+    tmpl->Set(isolate, "SRC_ALPHA_SATURATE", v8::Integer::NewFromUnsigned(isolate, 0x0308));
 
 
-    tmpl->Set(isolate, "CONSTANT_COLOR", v8::Uint32::New(isolate, 0x8001));
-    tmpl->Set(isolate, "ONE_MINUS_CONSTANT_COLOR", v8::Uint32::New(isolate, 0x8002));
-    tmpl->Set(isolate, "CONSTANT_ALPHA", v8::Uint32::New(isolate, 0x8003));
-    tmpl->Set(isolate, "ONE_MINUS_CONSTANT_ALPHA", v8::Uint32::New(isolate, 0x8004));
+    tmpl->Set(isolate, "CONSTANT_COLOR", v8::Integer::NewFromUnsigned(isolate, 0x8001));
+    tmpl->Set(isolate, "ONE_MINUS_CONSTANT_COLOR", v8::Integer::NewFromUnsigned(isolate, 0x8002));
+    tmpl->Set(isolate, "CONSTANT_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x8003));
+    tmpl->Set(isolate, "ONE_MINUS_CONSTANT_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x8004));
 
 
     /* Blending equations */
 
-    tmpl->Set(isolate, "FUNC_ADD", v8::Uint32::New(isolate, 0x8006));
-    tmpl->Set(isolate, "FUNC_SUBTRACT", v8::Uint32::New(isolate, 0x800A));
-    tmpl->Set(isolate, "FUNC_REVERSE_SUBTRACT", v8::Uint32::New(isolate, 0x800B));
-    tmpl->Set(isolate, "BLEND_EQUATION", v8::Uint32::New(isolate, 0x8009));
-    tmpl->Set(isolate, "BLEND_EQUATION_RGB", v8::Uint32::New(isolate, 0x8009));
-    tmpl->Set(isolate, "BLEND_EQUATION_ALPHA", v8::Uint32::New(isolate, 0x883D));
-
-
-    tmpl->Set(isolate, "BLEND_DST_RGB", v8::Uint32::New(isolate, 0x80C8));
-    tmpl->Set(isolate, "BLEND_SRC_RGB", v8::Uint32::New(isolate, 0x80C9));
-    tmpl->Set(isolate, "BLEND_DST_ALPHA", v8::Uint32::New(isolate, 0x80CA));
-
-
-    tmpl->Set(isolate, "BLEND_SRC_ALPHA", v8::Uint32::New(isolate, 0x80CB));
-    tmpl->Set(isolate, "BLEND_COLOR", v8::Uint32::New(isolate, 0x8005));
-    tmpl->Set(isolate, "ARRAY_BUFFER_BINDING", v8::Uint32::New(isolate, 0x8894));
-
-
-    tmpl->Set(isolate, "ELEMENT_ARRAY_BUFFER_BINDING", v8::Uint32::New(isolate, 0x8895));
-    tmpl->Set(isolate, "LINE_WIDTH", v8::Uint32::New(isolate, 0x0B21));
-    tmpl->Set(isolate, "ALIASED_POINT_SIZE_RANGE", v8::Uint32::New(isolate, 0x846D));
-
-    tmpl->Set(isolate, "ALIASED_LINE_WIDTH_RANGE", v8::Uint32::New(isolate, 0x846E));
-    tmpl->Set(isolate, "CULL_FACE_MODE", v8::Uint32::New(isolate, 0x0B45));
-    tmpl->Set(isolate, "FRONT_FACE", v8::Uint32::New(isolate, 0x0B46));
-
-    tmpl->Set(isolate, "DEPTH_RANGE", v8::Uint32::New(isolate, 0x0B70));
-    tmpl->Set(isolate, "DEPTH_WRITEMASK", v8::Uint32::New(isolate, 0x0B72));
-    tmpl->Set(isolate, "DEPTH_CLEAR_VALUE", v8::Uint32::New(isolate, 0x0B73));
-
-    tmpl->Set(isolate, "DEPTH_FUNC", v8::Uint32::New(isolate, 0x0B74));
-    tmpl->Set(isolate, "STENCIL_CLEAR_VALUE", v8::Uint32::New(isolate, 0x0B91));
-    tmpl->Set(isolate, "STENCIL_FUNC", v8::Uint32::New(isolate, 0x0B92));
-
-    tmpl->Set(isolate, "STENCIL_FAIL", v8::Uint32::New(isolate, 0x0B94));
-    tmpl->Set(isolate, "STENCIL_PASS_DEPTH_FAIL", v8::Uint32::New(isolate, 0x0B95));
-    tmpl->Set(isolate, "STENCIL_PASS_DEPTH_PASS", v8::Uint32::New(isolate, 0x0B96));
-
-    tmpl->Set(isolate, "STENCIL_REF", v8::Uint32::New(isolate, 0x0B97));
-    tmpl->Set(isolate, "STENCIL_VALUE_MASK", v8::Uint32::New(isolate, 0x0B93));
-    tmpl->Set(isolate, "STENCIL_WRITEMASK", v8::Uint32::New(isolate, 0x0B98));
-
-    tmpl->Set(isolate, "STENCIL_BACK_FUNC", v8::Uint32::New(isolate, 0x8800));
-    tmpl->Set(isolate, "STENCIL_BACK_FAIL", v8::Uint32::New(isolate, 0x8801));
-    tmpl->Set(isolate, "STENCIL_BACK_PASS_DEPTH_FAIL", v8::Uint32::New(isolate, 0x8802));
-
-    tmpl->Set(isolate, "STENCIL_BACK_PASS_DEPTH_PASS", v8::Uint32::New(isolate, 0x8803));
-    tmpl->Set(isolate, "STENCIL_BACK_REF", v8::Uint32::New(isolate, 0x8CA3));
-    tmpl->Set(isolate, "STENCIL_BACK_VALUE_MASK", v8::Uint32::New(isolate, 0x8CA4));
-    tmpl->Set(isolate, "STENCIL_BACK_WRITEMASK", v8::Uint32::New(isolate, 0x8CA5));
-
-    tmpl->Set(isolate, "VIEWPORT", v8::Uint32::New(isolate, 0x0BA2));
-    tmpl->Set(isolate, "SCISSOR_BOX", v8::Uint32::New(isolate, 0x0C10));
-    tmpl->Set(isolate, "COLOR_CLEAR_VALUE", v8::Uint32::New(isolate, 0x0C22));
-    tmpl->Set(isolate, "COLOR_WRITEMASK", v8::Uint32::New(isolate, 0x0C23));
-
-    tmpl->Set(isolate, "UNPACK_ALIGNMENT", v8::Uint32::New(isolate, 0x0CF5));
-    tmpl->Set(isolate, "PACK_ALIGNMENT", v8::Uint32::New(isolate, 0x0D05));
-    tmpl->Set(isolate, "MAX_TEXTURE_SIZE", v8::Uint32::New(isolate, 0x0D33));
-
-
-    tmpl->Set(isolate, "MAX_VIEWPORT_DIMS", v8::Uint32::New(isolate, 0x0D3A));
-    tmpl->Set(isolate, "SUBPIXEL_BITS", v8::Uint32::New(isolate, 0x0D50));
-
-    tmpl->Set(isolate, "RED_BITS", v8::Uint32::New(isolate, 0x0D52));
-    tmpl->Set(isolate, "GREEN_BITS", v8::Uint32::New(isolate, 0x0D53));
-    tmpl->Set(isolate, "BLUE_BITS", v8::Uint32::New(isolate, 0x0D54));
-    tmpl->Set(isolate, "ALPHA_BITS", v8::Uint32::New(isolate, 0x0D55));
-
-    tmpl->Set(isolate, "STENCIL_BITS", v8::Uint32::New(isolate, 0x0D57));
-    tmpl->Set(isolate, "POLYGON_OFFSET_UNITS", v8::Uint32::New(isolate, 0x2A00));
-    tmpl->Set(isolate, "POLYGON_OFFSET_FACTOR", v8::Uint32::New(isolate, 0x8038));
-
-    tmpl->Set(isolate, "TEXTURE_BINDING_2D", v8::Uint32::New(isolate, 0x8069));
-    tmpl->Set(isolate, "SAMPLE_BUFFERS", v8::Uint32::New(isolate, 0x80A8));
-    tmpl->Set(isolate, "SAMPLES", v8::Uint32::New(isolate, 0x80A9));
-    tmpl->Set(isolate, "SAMPLE_COVERAGE_VALUE", v8::Uint32::New(isolate, 0x80AA));
-
-    tmpl->Set(isolate, "SAMPLE_COVERAGE_INVERT", v8::Uint32::New(isolate, 0x80AB));
-    tmpl->Set(isolate, "COMPRESSED_TEXTURE_FORMATS", v8::Uint32::New(isolate, 0x86A3));
-    tmpl->Set(isolate, "VENDOR", v8::Uint32::New(isolate, 0x1F00));
-    tmpl->Set(isolate, "RENDERER", v8::Uint32::New(isolate, 0x1F01));
-
-    tmpl->Set(isolate, "VERSION", v8::Uint32::New(isolate, 0x1F02));
-    tmpl->Set(isolate, "IMPLEMENTATION_COLOR_READ_TYPE", v8::Uint32::New(isolate, 0x8B9A));
-    tmpl->Set(isolate, "IMPLEMENTATION_COLOR_READ_FORMAT", v8::Uint32::New(isolate, 0x8B9B));
-    tmpl->Set(isolate, "BROWSER_DEFAULT_WEBGL", v8::Uint32::New(isolate, 0x9244));
-
-    tmpl->Set(isolate, "STATIC_DRAW", v8::Uint32::New(isolate, 0x88E4));
-    tmpl->Set(isolate, "STREAM_DRAW", v8::Uint32::New(isolate, 0x88E0));
-    tmpl->Set(isolate, "DYNAMIC_DRAW", v8::Uint32::New(isolate, 0x88E8));
-    tmpl->Set(isolate, "ARRAY_BUFFER", v8::Uint32::New(isolate, 0x8892));
-
-    tmpl->Set(isolate, "ELEMENT_ARRAY_BUFFER", v8::Uint32::New(isolate, 0x8893));
-    tmpl->Set(isolate, "BUFFER_SIZE", v8::Uint32::New(isolate, 0x8764));
-    tmpl->Set(isolate, "BUFFER_USAGE", v8::Uint32::New(isolate, 0x8765));
-    tmpl->Set(isolate, "CURRENT_VERTEX_ATTRIB", v8::Uint32::New(isolate, 0x8626));
-
-
-    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_ENABLED", v8::Uint32::New(isolate, 0x8622));
-    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_SIZE", v8::Uint32::New(isolate, 0x8623));
-    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_STRIDE", v8::Uint32::New(isolate, 0x8624));
-    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_TYPE", v8::Uint32::New(isolate, 0x8625));
-    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_NORMALIZED", v8::Uint32::New(isolate, 0x886A));
-    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_POINTER", v8::Uint32::New(isolate, 0x8645));
-    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", v8::Uint32::New(isolate, 0x889F));
-
-    tmpl->Set(isolate, "CULL_FACE", v8::Uint32::New(isolate, 0x0B44));
-    tmpl->Set(isolate, "FRONT", v8::Uint32::New(isolate, 0x0404));
-    tmpl->Set(isolate, "BACK", v8::Uint32::New(isolate, 0x0405));
-    tmpl->Set(isolate, "FRONT_AND_BACK", v8::Uint32::New(isolate, 0x0408));
+    tmpl->Set(isolate, "FUNC_ADD", v8::Integer::NewFromUnsigned(isolate, 0x8006));
+    tmpl->Set(isolate, "FUNC_SUBTRACT", v8::Integer::NewFromUnsigned(isolate, 0x800A));
+    tmpl->Set(isolate, "FUNC_REVERSE_SUBTRACT", v8::Integer::NewFromUnsigned(isolate, 0x800B));
+    tmpl->Set(isolate, "BLEND_EQUATION", v8::Integer::NewFromUnsigned(isolate, 0x8009));
+    tmpl->Set(isolate, "BLEND_EQUATION_RGB", v8::Integer::NewFromUnsigned(isolate, 0x8009));
+    tmpl->Set(isolate, "BLEND_EQUATION_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x883D));
 
-    tmpl->Set(isolate, "BLEND", v8::Uint32::New(isolate, 0x0BE2));
-    tmpl->Set(isolate, "DEPTH_TEST", v8::Uint32::New(isolate, 0x0B71));
-    tmpl->Set(isolate, "DITHER", v8::Uint32::New(isolate, 0x0BD0));
-    tmpl->Set(isolate, "POLYGON_OFFSET_FILL", v8::Uint32::New(isolate, 0x8037));
 
-    tmpl->Set(isolate, "SAMPLE_ALPHA_TO_COVERAGE", v8::Uint32::New(isolate, 0x809E));
-    tmpl->Set(isolate, "SAMPLE_COVERAGE", v8::Uint32::New(isolate, 0x80A0));
-    tmpl->Set(isolate, "SCISSOR_TEST", v8::Uint32::New(isolate, 0x0C11));
-    tmpl->Set(isolate, "STENCIL_TEST", v8::Uint32::New(isolate, 0x0B90));
+    tmpl->Set(isolate, "BLEND_DST_RGB", v8::Integer::NewFromUnsigned(isolate, 0x80C8));
+    tmpl->Set(isolate, "BLEND_SRC_RGB", v8::Integer::NewFromUnsigned(isolate, 0x80C9));
+    tmpl->Set(isolate, "BLEND_DST_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x80CA));
+
+
+    tmpl->Set(isolate, "BLEND_SRC_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x80CB));
+    tmpl->Set(isolate, "BLEND_COLOR", v8::Integer::NewFromUnsigned(isolate, 0x8005));
+    tmpl->Set(isolate, "ARRAY_BUFFER_BINDING", v8::Integer::NewFromUnsigned(isolate, 0x8894));
+
+
+    tmpl->Set(isolate, "ELEMENT_ARRAY_BUFFER_BINDING",
+              v8::Integer::NewFromUnsigned(isolate, 0x8895));
+    tmpl->Set(isolate, "LINE_WIDTH", v8::Integer::NewFromUnsigned(isolate, 0x0B21));
+    tmpl->Set(isolate, "ALIASED_POINT_SIZE_RANGE", v8::Integer::NewFromUnsigned(isolate, 0x846D));
+
+    tmpl->Set(isolate, "ALIASED_LINE_WIDTH_RANGE", v8::Integer::NewFromUnsigned(isolate, 0x846E));
+    tmpl->Set(isolate, "CULL_FACE_MODE", v8::Integer::NewFromUnsigned(isolate, 0x0B45));
+    tmpl->Set(isolate, "FRONT_FACE", v8::Integer::NewFromUnsigned(isolate, 0x0B46));
+
+    tmpl->Set(isolate, "DEPTH_RANGE", v8::Integer::NewFromUnsigned(isolate, 0x0B70));
+    tmpl->Set(isolate, "DEPTH_WRITEMASK", v8::Integer::NewFromUnsigned(isolate, 0x0B72));
+    tmpl->Set(isolate, "DEPTH_CLEAR_VALUE", v8::Integer::NewFromUnsigned(isolate, 0x0B73));
+
+    tmpl->Set(isolate, "DEPTH_FUNC", v8::Integer::NewFromUnsigned(isolate, 0x0B74));
+    tmpl->Set(isolate, "STENCIL_CLEAR_VALUE", v8::Integer::NewFromUnsigned(isolate, 0x0B91));
+    tmpl->Set(isolate, "STENCIL_FUNC", v8::Integer::NewFromUnsigned(isolate, 0x0B92));
+
+    tmpl->Set(isolate, "STENCIL_FAIL", v8::Integer::NewFromUnsigned(isolate, 0x0B94));
+    tmpl->Set(isolate, "STENCIL_PASS_DEPTH_FAIL", v8::Integer::NewFromUnsigned(isolate, 0x0B95));
+    tmpl->Set(isolate, "STENCIL_PASS_DEPTH_PASS", v8::Integer::NewFromUnsigned(isolate, 0x0B96));
+
+    tmpl->Set(isolate, "STENCIL_REF", v8::Integer::NewFromUnsigned(isolate, 0x0B97));
+    tmpl->Set(isolate, "STENCIL_VALUE_MASK", v8::Integer::NewFromUnsigned(isolate, 0x0B93));
+    tmpl->Set(isolate, "STENCIL_WRITEMASK", v8::Integer::NewFromUnsigned(isolate, 0x0B98));
+
+    tmpl->Set(isolate, "STENCIL_BACK_FUNC", v8::Integer::NewFromUnsigned(isolate, 0x8800));
+    tmpl->Set(isolate, "STENCIL_BACK_FAIL", v8::Integer::NewFromUnsigned(isolate, 0x8801));
+    tmpl->Set(isolate, "STENCIL_BACK_PASS_DEPTH_FAIL",
+              v8::Integer::NewFromUnsigned(isolate, 0x8802));
+
+    tmpl->Set(isolate, "STENCIL_BACK_PASS_DEPTH_PASS",
+              v8::Integer::NewFromUnsigned(isolate, 0x8803));
+    tmpl->Set(isolate, "STENCIL_BACK_REF", v8::Integer::NewFromUnsigned(isolate, 0x8CA3));
+    tmpl->Set(isolate, "STENCIL_BACK_VALUE_MASK", v8::Integer::NewFromUnsigned(isolate, 0x8CA4));
+    tmpl->Set(isolate, "STENCIL_BACK_WRITEMASK", v8::Integer::NewFromUnsigned(isolate, 0x8CA5));
+
+    tmpl->Set(isolate, "VIEWPORT", v8::Integer::NewFromUnsigned(isolate, 0x0BA2));
+    tmpl->Set(isolate, "SCISSOR_BOX", v8::Integer::NewFromUnsigned(isolate, 0x0C10));
+    tmpl->Set(isolate, "COLOR_CLEAR_VALUE", v8::Integer::NewFromUnsigned(isolate, 0x0C22));
+    tmpl->Set(isolate, "COLOR_WRITEMASK", v8::Integer::NewFromUnsigned(isolate, 0x0C23));
+
+    tmpl->Set(isolate, "UNPACK_ALIGNMENT", v8::Integer::NewFromUnsigned(isolate, 0x0CF5));
+    tmpl->Set(isolate, "PACK_ALIGNMENT", v8::Integer::NewFromUnsigned(isolate, 0x0D05));
+    tmpl->Set(isolate, "MAX_TEXTURE_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x0D33));
+
+
+    tmpl->Set(isolate, "MAX_VIEWPORT_DIMS", v8::Integer::NewFromUnsigned(isolate, 0x0D3A));
+    tmpl->Set(isolate, "SUBPIXEL_BITS", v8::Integer::NewFromUnsigned(isolate, 0x0D50));
+
+    tmpl->Set(isolate, "RED_BITS", v8::Integer::NewFromUnsigned(isolate, 0x0D52));
+    tmpl->Set(isolate, "GREEN_BITS", v8::Integer::NewFromUnsigned(isolate, 0x0D53));
+    tmpl->Set(isolate, "BLUE_BITS", v8::Integer::NewFromUnsigned(isolate, 0x0D54));
+    tmpl->Set(isolate, "ALPHA_BITS", v8::Integer::NewFromUnsigned(isolate, 0x0D55));
+
+    tmpl->Set(isolate, "STENCIL_BITS", v8::Integer::NewFromUnsigned(isolate, 0x0D57));
+    tmpl->Set(isolate, "POLYGON_OFFSET_UNITS", v8::Integer::NewFromUnsigned(isolate, 0x2A00));
+    tmpl->Set(isolate, "POLYGON_OFFSET_FACTOR", v8::Integer::NewFromUnsigned(isolate, 0x8038));
+
+    tmpl->Set(isolate, "TEXTURE_BINDING_2D", v8::Integer::NewFromUnsigned(isolate, 0x8069));
+    tmpl->Set(isolate, "SAMPLE_BUFFERS", v8::Integer::NewFromUnsigned(isolate, 0x80A8));
+    tmpl->Set(isolate, "SAMPLES", v8::Integer::NewFromUnsigned(isolate, 0x80A9));
+    tmpl->Set(isolate, "SAMPLE_COVERAGE_VALUE", v8::Integer::NewFromUnsigned(isolate, 0x80AA));
+
+    tmpl->Set(isolate, "SAMPLE_COVERAGE_INVERT", v8::Integer::NewFromUnsigned(isolate, 0x80AB));
+    tmpl->Set(isolate, "COMPRESSED_TEXTURE_FORMATS", v8::Integer::NewFromUnsigned(isolate, 0x86A3));
+    tmpl->Set(isolate, "VENDOR", v8::Integer::NewFromUnsigned(isolate, 0x1F00));
+    tmpl->Set(isolate, "RENDERER", v8::Integer::NewFromUnsigned(isolate, 0x1F01));
+
+    tmpl->Set(isolate, "VERSION", v8::Integer::NewFromUnsigned(isolate, 0x1F02));
+    tmpl->Set(isolate, "IMPLEMENTATION_COLOR_READ_TYPE",
+              v8::Integer::NewFromUnsigned(isolate, 0x8B9A));
+    tmpl->Set(isolate, "IMPLEMENTATION_COLOR_READ_FORMAT",
+              v8::Integer::NewFromUnsigned(isolate, 0x8B9B));
+    tmpl->Set(isolate, "BROWSER_DEFAULT_WEBGL", v8::Integer::NewFromUnsigned(isolate, 0x9244));
+
+    tmpl->Set(isolate, "STATIC_DRAW", v8::Integer::NewFromUnsigned(isolate, 0x88E4));
+    tmpl->Set(isolate, "STREAM_DRAW", v8::Integer::NewFromUnsigned(isolate, 0x88E0));
+    tmpl->Set(isolate, "DYNAMIC_DRAW", v8::Integer::NewFromUnsigned(isolate, 0x88E8));
+    tmpl->Set(isolate, "ARRAY_BUFFER", v8::Integer::NewFromUnsigned(isolate, 0x8892));
+
+    tmpl->Set(isolate, "ELEMENT_ARRAY_BUFFER", v8::Integer::NewFromUnsigned(isolate, 0x8893));
+    tmpl->Set(isolate, "BUFFER_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8764));
+    tmpl->Set(isolate, "BUFFER_USAGE", v8::Integer::NewFromUnsigned(isolate, 0x8765));
+    tmpl->Set(isolate, "CURRENT_VERTEX_ATTRIB", v8::Integer::NewFromUnsigned(isolate, 0x8626));
+
+
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_ENABLED",
+              v8::Integer::NewFromUnsigned(isolate, 0x8622));
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8623));
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_STRIDE", v8::Integer::NewFromUnsigned(isolate, 0x8624));
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_TYPE", v8::Integer::NewFromUnsigned(isolate, 0x8625));
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_NORMALIZED",
+              v8::Integer::NewFromUnsigned(isolate, 0x886A));
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_POINTER",
+              v8::Integer::NewFromUnsigned(isolate, 0x8645));
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",
+              v8::Integer::NewFromUnsigned(isolate, 0x889F));
+
+    tmpl->Set(isolate, "CULL_FACE", v8::Integer::NewFromUnsigned(isolate, 0x0B44));
+    tmpl->Set(isolate, "FRONT", v8::Integer::NewFromUnsigned(isolate, 0x0404));
+    tmpl->Set(isolate, "BACK", v8::Integer::NewFromUnsigned(isolate, 0x0405));
+    tmpl->Set(isolate, "FRONT_AND_BACK", v8::Integer::NewFromUnsigned(isolate, 0x0408));
+
+    tmpl->Set(isolate, "BLEND", v8::Integer::NewFromUnsigned(isolate, 0x0BE2));
+    tmpl->Set(isolate, "DEPTH_TEST", v8::Integer::NewFromUnsigned(isolate, 0x0B71));
+    tmpl->Set(isolate, "DITHER", v8::Integer::NewFromUnsigned(isolate, 0x0BD0));
+    tmpl->Set(isolate, "POLYGON_OFFSET_FILL", v8::Integer::NewFromUnsigned(isolate, 0x8037));
+
+    tmpl->Set(isolate, "SAMPLE_ALPHA_TO_COVERAGE", v8::Integer::NewFromUnsigned(isolate, 0x809E));
+    tmpl->Set(isolate, "SAMPLE_COVERAGE", v8::Integer::NewFromUnsigned(isolate, 0x80A0));
+    tmpl->Set(isolate, "SCISSOR_TEST", v8::Integer::NewFromUnsigned(isolate, 0x0C11));
+    tmpl->Set(isolate, "STENCIL_TEST", v8::Integer::NewFromUnsigned(isolate, 0x0B90));
 
 
     /* Errors */
 
-    tmpl->Set(isolate, "NO_ERROR", v8::Uint32::New(isolate, 0));
-    tmpl->Set(isolate, "INVALID_ENUM", v8::Uint32::New(isolate, 0x0500));
-    tmpl->Set(isolate, "INVALID_VALUE", v8::Uint32::New(isolate, 0x0501));
-    tmpl->Set(isolate, "INVALID_OPERATION", v8::Uint32::New(isolate, 0x0502));
+    tmpl->Set(isolate, "NO_ERROR", v8::Integer::NewFromUnsigned(isolate, 0));
+    tmpl->Set(isolate, "INVALID_ENUM", v8::Integer::NewFromUnsigned(isolate, 0x0500));
+    tmpl->Set(isolate, "INVALID_VALUE", v8::Integer::NewFromUnsigned(isolate, 0x0501));
+    tmpl->Set(isolate, "INVALID_OPERATION", v8::Integer::NewFromUnsigned(isolate, 0x0502));
 
-    tmpl->Set(isolate, "OUT_OF_MEMORY", v8::Uint32::New(isolate, 0x0505));
-    tmpl->Set(isolate, "CONTEXT_LOST_WEBGL", v8::Uint32::New(isolate, 0x9242));
-    tmpl->Set(isolate, "CW", v8::Uint32::New(isolate, 0x0900));
-    tmpl->Set(isolate, "CCW", v8::Uint32::New(isolate, 0x0901));
+    tmpl->Set(isolate, "OUT_OF_MEMORY", v8::Integer::NewFromUnsigned(isolate, 0x0505));
+    tmpl->Set(isolate, "CONTEXT_LOST_WEBGL", v8::Integer::NewFromUnsigned(isolate, 0x9242));
+    tmpl->Set(isolate, "CW", v8::Integer::NewFromUnsigned(isolate, 0x0900));
+    tmpl->Set(isolate, "CCW", v8::Integer::NewFromUnsigned(isolate, 0x0901));
 
-    tmpl->Set(isolate, "DONT_CARE", v8::Uint32::New(isolate, 0x1100));
-    tmpl->Set(isolate, "FASTEST", v8::Uint32::New(isolate, 0x1101));
-    tmpl->Set(isolate, "NICEST", v8::Uint32::New(isolate, 0x1102));
-    tmpl->Set(isolate, "GENERATE_MIPMAP_HINT", v8::Uint32::New(isolate, 0x8192));
+    tmpl->Set(isolate, "DONT_CARE", v8::Integer::NewFromUnsigned(isolate, 0x1100));
+    tmpl->Set(isolate, "FASTEST", v8::Integer::NewFromUnsigned(isolate, 0x1101));
+    tmpl->Set(isolate, "NICEST", v8::Integer::NewFromUnsigned(isolate, 0x1102));
+    tmpl->Set(isolate, "GENERATE_MIPMAP_HINT", v8::Integer::NewFromUnsigned(isolate, 0x8192));
 
-    tmpl->Set(isolate, "BYTE", v8::Uint32::New(isolate, 0x1400));
-    tmpl->Set(isolate, "UNSIGNED_BYTE", v8::Uint32::New(isolate, 0x1401));
-    tmpl->Set(isolate, "SHORT", v8::Uint32::New(isolate, 0x1402));
-    tmpl->Set(isolate, "UNSIGNED_SHORT", v8::Uint32::New(isolate, 0x1403));
+    tmpl->Set(isolate, "BYTE", v8::Integer::NewFromUnsigned(isolate, 0x1400));
+    tmpl->Set(isolate, "UNSIGNED_BYTE", v8::Integer::NewFromUnsigned(isolate, 0x1401));
+    tmpl->Set(isolate, "SHORT", v8::Integer::NewFromUnsigned(isolate, 0x1402));
+    tmpl->Set(isolate, "UNSIGNED_SHORT", v8::Integer::NewFromUnsigned(isolate, 0x1403));
 
-    tmpl->Set(isolate, "BYTE", v8::Uint32::New(isolate, 0x1400));
-    tmpl->Set(isolate, "UNSIGNED_BYTE", v8::Uint32::New(isolate, 0x1401));
-    tmpl->Set(isolate, "SHORT", v8::Uint32::New(isolate, 0x1402));
-    tmpl->Set(isolate, "UNSIGNED_SHORT", v8::Uint32::New(isolate, 0x1403));
+    tmpl->Set(isolate, "BYTE", v8::Integer::NewFromUnsigned(isolate, 0x1400));
+    tmpl->Set(isolate, "UNSIGNED_BYTE", v8::Integer::NewFromUnsigned(isolate, 0x1401));
+    tmpl->Set(isolate, "SHORT", v8::Integer::NewFromUnsigned(isolate, 0x1402));
+    tmpl->Set(isolate, "UNSIGNED_SHORT", v8::Integer::NewFromUnsigned(isolate, 0x1403));
 
-    tmpl->Set(isolate, "INT", v8::Uint32::New(isolate, 0x1404));
-    tmpl->Set(isolate, "UNSIGNED_INT", v8::Uint32::New(isolate, 0x1405));
-    tmpl->Set(isolate, "FLOAT", v8::Uint32::New(isolate, 0x1406));
-    tmpl->Set(isolate, "DEPTH_COMPONENT", v8::Uint32::New(isolate, 0x1902));
+    tmpl->Set(isolate, "INT", v8::Integer::NewFromUnsigned(isolate, 0x1404));
+    tmpl->Set(isolate, "UNSIGNED_INT", v8::Integer::NewFromUnsigned(isolate, 0x1405));
+    tmpl->Set(isolate, "FLOAT", v8::Integer::NewFromUnsigned(isolate, 0x1406));
+    tmpl->Set(isolate, "DEPTH_COMPONENT", v8::Integer::NewFromUnsigned(isolate, 0x1902));
 
-    tmpl->Set(isolate, "ALPHA", v8::Uint32::New(isolate, 0x1906));
-    tmpl->Set(isolate, "RGB", v8::Uint32::New(isolate, 0x1907));
+    tmpl->Set(isolate, "ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x1906));
+    tmpl->Set(isolate, "RGB", v8::Integer::NewFromUnsigned(isolate, 0x1907));
 
     /* Clearing buffers */
 
-    tmpl->Set(isolate, "RGBA", v8::Uint32::New(isolate, 0x1908));
-    tmpl->Set(isolate, "LUMINANCE", v8::Uint32::New(isolate, 0x1909));
-    tmpl->Set(isolate, "LUMINANCE_ALPHA", v8::Uint32::New(isolate, 0x190A));
+    tmpl->Set(isolate, "RGBA", v8::Integer::NewFromUnsigned(isolate, 0x1908));
+    tmpl->Set(isolate, "LUMINANCE", v8::Integer::NewFromUnsigned(isolate, 0x1909));
+    tmpl->Set(isolate, "LUMINANCE_ALPHA", v8::Integer::NewFromUnsigned(isolate, 0x190A));
 
     /* Clearing buffers */
 
     /* Rendering primitives */
 
-    tmpl->Set(isolate, "UNSIGNED_SHORT_4_4_4_4", v8::Uint32::New(isolate, 0x8033));
-    tmpl->Set(isolate, "UNSIGNED_SHORT_5_5_5_1", v8::Uint32::New(isolate, 0x8034));
-    tmpl->Set(isolate, "UNSIGNED_SHORT_5_6_5", v8::Uint32::New(isolate, 0x8363));
-    tmpl->Set(isolate, "FRAGMENT_SHADER", v8::Uint32::New(isolate, 0x8B30));
-    tmpl->Set(isolate, "VERTEX_SHADER", v8::Uint32::New(isolate, 0x8B31));
-    tmpl->Set(isolate, "COMPILE_STATUS", v8::Uint32::New(isolate, 0x8B81));
-    tmpl->Set(isolate, "DELETE_STATUS", v8::Uint32::New(isolate, 0x8B80));
+    tmpl->Set(isolate, "UNSIGNED_SHORT_4_4_4_4", v8::Integer::NewFromUnsigned(isolate, 0x8033));
+    tmpl->Set(isolate, "UNSIGNED_SHORT_5_5_5_1", v8::Integer::NewFromUnsigned(isolate, 0x8034));
+    tmpl->Set(isolate, "UNSIGNED_SHORT_5_6_5", v8::Integer::NewFromUnsigned(isolate, 0x8363));
+    tmpl->Set(isolate, "FRAGMENT_SHADER", v8::Integer::NewFromUnsigned(isolate, 0x8B30));
+    tmpl->Set(isolate, "VERTEX_SHADER", v8::Integer::NewFromUnsigned(isolate, 0x8B31));
+    tmpl->Set(isolate, "COMPILE_STATUS", v8::Integer::NewFromUnsigned(isolate, 0x8B81));
+    tmpl->Set(isolate, "DELETE_STATUS", v8::Integer::NewFromUnsigned(isolate, 0x8B80));
 
     /* Rendering primitives */
 
     /* Blending modes */
 
-    tmpl->Set(isolate, "LINK_STATUS", v8::Uint32::New(isolate, 0x8B82));
-    tmpl->Set(isolate, "VALIDATE_STATUS", v8::Uint32::New(isolate, 0x8B83));
-    tmpl->Set(isolate, "ATTACHED_SHADERS", v8::Uint32::New(isolate, 0x8B85));
-    tmpl->Set(isolate, "ACTIVE_ATTRIBUTES", v8::Uint32::New(isolate, 0x8B89));
-    tmpl->Set(isolate, "ACTIVE_UNIFORMS", v8::Uint32::New(isolate, 0x8B86));
-    tmpl->Set(isolate, "MAX_VERTEX_ATTRIBS", v8::Uint32::New(isolate, 0x8869));
-    tmpl->Set(isolate, "MAX_VERTEX_UNIFORM_VECTORS", v8::Uint32::New(isolate, 0x8DFB));
-    tmpl->Set(isolate, "MAX_VARYING_VECTORS", v8::Uint32::New(isolate, 0x8DFC));
-    tmpl->Set(isolate, "MAX_COMBINED_TEXTURE_IMAGE_UNITS", v8::Uint32::New(isolate, 0x8B4D));
-    tmpl->Set(isolate, "MAX_VERTEX_TEXTURE_IMAGE_UNITS", v8::Uint32::New(isolate, 0x8B4C));
-    tmpl->Set(isolate, "MAX_TEXTURE_IMAGE_UNITS", v8::Uint32::New(isolate, 0x8872));
-    tmpl->Set(isolate, "MAX_FRAGMENT_UNIFORM_VECTORS", v8::Uint32::New(isolate, 0x8DFD));
-    tmpl->Set(isolate, "SHADER_TYPE", v8::Uint32::New(isolate, 0x8B4F));
-    tmpl->Set(isolate, "SHADING_LANGUAGE_VERSION", v8::Uint32::New(isolate, 0x8B8C));
-    tmpl->Set(isolate, "CURRENT_PROGRAM", v8::Uint32::New(isolate, 0x8B8D));
+    tmpl->Set(isolate, "LINK_STATUS", v8::Integer::NewFromUnsigned(isolate, 0x8B82));
+    tmpl->Set(isolate, "VALIDATE_STATUS", v8::Integer::NewFromUnsigned(isolate, 0x8B83));
+    tmpl->Set(isolate, "ATTACHED_SHADERS", v8::Integer::NewFromUnsigned(isolate, 0x8B85));
+    tmpl->Set(isolate, "ACTIVE_ATTRIBUTES", v8::Integer::NewFromUnsigned(isolate, 0x8B89));
+    tmpl->Set(isolate, "ACTIVE_UNIFORMS", v8::Integer::NewFromUnsigned(isolate, 0x8B86));
+    tmpl->Set(isolate, "MAX_VERTEX_ATTRIBS", v8::Integer::NewFromUnsigned(isolate, 0x8869));
+    tmpl->Set(isolate, "MAX_VERTEX_UNIFORM_VECTORS", v8::Integer::NewFromUnsigned(isolate, 0x8DFB));
+    tmpl->Set(isolate, "MAX_VARYING_VECTORS", v8::Integer::NewFromUnsigned(isolate, 0x8DFC));
+    tmpl->Set(isolate, "MAX_COMBINED_TEXTURE_IMAGE_UNITS",
+              v8::Integer::NewFromUnsigned(isolate, 0x8B4D));
+    tmpl->Set(isolate, "MAX_VERTEX_TEXTURE_IMAGE_UNITS",
+              v8::Integer::NewFromUnsigned(isolate, 0x8B4C));
+    tmpl->Set(isolate, "MAX_TEXTURE_IMAGE_UNITS", v8::Integer::NewFromUnsigned(isolate, 0x8872));
+    tmpl->Set(isolate, "MAX_FRAGMENT_UNIFORM_VECTORS",
+              v8::Integer::NewFromUnsigned(isolate, 0x8DFD));
+    tmpl->Set(isolate, "SHADER_TYPE", v8::Integer::NewFromUnsigned(isolate, 0x8B4F));
+    tmpl->Set(isolate, "SHADING_LANGUAGE_VERSION", v8::Integer::NewFromUnsigned(isolate, 0x8B8C));
+    tmpl->Set(isolate, "CURRENT_PROGRAM", v8::Integer::NewFromUnsigned(isolate, 0x8B8D));
 
     /* Blending modes */
 
-    tmpl->Set(isolate, "NEVER", v8::Uint32::New(isolate, 0x0200));
-    tmpl->Set(isolate, "LESS", v8::Uint32::New(isolate, 0x0201));
-    tmpl->Set(isolate, "EQUAL", v8::Uint32::New(isolate, 0x0202));
+    tmpl->Set(isolate, "NEVER", v8::Integer::NewFromUnsigned(isolate, 0x0200));
+    tmpl->Set(isolate, "LESS", v8::Integer::NewFromUnsigned(isolate, 0x0201));
+    tmpl->Set(isolate, "EQUAL", v8::Integer::NewFromUnsigned(isolate, 0x0202));
 
     /* Blending equations */
 
     /* Getting GL parameter information */
 
-    tmpl->Set(isolate, "LEQUAL", v8::Uint32::New(isolate, 0x0203));
-    tmpl->Set(isolate, "GREATER", v8::Uint32::New(isolate, 0x0204));
-    tmpl->Set(isolate, "NOTEQUAL", v8::Uint32::New(isolate, 0x0205));
-    tmpl->Set(isolate, "GEQUAL", v8::Uint32::New(isolate, 0x0206));
-    tmpl->Set(isolate, "ALWAYS", v8::Uint32::New(isolate, 0x0207));
-    tmpl->Set(isolate, "KEEP", v8::Uint32::New(isolate, 0x1E00));
-    tmpl->Set(isolate, "REPLACE", v8::Uint32::New(isolate, 0x1E01));
-    tmpl->Set(isolate, "INCR", v8::Uint32::New(isolate, 0x1E02));
-    tmpl->Set(isolate, "DECR", v8::Uint32::New(isolate, 0x1E03));
-    tmpl->Set(isolate, "INVERT", v8::Uint32::New(isolate, 0x150A));
-    tmpl->Set(isolate, "INCR_WRAP", v8::Uint32::New(isolate, 0x8507));
-    tmpl->Set(isolate, "DECR_WRAP", v8::Uint32::New(isolate, 0x8508));
-    tmpl->Set(isolate, "NEAREST", v8::Uint32::New(isolate, 0x2600));
-    tmpl->Set(isolate, "LINEAR", v8::Uint32::New(isolate, 0x2601));
-    tmpl->Set(isolate, "NEAREST_MIPMAP_NEAREST", v8::Uint32::New(isolate, 0x2700));
-    tmpl->Set(isolate, "LINEAR_MIPMAP_NEAREST", v8::Uint32::New(isolate, 0x2701));
-    tmpl->Set(isolate, "NEAREST_MIPMAP_LINEAR", v8::Uint32::New(isolate, 0x2702));
-    tmpl->Set(isolate, "LINEAR_MIPMAP_LINEAR", v8::Uint32::New(isolate, 0x2703));
-    tmpl->Set(isolate, "TEXTURE_MAG_FILTER", v8::Uint32::New(isolate, 0x2800));
-    tmpl->Set(isolate, "TEXTURE_MIN_FILTER", v8::Uint32::New(isolate, 0x2801));
-    tmpl->Set(isolate, "TEXTURE_WRAP_S", v8::Uint32::New(isolate, 0x2802));
-    tmpl->Set(isolate, "TEXTURE_WRAP_T", v8::Uint32::New(isolate, 0x2803));
-    tmpl->Set(isolate, "TEXTURE_2D", v8::Uint32::New(isolate, 0x0DE1));
-    tmpl->Set(isolate, "TEXTURE", v8::Uint32::New(isolate, 0x1702));
-    tmpl->Set(isolate, "TEXTURE_CUBE_MAP", v8::Uint32::New(isolate, 0x8513));
-    tmpl->Set(isolate, "TEXTURE_BINDING_CUBE_MAP", v8::Uint32::New(isolate, 0x8514));
-    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_POSITIVE_X", v8::Uint32::New(isolate, 0x8515));
-    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_NEGATIVE_X", v8::Uint32::New(isolate, 0x8516));
-    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_POSITIVE_Y", v8::Uint32::New(isolate, 0x8517));
-    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_NEGATIVE_Y", v8::Uint32::New(isolate, 0x8518));
-    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_POSITIVE_Z", v8::Uint32::New(isolate, 0x8519));
-    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_NEGATIVE_Z", v8::Uint32::New(isolate, 0x851A));
-    tmpl->Set(isolate, "MAX_CUBE_MAP_TEXTURE_SIZE", v8::Uint32::New(isolate, 0x851C));
-    tmpl->Set(isolate, "TEXTURE0", v8::Uint32::New(isolate, 0x84C0));
-    tmpl->Set(isolate, "TEXTURE1", v8::Uint32::New(isolate, 0x84C1));
-    tmpl->Set(isolate, "TEXTURE2", v8::Uint32::New(isolate, 0x84C2));
-    tmpl->Set(isolate, "TEXTURE3", v8::Uint32::New(isolate, 0x84C3));
-    tmpl->Set(isolate, "TEXTURE4", v8::Uint32::New(isolate, 0x84C4));
-    tmpl->Set(isolate, "TEXTURE5", v8::Uint32::New(isolate, 0x84C5));
-    tmpl->Set(isolate, "TEXTURE6", v8::Uint32::New(isolate, 0x84C6));
-    tmpl->Set(isolate, "TEXTURE7", v8::Uint32::New(isolate, 0x84C7));
-    tmpl->Set(isolate, "TEXTURE8", v8::Uint32::New(isolate, 0x84C8));
-    tmpl->Set(isolate, "TEXTURE9", v8::Uint32::New(isolate, 0x84C9));
-    tmpl->Set(isolate, "TEXTURE10", v8::Uint32::New(isolate, 0x84CA));
-    tmpl->Set(isolate, "TEXTURE11", v8::Uint32::New(isolate, 0x84CB));
-    tmpl->Set(isolate, "TEXTURE12", v8::Uint32::New(isolate, 0x84CC));
-    tmpl->Set(isolate, "TEXTURE13", v8::Uint32::New(isolate, 0x84CD));
-    tmpl->Set(isolate, "TEXTURE14", v8::Uint32::New(isolate, 0x84CE));
-    tmpl->Set(isolate, "TEXTURE15", v8::Uint32::New(isolate, 0x84CF));
-    tmpl->Set(isolate, "TEXTURE16", v8::Uint32::New(isolate, 0x84D0));
-    tmpl->Set(isolate, "TEXTURE17", v8::Uint32::New(isolate, 0x84D1));
-    tmpl->Set(isolate, "TEXTURE18", v8::Uint32::New(isolate, 0x84D2));
-    tmpl->Set(isolate, "TEXTURE19", v8::Uint32::New(isolate, 0x84D3));
-    tmpl->Set(isolate, "TEXTURE20", v8::Uint32::New(isolate, 0x84D4));
-    tmpl->Set(isolate, "TEXTURE21", v8::Uint32::New(isolate, 0x84D5));
-    tmpl->Set(isolate, "TEXTURE22", v8::Uint32::New(isolate, 0x84D6));
-    tmpl->Set(isolate, "TEXTURE23", v8::Uint32::New(isolate, 0x84D7));
-    tmpl->Set(isolate, "TEXTURE24", v8::Uint32::New(isolate, 0x84D8));
-    tmpl->Set(isolate, "TEXTURE25", v8::Uint32::New(isolate, 0x84D9));
-    tmpl->Set(isolate, "TEXTURE26", v8::Uint32::New(isolate, 0x84DA));
-    tmpl->Set(isolate, "TEXTURE27", v8::Uint32::New(isolate, 0x84DB));
-    tmpl->Set(isolate, "TEXTURE28", v8::Uint32::New(isolate, 0x84DC));
-    tmpl->Set(isolate, "TEXTURE29", v8::Uint32::New(isolate, 0x84DD));
+    tmpl->Set(isolate, "LEQUAL", v8::Integer::NewFromUnsigned(isolate, 0x0203));
+    tmpl->Set(isolate, "GREATER", v8::Integer::NewFromUnsigned(isolate, 0x0204));
+    tmpl->Set(isolate, "NOTEQUAL", v8::Integer::NewFromUnsigned(isolate, 0x0205));
+    tmpl->Set(isolate, "GEQUAL", v8::Integer::NewFromUnsigned(isolate, 0x0206));
+    tmpl->Set(isolate, "ALWAYS", v8::Integer::NewFromUnsigned(isolate, 0x0207));
+    tmpl->Set(isolate, "KEEP", v8::Integer::NewFromUnsigned(isolate, 0x1E00));
+    tmpl->Set(isolate, "REPLACE", v8::Integer::NewFromUnsigned(isolate, 0x1E01));
+    tmpl->Set(isolate, "INCR", v8::Integer::NewFromUnsigned(isolate, 0x1E02));
+    tmpl->Set(isolate, "DECR", v8::Integer::NewFromUnsigned(isolate, 0x1E03));
+    tmpl->Set(isolate, "INVERT", v8::Integer::NewFromUnsigned(isolate, 0x150A));
+    tmpl->Set(isolate, "INCR_WRAP", v8::Integer::NewFromUnsigned(isolate, 0x8507));
+    tmpl->Set(isolate, "DECR_WRAP", v8::Integer::NewFromUnsigned(isolate, 0x8508));
+    tmpl->Set(isolate, "NEAREST", v8::Integer::NewFromUnsigned(isolate, 0x2600));
+    tmpl->Set(isolate, "LINEAR", v8::Integer::NewFromUnsigned(isolate, 0x2601));
+    tmpl->Set(isolate, "NEAREST_MIPMAP_NEAREST", v8::Integer::NewFromUnsigned(isolate, 0x2700));
+    tmpl->Set(isolate, "LINEAR_MIPMAP_NEAREST", v8::Integer::NewFromUnsigned(isolate, 0x2701));
+    tmpl->Set(isolate, "NEAREST_MIPMAP_LINEAR", v8::Integer::NewFromUnsigned(isolate, 0x2702));
+    tmpl->Set(isolate, "LINEAR_MIPMAP_LINEAR", v8::Integer::NewFromUnsigned(isolate, 0x2703));
+    tmpl->Set(isolate, "TEXTURE_MAG_FILTER", v8::Integer::NewFromUnsigned(isolate, 0x2800));
+    tmpl->Set(isolate, "TEXTURE_MIN_FILTER", v8::Integer::NewFromUnsigned(isolate, 0x2801));
+    tmpl->Set(isolate, "TEXTURE_WRAP_S", v8::Integer::NewFromUnsigned(isolate, 0x2802));
+    tmpl->Set(isolate, "TEXTURE_WRAP_T", v8::Integer::NewFromUnsigned(isolate, 0x2803));
+    tmpl->Set(isolate, "TEXTURE_2D", v8::Integer::NewFromUnsigned(isolate, 0x0DE1));
+    tmpl->Set(isolate, "TEXTURE", v8::Integer::NewFromUnsigned(isolate, 0x1702));
+    tmpl->Set(isolate, "TEXTURE_CUBE_MAP", v8::Integer::NewFromUnsigned(isolate, 0x8513));
+    tmpl->Set(isolate, "TEXTURE_BINDING_CUBE_MAP", v8::Integer::NewFromUnsigned(isolate, 0x8514));
+    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_POSITIVE_X",
+              v8::Integer::NewFromUnsigned(isolate, 0x8515));
+    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_NEGATIVE_X",
+              v8::Integer::NewFromUnsigned(isolate, 0x8516));
+    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_POSITIVE_Y",
+              v8::Integer::NewFromUnsigned(isolate, 0x8517));
+    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_NEGATIVE_Y",
+              v8::Integer::NewFromUnsigned(isolate, 0x8518));
+    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_POSITIVE_Z",
+              v8::Integer::NewFromUnsigned(isolate, 0x8519));
+    tmpl->Set(isolate, "TEXTURE_CUBE_MAP_NEGATIVE_Z",
+              v8::Integer::NewFromUnsigned(isolate, 0x851A));
+    tmpl->Set(isolate, "MAX_CUBE_MAP_TEXTURE_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x851C));
+    tmpl->Set(isolate, "TEXTURE0", v8::Integer::NewFromUnsigned(isolate, 0x84C0));
+    tmpl->Set(isolate, "TEXTURE1", v8::Integer::NewFromUnsigned(isolate, 0x84C1));
+    tmpl->Set(isolate, "TEXTURE2", v8::Integer::NewFromUnsigned(isolate, 0x84C2));
+    tmpl->Set(isolate, "TEXTURE3", v8::Integer::NewFromUnsigned(isolate, 0x84C3));
+    tmpl->Set(isolate, "TEXTURE4", v8::Integer::NewFromUnsigned(isolate, 0x84C4));
+    tmpl->Set(isolate, "TEXTURE5", v8::Integer::NewFromUnsigned(isolate, 0x84C5));
+    tmpl->Set(isolate, "TEXTURE6", v8::Integer::NewFromUnsigned(isolate, 0x84C6));
+    tmpl->Set(isolate, "TEXTURE7", v8::Integer::NewFromUnsigned(isolate, 0x84C7));
+    tmpl->Set(isolate, "TEXTURE8", v8::Integer::NewFromUnsigned(isolate, 0x84C8));
+    tmpl->Set(isolate, "TEXTURE9", v8::Integer::NewFromUnsigned(isolate, 0x84C9));
+    tmpl->Set(isolate, "TEXTURE10", v8::Integer::NewFromUnsigned(isolate, 0x84CA));
+    tmpl->Set(isolate, "TEXTURE11", v8::Integer::NewFromUnsigned(isolate, 0x84CB));
+    tmpl->Set(isolate, "TEXTURE12", v8::Integer::NewFromUnsigned(isolate, 0x84CC));
+    tmpl->Set(isolate, "TEXTURE13", v8::Integer::NewFromUnsigned(isolate, 0x84CD));
+    tmpl->Set(isolate, "TEXTURE14", v8::Integer::NewFromUnsigned(isolate, 0x84CE));
+    tmpl->Set(isolate, "TEXTURE15", v8::Integer::NewFromUnsigned(isolate, 0x84CF));
+    tmpl->Set(isolate, "TEXTURE16", v8::Integer::NewFromUnsigned(isolate, 0x84D0));
+    tmpl->Set(isolate, "TEXTURE17", v8::Integer::NewFromUnsigned(isolate, 0x84D1));
+    tmpl->Set(isolate, "TEXTURE18", v8::Integer::NewFromUnsigned(isolate, 0x84D2));
+    tmpl->Set(isolate, "TEXTURE19", v8::Integer::NewFromUnsigned(isolate, 0x84D3));
+    tmpl->Set(isolate, "TEXTURE20", v8::Integer::NewFromUnsigned(isolate, 0x84D4));
+    tmpl->Set(isolate, "TEXTURE21", v8::Integer::NewFromUnsigned(isolate, 0x84D5));
+    tmpl->Set(isolate, "TEXTURE22", v8::Integer::NewFromUnsigned(isolate, 0x84D6));
+    tmpl->Set(isolate, "TEXTURE23", v8::Integer::NewFromUnsigned(isolate, 0x84D7));
+    tmpl->Set(isolate, "TEXTURE24", v8::Integer::NewFromUnsigned(isolate, 0x84D8));
+    tmpl->Set(isolate, "TEXTURE25", v8::Integer::NewFromUnsigned(isolate, 0x84D9));
+    tmpl->Set(isolate, "TEXTURE26", v8::Integer::NewFromUnsigned(isolate, 0x84DA));
+    tmpl->Set(isolate, "TEXTURE27", v8::Integer::NewFromUnsigned(isolate, 0x84DB));
+    tmpl->Set(isolate, "TEXTURE28", v8::Integer::NewFromUnsigned(isolate, 0x84DC));
+    tmpl->Set(isolate, "TEXTURE29", v8::Integer::NewFromUnsigned(isolate, 0x84DD));
 
     /* Getting GL parameter information */
 
     /* Buffers */
 
-    tmpl->Set(isolate, "TEXTURE30", v8::Uint32::New(isolate, 0x84DE));
-    tmpl->Set(isolate, "TEXTURE31", v8::Uint32::New(isolate, 0x84DF));
-    tmpl->Set(isolate, "ACTIVE_TEXTURE", v8::Uint32::New(isolate, 0x84E0));
-    tmpl->Set(isolate, "REPEAT", v8::Uint32::New(isolate, 0x2901));
-    tmpl->Set(isolate, "CLAMP_TO_EDGE", v8::Uint32::New(isolate, 0x812F));
-    tmpl->Set(isolate, "MIRRORED_REPEAT", v8::Uint32::New(isolate, 0x8370));
-    tmpl->Set(isolate, "FLOAT_VEC2", v8::Uint32::New(isolate, 0x8B50));
+    tmpl->Set(isolate, "TEXTURE30", v8::Integer::NewFromUnsigned(isolate, 0x84DE));
+    tmpl->Set(isolate, "TEXTURE31", v8::Integer::NewFromUnsigned(isolate, 0x84DF));
+    tmpl->Set(isolate, "ACTIVE_TEXTURE", v8::Integer::NewFromUnsigned(isolate, 0x84E0));
+    tmpl->Set(isolate, "REPEAT", v8::Integer::NewFromUnsigned(isolate, 0x2901));
+    tmpl->Set(isolate, "CLAMP_TO_EDGE", v8::Integer::NewFromUnsigned(isolate, 0x812F));
+    tmpl->Set(isolate, "MIRRORED_REPEAT", v8::Integer::NewFromUnsigned(isolate, 0x8370));
+    tmpl->Set(isolate, "FLOAT_VEC2", v8::Integer::NewFromUnsigned(isolate, 0x8B50));
 
     /* Buffers */
 
     /* Vertex attributes */
 
-    tmpl->Set(isolate, "FLOAT_VEC3", v8::Uint32::New(isolate, 0x8B51));
-    tmpl->Set(isolate, "FLOAT_VEC4", v8::Uint32::New(isolate, 0x8B52));
-    tmpl->Set(isolate, "INT_VEC2", v8::Uint32::New(isolate, 0x8B53));
-    tmpl->Set(isolate, "INT_VEC3", v8::Uint32::New(isolate, 0x8B54));
-    tmpl->Set(isolate, "INT_VEC4", v8::Uint32::New(isolate, 0x8B55));
-    tmpl->Set(isolate, "BOOL", v8::Uint32::New(isolate, 0x8B56));
-    tmpl->Set(isolate, "BOOL_VEC2", v8::Uint32::New(isolate, 0x8B57));
-    tmpl->Set(isolate, "BOOL_VEC3", v8::Uint32::New(isolate, 0x8B58));
+    tmpl->Set(isolate, "FLOAT_VEC3", v8::Integer::NewFromUnsigned(isolate, 0x8B51));
+    tmpl->Set(isolate, "FLOAT_VEC4", v8::Integer::NewFromUnsigned(isolate, 0x8B52));
+    tmpl->Set(isolate, "INT_VEC2", v8::Integer::NewFromUnsigned(isolate, 0x8B53));
+    tmpl->Set(isolate, "INT_VEC3", v8::Integer::NewFromUnsigned(isolate, 0x8B54));
+    tmpl->Set(isolate, "INT_VEC4", v8::Integer::NewFromUnsigned(isolate, 0x8B55));
+    tmpl->Set(isolate, "BOOL", v8::Integer::NewFromUnsigned(isolate, 0x8B56));
+    tmpl->Set(isolate, "BOOL_VEC2", v8::Integer::NewFromUnsigned(isolate, 0x8B57));
+    tmpl->Set(isolate, "BOOL_VEC3", v8::Integer::NewFromUnsigned(isolate, 0x8B58));
 
     /* Vertex attributes */
 
     /* Culling */
 
-    tmpl->Set(isolate, "BOOL_VEC4", v8::Uint32::New(isolate, 0x8B59));
-    tmpl->Set(isolate, "FLOAT_MAT2", v8::Uint32::New(isolate, 0x8B5A));
-    tmpl->Set(isolate, "FLOAT_MAT3", v8::Uint32::New(isolate, 0x8B5B));
-    tmpl->Set(isolate, "FLOAT_MAT4", v8::Uint32::New(isolate, 0x8B5C));
+    tmpl->Set(isolate, "BOOL_VEC4", v8::Integer::NewFromUnsigned(isolate, 0x8B59));
+    tmpl->Set(isolate, "FLOAT_MAT2", v8::Integer::NewFromUnsigned(isolate, 0x8B5A));
+    tmpl->Set(isolate, "FLOAT_MAT3", v8::Integer::NewFromUnsigned(isolate, 0x8B5B));
+    tmpl->Set(isolate, "FLOAT_MAT4", v8::Integer::NewFromUnsigned(isolate, 0x8B5C));
 
     /* Culling */
 
     /* Enabling and disabling */
 
-    tmpl->Set(isolate, "SAMPLER_2D", v8::Uint32::New(isolate, 0x8B5E));
-    tmpl->Set(isolate, "SAMPLER_CUBE", v8::Uint32::New(isolate, 0x8B60));
-    tmpl->Set(isolate, "LOW_FLOAT", v8::Uint32::New(isolate, 0x8DF0));
-    tmpl->Set(isolate, "MEDIUM_FLOAT", v8::Uint32::New(isolate, 0x8DF1));
-    tmpl->Set(isolate, "HIGH_FLOAT", v8::Uint32::New(isolate, 0x8DF2));
-    tmpl->Set(isolate, "LOW_INT", v8::Uint32::New(isolate, 0x8DF3));
-    tmpl->Set(isolate, "MEDIUM_INT", v8::Uint32::New(isolate, 0x8DF4));
-    tmpl->Set(isolate, "HIGH_INT", v8::Uint32::New(isolate, 0x8DF5));
+    tmpl->Set(isolate, "SAMPLER_2D", v8::Integer::NewFromUnsigned(isolate, 0x8B5E));
+    tmpl->Set(isolate, "SAMPLER_CUBE", v8::Integer::NewFromUnsigned(isolate, 0x8B60));
+    tmpl->Set(isolate, "LOW_FLOAT", v8::Integer::NewFromUnsigned(isolate, 0x8DF0));
+    tmpl->Set(isolate, "MEDIUM_FLOAT", v8::Integer::NewFromUnsigned(isolate, 0x8DF1));
+    tmpl->Set(isolate, "HIGH_FLOAT", v8::Integer::NewFromUnsigned(isolate, 0x8DF2));
+    tmpl->Set(isolate, "LOW_INT", v8::Integer::NewFromUnsigned(isolate, 0x8DF3));
+    tmpl->Set(isolate, "MEDIUM_INT", v8::Integer::NewFromUnsigned(isolate, 0x8DF4));
+    tmpl->Set(isolate, "HIGH_INT", v8::Integer::NewFromUnsigned(isolate, 0x8DF5));
 
     /* Enabling and disabling */
 
-    tmpl->Set(isolate, "FRAMEBUFFER", v8::Uint32::New(isolate, 0x8D40));
-    tmpl->Set(isolate, "RENDERBUFFER", v8::Uint32::New(isolate, 0x8D41));
-    tmpl->Set(isolate, "RGBA4", v8::Uint32::New(isolate, 0x8056));
-    tmpl->Set(isolate, "RGB5_A1", v8::Uint32::New(isolate, 0x8057));
-    tmpl->Set(isolate, "RGB565", v8::Uint32::New(isolate, 0x8D62));
-    tmpl->Set(isolate, "DEPTH_COMPONENT16", v8::Uint32::New(isolate, 0x81A5));
-    tmpl->Set(isolate, "STENCIL_INDEX8", v8::Uint32::New(isolate, 0x8D48));
+    tmpl->Set(isolate, "FRAMEBUFFER", v8::Integer::NewFromUnsigned(isolate, 0x8D40));
+    tmpl->Set(isolate, "RENDERBUFFER", v8::Integer::NewFromUnsigned(isolate, 0x8D41));
+    tmpl->Set(isolate, "RGBA4", v8::Integer::NewFromUnsigned(isolate, 0x8056));
+    tmpl->Set(isolate, "RGB5_A1", v8::Integer::NewFromUnsigned(isolate, 0x8057));
+    tmpl->Set(isolate, "RGB565", v8::Integer::NewFromUnsigned(isolate, 0x8D62));
+    tmpl->Set(isolate, "DEPTH_COMPONENT16", v8::Integer::NewFromUnsigned(isolate, 0x81A5));
+    tmpl->Set(isolate, "STENCIL_INDEX8", v8::Integer::NewFromUnsigned(isolate, 0x8D48));
 
     /* Errors */
 
     /* Front face directions */
 
-    tmpl->Set(isolate, "DEPTH_STENCIL", v8::Uint32::New(isolate, 0x84F9));
-    tmpl->Set(isolate, "RENDERBUFFER_WIDTH", v8::Uint32::New(isolate, 0x8D42));
+    tmpl->Set(isolate, "DEPTH_STENCIL", v8::Integer::NewFromUnsigned(isolate, 0x84F9));
+    tmpl->Set(isolate, "RENDERBUFFER_WIDTH", v8::Integer::NewFromUnsigned(isolate, 0x8D42));
 
     /* Front face directions */
 
     /* Hints */
 
-    tmpl->Set(isolate, "RENDERBUFFER_HEIGHT", v8::Uint32::New(isolate, 0x8D43));
-    tmpl->Set(isolate, "RENDERBUFFER_INTERNAL_FORMAT", v8::Uint32::New(isolate, 0x8D44));
-    tmpl->Set(isolate, "RENDERBUFFER_RED_SIZE", v8::Uint32::New(isolate, 0x8D50));
-    tmpl->Set(isolate, "RENDERBUFFER_GREEN_SIZE", v8::Uint32::New(isolate, 0x8D51));
+    tmpl->Set(isolate, "RENDERBUFFER_HEIGHT", v8::Integer::NewFromUnsigned(isolate, 0x8D43));
+    tmpl->Set(isolate, "RENDERBUFFER_INTERNAL_FORMAT",
+              v8::Integer::NewFromUnsigned(isolate, 0x8D44));
+    tmpl->Set(isolate, "RENDERBUFFER_RED_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8D50));
+    tmpl->Set(isolate, "RENDERBUFFER_GREEN_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8D51));
 
     /* Hints */
 
     /* Data types */
 
-    tmpl->Set(isolate, "RENDERBUFFER_BLUE_SIZE", v8::Uint32::New(isolate, 0x8D52));
-    tmpl->Set(isolate, "RENDERBUFFER_ALPHA_SIZE", v8::Uint32::New(isolate, 0x8D53));
-    tmpl->Set(isolate, "RENDERBUFFER_DEPTH_SIZE", v8::Uint32::New(isolate, 0x8D54));
-    tmpl->Set(isolate, "RENDERBUFFER_STENCIL_SIZE", v8::Uint32::New(isolate, 0x8D55));
-    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", v8::Uint32::New(isolate, 0x8CD0));
-    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", v8::Uint32::New(isolate, 0x8CD1));
-    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", v8::Uint32::New(isolate, 0x8CD2));
+    tmpl->Set(isolate, "RENDERBUFFER_BLUE_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8D52));
+    tmpl->Set(isolate, "RENDERBUFFER_ALPHA_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8D53));
+    tmpl->Set(isolate, "RENDERBUFFER_DEPTH_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8D54));
+    tmpl->Set(isolate, "RENDERBUFFER_STENCIL_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x8D55));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
+              v8::Integer::NewFromUnsigned(isolate, 0x8CD0));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",
+              v8::Integer::NewFromUnsigned(isolate, 0x8CD1));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",
+              v8::Integer::NewFromUnsigned(isolate, 0x8CD2));
 
     /* Data types */
 
     /* Pixel formats */
 
     tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",
-              v8::Uint32::New(isolate, 0x8CD3));
-    tmpl->Set(isolate, "COLOR_ATTACHMENT0", v8::Uint32::New(isolate, 0x8CE0));
-    tmpl->Set(isolate, "DEPTH_ATTACHMENT", v8::Uint32::New(isolate, 0x8D00));
-    tmpl->Set(isolate, "STENCIL_ATTACHMENT", v8::Uint32::New(isolate, 0x8D20));
-    tmpl->Set(isolate, "DEPTH_STENCIL_ATTACHMENT", v8::Uint32::New(isolate, 0x821A));
-    tmpl->Set(isolate, "NONE", v8::Uint32::New(isolate, 0));
+              v8::Integer::NewFromUnsigned(isolate, 0x8CD3));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT0", v8::Integer::NewFromUnsigned(isolate, 0x8CE0));
+    tmpl->Set(isolate, "DEPTH_ATTACHMENT", v8::Integer::NewFromUnsigned(isolate, 0x8D00));
+    tmpl->Set(isolate, "STENCIL_ATTACHMENT", v8::Integer::NewFromUnsigned(isolate, 0x8D20));
+    tmpl->Set(isolate, "DEPTH_STENCIL_ATTACHMENT", v8::Integer::NewFromUnsigned(isolate, 0x821A));
+    tmpl->Set(isolate, "NONE", v8::Integer::NewFromUnsigned(isolate, 0));
 
     /* Pixel formats */
 
     /* Pixel types */
 
-    tmpl->Set(isolate, "FRAMEBUFFER_COMPLETE", v8::Uint32::New(isolate, 0x8CD5));
-    tmpl->Set(isolate, "FRAMEBUFFER_INCOMPLETE_ATTACHMENT", v8::Uint32::New(isolate, 0x8CD6));
+    tmpl->Set(isolate, "FRAMEBUFFER_COMPLETE", v8::Integer::NewFromUnsigned(isolate, 0x8CD5));
+    tmpl->Set(isolate, "FRAMEBUFFER_INCOMPLETE_ATTACHMENT",
+              v8::Integer::NewFromUnsigned(isolate, 0x8CD6));
     tmpl->Set(isolate, "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",
-              v8::Uint32::New(isolate, 0x8CD7));
+              v8::Integer::NewFromUnsigned(isolate, 0x8CD7));
 
     /* Pixel types */
 
     /* Shaders */
 
-    tmpl->Set(isolate, "FRAMEBUFFER_INCOMPLETE_DIMENSIONS", v8::Uint32::New(isolate, 0x8CD9));
-    tmpl->Set(isolate, "FRAMEBUFFER_UNSUPPORTED", v8::Uint32::New(isolate, 0x8CDD));
-    tmpl->Set(isolate, "FRAMEBUFFER_BINDING", v8::Uint32::New(isolate, 0x8CA6));
-    tmpl->Set(isolate, "RENDERBUFFER_BINDING", v8::Uint32::New(isolate, 0x8CA7));
-    tmpl->Set(isolate, "MAX_RENDERBUFFER_SIZE", v8::Uint32::New(isolate, 0x84E8));
-    tmpl->Set(isolate, "INVALID_FRAMEBUFFER_OPERATION", v8::Uint32::New(isolate, 0x0506));
-    tmpl->Set(isolate, "UNPACK_FLIP_Y_WEBGL", v8::Uint32::New(isolate, 0x9240));
-    tmpl->Set(isolate, "UNPACK_PREMULTIPLY_ALPHA_WEBGL", v8::Uint32::New(isolate, 0x9241));
-    tmpl->Set(isolate, "UNPACK_COLORSPACE_CONVERSION_WEBGL", v8::Uint32::New(isolate, 0x9243));
+    tmpl->Set(isolate, "FRAMEBUFFER_INCOMPLETE_DIMENSIONS",
+              v8::Integer::NewFromUnsigned(isolate, 0x8CD9));
+    tmpl->Set(isolate, "FRAMEBUFFER_UNSUPPORTED", v8::Integer::NewFromUnsigned(isolate, 0x8CDD));
+    tmpl->Set(isolate, "FRAMEBUFFER_BINDING", v8::Integer::NewFromUnsigned(isolate, 0x8CA6));
+    tmpl->Set(isolate, "RENDERBUFFER_BINDING", v8::Integer::NewFromUnsigned(isolate, 0x8CA7));
+    tmpl->Set(isolate, "MAX_RENDERBUFFER_SIZE", v8::Integer::NewFromUnsigned(isolate, 0x84E8));
+    tmpl->Set(isolate, "INVALID_FRAMEBUFFER_OPERATION",
+              v8::Integer::NewFromUnsigned(isolate, 0x0506));
+    tmpl->Set(isolate, "UNPACK_FLIP_Y_WEBGL", v8::Integer::NewFromUnsigned(isolate, 0x9240));
+    tmpl->Set(isolate, "UNPACK_PREMULTIPLY_ALPHA_WEBGL",
+              v8::Integer::NewFromUnsigned(isolate, 0x9241));
+    tmpl->Set(isolate, "UNPACK_COLORSPACE_CONVERSION_WEBGL",
+              v8::Integer::NewFromUnsigned(isolate, 0x9243));
 }
 
 void WebGLRenderingContext::SetProps(v8::Isolate *isolate,